Bad Byte Bootstrap Blues

Unrealscript Overview Part Six : Actor

2011-12-02T20:04:00.001Z

We don't actually place bubbles in the world. We use an object placed in the level as a point to spawn bubbles from, particle - system style. BubbleSpawner is this object. Note that it is marked as a placable so that it can be placed in the editor. The variables qualified by the (Bubble) suffix in their declaration appear as editiable properties in-game. This is an important mechanism to allow designers and artists to tweak the game without programmer input, letting you get on with core logic implementation.

In PostBeginPlay we vary the spawnCounter a bit, to be sure that mutliple emitters aren't in phase. Tick() just counts down using delta time, waiting until the time calsle to spawn a bubble. When it comes, the Spawn() function is called to randomly create a new BubblePawn somewhere randomly around the general vicinity of the spawner. That's all it takes to dynamically create a new in-world actor - the Pawn itself should take care of spawning it's controller.

class BubbleSpawner extends Actor placeable;

var(Bubble) float spawnRange;
var float spawnCountDown;
var(Bubble) float spawnInterval;

event PostBeginPlay()
{
   spawnCountDown = spawnInterval * 2.5;
   super.PostBeginPlay();
   SetHidden(True);
}

event Tick(float DeltaTime)
{
   local Vector SpawnLocation;
   spawnCountDown -= DeltaTime;
   if (spawnCountDown < 0)
   {
   SpawnLocation = self.Location;
   SpawnLocation.X += -spawnRange + FRand() * (spawnRange * 2.0);
   SpawnLocation.Y += -spawnRange + FRand() * (spawnRange * 2.0);
   spawnCountDown = spawnInterval;
   Spawn(class'LavaLamp.BubblePawn', Self,, SpawnLocation );
   }  
}

defaultproperties
{
   spawnInterval = 0.75
   spawnRange    = 64.0
}

Unrealscript Overview Part Five : Player Controller and Camera

2011-12-02T19:40:00.005Z

The PlayerController, derived from GamePlayerController, is the Player counterpart of the NPC GameAIController. The Player is put into the walking state by default. We co straight from here to the Spectating state, suitable for a free-flying camera. The states are implemented in GamePlayerController and it's base classes. The UpdateRotation() method is called from the base controllers Tick(). It's job is to transfer changes in PlayerInput and translate them into actual motion that sets the position and orientation of the player. ProcessMove() simply updates the Pawn's acceleration and leaves it to the base clases to update the Pawns velocity and position accordingly.

Player Controller


class LavaLampPlayerController extends GamePlayerController;

defaultproperties 
{
 CameraClass=class'LavaLamp.LavaLampPlayerCamera'
}


simulated event PostBeginPlay()
{
 super.PostBeginPlay();
}



/*
* The default state for the player controller
*/

state PlayerWalking
{
 event BeginState(Name PreviousStateName)
 {
  GotoState('Spectating');
 }
}


/*
* The default state for the lava lamp demo
*/

state PlayerSpectating
{
 event BeginState(Name PreviousStateName)
 {
  bCollideWorld = false;
 }

 function ProcessMove(float DeltaTime, vector NewAccel, eDoubleClickDir DoubleClickMove, rotator DeltaRot)
 {
  if( Pawn == None )
  {
   return;
  }

  if (Role == ROLE_Authority)
  {
   // Update ViewPitch for remote clients
   Pawn.SetRemoteViewPitch( Rotation.Pitch );
  }

  Pawn.Acceleration = NewAccel;
 }



 function UpdateRotation( float DeltaTime )
 {
  local Rotator   DeltaRot, newRotation, ViewRotation;

  ViewRotation = Rotation;
  if (Pawn!=none)
  {
   Pawn.SetDesiredRotation(ViewRotation);
  }


  // Calculate Delta to be applied on ViewRotation
  DeltaRot.Yaw      = PlayerInput.aTurn;
  DeltaRot.Pitch    = PlayerInput.aLookUp;

  ProcessViewRotation( DeltaTime, ViewRotation, DeltaRot );

  SetRotation(ViewRotation);
  NewRotation = ViewRotation;
  NewRotation.Roll = Rotation.Roll;
  if ( Pawn != None ) {
   Pawn.FaceRotation(NewRotation, deltatime);
  }
 }
}

Player Camera


class LavaLampPlayerCamera extends Camera;


function UpdateViewTarget(out TViewTarget OutVT, float DeltaTime)
{
 local CameraActor   CamActor;
 local Pawn     TPawn;

 // Don't update outgoing viewtarget during an interpolation 

 if( PendingViewTarget.Target != None && OutVT == ViewTarget && BlendParams.bLockOutgoing )
 {
  return;
 }

 // Default FOV on viewtarget
 OutVT.POV.FOV = DefaultFOV;

 // Viewing through a camera actor.
 CamActor = CameraActor(OutVT.Target);

 if( CamActor != None )
 {
  CamActor.GetCameraView(DeltaTime, OutVT.POV);

  // Grab aspect ratio from the CameraActor.
  bConstrainAspectRatio   = bConstrainAspectRatio || CamActor.bConstrainAspectRatio;
  OutVT.AspectRatio   = CamActor.AspectRatio;

  // See if the CameraActor wants to override the PostProcess settings used.
  CamOverridePostProcessAlpha = CamActor.CamOverridePostProcessAlpha;
  CamPostProcessSettings = CamActor.CamOverridePostProcess;
 }
 else
 {
  TPawn = Pawn(OutVT.Target);

  // Give Pawn Viewtarget a chance to dictate the camera position.
  // If Pawn doesn't override the camera view, then we proceed with our own defaults
  if( TPawn == None || !TPawn.CalcCamera(DeltaTime, OutVT.POV.Location, OutVT.POV.Rotation, OutVT.POV.FOV) )
  {   
   // for this demo, we just follow the player controller
   OutVT.POV.Rotation = PCOwner.Rotation;              
   OutVT.POV.Location = PCOwner.Location;
  }
 }


 // Apply camera modifiers at the end (view shakes for example)
 ApplyCameraModifiers(DeltaTime, OutVT.POV);
}


defaultproperties
{

}

Unrealscript Overview Part Four : Player Pawn

2011-12-02T19:35:00.002Z

Our "Player" class is much less interesting than you might expect, as we are not implementing a player as such but a simple free camera. We override GetBaseAimRotation to control the viewpoint of the Pawn. We ensure that the Pawn can have it's view updated fully by the rotation pitch, roll and yaw angles. If we wanted to limit the viewing direction we would hard code tempRot.pitch = 0 in this routine to disable looking up and down for instance. BecomeViewTarget is called when a camera focuses on the player, and is our chance to block the request. Here, we allow it. As there is no mesh associated with our "Player" the light enviroment is redundant.


class LavaLampPawn extends GamePawn;



var DynamicLightEnvironmentComponent LightEnvironment;


//override to make player mesh visible by default

simulated event BecomeViewTarget( PlayerController PC )
{
 Super.BecomeViewTarget(PC);
}



simulated singular event Rotator GetBaseAimRotation()
{
 local Rotator tempRot;
 tempRot = Rotation;
 SetRotation(tempRot);
 return tempRot;
}



defaultproperties
{
 bCanWalk = true
 bCanSwim = false
 bCanFly  = false
 bCanClimbLadders = false
 bWorldGeometry = true
 bCollideActors = false
 bCollideWorld  = false
 bBlockActors   = false
 Begin Object Class=DynamicLightEnvironmentComponent Name=MyLightEnvironment
  bSynthesizeSHLight=TRUE
  bIsCharacterLightEnvironment=TRUE
  bUseBooleanEnvironmentShadowing=FALSE
 End Object

 Components.Add(MyLightEnvironment)
 LightEnvironment=MyLightEnvironment
}

Unrealscript Overview Part Three : NPC Controller

2011-12-02T18:38:00.005Z

However, a pawn is not enough to give you a full NPC. A controller is also needed. Think of this as a model - view - controller set up. The view is handled by the rendering engine iteslf, the model is the unrealscript code for the pawn, and the actual controller is the controller class associated with the Pawn itself. Nearly all NPC or player pawns will have a controller associated with them. In the case of NPCs this will derive from AIController, which derives from GameController. These base classes define some logic for simple pathfollowing which may or may not be useful. In our example, the BubbleController does not use this derived class code.

AI Controllers usually are implemented as State machines. Unrealscript has a state construct that makes this easy. Code enclosed in a named state block is executed only when the object enters that state. The controller has an explicit method for switching state called GotoState(). As this is a simple example I have not overridden any methods inside the state block, but have written short fragments of code that can be executed latentley. Latent functions are Unrealscript speak for functions that run in the background. There are a small group of these available to you (grepping through the Controller, Actor and Pawn classes should reaval them), mostly related to Pawn movmement. Here, the rising state sets the Pawn velocity when it is etered, and then periodically checks to see if the bubble has risen too far. When it has, it enters the Popping state, wherein it stands still for a second, and then is destroyed.

The Destroy() function brings us to another point. Objects derived from actor have a special property in that they are spawned rather than created with the new() operator. In our BubblePawn class we called a base method called SpawnDefaultController(), and set ControllerClass to class'LavaLamp.BubbleController'. SpawnDefaultController will then create an instance of that controller class, and ensure that the controller Poseses (ie controls/owns) the Pawn by calling Posses. It is perfectly theoretially possible to pass a pawn around different controllers to implement different behaviours - although the state mechanism makes this less useful than it might sound.


class BubbleController extends AIController;



var float RisingDistance;

var float ExtraVelocity;



simulated Event SetInitialState() 

{

 ExtraVelocity = FRand() * 1.25;

 bScriptInitialized = true;

 GotoState('Rising');

}



state Rising

{

Begin: 

 Pawn.Velocity = vect(0.0, 0.0, 0.85);

 Pawn.Velocity.Z += ExtraVelocity;

RisingLoop:

 if (Pawn.Location.Z  > RisingDistance)  {

  StopLatentExecution();

  GotoState('Popping');

 }

 Sleep(1);

 goto 'RisingLoop';

}



state Popping

{

Begin:

 Pawn.Velocity = vect(0.0, 0.0, 0.0);

PoppingLoop:

 Sleep(1);

 Pawn.Destroy();

 Pawn = None;

 Destroy();

 goto 'PoppingLoop';

}





defaultproperties

{

 RisingDistance = 2048.0

}

Unrealscript Overview Part Two : NPC Pawn

2011-12-02T18:34:00.003Z

The second class to look at is Pawn. The Pawn class extends the Object and Actor class and is responsible for most in-game entities. PostBeginPlay() is the method that is called when all engine-side initialisation of an actor is complete, so we usually do setup in here. In the case of the player, this means also spawning a default controller.

In BubblePawn, we are also initalising a material instance, an instance of a Material created with the Material Editor and given some named parameters within that editor. Creating a Material Instance lets us vary those parameters on a per-instance basis without creating a whole new material.

Tick() is the routine called every time the game state is updated. Overriding it enables you to completely alter the behavior of a given Pawn. In our case we are simply moving the bubble upward and varying it's scale to give a throbbing effect.

We are using dynamic lighting in our environment and thus we define properties for dynamic lighting of the object in our default properties. To aid speed we also turn off as many collision checks as possible. The static mesh component that we add is the mesh drawn by the renderer for this Pawn. The components are simply entries in a dynamic array of components and may be created or destroyed dynamically. The sprite removal is to simly remove a default placeholder sprite automatically added by the system, as this is a placeable and can actually be placed in the editor in the scene.






class BubblePawn extends Pawn placeable;



var float   accumulatedTime;

var StaticMeshComponent BubbleMesh;

var MaterialInstanceConstant MatInst;



simulated event PostBeginPlay()

{

 local LinearColor specularColor;



 accumulatedTime = FRand() * 180.0;

 super.PostBeginPlay();

 `log("spawning bubble ... ");

 SpawnDefaultController();

 MatInst = new(None) Class'MaterialInstanceConstant';

 MatInst.SetParent(BubbleMesh.GetMaterial(0)); 

 BubbleMesh.SetMaterial(0, MatInst);

 MatInst.SetScalarParameterValue('LavaEmissiveMultiplier', FRand());

 MatInst.SetScalarParameterValue('LavaSpecularPower', FRand() * 16.0); 

 specularColor = makeLinearColor(FRand(), FRand(), FRand(), 1.0);

 MatInst.SetVectorParameterValue('LavalSpecularColor', specularColor);

}



event Tick(float DeltaTime) 

{

 accumulatedTime += DeltaTime;

 SetDrawScale( 1.0 + 0.75 * Sin(accumulatedTime) );

 Move(self.Velocity);

 super.Tick(DeltaTime);

}





defaultproperties

{

 WalkingPhysics=Phys_NONE

 bCollideActors=false

 bCollideWorld=false

 DrawScale3D=(X=32.0,Y=32.0,Z=32.0)

 bNoEncroachCheck = true

 bIgnoreEncroachers = true

 ControllerClass=class'LavaLamp.BubbleController'

Begin Object Class=DynamicLightEnvironmentComponent Name=BubbleLightEnvironment

 ModShadowFadeoutTime=0.25

 MinTimeBetweenFullUpdates=0.2

 AmbientGlow=(R=.25,G=.25,B=.25,A=1)

 AmbientShadowColor=(R=0.15,G=0.15,B=0.15)

 LightShadowMode=LightShadow_ModulateBetter

 ShadowFilterQuality=SFQ_High

 bSynthesizeSHLight=TRUE

End Object

Components.Add(BubbleLightEnvironment)

Begin Object Class=StaticMeshComponent Name=InitialMesh

 StaticMesh=StaticMesh'Lava.Meshes.Bubble'

 bOwnerNoSee=false

 LightEnvironment=BubbleLightEnvironment;

 BlockRigidBody=false

 CollideActors=false

 BlockZeroExtent=false

 BlockNonZeroExtent=false

End Object

Components.Add(InitialMesh);

Components.Remove(Sprite);

BubbleMesh = InitialMesh

name='Bubble';

}

Dumping Blender Scenes as Lua

2011-12-02T11:45:00.004Z

Following on to the previous post where I dumped blender scenes as Lisp, I've also written a modified version which is more usual for mainstream use that dumps the entire active object as an enormous Lua literal. I think this would be more useful for mainstream use as the Lua could then be compiled to binary and loaded into a tool, which could pick out and use the useful bits on a per-project basis. My next project is to investigate if such a thing is also possible with FBX & Python - again for more mainstream use.

Once more, here is the source Luke - use it :-)

Implementing Lisp in C++

2011-11-15T12:21:00.003Z

I've been spending some time implementing a small Lisp for embedding and bootstrapping in C++, somewhat in the spirit of Scheme from Scratch.

The brief I've given myself is a bit contradictory in that I'm eschewing the use of virtual functions (as they make linking C to C++ more complicated) but, for now I'm still allowing boost as a dependency.

It turns out that Boost is highly useful for implementing polymorphic objects, since it contains variant - which can be used instead of the usual tagged unions.

To implement the basic Lisp Object I've created a template that implements the properties of the lisp object (copyable, assignable, and freely convertible to a base C type) and created a boost variant of all the different specialisations of this template which is the base class of our object.

This template should save writing boatloads of boilerplate code when contrasted with C and it should be much more easy to plug in new types. This has to be a win over C. The other big advantage (as noted before when I wrote the simpler Lisp) is that shared_ptr gives reference counted garbage collection more - or - less for free.

As usual, here's the code.

Exporting Lisp From Blender

2011-10-20T12:28:00.003+01:00

Writing a custom scene exporter for Blender turns out to be ridiculously easy compared to just about every other 3d package I've come across, mainly due to the power of Python introspection. This Python script shows how easy it is to introspect over a Blender Scene. After some fiddling I ended up with the Python script at the bottom of the post, which dumps the entire scene as an S-Expression for a Lisp instance to read.
My Lisp-based export problems are over!

Things that freak me out about Clojure

2011-09-07T10:59:00.002+01:00

Coming from a Common Lisp/C++ background to Clojure is kind of .. interesting... there are several things that have made me take pause and wonder if Common Lisp is doing things the right way.

* Maps and Sets are functions. You can apply a value to a set and it returns that value if it's a member, nil if it's not. Similarly with maps. Apply a value to a map and it either returns nil, or the value the value maps to in the map. Seems strange at first but it allows some neat filtering tricks

* Keywords are functions. Keywords evaluate to themselves, just like in CL. Unlike in CL they are also functions so (:keyword map) actually tests map for membership of :keyword and returns the value mapped to the keyword. Again, this is handy.

* -> : This macro flattens out nested function calls so (-> fn1 fn2 fn3) is (fn1 (fn2 (fn3))). I really dislike this: I can see how coming from Java it would seemingly make code easier to read, and reduce syntatic noise, but I find the parens useful as a guide for indentation. This might be down to taste.

* Iteration is totally different. There's nothing like the LOOP or ITERATE. There is a while and a loop/recur, but the sequence handling is sufficently powerful that this is a fallback. It forces me to think differently and this is definitely a good thing.

* Probably more to come, but meanwhile I'll keep in mind these rules for writing Clojure.

Code Kata For Game Developers

2011-08-13T11:33:00.003+01:00

I've spent some time wondering what a set of Code Katas for game developers would look like. I'm thinking mostly in the context of learning a new language. Here's the list I have so far.

Mandelbrot set plotting
Simple raytracer.
Breakout clone.
Simple MUD.

Each kata would conentrate on different aspects of coding. The first, the Mandelbrot set is an old standard. Once it's done, you will know the mechanics of creating a 2d display, drawing on it, and getting decent performance out of simple numeric computation.

The raytracer, our second kata, takes us through the basics of 3d math and rendering, without actually requiring interactivity and will allow us to deploy most of the maths code needed to support 3d games on the platform. The two games suggested as exercies are Breakout and a simple MUD.

Breakout is a 2D graphical game, which would build on what was learnt performing the Mandelbrot set kata, and in addition require realtime interactivity and input, something not covered by the previous two katas, and also be a "proper" game with an initalisation phase, along with an update and render loop, giving us a framework to build our actual games around.

The final kata, the MUD concentrates on areas neglected until now: networking and text processing. These are important aspects of any platform and multi-player play. It should have enough game logic to support NPCs, and containers at the very least, but can be elaborated indefinitely..

I think these four kata would leave you in a very good position to go on to implement games on the platform you were exploring.

I'm wondering if there should be a fifth kata? I don't want this to become an exhaustive list - it needs to be a set of exercises that should take little more than a day each. One working week seems a reasonable time for a professional game developer to explore a new platform. What would he/she do on the fifth day. Any suggestions?

Unrealscript Overview Part One: The Game Info Class

2011-06-01T19:53:00.003+01:00

A lot of Unrealscript source code ships with Unreal, and it's hard to know where to begin. This tutorial is to get you started and point out the major classes to extend, and methods to override. Its intended for programmers who already know one decent langauge like JavaScript, C++ or Java, to let them quickly locate key classes and methods and show how they fit together. The example centres round a simple level full of bubbles that keep continouosly spawning, with a a material, size and speed that varies per bubble.

The most central one is probably GameInfo. So, lets start there. GameInfo is the class that defines the Game rules and creates, tracks and destroys objects in the game world itself, and controls the game flow, as outlined on UDN

The very basic version of GameInfo needs to know only two things - the class which is used to implement the player Pawn and Controller. This is added in a defaultproperties section that usually comes after any code and is used to initialise variables at instance creation time. The PostLogin() is called by the engine after the player has been spawned and is meant to call StartMatch(), StartHumans(), RestartPlayer(), and SpawnDefaultPawnFor() in order to run the game. We override PostLogin() in our demo as we are implementing a demo and not a game, and do not want death and restart logic to apply to the player.

Emas and the Unreal Development Kit Workflow

2011-05-16T11:31:00.004+01:00

I've been spending some more time with the Unreal Development Kit, as it seems to be trending in the world of games development, and partly to keep my hand in. I've been developing an Emacs based workflow and I thought I'd just quickly blog about it, in case my Emacs Lisp is of any help to any Emacs oldbies confronting this tech. The usual way to develop for it is with nFringe's pixel Mine and Visual Studio. And while Visual Studio is an excellent debugger, it lacks in the actual text editing department, as even Vi users know...

My tools of choice are Emacs AutoComplete mode, which gives Emacs intelli-sense like capabilities over a broad range of languages (it's pretty magical with Lisp, as you'd expect) and the good old Exuberant Ctags, primed to tag Unrealscript, with the following regular expressions in ~/ectags.cnf. I have to say ectags-select is very handy for working with these, as an alternative to the usual way of working with tags in Emacs as it lets you browse the enormous range of options that pop up.

These are the expressions to use for Exubrerant Ctags when tagging Unrealscript.

This is the support code I have: a set of interactive functions for invoking the udk, building code, running the editor. It creates a group of settings that can be customised with M-x customize-group udk. I watch the log in an emacs buffer via global-revert-tail mode. I have not yet added support for UDK log files to compilation mode, but thats an obvious tweak I'll try at some point. I've had enough fiddling with regular expressions for now.

PS: I thought I'd reproduce the unrealscript mode here, just in case. It lives where you put your other extra mode files.

Bricolage - Now with font rendering.

2011-04-07T07:15:00.003+01:00

The next step for the bricolage engine I'm writing is to add font rendering. Something one should add early on in development, so you can read all those panic messages from your machine and keep an eye on CPU usage and memory usage as you go along. For this I have been using Angel Code's BMFont tool, which is noticeably better than any other I've seen: even supports signed distance fields..

Bricolage engine starts rendering

2011-03-14T11:58:00.005Z

My experimental bricolage lash-up has started rendering (actually, two weeks ago) .. here's a screenshot of it rendering the videogame testcard..next step is to get a nice font rendering module and debugging console going..before delving into 3d..

Bricolage progress.

2011-02-04T15:46:00.002Z

The initial version of the Bricolage engine is complete. It uses nedmalloc for memory allocation, EASTL for generic containers and GLEW and GLFW for OpenGL and platform abstraction layers, although at the moment the only platform I'm supporting is Windows. It should be more than enough to get an image on the screen, run a shader, and build some basic component - entity architecture. So, here we go...

A New Engine

2011-01-25T15:12:00.008Z

I am between projects at the moment, in a phase of experimentation. One thing I've wanted to do is construct a good testbed engine for experiments. However an entire engine is a major undertaking - three months to get the basics down pat. A third party engine always takes time to learn, though. There's nothing to replace the familiarity of something you coded yourself.

It occured to me that there is a third alternative. Bricolage - to assemble an engine or as much as possible of an engine from the multitude of FOSS libraries that are available. Such would be in accord with the UNIX philosophy: to have small programs or tools that do one thing well, and arrange it so that the sum of the parts are greater than the whole. This should give me a platform for experimentation in a much faster time than full self-assembly, but have the advantage of familiarity that comes with self-designed API's.

With no further ado, I introduce the Bricolage engine. I will blog about each component as I add it. Eventually it should be a reasonably featured engine that works with mingw on Windows and is ready for porting to other platforms. To quote Wikipedia:

Bricolage is a term used in several disciplines, among them the visual arts
and literature, to refer to the construction or creation of a work from a
diverse range of things that happen to be available, or a work created by
such a process. The term is borrowed from the French word bricolage, from
the verb bricoler, the core meaning in French being, "fiddle, tinker" and,
by extension, "to make creative and resourceful use of whatever materials
are at hand (regardless of their original purpose)"

My main goal is portability. I need to be able to support mutiple renderers and platforms if at all possible. This pretty much limits me to gcc as a compiler and OpenGL (and it's junior cousin, OpenGLES) as a rendering API. I chose SCons as a build tool, mainly for reasons of tast. It's as portable as Python is and I know it and Python reasonably well. CMake or autotools are equally valid choices.

How network games work...

2010-12-14T16:35:00.004Z

Highly handy comment from PlayerController.uc in the Unreal Development Kit: Multiplayer net games 101..



/*
========================================================================
Here's how player movement prediction, replication and correction works in network games:

Every tick, the PlayerTick() function is called.  It calls the PlayerMove() function (which is implemented
in various states).  PlayerMove() figures out the acceleration and rotation, and then calls ProcessMove()
(for single player or listen servers), or ReplicateMove() (if its a network client).

ReplicateMove() saves the move (in the PendingMove list), calls ProcessMove(), and then replicates the move
to the server by calling the replicated function ServerMove() - passing the movement parameters, the client's
resultant position, and a timestamp.

ServerMove() is executed on the server.  It decodes the movement parameters and causes the appropriate movement
to occur.  It then looks at the resulting position and if enough time has passed since the last response, or the
position error is significant enough, the server calls ClientAdjustPosition(), a replicated function.

ClientAdjustPosition() is executed on the client.  The client sets its position to the servers version of position,
and sets the bUpdatePosition flag to true.

When PlayerTick() is called on the client again, if bUpdatePosition is true, the client will call
ClientUpdatePosition() before calling PlayerMove().  ClientUpdatePosition() replays all the moves in the pending
move list which occured after the timestamp of the move the server was adjusting.
*/

Unrealscript Mode for Emacs Reloaded

2010-12-01T17:39:00.002Z

I actually started picking up Unreal again, and Unrealscript. My previous attempt at an Unrealscript mode was badly flawed. It was based on CC-mode, which I did not fully pursuade to understand the syntax of Unrealscript. This time, I've gone back to first principles and created simple progmode not derived from cc-mode. This means a loss of functionality, but it does mean correct indenting, and true case insensitivity. I found CC mode would have to be patched to handle a case insensitive language like UnrealScript. Anyway, without further ado, here it is. I reccomend it over the previous ones.


(defvar unrealscript-mode-hook nil)

(defvar unrealscript-mode-map
  (let ((unrealscript-mode-map (make-sparse-keymap)))
 (define-key unrealscript-mode-map "\C-j" 'newline-and-indent)
 unrealscript-mode-map)
  "Keymap for UNREALSCRIPT major mode")


(defconst unrealscript-font-lock-keywords-1
  (list
   '("\\<\\(?:break\\|c\\(?:\\(?:as\\|ontinu\\)e\\)\\|do\\|e\\(?:lse\\|xtends\\)\\|for\\(?:each\\)?\\|i\\(?:f\\|nterface\\)\\|new\\|return\\|switch\\|var\\|while\\|class\\)\\>" . font-lock-keyword-face))
  "Minimal highlighting expressions for UNREALSCRIPT mode.")

(defconst unrealscript-font-lock-keywords-2
  (append unrealscript-font-lock-keywords-1
    (list
     '("\\<\\(?:array\\|b\\(?:ool\\|yte\\)\\|c\\(?:lass\\|o\\(?:erce\\|lor\\|ords\\)\\)\\|de\\(?:faultproperties\\|legate\\)\\|e\\(?:num\\|vent\\)\\|f\\(?:alse\\|loat\\|unction\\)\\|int\\|local\\|name\\|o\\(?:ptional\\|ut\\)\\|plane\\|r\\(?:egion\\|otator\\)\\|st\\(?:ate\\|r\\(?:ing\\|uct\\)\\)\\|true\\|v\\(?:\\(?:a\\|ecto\\)r\\)\\)\\>" . font-lock-keyword-face)))
  "Additional Keywords to highlight in UNREALSCRIPT mode.")


(defconst unrealscript-font-lock-keywords-3
  (append unrealscript-font-lock-keywords-2
    (list
     '("\\<\\(?:A\\(?:bstract\\|llowAbstract\\|uto\\(?:Comment\\|ExpandCategories\\)\\)\\|Co\\(?:llapseCategories\\|nfig\\)\\|D\\(?:ep\\(?:endsOn\\|recated\\)\\|isplayName\\|ontCollapseCategories\\)\\|Edit\\(?:Condition\\|InlineNew\\)\\|FriendlyName\\|Hide\\(?:Categories\\|DropDown\\)\\|I\\(?:\\(?:mplemen\\|nheri\\)ts\\)\\|N\\(?:ative\\(?:Replication\\)?\\|o\\(?:Export\\|nTransient\\|t\\(?:EditInlineNew\\|Placeable\\)\\)\\)\\|P\\(?:erObject\\(?:Config\\|Localized\\)\\|laceable\\)\\|ShowCategories\\|T\\(?:oolTip\\|ransient\\)\\|Within\\)\\>" . font-lock-type-face)
     '("\\<\\(?:auto\\|c\\(?:lient\\|on\\(?:fig\\|st\\)\\)\\|d\\(?:atabinding\\|eprecated\\|uplicatetransient\\)\\|e\\(?:dit\\(?:const\\|fixedsize\\|inline\\(?:use\\)?\\|oronly\\)\\|x\\(?:ec\\|port\\)\\)\\|globalconfig\\|i\\(?:gnores\\|n\\(?:it\\|put\\|stanced\\|terp\\)\\|terator\\)\\|l\\(?:atent\\|ocalized\\)\\|n\\(?:ative\\(?:replication\\)?\\|o\\(?:clear\\|export\\|import\\|ntransactional\\|tforconsole\\)\\)\\|operator\\|p\\(?:o\\(?:\\(?:inte\\|stoperato\\)r\\)\\|r\\(?:eoperator\\|ivate\\|otected\\)\\|ublic\\)\\|re\\(?:liable\\|pnotify\\)\\|s\\(?:erver\\|i\\(?:mulated\\|ngular\\)\\|kip\\|tatic\\)\\|tra\\(?:nsient\\|vel\\)\\|unreliable\\)\\>" . font-lock-keyword-face)
     '("\\<\\(?:A\\(?:bs\\|cos\\|dd\\(?:Item\\)?\\|llActors\\|s\\(?:c\\|in\\)\\|tan\\)\\|B\\(?:asedActors\\|egin\\(?:Play\\|State\\)\\)\\|C\\(?:aps\\|eil\\|h\\(?:ildActors\\|r\\)\\|l\\(?:amp\\|earTimer\\)\\|o\\(?:\\(?:llidingActor\\)?s\\)\\)\\|D\\(?:estroyed\\|i\\(?:\\(?:sabl\\|vid\\)e\\)\\|ynamicActors\\)\\|E\\(?:mpty\\|n\\(?:\\(?:abl\\|dStat\\)e\\)\\|val\\|xp\\)\\|F\\(?:Clamp\\|M\\(?:ax\\|in\\)\\|Rand\\|astTrace\\|in\\(?:d\\|ish\\(?:Anim\\|Interpolation\\)\\)\\)\\|G\\(?:etTimer\\(?:Count\\|Rate\\)\\|oTo\\(?:State\\)?\\)\\|I\\(?:n\\(?:Str\\|itGame\\|sert\\(?:Item\\)?\\|vert\\)\\|s\\(?:\\(?:InStat\\|TimerActiv\\)e\\)\\)\\|L\\(?:e\\(?:ft\\|n\\|rp\\)\\|o\\(?:cs\\|ge\\)\\)\\|M\\(?:ax\\|i\\(?:rrorVectorByNormal\\|[dn]\\)\\)\\|Normal\\|OverlappingActors\\|P\\(?:o\\(?:pState\\|stBeginPlay\\)\\|reBeginPlay\\|ushState\\)\\|R\\(?:and\\|e\\(?:move\\(?:I\\(?:ndex\\|tem\\)\\)?\\|pl\\(?:ace\\)?\\)\\|ight\\|ound\\)\\|S\\(?:et\\(?:State\\|Timer\\)\\|in\\|leep\\|merp\\|p\\(?:awn\\|lit\\)\\|q\\(?:rt\\|uare\\)\\)\\|T\\(?:an\\|ick\\|ouchingActors\\|race\\(?:Actors\\)?\\)\\|V\\(?:Rand\\|Size\\|isible\\(?:\\(?:Colliding\\)?Actors\\)\\)\\|\\(?:ro\\|vec\\)t\\)\\>" . font-lock-function-name-face)))
  "Balls-out highlighting in UNREALSCRIPT mode.")

(defvar unrealscript-font-lock-keywords unrealscript-font-lock-keywords-3
  "Default highlighting expressions for UNREALSCRIPT mode.")


(defvar unrealscript-indent-width 4)

(defun looking-at-unrealscript-indent-keyword ()
  (or (looking-at "^[\t ]*while") (looking-at "^[\t ]*if") (looking-at "^[\t ]*else") (looking-at "^[\t ]*for")))

(defun looking-at-unrealscript-block-end ()  
  (or (looking-at "^[\t ]*end") (and (looking-at "^.*}[ \t]*$") (not (looking-at "^.*{")))))

(defun looking-at-unrealscript-block-start ()
  (or (looking-at "^[\t ]*begin") (and (looking-at "^.*{") (not (looking-at "^.*}[ \t]*$")))))

;; Function to control indenting.
(defun unrealscript-indent-line ()
  "Indent current line as Unrealscript code"
  (interactive)
  ;; Set the point to beginning of line.
  (beginning-of-line)
  (if (bobp)
   (indent-line-to 0)
 (let ((not-indented t) (lines-back 0) cur-indent)
   (if  (looking-at-unrealscript-block-end) ; Check for closing brace
    ;; if we are at the end of a block
    (progn
   (save-excursion
     (forward-line -1)
     (setq lines-back (+ lines-back 1))
     (setq cur-indent (- (current-indentation) unrealscript-indent-width)))
   ;; Safety check to make sure we don't indent negative.
   (if (< cur-indent 0)
    (setq cur-indent 0)))
  ;; else scan backward 
  (save-excursion
    (if (looking-at-unrealscript-block-start) ; Opening block     
     (progn
    (forward-line -1)
    (setq lines-back (+ lines-back 1))
    (setq cur-indent (current-indentation))
    (setq not-indented nil))
   (while not-indented
     (forward-line -1)
     (setq lines-back (+ lines-back 1))
     (if (looking-at-unrealscript-block-end) ;; Closing Block
      (progn
     (setq cur-indent (current-indentation))
     (setq not-indented nil))
    (if (looking-at-unrealscript-block-start)
     (progn
       (setq cur-indent (+ (current-indentation) unrealscript-indent-width))
       (setq not-indented nil))
      (if (looking-at-unrealscript-indent-keyword)
       (progn
      (setq cur-indent (current-indentation))
      (forward-line 1)
      (setq lines-back (- lines-back 1))
      (if (looking-at-unrealscript-block-start)
       (setq not-indented nil) ;; has block
        (if (zerop lines-back) ;; no block
         (progn
        (setq cur-indent (+ cur-indent unrealscript-indent-width))       
        (setq not-indented nil))
       (setq not-indented nil))))
     (if (bobp)
      (setq not-indented nil)))))))))
   (if cur-indent
    (indent-line-to cur-indent)
  (indent-line-to 0))))) 

(defun unrealscript-populate-syntax-table (table)
  "Populate the given syntax table as necessary for a C-like language.
This includes setting ' and \" as string delimiters, and setting up
the comment syntax to handle both line style \"//\" and block style
\"/*\" \"*/\" comments."

  (modify-syntax-entry ?_  "_"    table)
  (modify-syntax-entry ?\\ "\\"    table)
  (modify-syntax-entry ?+  "."    table)
  (modify-syntax-entry ?-  "."    table)
  (modify-syntax-entry ?=  "."    table)
  (modify-syntax-entry ?%  "."    table)
  (modify-syntax-entry ?<  "."    table)
  (modify-syntax-entry ?>  "."    table)
  (modify-syntax-entry ?&  "."    table)
  (modify-syntax-entry ?|  "."    table)
  (modify-syntax-entry ?\' "\""    table)
  (modify-syntax-entry ?\240 "."  table)

  ;; Set up block and line oriented comments.  The new C
  ;; standard mandates both comment styles even in C, so since
  ;; all languages now require dual comments, we make this the
  ;; default.
  (modify-syntax-entry ?/  ". 124b" table)
  (modify-syntax-entry ?*  ". 23" table)

  (modify-syntax-entry ?\n "> b" table)
  ;; Give CR the same syntax as newline, for selective-display
  (modify-syntax-entry ?\^m "> b" table)
  table)

(defvar unrealscript-mode-syntax-table
  (let ((unrealscript-mode-syntax-table (unrealscript-populate-syntax-table (make-syntax-table))))
 unrealscript-mode-syntax-table)
  "Syntax table for unrealscript-mode")

(defun unrealscript-mode ()
  "Major mode for editing Unrealscript files"
  (interactive)
  (kill-all-local-variables)
  (set-syntax-table unrealscript-mode-syntax-table)
  (use-local-map unrealscript-mode-map)
  (setq indent-line-function 'unrealscript-indent-line)
  (setq font-lock-defaults '(unrealscript-font-lock-keywords nil t))
  (setq major-mode 'unrealscript-mode)
  (setq mode-name "UNREALSCRIPT")
  (run-hooks 'unrealscript-mode-hook)
  (setq case-fold-search t)
  (setq font-lock-keywords-case-fold-search t))


(provide 'unrealscript-mode)

A micro manual for Lisp in C++

2010-09-15T22:18:00.007+01:00

It was with some interest that I read A Micro Manual for Lisp in C. One thing I have noticed about such efforts is that they are nearly always implemented in idiomatic C. I thought (out of idle curiosity, mainly) I'd see what a similar thing implemented in idomatic C++ would look like.

The main practical advantage that it offered in the end was the fact that boost::shared_ptr gave me rudimentary garbage collection for free. I used boost::variant to give me polymorphic lisp objects and thus did not have to use naked pointers anywhere, which seems to me to be an improvement in code safety. The price of this is a nosier syntax. You pay your money and you takes your choice..

As a concrete example here is what the implementation of CONS looked like.


boost::shared_ptr<lisp::object> fn_cons(boost::shared_ptr<lisp::object> args,
                                        boost::shared_ptr<lisp::object> env) {

    boost::shared_ptr<lisp::object> list = make_cons(car(args), boost::shared_ptr<lisp::object>());
    args = car(cdr(args));

    while ((args != NULL) && (args->which() == lisp::e_CONS)) {
        append(list, car(args));
        args = cdr(args);
    }
    return list;
}

Its probably also worth noting that avoiding naked pointers meant using boost::function for function objects, thusly..


    enum kind {
        e_ATOM = 0,
        e_CONS,
        e_FUNC,
        e_LAMBDA
    };

    struct atom {
        std::string name;

        atom(const std::string& n) : name(n) {
        }
    };

    struct cons {
        boost::shared_ptr<object> car;
        boost::shared_ptr<object> cdr;

        cons(boost::shared_ptr<object> first, boost::shared_ptr<object> second) : car(first), cdr(second) {

        }
    };

    typedef boost::function< boost::shared_ptr<object> (boost::shared_ptr<object>,boost::shared_ptr<object>) > lisp_func;

    struct func {
        lisp_func fn;

        func(const lisp_func& f) : fn(f) {

        }
    };

    struct lambda {
        boost::shared_ptr<object> args;
        boost::shared_ptr<object> sexp;

        lambda(boost::shared_ptr<object> a, boost::shared_ptr<object> s) : args(a), sexp(s) {

        }
    };

    typedef boost::variant< atom, cons, func, lambda > base_object;

And creating the environment like so...


boost::shared_ptr<lisp::object> init_env() {

    boost::shared_ptr<lisp::object> nul;

    boost::shared_ptr<lisp::object> a_quote(new lisp::object(std::string("QUOTE")));
    boost::shared_ptr<lisp::object> f_quote(new lisp::object(fn_quote));

    boost::shared_ptr<lisp::object> a_car(new lisp::object(std::string("CAR")));
    boost::shared_ptr<lisp::object> f_car(new lisp::object(fn_car));

    boost::shared_ptr<lisp::object> a_cdr(new lisp::object(std::string("CDR")));
    boost::shared_ptr<lisp::object> f_cdr(new lisp::object(fn_cdr));

    boost::shared_ptr<lisp::object> a_cons(new lisp::object(std::string("CONS")));
    boost::shared_ptr<lisp::object> f_cons(new lisp::object(fn_cons));

    boost::shared_ptr<lisp::object> a_equal(new lisp::object(std::string("EQUAL")));
    boost::shared_ptr<lisp::object> f_equal(new lisp::object(fn_equal));

    boost::shared_ptr<lisp::object> a_atom(new lisp::object(std::string("ATOM")));
    boost::shared_ptr<lisp::object> f_atom(new lisp::object(fn_atom));

    boost::shared_ptr<lisp::object> a_cond(new lisp::object(std::string("COND")));
    boost::shared_ptr<lisp::object> f_cond(new lisp::object(fn_cond));

    boost::shared_ptr<lisp::object> a_lambda(new lisp::object(std::string("LAMBDA")));
    boost::shared_ptr<lisp::object> f_lambda(new lisp::object(fn_lambda));

    boost::shared_ptr<lisp::object> a_label(new lisp::object(std::string("LABEL")));
    boost::shared_ptr<lisp::object> f_label(new lisp::object(fn_label));


    boost::shared_ptr<lisp::object> env = make_cons(make_cons(a_quote,make_cons(f_quote,nul)),nul);


    append(env,make_cons(a_car,   make_cons(f_car,nul)));
    append(env,make_cons(a_cdr,   make_cons(f_cdr,nul)));
    append(env,make_cons(a_cons,  make_cons(f_cons,nul)));
    append(env,make_cons(a_equal, make_cons(f_equal,nul)));
    append(env,make_cons(a_atom,  make_cons(f_atom,nul)));
    append(env,make_cons(a_cond,  make_cons(f_cond,nul)));
    append(env,make_cons(a_lambda, make_cons(f_lambda,nul)));
    append(env,make_cons(a_label,  make_cons(f_label,nul)));

    boost::shared_ptr<lisp::object> a_tee(new lisp::object(std::string("#T")));
    tee = a_tee;
    nil = make_cons(nul,nul);

    return env;
}

OpenGL Development on Windows with Slime

2010-08-11T20:35:00.002+01:00

I've been playing with OpenGL, Common Lisp (SBCL, CCL, Lispworks Personal) and SLIME again. Mostly I've been establishing a S-Expression exporter for Blender so I can export entire scenes to the engine I'm working on.

I did discover some wrinkles of working on OpenGL development with SLIME in Windows. CCL uses the :spawn communication style in SLIME which uses it's multi-threaded nature to run each repl request in a seperate thread from the executing lisp code. So if you have your OpenGL app running in the background as you develop it, if you write an experimental form at the repl that includes OpenGL calls, its going to fail, since it will not be executing in the main OpenGL thread.

The solution is to fall back on the nil communication style, which is not threaded and is blocking. This has the less than desirable effect of blocking your repl until the executing app finishes. This can be circumvented by calling swank-handle-requests - like so


(iterate 
 (initially (progn ,init-forms))
 (with-simple-restart 
  (skip-photons-loop "Skip photons loop body")
  ,@body)
 #+photons-debug 
 (with-simple-restart
  (skip-swank-request "Skip swank evaluation")
  (let ((connection
   (or swank::*emacs-connection* (swank::default-connection))))
 (swank::handle-requests connection t)))
 (glfwSwapBuffers)
 (until ,exit-test)
 (finally (progn ,exit-forms))))

There are actually some subtelties here. The skip-photons-loop restart allows you to recover from an error in the loop body, by recompiling the offending form, when the handle-requests function is called, while the skip-swank-request restart allows you to recover from entering an invalid form at the repl without losing the application.

Rooms at last

2009-09-14T22:41:00.003+01:00

You might have noticed a hiatus on this project, but finally I returned to it to finish off the floorplan: here it is. The rooms were generated mainly by using polar coordinates around the space defined by the corridoor end points, and turned out to be relatively straightforward.

At this point, the project really needs to switch away from pyglet to something more useful, that can do the needed 3d extrusion more easily...

Dungeon Generation Part 4: Clearing space for the rooms

2009-07-05T08:17:00.003+01:00

Here we are, we now have spaces where the rooms are going to go: my initial attempts at creating rooms did not go so well, so I had to backtrack and refactor the code, in order to get this to work.

Its actually a fairly simple computation: work out the length of the corridor, scale it, and re-adjust the co-ordinates of each end. This requires some book keeping in terms of data structures: knowing which end terminates at which room, so that you don't accidentally srhink the worong end.

Dungeon Generation Part 3 : Doors

2009-06-17T22:50:00.003+01:00

Thinking about key points in positioning a room, I decided doors were a good idea, so I tried to code up a routine that would reasonably place doors. I interpolated about 30% up along a line and placed a small black perpendicular line prependicular to the line along the centre of the corridor. I went with the simple rule of thumb that a point that connected more than two corridors was the centre of the room. I got this:

Not bad, but not quite right. Probably the best way forward is to decide on an overall radius that will establish the size of the room and fit the doors to that.

Dungeon Generation Part Two: Corridors

2009-06-15T22:35:00.003+01:00

And once the network is complete, we do corridors. This is straigtforward geometry: extrude two lines at either end of our connecting line, perpendicular to said line, then join them up. When you do that you get this:

A floorplan which should extrude nicely into the third dimension. However there's one more thing to do before we tackle this, and that is the actual rooms. Which is where things get a tad harder..

Dungeon generation for fun and..well, fun...

2009-06-11T13:05:00.003+01:00

Recently I was inspired by the PixelCity series of articles. I was impressed what could be achieved by judicious application of basic OpenGL and some clever aesthetic decisions. I'm inspired enough to try the same thing, only with dungeons. My weapons of choice are pyglet and Python.

The first and most obvious thing to try was to generate a network of corridors. Here's what I ended up with.

I generated this mainly by picking a point and then connecting it to one of it's closest neighbours. The points are initially distributed on a grid and peturbed by a random amount to make the layout less "manhattan" like. The order the points are picked in is related to the grid order, which is why you see a "spine" at the side of the dungeon. I thought this would make for interersting gameplay: monster - infested branches connected by a relatively safe trunk. So this is what I went with. In the next part, we will get some corridoor walls. Once I have a decent looking dungeon, I will release the source.

Give it a kick, it might still be going..

2009-02-07T00:07:00.003Z

Just to prove I haven't been completely inactive on the project front since my flirtation with Lisp (which isn't over yet, either, just maturing slowly), here's a screenshot of yet another thing. Basically this is a mesh importer for the excellent OGRE engine, powered by wxWidgets and The Open Asset Import Library. It doesn't handle textures or bones yet, but it does more than enough for now as the Open Asset Import Library imports an ungodly number of formats, it should be possible to magpie bits of free art from the web in whatever format and assemble them into a passable scene using this thing..

More Emacs Help

2008-12-16T14:42:00.003Z

As well as keying the help provided by Google in Emacs to the major-mode, it's possible to use it with multiple libraries as well. For instance, the following snippet lets me look up documentation for one library (OGRE) by pressing 'o' and for another by pressing 'a' , rather like the Slime selector, discussed previously. It's a huseful way of pulling together doxygen API documentation when working on clonk-loads of libraries, as is all to typical of C++ or Java development.


(defun search-site-url (keyword &optional site inurl lucky)
 "Do a Google search for KEYWORD. Restrict to SITE and INURL, if specified.
Jump to best match (I Feel Lucky) if LUCKY set.
"
;;  (message (list keyword site inurl lucky))
 (concat "http://www.google.com/"
         (format "search?q=%s" (url-hexify-string keyword))
         (if site (format "+site:%s" (url-hexify-string site)))
         (if inurl (format "+inurl:%s" (url-hexify-string inurl)))
         (if lucky "&btnI")))


(defun help-selector ()
 (interactive)
 (message "Select [%s]: "
          (apply #'string (mapcar #'car help-selector-methods)))
 (let* ((ch (save-window-excursion
              (select-window (minibuffer-window))
              (read-char)))
        (params (find ch help-selector-methods :key #'car)))
   (browse-url (apply #'search-site-url (thing-at-point 'symbol) (list   (third params) (fourth params) (fifth params))))))

(defvar help-selector-methods '(( ?a "Assimp"
                                    "assimp.sourceforge.net" "/lib_html/" t)
                               ( ?o "Ogre"
                                    "www.ogre3d.org"  "/docs/api/html/" t)
                               ( ?w "WxWidgets"
                                     "docs.wxwidgets.org" "/stable/" t)))

(global-set-key [(shift f1)] 'help-selector)

Lambda of the Daleks

2008-08-21T02:59:00.002+01:00

As promised, the Daleks appear. They have been loaded dynamically from an md2 whilst the framework was running. Sometimes I find myself fighting my C++ reflexes. There's no need to bring the framework down in order to change it. It still seems like magic when I edit a function definition, compile it and *bam* the change appears in the game window...

...one day, all software will be developed this way. Onwards..

And now for a bit of swank..

2008-08-17T17:02:00.002+01:00

Now my testbed talks happily to emacs via slime. That's the "exploratory" part of "exploratory game developement.". Next up: Daleks...

And now for something completley different.

2008-08-17T00:19:00.004+01:00

You guessed it - another testbed. This time, in 100% Common Lisp (SBCL), just for comparison.

More testbed

2008-08-13T11:33:00.003+01:00

I've done some more playing around with that testbed, integrating ECL and G3Ds Shape API. It works ok, apart from a few wrinkles. It might even be the beginnings of a nice educational app for learning 3d transforms and the like. The main improvement is that the REPL gives you error feedback rather than crashing the app when you give it a bad form. A distinct must for interactivity...

What next?

2008-07-22T12:42:00.003+01:00

Embedding ECLS in a 3D Engine - G3D - proved remarkably easy. The question is - now what. What should live on the Lisp side and what should live on the C++ side? Geometry for C++? AI for Lisp..what about collisions, then? Hmm..

Using Google for Context Sensitive Help in Emacs

2008-07-16T16:34:00.010+01:00

Here's a hack that combines three of the most useful things in the known Universe: Google, Emacs and Firefox. Emacs 22.x has a standard method for invoking a browser: the browse URL function. To customise it use:


M-x customize-group browse-url

We are interested in the settings: Browse Url Browser Function which should be set to

browse-url-firefox

Then there is Browse Url Firefox Program which should be set to the full path of wherever firefox lives on your machine, and Browse Url Firefox New Window Is Tab which should be on to prevent multiple firefoxen cluttering up your windows when you try this.

Now that you have customized everything, you drop a crafted function into your .emacs and bind it to a key:


;; -- INTEGRATED HELP
(require 'url)
(defun search-site-url (site url keyword)
(concat "http://www.google.com/"
    (format "search?q=%s+site:%s+inurl:%s&btnI"  
        (url-hexify-string keyword)  
        (url-hexify-string site)  
        (url-hexify-string url))))

(defun wxhelp ()
"Open a window showing the wxWidgets documentation for the word under the point"
(interactive)
(browse-url (search-site-url  "docs.wxwidgets.org" "2\\\\.8\\\\.6" 
               (thing-at-point 'symbol))))

(global-set-key "\C-h\C-w" 'wxhelp)

Now, if you type Control H Control W while the cursor is over a symbol, Emacs will look it up via Google. For instance, if your cursor is over wxApp, by the magic of "I'm feeling Lucky", Google will find http://docs.wxwidgets.org/2.8.6/wx_wxapp.html which is the manual page for wxApp

Obviously the interesting function here is

site-search-url

which munges up an URL to feed to google to make it search a specific site for a keyword, filtering URLs that do not contain a certian string. The highly escaped \\\\ is to ensure that 2\.8\.6 appears in the final URL so that Google treats . as a literal.

The great utility of this hack is its universiality. It will work for any language or library with a sanely organised reference web site. Language specific lookup functions based on sites like cppreference.com are left as an exercise for the reader...

Emacs Selectors

2008-03-14T06:25:00.003Z

One of the nicer things that comes with slime is the slime-selector: it's just a little buffer switching thing, that lets you press r to switch to the repl buffer, d to switch to the debugger buffer, s to switch to the scratch buffer and so forth. Bound to a function key, it's an extraordinarily convenient way of switching to a specific buffer.

Of course, it's geared to SLIME and Lisp, but when coding C++ on the day job I often find myself switching between code, the debugger, shell and compilation buffer, so without further ado, here is the C equivalent, which is easily hacked up to include other buffers, too: actually, I'm beginning to think something like this functionality should be in emacs by default, as it eliminates a lot of keyboard gymnastics.


;; slime selector clone for c  ----------------------------------

(defvar c-selector-methods nil)

(defun c-selector ()
  (interactive)
  (message "Select [%s]: "
           (apply #'string (mapcar #'car c-selector-methods)))
  (let* ((ch (save-window-excursion
               (select-window (minibuffer-window))
                              (read-char)))
         (method (find ch c-selector-methods :key #'car)))
    (cond ((null method)
           (message (format "No method for charachter: %s" ch))
           (ding)
           (sleep-for 1)
           (discard-input)
           (c-selector))
          (t 
           (funcall (third method))))))
          
         
(defmacro def-c-selector-method (key description &rest body)
  `(setq c-selector-methods
         (sort* (cons (list ,key ,description
                            (lambda () 
                              (let ((buffer (progn ,@body)))
                                (cond ((get-buffer buffer)
                                       (switch-to-buffer buffer))
                                      (t
                                       (message  "No such buffer")
                                       (ding))))))
                      (remove* ,key c-selector-methods :key #'car))
                #'< :key #'car)))
  
(def-c-selector-method ?d "GDB debugger buffer"
  gud-comint-buffer)

(def-c-selector-method ?g "Grep buffer"
  grep-last-buffer)

(def-c-selector-method ?l "Buffer List"
  (let ((result (get-buffer "*buffer-selection*")))
    (if result
        result
      ((bs-show)
       (get-buffer "*buffer-selection*")))))

(def-c-selector-method ?c "Compilation buffer"
  (let ((result (get-buffer "*compilation*")))
    (if result
        result
      (compilation-find-buffer))))

(def-c-selector-method ?s "Shell buffer"
  (get-buffer "*shell*"))

ASDF for the slightly confused

2008-02-22T17:36:00.006Z

Well, you have a shiny new lisp compiler/interpreter/environment on your machine, and like an eager and smart newbie you want to do something with it. Right there and then many lisp newbies go SPLAT and end up as a bug on a windscreen, later to be scraped off and fed to Guido's pet snake. So here is ASDF for confused newbies (a very different proposition from a dummy, who should go back to reading bright yellow paperbacks and programming Java in the enterprise shop window).

ASDF is about 500 lines of lisp source, and a dot asd file is the lisp equivalent of the ubqutious make; you can't do anything in a serious modern lisp environment without it, so lets take you through it step by step. An asd file describes a system that contains modules and components. Components are usually individual files. Modules are collections of files, usually in subdirectories. Let's look at an example dot asd file: this one is for cowl - a simple opengl gui written by William Robinson who is working on Cityscape, a promising
game found at this address.


(defsystem #:cowl-ftgl
 :depends-on (#:cffi)
 :description "FTGL Common Lisp wrapper for Cowl."
 :components ((:module "src"
              :components 
             ((:file "cowl-ftgl")))))

The defsystem form then defines a system with one component which is a module called src which in turn contains one component in a file called cowl-ftgl, which will be a lisp file, naturally: since it's in a module called src, it will be loaded in the src directory below the directory that holds the dot asd file. Sometimes it is necessary to wrap the defsystem form in it's own package using defpackage and a throwaway package name. We do not do that here because we do not define any symbols that we would need to refer to externally, but we would need to if we were defining new component classes or methods to be used in the system, examples of which will follow later in the article.

Components, modules and systems are defined as CLOS objects in asdf.lisp, so of course they can be operated upon with generic functions, and there are quite a few that come with asdf. The key one is named with Arc-like gnomicness: "oos" - which I imagine is short for "Operate on System". It takes at least two parameters: the operation to perform and the system to perform it on.

The operation you are most likely to perfom is load-op: this loads and compiles a system, and the form is simply:

(asdf:oos 'asdf:load-op 'system-name)

Other operations are compile-op, and test-op: the latter will only have meaning if the author of your system has provided tests, as some packages do.

ASDF will search for systems using the list of functions referred to by *system-definition-search-functions* used to search for .asd files in the filesystem. By default this contains only one function, (sysdef-central-registry-search) which is perfectly adequate for file systems with symbolic links. The modus operandi on such system is to have a share/common-lisp/systems directory populated with symbolic links to dot asd files which may be downloaded and untarred in any part of the fs tree to which the user has access. Then the (sysdef-central-registry-search) scans the list of directories referred to by *central-registry* for dot asd files containing the system which it needs to operate on.

To put it another way, procedurally this translates to:

Download your asdf package

Unzip - say to ~/thinngy/cl-blab

Note that ~/thinngy/cl-blab/cl-blab.asd is the system.

Create a ~/share/common-lisp/systems directory for systems
```
cd ~/share/common-lisp/system
```

ln -s ~/thinggy/cl-blab/cl-blab.asd cl-blab.asd

now fire up your lisp and enter..


;; for systems that don't do (require 'asdf)
(load #"/path/to/asdf.lisp")

;; the / on the end of the path is important, don't forget it
(push #"/home/me/share/common-lisp/systems/" asdf:*central-registry*)

(asdf:oos 'asdf:load-op 'cl-blab)

For Windows the situation is sligtly more complicated: either you write your own search function *or*, more practically apply a patch that lets you use shortcuts in place of symlinks.

You'd be right to point out that this is on the laborious side, but the purpose of this article is to demonstrate how asdf *works*. There are two packages for automating lisp package and asdf system installation: asdf-install and clbuild, which I encourage newbies to investigate, in the usual sadistic exercise for the reader.

Why go through all this palaver with asdf? Well the beauty of asdf is that systems, components and modules are in fact CLOS objects, so we can do tricks like this:


(cffi:load-foreign-library 
 (make-pathname 
  :name "cftgl" 
  :type "so" 
  :directory (directory-namestring (asdf:component-pathname 
                                    (asdf:find-system :cowl-ftgl)))))

..which loads "clftgl.so" which is found in the same directory as the dot asd file containing the system definition. Highly useful when distributing a C shared lib that wraps a C++ library so that it can be called into from Lisp.

The fact that source files are component, lets us write specialist methods for different kinds of source file such as c-source-file, java-source-file, html-file (all defined in asdf.lisp) allows asdf to work as a make replacement, operating on non-lisp source, thus:


(defmethod output-files ((op compile-op) (c c-source-file))
    (list (make-pathname :type "o" :defaults
                                                 (component-pathname c))))

(defmethod perform ((op compile-op) (c c-source-file))
    (unless
       (= 0 (run-shell-command "/usr/bin/gcc -fPIC -o ~S -c ~S"
                               (unix-name (car (output-files op c)))
                               (unix-name (component-pathname c))))
     (error 'operation-error :operation op :component c)))

(defmethod perform ((operation load-op) (c c-source-file))
    t)

There is an extended example of this kind of thing where asdf is extended to work with a fortran to lisp converter here.

To conclude: like many things in Lisp, asdf is prickly for newbies and takes time to get to know and use well. However, when you do you can do things with it for which you'd normally need another build system, independent of your language. As Brucio would observe: Lisp does not have this limitation and Common Lispers laugh at things like ant.

Hippie Expand and Autocompletion in Emacs

2007-12-28T14:47:00.003Z

The Emacs way of doing auto - completion is known as Hippie Expand which is a function that uses a variety of methods to try and expand an incomplete word near the point. Why it's called Hippie Expand I have no idea. The name is a bit misleading; for a long time I thought it was related to zippy or pinhead. Perhaps it's something to do with Emacs being used and written by hippies, who knows?

The nice thing about hippie expand is that like many things in Emacs, it can be customized and expanded, via the make-hippie-expand function. For instance, here is the hippie-expand function I use for c-mode


(make-hippie-expand-function
'(try-expand-dabbrev-visible
 try-expand-dabbrev-from-kill
 try-expand-dabbrev-all-buffers
 try-complete-file-name-partially
 try-complete-file-name)))))

This function first tries to expand the thing found at the point as a dynamic abbreviation, which is based on a scan of existing text for words or symbols with the same beginning as the one at the point. For instance, if "catalogue" is in the buffer, and you expand "cat", then "catalogue" will be one of the expansions offered, which is useful if "catalogue" is a variable name you use a lot.

The hippie expand function is bound to a key (I use M-/) and each press of that key will cycle through the possible completions for you. It's not Intellisense, but it does cut down on typing if you use descriptive variable names.

It's also fairly trivial to write your own hippie-expand function. Here is an example of a hippie expand function which does completion based on a list of current tags - which are sometimes more useful than dabbrevs.


;; This is a simple function to return the point at the beginning of the symbol to be completed
(defun he-tag-beg ()
(let ((p
      (save-excursion
        (backward-word 1)
        (point))))
 p))

;; The actual expansion function
(defun try-expand-tag (old)
;; old is true if we have already attempted an expansion
(unless  old
 ;; he-init-string is used to capture the string we are trying to complete
 (he-init-string (he-tag-beg) (point))
 ;; he-expand list is the list of possible expansions
 (setq he-expand-list (sort
                       (all-completions he-search-string 'tags-complete-tag) 'string-lessp)))
;; now we go through the list, looking for an expansion that isn't in the table of previously
;; tried expansions
(while (and he-expand-list
           (he-string-member (car he-expand-list) he-tried-table))
           (setq he-expand-list (cdr he-expand-list)))
;; if we didn't have any expansions left, reset the expansion list
(if (null he-expand-list)
   (progn
     (when old (he-reset-string))
     ())
 ;; otherwise offer the expansion at the head of the list
 (he-substitute-string (car he-expand-list))
 ;; and put that expansion into the tried expansions list
 (setq he-expand-list (cdr he-expand-list))
 t))
;; done, now we just use it as a clause in our make-hippie-expand-function (as above)

Hippie-expand isn't the only auto-completion gizmo I work with in Emacs; there is also slime-complete-symbol which does symbol completion for my while I am working in SLIME. This can be neatly integrated into hippie-expand, like so..


;; hippie expand slime symbol
(defun he-slime-symbol-beg ()
(let ((p
      (slime-symbol-start-pos)))
 p))

(defun try-expand-slime-symbol (old)
(unless  old
 (he-init-string (he-slime-symbol-beg) (point))
 (setq he-expand-list (sort
                       (car (slime-contextual-completions (slime-symbol-start-pos) (slime-symbol-end-pos))) 'string-lessp)))
(while (and he-expand-list
           (he-string-member (car he-expand-list) he-tried-table))
           (setq he-expand-list (cdr he-expand-list)))
(if (null he-expand-list)
   (progn
     (when old (he-reset-string))
     ())
 (he-substitute-string (car he-expand-list))
 (setq he-expand-list (cdr he-expand-list))
 t))

EDIT: With newer (CVS and 3.0) versions of SLIME the api for symbol completion
has changed and the hippie-expand function for slime symbol completion is..


;; hippie expand slime symbol
(defun he-slime-symbol-beg ()
(let ((p
      (slime-symbol-start-pos)))
 p))

(defun try-expand-slime-symbol (old)
(unless  old
 (he-init-string (he-slime-symbol-beg) (point))
 (setq he-expand-list (sort
                       (car (slime-simple-completions
                             (buffer-substring-no-properties (slime-symbol-start-pos) (slime-symbol-end-pos))))
                       'string-lessp)))
(while (and he-expand-list
           (he-string-member (car he-expand-list) he-tried-table))
           (setq he-expand-list (cdr he-expand-list)))
(if (null he-expand-list)
   (progn
     (when old (he-reset-string))
     ())
 (he-substitute-string (car he-expand-list))
 (setq he-expand-list (cdr he-expand-list))
 t))

Final Results of Informal Programming Language Comparison.

2007-12-20T17:04:00.000Z

A recent post on programming.reddit.com about profanity in comments was highly amusing if you are childish enough to be amused by such things - I am, anyway - set me to thinking about the Google Code search thing and whether it could be used in any profitable way to compare programming languages. I quicky hit upon the hypothesis that programmers content with their language would be more likely to type comments along the lines of "this rocks" and ones more disaffected might type comments along the lines of "this sucks".

Hence, all that was required was to write a bit of code to tabutlate the search results by language and a clear winner would emerge. It did, and it wasn't the one I was expecting.

My final choice of metric was the ratio of incidence of the word "sucks" and the word "rocks" scaled by the frequency of a netural control word such as "okay" (and even so, poor old FORTH did not get a lookin as it got zero hits on any of these). I call this the suckage to rockage ration and henceforth regard it as the gold standard of programming metrics. Without further ado, here are the charts and the code.

Controversy is roughly the distance between suckage and rockage - high if the language arouses strong feelings, low if it's boring, staple stuff.

C!? I really didn't expect this. It might be due to the inability of the search to separate out C and C++. It's almost certianly due to a low suckage rather than a high rockage.

The code, which is Public Domain, if anyone is inclined to tinker.


(asdf:oos 'asdf:load-op 'drakma)
(asdf:oos 'asdf:load-op 's-xml)
(asdf:oos 'asdf:load-op 'clot)

(defpackage :code-index (:use :cl :clot :drakma :s-xml))

(in-package :code-index)

(defun code-search (regexp &key language license file package (output-type :sxml))
  (let ((url (concatenate 'string
                    "http://google.com/codesearch/feeds/search?q=" 
                    (when language (concatenate 'string  "lang:" language "+"))
                    (when license (concatenate 'string "license:" license "+"))
                    (when file (concatenate 'string "file:" file "+"))
                    (when package (concatenate 'string "package:" package "+"))
                    regexp)))
  (multiple-value-bind (body-or-stream status-code headers uri stream must-close reason-phrase)       
      (drakma::http-request url
        :force-binary t)
    (declare (ignore headers must-close stream reason-phrase))
    (format t "Request for ~A~%" uri)
    (format t "Status code ~A~%" status-code)
    (parse-xml-string (flexi-streams:octets-to-string  body-or-stream :external-format (flexi-streams:make-external-format :utf-8)) ))))

;; google returns a malformed string every time - wallies!
;;(code-search "sucks" :language "pascal")

(defun code-search-hit-count (results)
  (parse-integer (cadr (nth 5 results))))

(defun calculate-index-for-language (lang)
  (format t "~&For Langauge : ~A~&" lang)  
  (let* ((control-index 
         (code-search-hit-count (code-search "okay" :language lang)))
        (suckage-index 
         (/ (code-search-hit-count (code-search "sucks" :language lang))
            control-index))
        (rockage-index  
         (/  (code-search-hit-count (code-search "rocks" :language lang)) 
             control-index)))
     (format t "Suckage index ~D~&" suckage-index)
     (format t "Rockage index ~D~&" rockage-index)
     (format t "Controversy index ~F~&" (sqrt (+ (* rockage-index rockage-index) (* suckage-index suckage-index))))
;;     ;; admittedly it's a bust if no one ever says that language Y sucks, but how probable is that ;-)
;;    ;; but forth managed it...
     (format t "Suckage/Rockage ratio ~D~&" (/ rockage-index suckage-index))
    (list control-index suckage-index rockage-index 
                   (sqrt (+ (* rockage-index rockage-index) (* suckage-index suckage-index)))
                   (/ rockage-index suckage-index))))


(defun compare-languages ()
  (let* ((language-list '("c"  "ruby" "perl" "pascal"  "erlang" "javascript" "java" "smalltalk" "python" "lisp" "haskell" "ocaml"))
         (language-results  (mapcar #'calculate-index-for-language language-list))
         (control-list (append (list "Frequency" "brown") (mapcar #'(lambda (x) (nth 0 x)) language-results)))
         (suckage-list (append  (list "Suckage" "red") (mapcar #'(lambda (x) (nth 1 x)) language-results)))
         (rockage-list (append  (list "Rockage" "green") (mapcar #'(lambda (x) (nth 2 x)) language-results)))
         (controversy-list (append (list "Controversy" "blue") (mapcar #'(lambda (x) (nth 3 x)) language-results)))
         (suckage/rockage-list (append (list "Rockage to Suckage ratio" "yellow") (mapcar #'(lambda (x) (nth 4 x)) language-results))))
      (cl-gd:with-image* (640 480)
        (fill-image 0 0 :color "white")
        (plot-bar-chart (list suckage-list rockage-list controversy-list) :x-axis-labels language-list :bar-width .8 :vgrid t)
        (cl-gd:write-image-to-file
         (make-pathname :defaults clot-system:*base-directory* :name "languages" :type "png") :if-exists :supersede))
      (cl-gd:with-image* (640 480)
        (fill-image 0 0 :color "white")
        (plot-bar-chart (list suckage/rockage-list) :x-axis-labels language-list :bar-width .8 :vgrid t)
        (cl-gd:write-image-to-file
         (make-pathname :defaults clot-system:*base-directory* :name "suckage-to-rockage" :type "png") :if-exists :supersede))))

Programming Language Comparison

2007-12-20T16:33:00.001Z

First cut.

Devhelp Inform Designers Manual

2007-11-27T21:26:00.000Z

Another devhelp file courtesy of pyhtmlhelp. This time it's the Inform Designers manual.. Yes, I'm writing interactive fiction, again..

Change-class extensibility

2007-10-14T08:53:00.000+01:00

I made an interesting minor discovery today: change-class is extensible in much the way
initialize-instance is...


CL-USER> (defclass test-class () ((a-slot :initarg :a-slot-value :initform 0)))
#
CL-USER> (defclass derived-class (test-class) ())
#
CL-USER> (defmethod update-instance-for-different-class :after ((old test-class) (new derived-class) &key fixup-information)
           (format t "~A " fixup-information))
#                                                              DERIVED-CLASS) {A97F421}>
CL-USER> (make-instance 'test-class :a-slot-value 27)
#
CL-USER> (defparameter *test-instance* (make-instance 'test-class :a-slot-value 27))
*TEST-INSTANCE*
CL-USER> (change-class *test-instance* 'derived-class :fixup-information "Hello World")
Hello World 
#
CL-USER>

I'm not sure I actually want to use this, but it's nice to know it's there..

Automating Visual Studio

2007-08-29T12:01:00.000+01:00

Visual Studio is both a curse and a boon. A boon because it is a very good IDE for debugging. A curse because it's restricted to a single platform and tends to lock out third-party editors, such as Emacs, jEdit, SlickEdit, or whatever it is you use.

Most decent editors expect to be able to compile a file via a shell command, capture that commands output, and then scan the output for errors, enabling you to jump to the exact locaton. This can be via make, scons, and the regexp can be modified for different compilers.

However the 'Export Makefile' command dissapeared from Visual Studio with version six. The functionality to compile individual files from the command line has gone, leaving the non-Microsoft editor user with a dilemma. Whether to change their editing habits for the sake of a peaceful life with the GUI, or forsake the ability to compile individual files - whole projects can still be built via the DevEnv command.

However there is a nice Python hack that lets you get at the compiling functionality. You need to use the Python Win32 COM extensions to access Visual Stduio automation from Python. Micheal Graz created this script and tightly integrated it with Vim. I've taken out the vim-specific parts, and added only one Emacs specific part (in dte_get_file) to invoke Emacs when "getting" the current file from Visual Studio. The compilation output now goes to the command line rather than a vim quickfix buffer, so it should be possible to adapt this to your needs.


import os, sys, re, time, pywintypes, win32com.client

vsWindowKindTaskList     = '{4A9B7E51-AA16-11D0-A8C5-00A0C921A4D2}'
vsWindowKindFindResults1 = '{0F887920-C2B6-11D2-9375-0080C747D9A0}'
vsWindowKindFindResults2 = '{0F887921-C2B6-11D2-9375-0080C747D9A0}'
vsWindowKindOutput       = '{34E76E81-EE4A-11D0-AE2E-00A0C90FFFC3}'

vsBuildStateNotStarted = 1   # Build has not yet been started.
vsBuildStateInProgress = 2   # Build is currently in progress.
vsBuildStateDone = 3         # Build has been completed

#----------------------------------------------------------------------

def dte_compile_file ():
    dte = _get_dte()
    if not dte: return
    try:
        dte.ExecuteCommand ('Build.Compile')
    except Exception, e:
        _dte_exception (e)
        return
    # ExecuteCommand is not synchronous so we have to wait
    while dte.Solution.SolutionBuild.BuildState == vsBuildStateInProgress:
        time.sleep (0.1)
    dte_output ('output')
    _status_msg ('Compile file complete')

#----------------------------------------------------------------------

def dte_build_solution():
    dte = _get_dte()
    if not dte: return
    if dte.CSharpProjects.Count:
        dte.Documents.CloseAll()
    _dte_raise ()
    _dte_output_activate ()
    try:
        dte.Solution.SolutionBuild.Build (1)
        # Build is not synchronous so we have to wait
        while dte.Solution.SolutionBuild.BuildState != vsBuildStateDone:
            time.sleep (0.25)
    except Exception, e:
        _dte_exception (e)
        return
    dte_output ('output')
    _status_msg ('Build solution complete')


#----------------------------------------------------------------------

def dte_output (window_kind):
    if window_kind == 'find_results_1':
        window_name = 'Find Results 1'
        window_id = vsWindowKindFindResults1
    elif window_kind == 'find_results_2':
        window_name = 'Find Results 2'
        window_id = vsWindowKindFindResults2
    elif window_kind == 'output':
        window_name = 'Output'
        window_id = vsWindowKindOutput
    else:
        _msg ('Error: unrecognized window (%s)' % window_kind)
        return
    dte = _get_dte()
    if not dte: 
        print ">> Failed to get dte."
        return
    if window_id == vsWindowKindOutput:
        owp = dte.Windows.Item(window_id).Object.OutputWindowPanes.Item('Build')
        sel = owp.TextDocument.Selection
    else:
        sel = dte.Windows.Item(window_id).Selection
    sel.SelectAll()
    _status_msg ('VS %s' % window_name)
    print sel.Text
    sel.Collapse()


#----------------------------------------------------------------------

def dte_get_file ():
    dte = _get_dte()
    if not dte: return
    doc = dte.ActiveDocument
    if not doc:
        _status_msg ('No VS file!')
        return
    pt = doc.Selection.ActivePoint
    file = os.path.join (doc.Path, doc.Name)
    os.system("emacsclientw -n +%d:%d %s " % (pt.Line, pt.DisplayColumn, file))

#----------------------------------------------------------------------

def dte_put_file (filename, line_num, col_num):
    if not filename:
        return
    dte = _get_dte()
    if not dte: return
    io = dte.ItemOperations
    rc = io.OpenFile (os.path.abspath (filename))
    sel = dte.ActiveDocument.Selection
    sel.MoveToLineAndOffset (line_num, col_num)
    _dte_raise ()

#----------------------------------------------------------------------

def _get_dte ():
    try:
        return win32com.client.GetActiveObject ('VisualStudio.DTE')
    except pywintypes.com_error:
        _msg ('Cannot access VisualStudio. Not running?')
    return None

#----------------------------------------------------------------------

_wsh = None
def _get_wsh ():
    global _wsh
    if not _wsh:
        try:
            _wsh = win32com.client.Dispatch ('WScript.Shell')
        except pywintypes.com_error:
            _msg ('Cannot access WScript.Shell')
    return _wsh

#----------------------------------------------------------------------


#----------------------------------------------------------------------

def _dte_raise ():
    dte = _get_dte()
    if not dte: return
    try:
        dte.MainWindow.Activate ()
        _get_wsh().AppActivate (dte.MainWindow.Caption)
    except:
        pass

#----------------------------------------------------------------------

def _dte_output_activate ():
    dte = _get_dte()
    if not dte: return
    dte.Windows.Item(vsWindowKindOutput).Activate()

#----------------------------------------------------------------------

def _dte_set_autoload ():
    dte = _get_dte()
    if not dte: return
    p = dte.Properties ('Environment', 'Documents')
    p.Item('DetectFileChangesOutsideIDE').Value = 1
    p.Item('AutoloadExternalChanges').Value = 1


#----------------------------------------------------------------------

def _dte_exception (e):
    if isinstance (e, pywintypes.com_error):
        try:
            msg = e[2][2]
        except:
            msg = None
    else:
        msg = e
    if not msg:
        msg = 'Encountered unknown exception'
    _status_msg ('ERROR %s' % msg)

#----------------------------------------------------------------------

def _status_msg (msg):
    try:
        caption = _get_dte().MainWindow.Caption.split()[0]
    except:
        caption = None
    if caption:
        msg = msg + ' (' + caption + ')'
    _msg (msg)

#----------------------------------------------------------------------

def _msg (msg):
    print ">> " + msg


#----------------------------------------------------------------------
# eg vsgo.py dte_compile_file
#    vsgo.py dte_put_file GridToolPanelComponent.cpp 10 5
#    vsgo.py dte_get_file
#    vsgo.py dte_build_solution

def main ():
    prog = os.path.basename(sys.argv[0])
    if len(sys.argv) == 1:
        print 'echo "ERROR: not enough args to %s"' % prog
        return

    fcn_name = sys.argv[1]
    if not globals().has_key(fcn_name):
        print 'echo "ERROR: no such fcn %s in %s"' % (fcn_name, prog)
        return

    fcn = globals()[fcn_name]
    try:
        apply(fcn, sys.argv[2:])

    except TypeError, e:
        print 'echo "ERROR in %s: %s"' % (prog, str(e))
        return

if __name__ == '__main__': main()

Lisp Array Setter Syntax

2007-06-12T09:49:00.000+01:00

Not the most inituituve in the world


(defmethod (setf setter-name) (value (self  class-type) x y z)
  (setf (row-major-aref (array-of self) (* x ... blah... ))))


(setf (setter-name self) x-index y-index z-index value)

The thing to remember is that the value always comes first.

wxWidgets Documentation in Devhelp format

2007-06-09T14:06:00.001+01:00

This post is what it says on the tin. I converted the wxWidgets help from htb to devhelp using this handy help converter. Here is the result. It needs to live somewhere where devhelp can find it: usually /usr/share/devhelp/books or ~/.devhelp/books, although the latter did not work for me

Why did I want devhelp and not HTB. Partly because devhelp integrates much more nicely with Gnome, but also because it made it trivial to get context - sensitive help out of Emacs with this little gem:


(defun devhelp-word-at-point ()
  "runs devhelp"
  (interactive)
  (setq w (current-word))
  (start-process-shell-command "devhelp" nil "devhelp" "-s" w))

Save Slime And Die

2007-06-04T23:24:00.000+01:00

The best way to work with a Lisp is to leave it running all the time and hack on it bit by bit, building up your program bit by bit, doing mini-tests and off-the-cuff code as you go along and shaping it..

Except if you are like me, you might be working on a laptop with a limited battery life and have a strict time limit to your lisp hacking. It's bothered me that when working with SLIME the only way to save a core was to start a lisp in a terminal, load up your systems and your files, then dump and use that with C-u M-x slime, which lets you enter a command line to start your lisp.

It annoys me because if you are like me, your code doesn't necessarily capture the actual state of your core: it also contains half a dozen test variables and functions that you entered in the repl and are useful to have hang around. So I tried to find a way to dump and restore core from within slime. I came up with the following function


(defun save-slime-and-die (core-file-name)
           ;; close all 
  (mapcar #'(lambda (x) (swank::close-connection x)) swank::*connections*)
  #+sb-thread
  (dolist (thread (remove (swank::current-thread) (swank::all-threads)))
    (swank::kill-thread thread))
  (sleep 1)
  (save-lisp-and-die core-file-name))

It's obviously for sbcl, and the gotcha is that it has to be executed in the *inferior-lisp* buffer, but it works..C-u M-x sbcl --core test.core brings back core dumped with (save-slime-and-die #P"test.core")

CPP Evil

2007-05-03T23:47:00.002+01:00

Possibly the most incomprehensible line of code I have ever written.


#define ALLOCATE_ENGINE_OBJECT(type) reinterpret_cast<Engine##type##Object*>(\
      world.allocate<Engine##type##Object>()->init_object(\
         type##Pool.allocate<Engine##type##Data>()))

Unrealscript mode for Emacs

2007-03-04T18:33:00.001Z

Edit: I've since abandoned this mode and moved to a simpler (but less buggy) version not based on cc-mode that lives here


;;; unrealscript-mode.el --- unrealscript mode derived from cc-mode

;; Author:     2007 John Connors
;; Maintainer: John Connors <johnc at yagc dot co dot uk>
;; Created:    March 2007
;; Version:    See cc-mode.el
;; Keywords:   unrealscript cc-mode languages oop

;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2 of the License, or
;; (at your option) any later version.
;; 
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;; 
;; You should have received a copy of the GNU General Public License
;; along with this program; see the file COPYING.  If not, write to
;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.

;;; Commentary:


;; Note: The interface used in this file requires CC Mode 5.30 or
;; later.

;;; Code:

(require 'cc-mode)

;; These are only required at compile time to get the sources for the
;; language constants.  (The cc-fonts require and the font-lock
;; related constants could additionally be put inside an
;; (eval-after-load "font-lock" ...) but then some trickery is
;; necessary to get them compiled.)
(eval-when-compile
  (require 'cc-langs)
  (require 'cc-fonts))

(eval-and-compile
  ;; Make our mode known to the language constant system.  Use Java
  ;; mode as the fallback for the constants we don't change here.
  ;; This needs to be done also at compile time since the language
  ;; constants are evaluated then.
  (c-add-language 'unrealscript-mode 'java-mode))

;; unrealscript has no boolean but a string and a vector type.
(c-lang-defconst c-primitive-type-kwds
  unrealscript 
  (append 
   '("bool" "name" "object" "actor" "string" "vector")
   (delete "boolean"
           ;; Use append to not be destructive on the
           ;; return value below.
           (append
            ;; Due to the fallback to Java, we need not give
            ;; a language to `c-lang-const'.
            (c-lang-const c-primitive-type-kwds)
            nil))))

(c-lang-defconst c-type-modifier-keywds
   unrealscript
    (append 
      '("config" "deprecated" "edfindable" "editconstarray" 
        "editinline" "export" "noexport" "globalconfig" 
        "localized" "const" "editconst" "input" "travel" 
        "skip" "export") 
      (c-lang-const c-type-modifier-keywds) 
      nil))


;;   "Keywords introducing extra declaration specifiers in the region
;; between the header and the body \(i.e. the \"K&R-region\") in
;; declarations."

(c-lang-defconst c-postfix-decl-spec-kwds
  unrealscript
  (append
   '("abstract" "native" "nativereplication" "nousercreate" "within" 
     "perobjectconfig" "transient" "noexport" "dependson" "exportstructs" 
     "cacheexempt" "hidedropdown" "parseconfig" "dontcollapsecategories"
     "collapsecategories" "hidecategories" "showcategories" "placeable"
     "notplaceable" "instanced")
   (c-lang-const c-postfix-decl-spec-kwds)
   nil))

;;   "Keywords that may be followed by a comma separated list of type
;; identifiers, where each optionally can be prefixed by keywords.  (Can
;; also be used for the special case when the list can contain only one
;; element.)"
(c-lang-defconst c-type-list-kwds
  unrealscript
  (cons "within"
        (c-lang-const c-type-list-kwds)))

;; Function declarations begin with "function" in this language.
;; There's currently no special keyword list for that in CC Mode, but
;; treating it as a modifier works fairly well.
(c-lang-defconst c-modifier-kwds
 unrealscript 
  (cons
    "function" 
   (c-lang-const c-modifier-kwds)))


(c-lang-defconst c-block-decls-with-vars
  unrealscript
  (cons 
   "state" 
        (c-lang-const c-other-block-decl-kwds)))

;; "Keywords that may be followed by a parenthesis expression that doesn't
;; contain type identifiers."
(c-lang-defconst c-paren-nontype-kwds
  unrealscript
  (append 
   '("state" "var")
   (c-lang-const c-paren-nontype-kwds)
   nil))


;;   "Keywords that may be followed by a parenthesis expression containing
;; type identifiers separated by arbitrary tokens."
(c-lang-defconst c-paren-type-kwds
  unrealscript
  (append
   '("config" "dependson")
   (c-lang-const c-paren-type-kwds)))

;; ;; No cpp in this language, but there's still a "#exec" directive to
;; ;; fontify.  (The definitions for the extra keywords above are enough
;; ;; to incorporate them into the fontification regexps for types and
;; ;; keywords, so no additional font-lock patterns are required.)
;; (c-lang-defconst c-cpp-matchers
;;   unrealscript 
;;       ;; Use the eval form for `font-lock-keywords' to be able to use
;;       ;; the `c-preprocessor-face-name' variable that maps to a
;;       ;; suitable face depending on the (X)Emacs version.
;;       '(eval . (list "^\\s *\\(#exec\\)\\>\\(.*\\)"
;;           (list 1 c-preprocessor-face-name)
;;           '(2 font-lock-string-face))))

(defcustom unrealscript-font-lock-extra-types nil
  "*List of extra types (aside from the type keywords) to recognize in Unrealscript mode.
Each list item should be a regexp matching a single identifier.")

(defconst unrealscript-font-lock-keywords-1 
  (c-lang-const c-matchers-1 unrealscript)
  "Minimal highlighting for UNREALSCRIPT mode.")

(defconst unrealscript-font-lock-keywords-2 
  (c-lang-const c-matchers-2 unrealscript)
  "Fast normal highlighting for UNREALSCRIPT mode.")

(defconst unrealscript-font-lock-keywords-3 
  (c-lang-const c-matchers-3 unrealscript)
  "Accurate normal highlighting for UNREALSCRIPT mode.")

(defvar unrealscript-font-lock-keywords unrealscript-font-lock-keywords-3
  "Default expressions to highlight in UNREALSCRIPT mode.")

(defvar unrealscript-mode-syntax-table nil
  "Syntax table used in unrealscript-mode buffers.")
(or unrealscript-mode-syntax-table
    (setq unrealscript-mode-syntax-table
      (funcall (c-lang-const c-make-mode-syntax-table unrealscript))))

(defvar unrealscript-mode-abbrev-table nil
  "Abbreviation table used in unrealscript-mode buffers.")

(c-define-abbrev-table 'unrealscript-mode-abbrev-table
  ;; Keywords that if they occur first on a line might alter the
  ;; syntactic context, and which therefore should trig reindentation
  ;; when they are completed.
  '(("else" "else" c-electric-continued-statement 0)
    ("while" "while" c-electric-continued-statement 0)))

(defvar unrealscript-mode-map (let ((map (c-make-inherited-keymap)))
              ;; Add bindings which are only useful for UNREALSCRIPT
              map)
  "Keymap used in unrealscript-mode buffers.")

(easy-menu-define unrealscript-menu unrealscript-mode-map "UNREALSCRIPT Mode Commands"
          ;; Can use `unrealscript' as the language for `c-mode-menu'
          ;; since its definition covers any language.  In
          ;; this case the language is used to adapt to the
          ;; nonexistence of a cpp pass and thus removing some
          ;; irrelevant menu alternatives.
          (cons "UNREALSCRIPT" (c-lang-const c-mode-menu unrealscript)))

;;;###Autoload
(add-to-list 'auto-mode-alist '("\\.uc\\'" . unrealscript-mode))

;;;###autoload
(defun unrealscript-mode ()
  "Major mode for editing UNREALSCRIPT UnrealScript is a
Java-like object-orientated programming (OOP) language created by
Epic Games for programming in-game content for the UnrealEngine.
 
The hook `c-mode-common-hook' is run with no args at mode
initialization, then `unrealscript-mode-hook'.

Key bindings:
\\{unrealscript-mode-map}"
  (interactive)
  (kill-all-local-variables)
  (c-initialize-cc-mode t)
  (set-syntax-table unrealscript-mode-syntax-table)
  (setq major-mode 'unrealscript-mode
    mode-name "UnrealScript"
    local-abbrev-table unrealscript-mode-abbrev-table
    abbrev-mode t)
  (use-local-map c-mode-map)
  ;; `c-init-language-vars' is a macro that is expanded at compile
  ;; time to a large `setq' with all the language variables and their
  ;; customized values for our language.
  (c-init-language-vars unrealscript-mode)
  ;; `c-common-init' initializes most of the components of a CC Mode
  ;; buffer, including setup of the mode menu, font-lock, etc.
  ;; There's also a lower level routine `c-basic-common-init' that
  ;; only makes the necessary initialization to get the syntactic
  ;; analysis and similar things working.
  (c-common-init 'unrealscript-mode)
  (easy-menu-add unrealscript-menu)
  (run-hooks 'c-mode-common-hook)
  (run-hooks 'unrealscript-mode-hook)
  (setq font-lock-keywords-case-fold-search t)
  (c-update-modeline))


(provide 'unrealscript-mode)

Isometric Projection Matrix

2007-03-01T23:37:00.000Z

One thing that seems to get asked a lot is how to create an isometric style game using a 3d pipline and textured quads, instead of 2d sprite tiles. It is also a question that does not seem to get answered much, so I thought I would whip out a quick demonstration of how to do it with the Irrlicht Engine.

One thing to note is that this is not a textbook isometric projection which is a form of axonometric projection, but a fudge that makes the width and height of a cube in the viewport equal. This emulates tile based games nicely. Of course, with a "real" projection it might be possible to dynamically change the projection angle, which might be an interesting effect.



#include <irrlicht.h>

using namespace irr;

using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;



int main()
{

   
   IrrlichtDevice *device =
      createDevice( video::EDT_SOFTWARE2, dimension2d<s32>(640, 480), 16,
                    false, false, false, 0);
   
   device->setWindowCaption(L"Isometric Projection");
   
   IVideoDriver* driver = device->getVideoDriver();


   while(device->run())
   {
      /*
        Anything can be drawn between a beginScene() and an endScene()
        call. The beginScene clears the screen with a color and also
        the depth buffer if wanted. Then we let the Scene Manager and
        the GUI Environment draw their content. With the endScene()
        call everything is presented on the screen.
      */
      driver->beginScene(true, true, SColor(255,100,101,140));

      /**
       * we are not interested in this transform so let us set it to
       * identity
       */
      driver->setTransform(video::ETS_WORLD, core::matrix4());
      driver->setTransform(video::ETS_VIEW, core::matrix4());

      /**
       * first portion of transform - in matrix form
       * x' = (x - z)
       * y' = y + 0.5 * ( x + z )
       * this maps the z to the x and y axes in such a way that 
       * the result appears isometric. 
       */ 
      matrix4 projMatrix;
      projMatrix.makeIdentity();
      projMatrix.M[0] = 1.0f;
      projMatrix.M[8] = -1.0f;
      projMatrix.M[1] = 0.5f;
      projMatrix.M[5] = 1.0f;
      projMatrix.M[9] = 0.5f;
      projMatrix.M[10] = 0.0;

      /**
       * second portion of transform -- scale to fit clipping
       * volume. If the scale is 1.0f then the unit vectors fit the
       * clipping volume. The volume is a cuboid, centered in the origin.
       * The scaling will determine the size of this volume which will
       * contain the portion of the world that we can see.
       */
      f32 scale = 4.0f;
      matrix4 clipMatrix;
      clipMatrix.buildProjectionMatrixOrthoLH(2 * scale, 2 * scale ,-1 * scale, 2 * scale);
       

      /**
       * concatentate transform - we multiply transforms together in
       * the opposite order to that which we would apply them to a
       * vector because of the law of associativity applies to
       * matrices, but not commutivity and NM != MN fun,
       * eh..matrices..gotta luv em..
       */
      projMatrix = clipMatrix * projMatrix;
        
      /**
       * ok we now have our projection matrix
       */
      driver->setTransform(video::ETS_PROJECTION, projMatrix);

 
      /**
       * draw unit x, y, and z vectors in our new space
       */

      // x axis is red
      driver->draw3DLine(vector3df(-1.0, 0.0, 0.0),
                         vector3df(1.0, 0.0, 0.0),
                         SColor(255,255,0,0));

      // y axis is green
      driver->draw3DLine(vector3df(0.0, -1.0, 0.0),
                         vector3df(0.0, 1.0, 0.0),
                         SColor(255,0,255,0));

      // z axis is blue
      driver->draw3DLine(vector3df(0.0, 0.0, -1.0),
                         vector3df(0.0, 0.0, 1.0),
                         SColor(255,0,0,255));
           
      /**
       * done
       */
      driver->endScene();
   }

   device->drop();

   return 0;
}

New Year Coding Resolutions

2006-12-31T12:16:00.000Z

Finish cl-screen

Finish and post my x86 assembler in Common Lisp to CommonLisp.net

Write a new software renderer in Lisp

Finally get the hang of writing setf expanders

Write an animation testbed in Lisp

At least make a start at writing a game again.

Learn some Haskell

Get more famililar with partial differential equations, the nabala operator and the jacobian matrix

A Games/3d oriented lisp

2006-12-30T19:24:00.000Z

Thoughts about the desirable properties of a Lisp optimised for fast 3d games use.

Generational and/or incremental garbage collection.

Incremental means gc collection can be time-bounded; generational will be more effective in culling short lived, small objects, and give us cache wins. Allocation should be trivial as possible.

Native vector, matrix and quaternion types that map to SIMD

De riguer for fast 3d operations: an inline assembler build into the language, coupled with macro expansion would probably mean that these not be coded

Hashtables

Too useful for lots of things

Property lists

Ditto: perfect for game AI

Simple function call syntax

CL's function call syntax is relatively complicated and makes optimisation harder.

Fast single dimensional arrays

A neccesity.

Unhygenic macros

A big system can be build from a relatively small one via CL-style macro-expansion..

Readtable

Ideal for rolling gustom syntax. CL's readtable has too many characters reserved. We need to keep ours free

Optional compile-time type declarations

Enables an optimiser to do a better job, and keeps more unboxed values arond

Integrated shader compiler

Shaders are just too useful not to have: an embedded lisp style shader with macroexpansion facilities would help a great deal.

Sockets

Needed for multiplayer games, and editors that run alongside the game

Good FFI - to bind to c/c++ libraries

A lot of exisiting code is in C - eg OpenGL

Fast, streamable file I/O library

Streaming in new data as the game runs is very important for large worlds.

Heaps

We will need to allocate hunks of memory for talking to 'C' libraries and just because we can? Not sure about this one

Datatypes /library specifically for geometry - flexible mesh loading/compilation

We will need acres of geometry, as usual..

Datatypes / library specifically for texture and image processing

And acres of texture maps, etc applied to them

Datatypes / library for spatial structures: quadrees, bsp trees, octtrees, r-trees

Good Scene management requires these

Aggressive optimization: register colouring, scheduling, peephole..etc

Goes without saying

That will do for now..;-)

The birth of an assembler.

2006-12-09T14:45:00.000Z

The story so far..It's all surprisingly easy in Lisp...


; SLIME 2006-10-28
CL-USER> (asdf:oos 'asdf:load-op 'cl-x86-asm)
; loading system definition from /home/johnc/.sbcl/systems/cl-x86-asm.asd
; into #
; registering # as CL-X86-ASM
; compiling file "/home/johnc/projects/msc/x86instructions.lisp" (written 09 DEC 2006 03:29:02 PM):
; compiling (IN-PACKAGE :CL-X86-ASM)
; compiling (DEFPARAMETER *INSTRUCTION-TABLE* ...)
; compiling (DEFPARAMETER *INSTRUCTION-LOOKUP-TABLE* ...)
; compiling (DEFUN MAKE-INSTRUCTION-HASH-TABLE ...)
; compiling (DEFUN LOOKUP-INSTRUCTION ...)

; /home/johnc/projects/msc/x86instructions.fasl written
; compilation finished in 0:00:00
; compiling file "/home/johnc/projects/msc/x86-assembler.lisp" (written 09 DEC 2006 03:28:00 PM):
; compiling (IN-PACKAGE :CL-X86-ASM)
; compiling (DEFPARAMETER *CURRENT-BITS-SIZE* ...)
; compiling (DEFUN SWITCH-BITS ...)
; compiling (DEFUN SYMBOL-IS-IN-PACKAGE ...)
; compiling (DEFUN IS-OPERAND-TYPE-P ...)
; compiling (DEFUN FIND-CORRECT-DESCRIPTION ...)
; compiling (DEFUN EXTRACT-ENCODING-FROM-DESCRIPTION ...)
; compiling (DEFUN PROCESS-ENCODING ...)

; file: /home/johnc/projects/msc/x86-assembler.lisp
; in: DEFUN PROCESS-ENCODING
;     (DEFUN CL-X86-ASM::PROCESS-ENCODING
;          (CL-X86-ASM::INSTRUCTION CL-X86-ASM::OPERANDS
;           CL-X86-ASM::OPERAND-DESCRIPTION)
;     CL-X86-ASM::OPERAND-DESCRIPTION)
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL-X86-ASM::PROCESS-ENCODING
;                          (CL-X86-ASM::INSTRUCTION CL-X86-ASM::OPERANDS
;                           CL-X86-ASM::OPERAND-DESCRIPTION)
;                          (BLOCK CL-X86-ASM::PROCESS-ENCODING
;                            CL-X86-ASM::OPERAND-DESCRIPTION))
; 
; caught STYLE-WARNING:
;   The variable INSTRUCTION is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable OPERANDS is defined but never used.

; compiling (DEFUN ASSEMBLE-INSTRUCTION-OR-DIRECTIVE ...)
; compiling (DEFUN ASSEMBLE-FORM ...)
; compiling (DEFUN ASSEMBLE-FORMS ...)

; /home/johnc/projects/msc/x86-assembler.fasl written
; compilation finished in 0:00:00
WARNING:
   COMPILE-FILE warned while performing # on
   #.

; file: /home/johnc/projects/msc/x86-assembler.lisp
; in: DEFUN CL-X86-ASM::IS-OPERAND-TYPE-P
;     (ASSOC CL-X86-ASM::OPERAND-TYPE CL-X86-ASM::*OPERAND-TYPE-CHECKERS*)
; 
; caught WARNING:
;   undefined variable: CL-X86-ASM::*OPERAND-TYPE-CHECKERS*

; in: DEFUN CL-X86-ASM::ASSEMBLE-FORM
;     (FIRST LIST)
; ==>
;   (CAR LIST)
; 
; caught WARNING:
;   undefined variable: LIST

; 
; caught WARNING:
;   These variables are undefined:
;     CL-X86-ASM::*OPERAND-TYPE-CHECKERS* LIST
; 
; compilation unit finished
;   caught 3 WARNING conditions
;   caught 2 STYLE-WARNING conditions
NIL
CL-USER> (cl-x86-asm::make-instruction-hash-table)
Adding :XORPS to table - ((xmm1 xmm2/m128) (15 87 /r)) 
Adding :XORPD to table - ((xmm1 xmm2/m128) (102 15 87 /r)) 
Adding :XOR to table - ((EAX imm32) (o32 53 id)) 
Adding :XOR to table - ((AX imm16) (o16 53 iw)) 
Adding :XOR to table - ((AL imm8) (52 ib)) 
Adding :XOR to table - ((r/m32 imm8) (o32 131 /6 ib)) 
Adding :XOR to table - ((r/m16 imm8) (o16 131 /6 ib)) 
Adding :XOR to table - ((r/m32 imm32) (o32 129 /6 id)) 
Adding :XOR to table - ((r/m16 imm16) (o16 129 /6 iw)) 
Adding :XOR to table - ((r/m8 imm8) (128 /6 ib)) 
Adding :XOR to table - ((reg32 r/m32) (o32 51 /r)) 
Adding :XOR to table - ((reg16 r/m16) (o16 51 /r)) 
Adding :XOR to table - ((reg8 r/m8) (50 /r)) 
Adding :XOR to table - ((r/m32 reg32) (o32 49 /r)) 
Adding :XOR to table - ((r/m16 reg16) (o16 49 /r)) 
Adding :XOR to table - ((r/m8 reg8) (48 /r)) 
Adding :XLATB to table - (NIL (215)) 
Adding :XLAT to table - (NIL (215)) 
Adding :XCHG to table - ((reg32 EAX) (o32 144 +r)) 
Adding :XCHG to table - ((reg16 AX) (o16 144 +r)) 
Adding :XCHG to table - ((EAX reg32) (o32 144 +r)) 
Adding :XCHG to table - ((AX reg16) (o16 144 +r)) 
Adding :XCHG to table - ((r/m32 reg32) (o32 135 /r)) 
Adding :XCHG to table - ((r/m16 reg16) (o16 135 /r)) 
Adding :XCHG to table - ((r/m8 reg8) (134 /r)) 
Adding :XCHG to table - ((reg32 r/m32) (o32 135 /r)) 
Adding :XCHG to table - ((reg16 r/m8) (o16 135 /r)) 
Adding :XCHG to table - ((reg8 r/m8) (134 /r)) 
Adding :XBTS to table - ((reg32 r/m32) (o32 15 166 /r)) 
Adding :XBTS to table - ((reg16 r/m16) (o16 15 166 /r)) 
Adding :XADD to table - ((r/m32 reg32) (o32 15 193 /r)) 
Adding :XADD to table - ((r/m16 reg16) (o16 15 193 /r)) 
Adding :XADD to table - ((r/m8 reg8) (15 192 /r)) 
Adding :WRSHR to table - ((r/m32) (15 55 /0)) 
Adding :WRMSR to table - (NIL (15 48)) 
Adding :WBINVD to table - (NIL (15 9)) 
Adding :FWAIT to table - (NIL (155)) 
Adding :WAIT to table - (NIL (155)) 
Adding :VERW to table - ((r/m16) (15 0 /5)) 
Adding :VERR to table - ((r/m16) (15 0 /4)) 
Adding :UNPCKLPS to table - ((xmm1 xmm2/m128) (15 20 /r)) 
Adding :UNPCKLPD to table - ((xmm1 xmm2/m128) (102 15 20 /r)) 
Adding :UNPCKHPS to table - ((xmm1 xmm2/m128) (15 21 /r)) 
Adding :UNPCKHPD to table - ((xmm1 xmm2/m128) (102 15 21 /r)) 
Adding :UMOV to table - ((reg32 r/m32) (o32 15 19 /r)) 
Adding :UMOV to table - ((reg16 r/m16) (o16 15 19 /r)) 
Adding :UMOV to table - ((reg8 r/m8) (15 18 /r)) 
Adding :UMOV to table - ((r/m32 reg32) (o32 15 17 /r)) 
Adding :UMOV to table - ((r/m16 reg16) (o16 15 17 /r)) 
Adding :UMOV to table - ((r/m8 reg8) (15 16 /r)) 
Adding :UD2 to table - (NIL (15 11)) 
Adding :UD1 to table - (NIL (15 185)) 
Adding :UD0 to table - (NIL (15 255)) 
Adding :UCOMISS to table - ((xmm1 xmm2/m128) (15 46 /r)) 
Adding :UCOMISD to table - ((xmm1 xmm2/m128) (102 15 46 /r)) 
Adding :TEST to table - ((EAX imm32) (o32 169 id)) 
Adding :TEST to table - ((AX imm16) (o16 169 iw)) 
Adding :TEST to table - ((AL imm8) (168 ib)) 
Adding :TEST to table - ((r/m32 imm32) (o32 247 /0 id)) 
Adding :TEST to table - ((r/m16 imm16) (o16 247 /0 iw)) 
Adding :TEST to table - ((r/m8 imm8) (246 /0 ib)) 
Adding :TEST to table - ((r/m32 reg32) (o32 133 /r)) 
Adding :TEST to table - ((r/m16 reg16) (o16 133 /r)) 
Adding :TEST to table - ((r/m8 reg8) (132 /r)) 
Adding :SYSRET to table - (NIL (15 7)) 
Adding :SYSEXIT to table - (NIL (15 53)) 
Adding :SYSENTER to table - (NIL (15 52)) 
Adding :SYSCALL to table - (NIL (15 5)) 
Adding :SVTS to table - ((m80) (15 124 /0)) 
Adding :SVLDT to table - ((m80) (15 122 /0)) 
Adding :SVDC to table - ((m80 segreg) (15 120 /r)) 
Adding :SUBSS to table - ((xmm1 xmm2/m128) (243 15 92 /r)) 
Adding :SUBSD to table - ((xmm1 xmm2/m128) (242 15 92 /r)) 
Adding :SUBPS to table - ((xmm1 xmm2/m128) (15 92 /r)) 
Adding :SUBPD to table - ((xmm1 xmm2/m128) (102 15 92 /r)) 
Adding :SUB to table - ((EAX imm32) (o32 45 id)) 
Adding :SUB to table - ((AX imm16) (o16 45 iw)) 
Adding :SUB to table - ((AL imm8) (44 ib)) 
Adding :SUB to table - ((r/m32 imm8) (o32 131 /5 ib)) 
Adding :SUB to table - ((r/m16 imm8) (o16 131 /5 ib)) 
Adding :SUB to table - ((r/m32 imm32) (o32 129 /5 id)) 
Adding :SUB to table - ((r/m16 imm16) (o16 129 /5 iw)) 
Adding :SUB to table - ((r/m8 imm8) (128 /5 ib)) 
Adding :SUB to table - ((reg32 r/m32) (o32 43 /r)) 
Adding :SUB to table - ((reg16 r/m16) (o16 43 /r)) 
Adding :SUB to table - ((reg8 r/m8) (42 /r)) 
Adding :SUB to table - ((r/m32 reg32) (o32 41 /r)) 
Adding :SUB to table - ((r/m16 reg16) (o16 41 /r)) 
Adding :SUB to table - ((r/m8 reg8) (40 /r)) 
Adding :STR to table - ((r/m16) (15 0 /1)) 
Adding :STOSD to table - (NIL (o32 171)) 
Adding :STOSW to table - (NIL (o16 171)) 
Adding :STOSB to table - (NIL (170)) 
Adding :STMXCSR to table - ((m32) (15 174 /3)) 
Adding :STI to table - (NIL (251)) 
Adding :STD to table - (NIL (253)) 
Adding :STC to table - (NIL (249)) 
Adding :SQRTSS to table - ((xmm1 xmm2/m128) (243 15 81 /r)) 
Adding :SQRTSD to table - ((xmm1 xmm2/m128) (242 15 81 /r)) 
Adding :SQRTPS to table - ((xmm1 xmm2/m128) (15 81 /r)) 
Adding :SQRTPD to table - ((xmm1 xmm2/m128) (102 15 81 /r)) 
Adding :SMSW to table - ((r/m16) (15 1 /4)) 
Adding :SMINTOLD to table - (NIL (15 126)) 
Adding :SMINT to table - (NIL (15 56)) 
Adding :SMI to table - (NIL (241)) 
Adding :SHUFPS to table - ((xmm1 xmm2/m128 imm8) (15 198 /r ib)) 
Adding :SHUFPD to table - ((xmm1 xmm2/m128 imm8) (102 15 198 /r ib)) 
Adding :SHRD to table - ((r/m32 reg32 CL) (o32 15 173 /r)) 
Adding :SHRD to table - ((r/m16 reg16 CL) (o16 15 173 /r)) 
Adding :SHRD to table - ((r/m32 reg32 imm8) (o32 15 172 /r ib)) 
Adding :SHRD to table - ((r/m16 reg16 imm8) (o16 15 172 /r ib)) 
Adding :SHLD to table - ((r/m16 reg32 CL) (o32 15 165 /r)) 
Adding :SHLD to table - ((r/m16 reg16 CL) (o16 15 165 /r)) 
Adding :SHLD to table - ((r/m16 reg32 imm8) (o32 15 164 /r ib)) 
Adding :SHLD to table - ((r/m16 reg16 imm8) (o16 15 164 /r ib)) 
Adding :SHR to table - ((r/m32 imm8) (o32 193 /5 ib)) 
Adding :SHR to table - ((r/m32 CL) (o32 211 /5)) 
Adding :SHR to table - ((r/m32 1) (o32 209 /5)) 
Adding :SHR to table - ((r/m16 imm8) (o16 193 /5 ib)) 
Adding :SHR to table - ((r/m16 CL) (o16 211 /5)) 
Adding :SHR to table - ((r/m16 1) (o16 209 /5)) 
Adding :SHR to table - ((r/m8 imm8) (192 /5 ib)) 
Adding :SHR to table - ((r/m8 CL) (210 /5)) 
Adding :SHR to table - ((r/m8 1) (208 /5)) 
Adding :SHL to table - ((r/m32 imm8) (o32 193 /4 ib)) 
Adding :SHL to table - ((r/m32 CL) (o32 211 /4)) 
Adding :SHL to table - ((r/m32 1) (o32 209 /4)) 
Adding :SHL to table - ((r/m16 imm8) (o16 193 /4 ib)) 
Adding :SHL to table - ((r/m16 CL) (o16 211 /4)) 
Adding :SHL to table - ((r/m16 1) (o16 209 /4)) 
Adding :SHL to table - ((r/m8 imm8) (192 /4 ib)) 
Adding :SHL to table - ((r/m8 CL) (210 /4)) 
Adding :SHL to table - ((r/m8 1) (208 /4)) 
Adding :SLDT to table - ((r/m16) (15 0 /0)) 
Adding :SIDT to table - ((mem) (15 1 /1)) 
Adding :SGDT to table - ((mem) (15 1 /0)) 
Adding :SFENCE to table - (NIL (15 174 /7)) 
Adding :SCASD to table - (NIL (o32 175)) 
Adding :SCASW to table - (NIL (o16 175)) 
Adding :SCASB to table - (NIL (174)) 
Adding :SBB to table - ((EAX imm32) (o32 29 id)) 
Adding :SBB to table - ((AX imm16) (o16 29 iw)) 
Adding :SBB to table - ((AL imm8) (28 ib)) 
Adding :SBB to table - ((r/m32 imm8) (o32 131 /3 ib)) 
Adding :SBB to table - ((r/m16 imm8) (o16 131 /3 ib)) 
Adding :SBB to table - ((r/m32 imm32) (o32 129 /3 id)) 
Adding :SBB to table - ((r/m16 imm16) (o16 129 /3 iw)) 
Adding :SBB to table - ((r/m8 imm8) (128 /3 ib)) 
Adding :SBB to table - ((reg32 r/m32) (o32 27 /r)) 
Adding :SBB to table - ((reg16 r/m16) (o16 27 /r)) 
Adding :SBB to table - ((reg8 r/m8) (26 /r)) 
Adding :SBB to table - ((r/m32 reg32) (o32 25 /r)) 
Adding :SBB to table - ((r/m16 reg16) (o16 25 /r)) 
Adding :SBB to table - ((r/m8 reg8) (24 /r)) 
Adding :SALC to table - (NIL (214)) 
Adding :SAR to table - ((r/m32 imm8) (o32 193 /7 ib)) 
Adding :SAR to table - ((r/m32 CL) (o32 211 /7)) 
Adding :SAR to table - ((r/m32 1) (o32 209 /7)) 
Adding :SAR to table - ((r/m16 imm8) (o16 193 /7 ib)) 
Adding :SAR to table - ((r/m16 CL) (o16 211 /7)) 
Adding :SAR to table - ((r/m16 1) (o16 209 /7)) 
Adding :SAR to table - ((r/m8 imm8) (192 /7 ib)) 
Adding :SAR to table - ((r/m8 CL) (210 /7)) 
Adding :SAR to table - ((r/m8 1) (208 /7)) 
Adding :SAL to table - ((r/m32 imm8) (o32 193 /4 ib)) 
Adding :SAL to table - ((r/m32 CL) (o32 211 /4)) 
Adding :SAL to table - ((r/m32 1) (o32 209 /4)) 
Adding :SAL to table - ((r/m16 imm8) (o16 193 /4 ib)) 
Adding :SAL to table - ((r/m16 CL) (o16 211 /4)) 
Adding :SAL to table - ((r/m16 1) (o16 209 /4)) 
Adding :SAL to table - ((r/m8 imm8) (192 /4 ib)) 
Adding :SAL to table - ((r/m8 CL) (210 /4)) 
Adding :SAL to table - ((r/m8 1) (208 /4)) 
Adding :SAHF to table - (NIL (158)) 
Adding :RSTS to table - ((m80) (15 125 /0)) 
Adding :RSQRTSS to table - ((xmm1 xmm2/m128) (243 15 82 /r)) 
Adding :RSQRTPS to table - ((xmm1 xmm2/m128) (15 82 /r)) 
Adding :RSM to table - (NIL (15 170)) 
Adding :RSLDT to table - ((m80) (15 123 /0)) 
Adding :RSDC to table - ((segreg m80) (15 121 /r)) 
Adding :ROR to table - ((r/m32 imm8) (o32 193 /1 ib)) 
Adding :ROR to table - ((r/m32 CL) (o32 211 /1)) 
Adding :ROR to table - ((r/m32 1) (o32 209 /1)) 
Adding :ROR to table - ((r/m16 imm8) (o16 193 /1 ib)) 
Adding :ROR to table - ((r/m16 CL) (o16 211 /1)) 
Adding :ROR to table - ((r/m16 1) (o16 209 /1)) 
Adding :ROR to table - ((r/m8 imm8) (192 /1 ib)) 
Adding :ROR to table - ((r/m8 CL) (210 /1)) 
Adding :ROR to table - ((r/m8 1) (208 /1)) 
Adding :ROL to table - ((r/m32 imm8) (o32 193 /0 ib)) 
Adding :ROL to table - ((r/m32 CL) (o32 211 /0)) 
Adding :ROL to table - ((r/m32 1) (o32 209 /0)) 
Adding :ROL to table - ((r/m16 imm8) (o16 193 /0 ib)) 
Adding :ROL to table - ((r/m16 CL) (o16 211 /0)) 
Adding :ROL to table - ((r/m16 1) (o16 209 /0)) 
Adding :ROL to table - ((r/m8 imm8) (192 /0 ib)) 
Adding :ROL to table - ((r/m8 CL) (210 /0)) 
Adding :ROL to table - ((r/m8 1) (208 /0)) 
Adding :RETN to table - ((imm16) (194 iw)) 
Adding :RETN to table - (NIL (195)) 
Adding :RETF to table - ((imm16) (202 iw)) 
Adding :RETF to table - (NIL (203)) 
Adding :RET to table - ((imm16) (194 iw)) 
Adding :RET to table - (NIL (195)) 
Adding :RDTSC to table - (NIL (15 49)) 
Adding :RDSHR to table - ((r/m32) (15 54 /0)) 
Adding :RDPMC to table - (NIL (15 51)) 
Adding :RDMSR to table - (NIL (15 50)) 
Adding :RCPSS to table - ((xmm1 xmm2/m128) (243 15 83 /r)) 
Adding :RCPPS to table - ((xmm1 xmm2/m128) (15 83 /r)) 
Adding :RCR to table - ((r/m32 imm8) (o32 193 /3 ib)) 
Adding :RCR to table - ((r/m32 CL) (o32 211 /3)) 
Adding :RCR to table - ((r/m32 1) (o32 209 /3)) 
Adding :RCR to table - ((r/m16 imm8) (o16 193 /3 ib)) 
Adding :RCR to table - ((r/m16 CL) (o16 211 /3)) 
Adding :RCR to table - ((r/m16 1) (o16 209 /3)) 
Adding :RCR to table - ((r/m8 imm8) (192 /3 ib)) 
Adding :RCR to table - ((r/m8 CL) (210 /3)) 
Adding :RCR to table - ((r/m8 1) (208 /3)) 
Adding :RCL to table - ((r/m32 imm8) (o32 193 /2 ib)) 
Adding :RCL to table - ((r/m32 CL) (o32 211 /2)) 
Adding :RCL to table - ((r/m32 1) (o32 209 /2)) 
Adding :RCL to table - ((r/m16 imm8) (o16 193 /2 ib)) 
Adding :RCL to table - ((r/m16 CL) (o16 211 /2)) 
Adding :RCL to table - ((r/m16 1) (o16 209 /2)) 
Adding :RCL to table - ((r/m8 imm8) (192 /2 ib)) 
Adding :RCL to table - ((r/m8 CL) (210 /2)) 
Adding :RCL to table - ((r/m8 1) (208 /2)) 
Adding :PXOR to table - ((xmm1 xmm2/m128) (102 15 239 /r)) 
Adding :PXOR to table - ((mm1 mm2/m64) (15 239 /r)) 
Adding :PUSHFW to table - (NIL (o16 156)) 
Adding :PUSHFD to table - (NIL (o32 156)) 
Adding :PUSHF to table - (NIL (156)) 
Adding :PUSHAW to table - (NIL (o16 96)) 
Adding :PUSHAD to table - (NIL (o32 96)) 
Adding :PUSHA to table - (NIL (96)) 
Adding :PUSH to table - ((imm32) (o32 104 id)) 
Adding :PUSH to table - ((imm16) (o16 104 iw)) 
Adding :PUSH to table - ((imm8) (106 ib)) 
Adding :PUSH to table - ((GS) (15 168)) 
Adding :PUSH to table - ((FS) (15 160)) 
Adding :PUSH to table - ((SS) (22)) 
Adding :PUSH to table - ((ES) (6)) 
Adding :PUSH to table - ((DS) (30)) 
Adding :PUSH to table - ((CS) (14)) 
Adding :PUSH to table - ((r/m32) (o32 255 /6)) 
Adding :PUSH to table - ((r/m16) (o16 255 /6)) 
Adding :PUSH to table - ((reg32) (o32 80 +r)) 
Adding :PUSH to table - ((reg16) (o16 80 +r)) 
Adding :PUNPCKLQDQ to table - ((xmm1 xmm2/m128) (102 15 108 /r)) 
Adding :PUNPCKLDQ to table - ((xmm1 xmm2/m128) (102 15 98 /r)) 
Adding :PUNPCKLWD to table - ((xmm1 xmm2/m128) (102 15 97 /r)) 
Adding :PUNPCKLBW to table - ((xmm1 xmm2/m128) (102 15 96 /r)) 
Adding :PUNPCKLDQ to table - ((mm1 mm2/m32) (15 98 /r)) 
Adding :PUNPCKLWD to table - ((mm1 mm2/m32) (15 97 /r)) 
Adding :PUNPCKLBW to table - ((mm1 mm2/m32) (15 96 /r)) 
Adding :PUNPCKHQDQ to table - ((xmm1 xmm2/m128) (102 15 109 /r)) 
Adding :PUNPCKHDQ to table - ((xmm1 xmm2/m128) (102 15 106 /r)) 
Adding :PUNPCKHWD to table - ((xmm1 xmm2/m128) (102 15 105 /r)) 
Adding :PUNPCKHBW to table - ((xmm1 xmm2/m128) (102 15 104 /r)) 
Adding :PUNPCKHDQ to table - ((mm1 mm2/m64) (15 106 /r)) 
Adding :PUNPCKHWD to table - ((mm1 mm2/m64) (15 105 /r)) 
Adding :PUNPCKHBW to table - ((mm1 mm2/m64) (15 104 /r)) 
Adding :PSWAPD to table - ((mm1 mm2/m64) (15 15 /r 187)) 
Adding :PSUBSIW to table - ((mm1 mm2/m64) (15 85 /r)) 
Adding :PSUBUSW to table - ((xmm1 xmm2/m128) (102 15 217 /r)) 
Adding :PSUBUSB to table - ((xmm1 xmm2/m128) (102 15 216 /r)) 
Adding :PSUBUSW to table - ((mm1 mm2/m64) (15 217 /r)) 
Adding :PSUBUSB to table - ((mm1 mm2/m64) (15 216 /r)) 
Adding :PSUBSW to table - ((xmm1 xmm2/m128) (102 15 233 /r)) 
Adding :PSUBSB to table - ((xmm1 xmm2/m128) (102 15 232 /r)) 
Adding :PSUBSW to table - ((mm1 mm2/m64) (15 233 /r)) 
Adding :PSUBSB to table - ((mm1 mm2/m64) (15 232 /r)) 
Adding :PSUBQ to table - ((xmm1 xmm2/m128) (102 15 251 /r)) 
Adding :PSUBD to table - ((xmm1 xmm2/m128) (102 15 250 /r)) 
Adding :PSUBW to table - ((xmm1 xmm2/m128) (102 15 249 /r)) 
Adding :PSUBB to table - ((xmm1 xmm2/m128) (102 15 248 /r)) 
Adding :PSUBQ to table - ((mm1 mm2/m64) (15 251 /r)) 
Adding :PSUBD to table - ((mm1 mm2/m64) (15 250 /r)) 
Adding :PSUBW to table - ((mm1 mm2/m64) (15 249 /r)) 
Adding :PSUBB to table - ((mm1 mm2/m64) (15 248 /r)) 
Adding :PSRLDQ to table - ((xmm1 imm8) (102 15 115 /3 ib)) 
Adding :PSRLQ to table - ((xmm imm8) (102 15 115 /2 ib)) 
Adding :PSRLQ to table - ((xmm1 xmm2/m128) (102 15 211 /r)) 
Adding :PSRLQ to table - ((mm imm8) (15 115 /2 ib)) 
Adding :PSRLQ to table - ((mm1 mm2/m64) (15 211 /r)) 
Adding :PSRLD to table - ((xmm imm8) (102 15 114 /2 ib)) 
Adding :PSRLD to table - ((xmm1 xmm2/m128) (102 15 210 /r)) 
Adding :PSRLD to table - ((mm imm8) (15 114 /2 ib)) 
Adding :PSRLD to table - ((mm1 mm2/m64) (15 210 /r)) 
Adding :PSRLW to table - ((xmm imm8) (102 15 113 /2 ib)) 
Adding :PSRLW to table - ((xmm1 xmm2/m128) (102 15 209 /r)) 
Adding :PSRLW to table - ((mm imm8) (15 113 /2 ib)) 
Adding :PSRLW to table - ((mm1 mm2/m64) (15 209 /r)) 
Adding :PSRAD to table - ((xmm imm8) (102 15 114 /4 ib)) 
Adding :PSRAD to table - ((xmm1 xmm2/m128) (102 15 226 /r)) 
Adding :PSRAD to table - ((mm imm8) (15 114 /4 ib)) 
Adding :PSRAD to table - ((mm1 mm2/m64) (15 226 /r)) 
Adding :PSRAW to table - ((xmm imm8) (102 15 113 /4 ib)) 
Adding :PSRAW to table - ((xmm1 xmm2/m128) (102 15 225 /r)) 
Adding :PSRAW to table - ((mm imm8) (15 113 /4 ib)) 
Adding :PSRAW to table - ((mm1 mm2/m64) (15 225 /r)) 
Adding :PSLLDQ to table - ((xmm1 imm8) (102 15 115 /7 ib)) 
Adding :PSLLQ to table - ((xmm imm8) (102 15 115 /6 ib)) 
Adding :PSLLQ to table - ((xmm1 xmm2/m128) (102 15 243 /r)) 
Adding :PSLLQ to table - ((mm imm8) (15 115 /6 ib)) 
Adding :PSLLQ to table - ((mm1 mm2/m64) (15 243 /r)) 
Adding :PSLLD to table - ((xmm imm8) (102 15 114 /6 ib)) 
Adding :PSLLD to table - ((xmm1 xmm2/m128) (102 15 242 /r)) 
Adding :PSLLD to table - ((mm imm8) (15 114 /6 ib)) 
Adding :PSLLD to table - ((mm1 mm2/m64) (15 242 /r)) 
Adding :PSLLW to table - ((xmm imm8) (102 15 113 /6 ib)) 
Adding :PSLLW to table - ((xmm1 xmm2/m128) (102 15 241 /r)) 
Adding :PSLLW to table - ((mm imm8) (15 113 /6 ib)) 
Adding :PSLLW to table - ((mm1 mm2/m64) (15 241 /r)) 
Adding :PSHUFW to table - ((mm1 mm2/m64 imm8) (15 112 /r ib)) 
Adding :PSHUFLW to table - ((xmm1 xmm2/m128 imm8) (242 15 112 /r ib)) 
Adding :PSHUFHW to table - ((xmm1 xmm2/m128 imm8) (243 15 112 /r ib)) 
Adding :PSHUFD to table - ((xmm1 xmm2/m128 imm8) (102 15 112 /r ib)) 
Adding :PSADBW to table - ((xmm1 xmm2/m128) (102 15 246 /r)) 
Adding :PSADBW to table - ((mm1 mm2/m64) (15 246 /r)) 
Adding :PREFETCHT2 to table - ((m8) (15 24 /3)) 
Adding :PREFETCHT1 to table - ((m8) (15 24 /2)) 
Adding :PREFETCHT0 to table - ((m8) (15 24 /1)) 
Adding :PREFETCHNTA to table - ((m8) (15 24 /0)) 
Adding :PREFETCHW to table - ((mem8) (15 13 /1)) 
Adding :PREFETCH to table - ((mem8) (15 13 /0)) 
Adding :POR to table - ((xmm1 xmm2/m128) (102 15 235 /r)) 
Adding :POR to table - ((mm1 mm2/m64) (15 235 /r)) 
Adding :POPFD to table - (NIL (o32 157)) 
Adding :POPFW to table - (NIL (o16 157)) 
Adding :POPF to table - (NIL (157)) 
Adding :POPAD to table - (NIL (o32 97)) 
Adding :POPAW to table - (NIL (o16 97)) 
Adding :POPA to table - (NIL (97)) 
Adding :POP to table - ((GS) (15 169)) 
Adding :POP to table - ((FS) (15 161)) 
Adding :POP to table - ((SS) (23)) 
Adding :POP to table - ((ES) (7)) 
Adding :POP to table - ((DS) (31)) 
Adding :POP to table - ((CS) (15)) 
Adding :POP to table - ((r/m32) (o32 143 /0)) 
Adding :POP to table - ((r/m16) (o16 143 /0)) 
Adding :POP to table - ((reg32) (o32 88 +r)) 
Adding :POP to table - ((reg16) (o16 88 +r)) 
Adding :PMVGEZB to table - ((mmxreg mem64) (15 92 /r)) 
Adding :PMVLZB to table - ((mmxreg mem64) (15 91 /r)) 
Adding :PMVNZB to table - ((mmxreg mem64) (15 90 /r)) 
Adding :PMVZB to table - ((mmxreg mem64) (15 88 /r)) 
Adding :PMULUDQ to table - ((xmm1 xmm2/m128) (102 15 244 /r)) 
Adding :PMULUDQ to table - ((mm1 mm2/m64) (15 244 /r)) 
Adding :PMULLW to table - ((xmm1 xmm2/m128) (102 15 213 /r)) 
Adding :PMULHW to table - ((xmm1 xmm2/m128) (102 15 229 /r)) 
Adding :PMULLW to table - ((mm1 mm2/m64) (15 213 /r)) 
Adding :PMULHW to table - ((mm1 mm2/m64) (15 229 /r)) 
Adding :PMULHUW to table - ((xmm1 xmm2/m128) (102 15 228 /r)) 
Adding :PMULHUW to table - ((mm1 mm2/m64) (15 228 /r)) 
Adding :PMULHRWA to table - ((mm1 mm2/m64) (15 15 /r 183)) 
Adding :PMULHRIW to table - ((mm1 mm2/m64) (15 93 /r)) 
Adding :PMULHRWC to table - ((mm1 mm2/m64) (15 89 /r)) 
Adding :PMOVMSKB to table - ((reg32 xmm) (102 15 215 /r)) 
Adding :PMOVMSKB to table - ((reg32 mm) (15 215 /r)) 
Adding :PMINUB to table - ((xmm1 xmm2/m128) (102 15 218 /r)) 
Adding :PMINUB to table - ((mm1 mm2/m64) (15 218 /r)) 
Adding :PMINSW to table - ((xmm1 xmm2/m128) (102 15 234 /r)) 
Adding :PMINSW to table - ((mm1 mm2/m64) (15 234 /r)) 
Adding :PMAXUB to table - ((xmm1 xmm2/m128) (102 15 222 /r)) 
Adding :PMAXUB to table - ((mm1 mm2/m64) (15 222 /r)) 
Adding :PMAXSW to table - ((xmm1 xmm2/m128) (102 15 238 /r)) 
Adding :PMAXSW to table - ((mm1 mm2/m64) (15 238 /r)) 
Adding :PMAGW to table - ((mm1 mm2/m64) (15 82 /r)) 
Adding :PMADDWD to table - ((xmm1 xmm2/m128) (102 15 245 /r)) 
Adding :PMADDWD to table - ((mm1 mm2/m64) (15 245 /r)) 
Adding :PMACHRIW to table - ((mm m64) (15 94 /r)) 
Adding :PINSRW to table - ((xmm r16/r32/m16 imm8) (102 15 196 /r ib)) 
Adding :PINSRW to table - ((mm r16/r32/m16 imm8) (15 196 /r ib)) 
Adding :PI2FW to table - ((mm1 mm2/m64) (15 15 /r 12)) 
Adding :PI2FD to table - ((mm1 mm2/m64) (15 15 /r 13)) 
Adding :PFSUBR to table - ((mm1 mm2/m64) (15 15 /r 170)) 
Adding :PFSUB to table - ((mm1 mm2/m64) (15 15 /r 154)) 
Adding :PFRSQRT to table - ((mm1 mm2/m64) (15 15 /r 151)) 
Adding :PFRSQIT1 to table - ((mm1 mm2/m64) (15 15 /r 167)) 
Adding :PFRCPIT2 to table - ((mm1 mm2/m64) (15 15 /r 182)) 
Adding :PFRCPIT1 to table - ((mm1 mm2/m64) (15 15 /r 166)) 
Adding :PFRCP to table - ((mm1 mm2/m64) (15 15 /r 150)) 
Adding :PFPNACC to table - ((mm1 mm2/m64) (15 15 /r 142)) 
Adding :PFNACC to table - ((mm1 mm2/m64) (15 15 /r 138)) 
Adding :PFMUL to table - ((mm1 mm2/m64) (15 15 /r 180)) 
Adding :PFMIN to table - ((mm1 mm2/m64) (15 15 /r 148)) 
Adding :PFMAX to table - ((mm1 mm2/m64) (15 15 /r 164)) 
Adding :PFCMPGT to table - ((mm1 mm2/m64) (15 15 /r 160)) 
Adding :PFCMPGE to table - ((mm1 mm2/m64) (15 15 /r 144)) 
Adding :PFCMPEQ to table - ((mm1 mm2/m64) (15 15 /r 176)) 
Adding :PFADD to table - ((mm1 mm2/m64) (15 15 /r 158)) 
Adding :PFACC to table - ((mm1 mm2/m64) (15 15 /r 174)) 
Adding :PF2IW to table - ((mm1 mm2/m64) (15 15 /r 28)) 
Adding :PF2ID to table - ((mm1 mm2/m64) (15 15 /r 29)) 
Adding :PEXTRW to table - ((reg32 xmm imm8) (102 15 197 /r ib)) 
Adding :PEXTRW to table - ((reg32 mm imm8) (15 197 /r ib)) 
Adding :PDISTIB to table - ((mm m64) (15 84 /r)) 
Adding :PCMPGTD to table - ((xmm1 xmm2/m128) (102 15 102 /r)) 
Adding :PCMPGTW to table - ((xmm1 xmm2/m128) (102 15 101 /r)) 
Adding :PCMPGTB to table - ((xmm1 xmm2/m128) (102 15 100 /r)) 
Adding :PCMPEQD to table - ((xmm1 xmm2/m128) (102 15 118 /r)) 
Adding :PCMPEQW to table - ((xmm1 xmm2/m128) (102 15 117 /r)) 
Adding :PCMPEQB to table - ((xmm1 xmm2/m128) (102 15 116 /r)) 
Adding :PCMPGTD to table - ((mm1 mm2/m64) (15 102 /r)) 
Adding :PCMPGTW to table - ((mm1 mm2/m64) (15 101 /r)) 
Adding :PCMPGTB to table - ((mm1 mm2/m64) (15 100 /r)) 
Adding :PCMPEQD to table - ((mm1 mm2/m64) (15 118 /r)) 
Adding :PCMPEQW to table - ((mm1 mm2/m64) (15 117 /r)) 
Adding :PCMPEQB to table - ((mm1 mm2/m64) (15 116 /r)) 
Adding :PAVGUSB to table - ((mm1 mm2/m64) (15 15 /r 191)) 
Adding :PAVGW to table - ((xmm1 xmm2/m128) (102 15 227 /r)) 
Adding :PAVGB to table - ((xmm1 xmm2/m128) (102 15 224 /r)) 
Adding :PAVGW to table - ((mm1 mm2/m64) (15 227 /r)) 
Adding :PAVGB to table - ((mm1 mm2/m64) (15 224 /r)) 
Adding :PAVEB to table - ((mmxreg r/m64) (15 80 /r)) 
Adding :PAUSE to table - (NIL (243 144)) 
Adding :PANDN to table - ((xmm1 xmm2/m128) (102 15 223 /r)) 
Adding :PAND to table - ((xmm1 xmm2/m128) (102 15 219 /r)) 
Adding :PANDN to table - ((mm1 mm2/m64) (15 223 /r)) 
Adding :PAND to table - ((mm1 mm2/m64) (15 219 /r)) 
Adding :PADDUSW to table - ((xmm1 xmm2/m128) (102 15 221 /r)) 
Adding :PADDUSB to table - ((xmm1 xmm2/m128) (102 15 220 /r)) 
Adding :PADDUSW to table - ((mm1 mm2/m64) (15 221 /r)) 
Adding :PADDUSB to table - ((mm1 mm2/m64) (15 220 /r)) 
Adding :PADDSIW to table - ((mmxreg r/m64) (15 81 /r)) 
Adding :PADDSW to table - ((xmm1 xmm2/m128) (102 15 237 /r)) 
Adding :PADDSB to table - ((xmm1 xmm2/m128) (102 15 236 /r)) 
Adding :PADDSW to table - ((mm1 mm2/m64) (15 237 /r)) 
Adding :PADDSB to table - ((mm1 mm2/m64) (15 236 /r)) 
Adding :PADDQ to table - ((xmm1 xmm2/m128) (102 15 212 /r)) 
Adding :PADDQ to table - ((mm1 mm2/m64) (15 212 /r)) 
Adding :PADDD to table - ((xmm1 xmm2/m128) (102 15 254 /r)) 
Adding :PADDW to table - ((xmm1 xmm2/m128) (102 15 253 /r)) 
Adding :PADDB to table - ((xmm1 xmm2/m128) (102 15 252 /r)) 
Adding :PADDD to table - ((mm1 mm2/m64) (15 254 /r)) 
Adding :PADDW to table - ((mm1 mm2/m64) (15 253 /r)) 
Adding :PADDB to table - ((mm1 mm2/m64) (15 252 /r)) 
Adding :PACKUSWB to table - ((xmm1 xmm2/m128) (102 15 103 /r)) 
Adding :PACKSSWB to table - ((xmm1 xmm2/m128) (102 15 99 /r)) 
Adding :PACKSSDW to table - ((xmm1 xmm2/m128) (102 15 107 /r)) 
Adding :PACKUSWB to table - ((mm1 mm2/m64) (15 103 /r)) 
Adding :PACKSSWB to table - ((mm1 mm2/m64) (15 99 /r)) 
Adding :PACKSSDW to table - ((mm1 mm2/m64) (15 107 /r)) 
Adding :OUTSD to table - (NIL (o32 111)) 
Adding :OUTSW to table - (NIL (o16 111)) 
Adding :OUTSB to table - (NIL (110)) 
Adding :OUT to table - ((DX EAX) (o32 239)) 
Adding :OUT to table - ((DX AX) (o16 239)) 
Adding :OUT to table - ((DX AL) (238)) 
Adding :OUT to table - ((imm8 EAX) (o32 231 ib)) 
Adding :OUT to table - ((imm8 AX) (o16 231 ib)) 
Adding :OUT to table - ((imm8 AL) (230 ib)) 
Adding :ORPS to table - ((xmm1 xmm2/m128) (15 86 /r)) 
Adding :ORPD to table - ((xmm1 xmm2/m128) (102 15 86 /r)) 
Adding :OR to table - ((EAX imm32) (o32 13 id)) 
Adding :OR to table - ((AX imm16) (o16 13 iw)) 
Adding :OR to table - ((AL imm8) (12 ib)) 
Adding :OR to table - ((r/m32 imm8) (o32 131 /1 ib)) 
Adding :OR to table - ((r/m16 imm8) (o16 131 /1 ib)) 
Adding :OR to table - ((r/m32 imm32) (o32 129 /1 id)) 
Adding :OR to table - ((r/m16 imm16) (o16 129 /1 iw)) 
Adding :OR to table - ((r/m8 imm8) (128 /1 ib)) 
Adding :OR to table - ((reg32 r/m32) (o32 11 /r)) 
Adding :OR to table - ((reg16 r/m16) (o16 11 /r)) 
Adding :OR to table - ((reg8 r/m8) (10 /r)) 
Adding :OR to table - ((r/m32 reg32) (o32 9 /r)) 
Adding :OR to table - ((r/m16 reg16) (o16 9 /r)) 
Adding :OR to table - ((r/m8 reg8) (8 /r)) 
Adding :NOP to table - (NIL (144)) 
Adding :NOT to table - ((r/m32) (o32 247 /2)) 
Adding :NOT to table - ((r/m16) (o16 247 /2)) 
Adding :NOT to table - ((r/m8) (246 /2)) 
Adding :NEG to table - ((r/m32) (o32 247 /3)) 
Adding :NEG to table - ((r/m16) (o16 247 /3)) 
Adding :NEG to table - ((r/m8) (246 /3)) 
Adding :MULSS to table - ((xmm1 xmm2/mem32) (243 15 89 /r)) 
Adding :MULSD to table - ((xmm1 xmm2/mem32) (242 15 89 /r)) 
Adding :MULPS to table - ((xmm1 xmm2/mem128) (15 89 /r)) 
Adding :MULPD to table - ((xmm1 xmm2/mem128) (102 15 89 /r)) 
Adding :MUL to table - ((r/m32) (o32 247 /4)) 
Adding :MUL to table - ((r/m16) (o16 247 /4)) 
Adding :MUL to table - ((r/m8) (246 /4)) 
Adding :MOVUPS to table - ((xmm1/mem128 xmm2) (15 17 /r)) 
Adding :MOVUPS to table - ((xmm1 xmm2/mem128) (15 16 /r)) 
Adding :MOVUPD to table - ((xmm1/mem128 xmm2) (102 15 17 /r)) 
Adding :MOVUPD to table - ((xmm1 xmm2/mem128) (102 15 16 /r)) 
Adding :MOVZX to table - ((reg32 r/m16) (o32 15 183 /r)) 
Adding :MOVZX to table - ((reg32 r/m8) (o32 15 182 /r)) 
Adding :MOVZX to table - ((reg16 r/m8) (o16 15 182 /r)) 
Adding :MOVSX to table - ((reg32 r/m16) (o32 15 191 /r)) 
Adding :MOVSX to table - ((reg32 r/m8) (o32 15 190 /r)) 
Adding :MOVSX to table - ((reg16 r/m8) (o16 15 190 /r)) 
Adding :MOVSS to table - ((xmm1/m32 xmm2) (243 15 17 /r)) 
Adding :MOVSS to table - ((xmm1 xmm2/m32) (243 15 16 /r)) 
Adding :MOVSD to table - ((xmm1/m64 xmm2) (242 15 17 /r)) 
Adding :MOVSD to table - ((xmm1 xmm2/m64) (242 15 16 /r)) 
Adding :MOVSD to table - (NIL (o32 165)) 
Adding :MOVSW to table - (NIL (o16 165)) 
Adding :MOVSB to table - (NIL (164)) 
Adding :MOVQ2DQ to table - ((xmm mm) (243 OF 214 /r)) 
Adding :MOVQ to table - ((xmm1/m64 xmm2) (102 15 214 /r)) 
Adding :MOVQ to table - ((xmm1 xmm2/m64) (243 15 126 /r)) 
Adding :MOVQ to table - ((mm1/m64 mm2) (15 127 /r)) 
Adding :MOVQ to table - ((mm1 mm2/m64) (15 111 /r)) 
Adding :MOVNTQ to table - ((m64 mm) (15 231 /r)) 
Adding :MOVNTPS to table - ((m128 xmm) (15 43 /r)) 
Adding :MOVNTPD to table - ((m128 xmm) (102 15 43 /r)) 
Adding :MOVNTI to table - ((m32 reg32) (15 195 /r)) 
Adding :MOVNTDQ to table - ((m128 xmm) (102 15 231 /r)) 
Adding :MOVMSKPS to table - ((reg32 xmm) (15 80 /r)) 
Adding :MOVMSKPD to table - ((reg32 xmm) (102 15 80 /r)) 
Adding :MOVLPS to table - ((m64 xmm) (OF 19 /r)) 
Adding :MOVLPS to table - ((xmm m64) (OF 18 /r)) 
Adding :MOVLPD to table - ((m64 xmm) (102 OF 19 /r)) 
Adding :MOVLPD to table - ((xmm m64) (102 OF 18 /r)) 
Adding :MOVLHPS to table - ((xmm1 xmm2) (OF 22 /r)) 
Adding :MOVHPS to table - ((m64 xmm) (15 23 /r)) 
Adding :MOVHPS to table - ((xmm m64) (15 22 /r)) 
Adding :MOVHPD to table - ((m64 xmm) (102 OF 23 /r)) 
Adding :MOVHPD to table - ((xmm m64) (102 OF 22 /r)) 
Adding :MOVHLPS to table - ((xmm1 xmm2) (OF 18 /r)) 
Adding :MOVDQU to table - ((xmm1/m128 xmm2) (243 OF 127 /r)) 
Adding :MOVDQU to table - ((xmm1 xmm2/m128) (243 OF 111 /r)) 
Adding :MOVDQA to table - ((xmm1/m128 xmm2) (102 OF 127 /r)) 
Adding :MOVDQA to table - ((xmm1 xmm2/m128) (102 OF 111 /r)) 
Adding :MOVDQ2Q to table - ((mm xmm) (242 OF 214 /r)) 
Adding :MOVD to table - ((r/m32 xmm) (102 15 126 /r)) 
Adding :MOVD to table - ((xmm r/m32) (102 15 110 /r)) 
Adding :MOVD to table - ((r/m32 mm) (15 126 /r)) 
Adding :MOVD to table - ((mm r/m32) (15 110 /r)) 
Adding :MOVAPS to table - ((xmm1/mem128 xmm2) (15 41 /r)) 
Adding :MOVAPS to table - ((xmm1 xmm2/mem128) (15 40 /r)) 
Adding :MOVAPD to table - ((xmm1/mem128 xmm2) (102 15 41 /r)) 
Adding :MOVAPD to table - ((xmm1 xmm2/mem128) (102 15 40 /r)) 
Adding :MOV to table - ((TR3/4/5/6/7 reg32) (15 38 /r)) 
Adding :MOV to table - ((DR0/1/2/3/6/7 reg32) (15 35 /r)) 
Adding :MOV to table - ((CR0/2/3/4 reg32) (15 34 /r)) 
Adding :MOV to table - ((reg32 TR3/4/5/6/7) (15 36 /r)) 
Adding :MOV to table - ((reg32 DR0/1/2/3/6/7) (15 33 /r)) 
Adding :MOV to table - ((reg32 CR0/2/3/4) (15 32 /r)) 
Adding :MOV to table - ((segreg r/m32) (o32 142 /r)) 
Adding :MOV to table - ((segreg r/m16) (o16 142 /r)) 
Adding :MOV to table - ((r/m32 segreg) (o32 140 /r)) 
Adding :MOV to table - ((r/m16 segreg) (o16 140 /r)) 
Adding :MOV to table - ((memoffs32 EAX) (o32 163 ow/od)) 
Adding :MOV to table - ((memoffs16 AX) (o16 163 ow/od)) 
Adding :MOV to table - ((memoffs8 AL) (162 ow/od)) 
Adding :MOV to table - ((EAX memoffs32) (o32 161 ow/od)) 
Adding :MOV to table - ((AX memoffs16) (o16 161 ow/od)) 
Adding :MOV to table - ((AL memoffs8) (160 ow/od)) 
Adding :MOV to table - ((r/m32 imm32) (o32 199 /0 id)) 
Adding :MOV to table - ((r/m16 imm16) (o16 199 /0 iw)) 
Adding :MOV to table - ((r/m8 imm8) (198 /0 ib)) 
Adding :MOV to table - ((reg32 imm32) (o32 184 +r id)) 
Adding :MOV to table - ((reg16 imm16) (o16 184 +r iw)) 
Adding :MOV to table - ((reg8 imm8) (176 +r ib)) 
Adding :MOV to table - ((reg32 r/m32) (o32 139 /r)) 
Adding :MOV to table - ((reg16 r/m16) (o16 139 /r)) 
Adding :MOV to table - ((reg8 r/m8) (138 /r)) 
Adding :MOV to table - ((r/m32 reg32) (o32 137 /r)) 
Adding :MOV to table - ((r/m16 reg16) (o16 137 /r)) 
Adding :MOV to table - ((r/m8 reg8) (136 /r)) 
Adding :MINSS to table - ((xmm1 xmm2/m32) (243 15 93 /r)) 
Adding :MINSD to table - ((xmm1 xmm2/m64) (242 15 93 /r)) 
Adding :MINPS to table - ((xmm1 xmm2/m128) (15 93 /r)) 
Adding :MINPD to table - ((xmm1 xmm2/m128) (102 15 93 /r)) 
Adding :MFENCE to table - (NIL (15 174 /6)) 
Adding :MAXSS to table - ((xmm1 xmm2/m32) (243 15 95 /r)) 
Adding :MAXSD to table - ((xmm1 xmm2/m64) (242 15 95 /r)) 
Adding :MAXPS to table - ((xmm1 xmm2/m128) (15 95 /r)) 
Adding :MAXPD to table - ((xmm1 xmm2/m128) (102 15 95 /r)) 
Adding :MASKMOVQ to table - ((mm1 mm2) (15 247 /r)) 
Adding :MASKMOVDQU to table - ((xmm1 xmm2) (102 15 247 /r)) 
Adding :LTR to table - ((r/m16) (15 0 /3)) 
Adding :LSL to table - ((reg32 r/m32) (o32 15 3 /r)) 
Adding :LSL to table - ((reg16 r/m16) (o16 15 3 /r)) 
Adding :LOOPNZ to table - ((imm ECX) (2610 224 rb)) 
Adding :LOOPNZ to table - ((imm CX) (2582 224 rb)) 
Adding :LOOPNZ to table - ((imm) (224 rb)) 
Adding :LOOPNE to table - ((imm ECX) (2610 224 rb)) 
Adding :LOOPNE to table - ((imm CX) (2582 224 rb)) 
Adding :LOOPNE to table - ((imm) (224 rb)) 
Adding :LOOPZ to table - ((imm ECX) (2610 225 rb)) 
Adding :LOOPZ to table - ((imm CX) (2582 225 rb)) 
Adding :LOOPZ to table - ((imm) (225 rb)) 
Adding :LOOPE to table - ((imm ECX) (2610 225 rb)) 
Adding :LOOPE to table - ((imm CX) (2582 225 rb)) 
Adding :LOOPE to table - ((imm) (225 rb)) 
Adding :LOOP to table - ((imm ECX) (2610 226 rb)) 
Adding :LOOP to table - ((imm CX) (2582 226 rb)) 
Adding :LOOP to table - ((imm) (226 rb)) 
Adding :LODSD to table - (NIL (o32 173)) 
Adding :LODSW to table - (NIL (o16 173)) 
Adding :LODSB to table - (NIL (172)) 
Adding :LOADALL286 to table - (NIL (15 5)) 
Adding :LOADALL to table - (NIL (15 7)) 
Adding :LMSW to table - ((r/m16) (15 1 /6)) 
Adding :LLDT to table - ((r/m16) (15 0 /2)) 
Adding :LIDT to table - ((mem) (15 1 /3)) 
Adding :LGDT to table - ((mem) (15 1 /2)) 
Adding :LFENCE to table - (NIL (15 174 /5)) 
Adding :LEAVE to table - (NIL (201)) 
Adding :LEA to table - ((reg32 mem) (o32 141 /r)) 
Adding :LEA to table - ((reg16 mem) (o16 141 /r)) 
Adding :LSS to table - ((reg32 mem) (o32 15 178 /r)) 
Adding :LSS to table - ((reg16 mem) (o16 15 178 /r)) 
Adding :LGS to table - ((reg32 mem) (o32 15 181 /r)) 
Adding :LGS to table - ((reg16 mem) (o16 15 181 /r)) 
Adding :LFS to table - ((reg32 mem) (o32 15 180 /r)) 
Adding :LFS to table - ((reg16 mem) (o16 15 180 /r)) 
Adding :LES to table - ((reg32 mem) (o32 196 /r)) 
Adding :LES to table - ((reg16 mem) (o16 196 /r)) 
Adding :LDS to table - ((reg32 mem) (o32 197 /r)) 
Adding :LDS to table - ((reg16 mem) (o16 197 /r)) 
Adding :LDMXCSR to table - ((mem32) (15 174 /2)) 
Adding :LAR to table - ((reg32 r/m32) (o32 15 2 /r)) 
Adding :LAR to table - ((reg16 r/m16) (o16 15 2 /r)) 
Adding :LAHF to table - (NIL (159)) 
Adding :JMP to table - ((r/m32) (o32 255 /4)) 
Adding :JMP to table - ((r/m16) (o16 255 /4)) 
Adding :JMP to table - ((mem32) (o32 255 /5)) 
Adding :JMP to table - ((mem) (o16 255 /5)) 
Adding :JMP to table - ((imm:imm32) (o32 234 id iw)) 
Adding :JMP to table - ((imm:imm16) (o16 234 iw iw)) 
Adding :JMP to table - ((imm) (235 rb)) 
Adding :JMP to table - ((imm) (233 rw/rd)) 
Adding :JECXZ to table - ((imm) (2610 227 rb)) 
Adding :JCXZ to table - ((imm) (2582 227 rb)) 
Adding :IRETD to table - (NIL (o32 207)) 
Adding :IRETW to table - (NIL (o16 207)) 
Adding :IRET to table - (NIL (207)) 
Adding :INVLPG to table - ((mem) (15 1 /7)) 
Adding :INVD to table - (NIL (15 8)) 
Adding :INTO to table - (NIL (206)) 
Adding :INT03 to table - (NIL (204)) 
Adding :INT3 to table - (NIL (204)) 
Adding :INT01 to table - (NIL (241)) 
Adding :ICEBP to table - (NIL (241)) 
Adding :INT1 to table - (NIL (241)) 
Adding :INT to table - ((imm8) (205 ib)) 
Adding :INSD to table - (NIL (o32 109)) 
Adding :INSW to table - (NIL (o16 109)) 
Adding :INSB to table - (NIL (108)) 
Adding :INC to table - ((r/m32) (o32 255 /0)) 
Adding :INC to table - ((r/m16) (o16 255 /0)) 
Adding :INC to table - ((r/m8) (254 /0)) 
Adding :INC to table - ((reg32) (o32 64 +r)) 
Adding :INC to table - ((reg16) (o16 64 +r)) 
Adding :IN to table - ((EAX DX) (o32 237)) 
Adding :IN to table - ((AX DX) (o16 237)) 
Adding :IN to table - ((AL DX) (236)) 
Adding :IN to table - ((EAX imm8) (o32 229 ib)) 
Adding :IN to table - ((AX imm8) (o16 229 ib)) 
Adding :IN to table - ((AL imm8) (228 ib)) 
Adding :IMUL to table - ((reg32 r/m32 imm32) (o32 105 /r id)) 
Adding :IMUL to table - ((reg32 r/m32 imm8) (o32 107 /r ib)) 
Adding :IMUL to table - ((reg16 r/m16 imm16) (o16 105 /r iw)) 
Adding :IMUL to table - ((reg16 r/m16 imm8) (o16 107 /r ib)) 
Adding :IMUL to table - ((reg32 imm32) (o32 105 /r id)) 
Adding :IMUL to table - ((reg32 imm8) (o32 107 /r ib)) 
Adding :IMUL to table - ((reg16 imm16) (o16 105 /r iw)) 
Adding :IMUL to table - ((reg16 imm8) (o16 107 /r ib)) 
Adding :IMUL to table - ((reg32 r/m32) (o32 15 175 /r)) 
Adding :IMUL to table - ((reg16 r/m16) (o16 15 175 /r)) 
Adding :IMUL to table - ((r/m32) (o32 247 /5)) 
Adding :IMUL to table - ((r/m16) (o16 247 /5)) 
Adding :IMUL to table - ((r/m8) (246 /5)) 
Adding :IDIV to table - ((r/m32) (o32 247 /7)) 
Adding :IDIV to table - ((r/m16) (o16 247 /7)) 
Adding :IDIV to table - ((r/m8) (246 /7)) 
Adding :IBTS to table - ((r/m32 reg32) (o32 15 167 /r)) 
Adding :IBTS to table - ((r/m16 reg16) (o16 15 167 /r)) 
Adding :HLT to table - (NIL (244)) 
Adding :FYL2XP1 to table - (NIL (217 249)) 
Adding :FYL2X to table - (NIL (217 241)) 
Adding :FXTRACT to table - (NIL (217 244)) 
Adding :FXSAVE to table - ((memory) (15 174 /0)) 
Adding :FXRSTOR to table - ((memory) (15 174 /1)) 
Adding :FXCH to table - ((ST0 fpureg) (217 200 +r)) 
Adding :FXCH to table - ((fpureg ST0) (217 200 +r)) 
Adding :FXCH to table - ((fpureg) (217 200 +r)) 
Adding :FXCH to table - (NIL (217 201)) 
Adding :FXAM to table - (NIL (217 229)) 
Adding :FUCOMIP to table - ((ST0 fpureg) (223 232 +r)) 
Adding :FUCOMIP to table - ((fpureg) (223 232 +r)) 
Adding :FUCOMI to table - ((ST0 fpureg) (219 232 +r)) 
Adding :FUCOMI to table - ((fpureg) (219 232 +r)) 
Adding :FUCOMPP to table - (NIL (218 233)) 
Adding :FUCOMP to table - ((ST0 fpureg) (221 232 +r)) 
Adding :FUCOMP to table - ((fpureg) (221 232 +r)) 
Adding :FUCOM to table - ((ST0 fpureg) (221 224 +r)) 
Adding :FUCOM to table - ((fpureg) (221 224 +r)) 
Adding :FTST to table - (NIL (217 228)) 
Adding :FSUBRP to table - ((fpureg ST0) (222 224 +r)) 
Adding :FSUBRP to table - ((fpureg) (222 224 +r)) 
Adding :FSUBP to table - ((fpureg ST0) (222 232 +r)) 
Adding :FSUBP to table - ((fpureg) (222 232 +r)) 
Adding :FSUBR to table - ((fpureg ST0) (220 224 +r)) 
Adding :FSUBR to table - ((fpureg) (220 224 +r)) 
Adding :FSUBR to table - ((ST0 fpureg) (216 232 +r)) 
Adding :FSUBR to table - ((fpureg) (216 232 +r)) 
Adding :FSUBR to table - ((mem64) (220 /5)) 
Adding :FSUBR to table - ((mem32) (216 /5)) 
Adding :FSUB to table - ((fpureg ST0) (220 232 +r)) 
Adding :FSUB to table - ((fpureg) (220 232 +r)) 
Adding :FSUB to table - ((ST0 fpureg) (216 224 +r)) 
Adding :FSUB to table - ((fpureg) (216 224 +r)) 
Adding :FSUB to table - ((mem64) (220 /4)) 
Adding :FSUB to table - ((mem32) (216 /4)) 
Adding :FNSTSW to table - ((AX) (223 224)) 
Adding :FNSTSW to table - ((mem16) (221 /7)) 
Adding :FSTSW to table - ((AX) (155 223 224)) 
Adding :FSTSW to table - ((mem16) (155 221 /7)) 
Adding :FNSTENV to table - ((mem) (217 /6)) 
Adding :FSTENV to table - ((mem) (155 217 /6)) 
Adding :FNSTCW to table - ((mem16) (217 /7)) 
Adding :FSTCW to table - ((mem16) (155 217 /7)) 
Adding :FSTP to table - ((fpureg) (221 216 +r)) 
Adding :FSTP to table - ((mem80) (219 /7)) 
Adding :FSTP to table - ((mem64) (221 /3)) 
Adding :FSTP to table - ((mem32) (217 /3)) 
Adding :FST to table - ((fpureg) (221 208 +r)) 
Adding :FST to table - ((mem64) (221 /2)) 
Adding :FST to table - ((mem32) (217 /2)) 
Adding :FSQRT to table - (NIL (217 250)) 
Adding :FSINCOS to table - (NIL (217 251)) 
Adding :FSIN to table - (NIL (217 254)) 
Adding :FSETPM to table - (NIL (219 228)) 
Adding :FSCALE to table - (NIL (217 253)) 
Adding :FRSTOR to table - ((mem) (221 /4)) 
Adding :FNSAVE to table - ((mem) (221 /6)) 
Adding :FSAVE to table - ((mem) (155 221 /6)) 
Adding :FRNDINT to table - (NIL (217 252)) 
Adding :FPREM1 to table - (NIL (217 245)) 
Adding :FPREM to table - (NIL (217 248)) 
Adding :FPTAN to table - (NIL (217 242)) 
Adding :FPATAN to table - (NIL (217 243)) 
Adding :FNOP to table - (NIL (217 208)) 
Adding :FMULP to table - ((fpureg ST0) (222 200 +r)) 
Adding :FMULP to table - ((fpureg) (222 200 +r)) 
Adding :FMUL to table - ((fpureg ST0) (220 200 +r)) 
Adding :FMUL to table - ((fpureg) (220 200 +r)) 
Adding :FMUL to table - ((ST0 fpureg) (216 200 +r)) 
Adding :FMUL to table - ((fpureg) (216 200 +r)) 
Adding :FMUL to table - ((mem64) (220 /1)) 
Adding :FMUL to table - ((mem32) (216 /1)) 
Adding :FLDENV to table - ((mem) (217 /4)) 
Adding :FLDCW to table - ((mem16) (217 /5)) 
Adding :FLDZ to table - (NIL (217 238)) 
Adding :FLDPI to table - (NIL (217 235)) 
Adding :FLDLN2 to table - (NIL (217 237)) 
Adding :FLDLG2 to table - (NIL (217 236)) 
Adding :FLDL2T to table - (NIL (217 233)) 
Adding :FLDL2E to table - (NIL (217 234)) 
Adding :FLD1 to table - (NIL (217 232)) 
Adding :FLD to table - ((fpureg) (217 192 +r)) 
Adding :FLD to table - ((mem80) (219 /5)) 
Adding :FLD to table - ((mem64) (221 /0)) 
Adding :FLD to table - ((mem32) (217 /0)) 
Adding :FISUBR to table - ((mem32) (218 /5)) 
Adding :FISUBR to table - ((mem16) (222 /5)) 
Adding :FISUB to table - ((mem32) (218 /4)) 
Adding :FISUB to table - ((mem16) (222 /4)) 
Adding :FNINIT to table - (NIL (219 227)) 
Adding :FINIT to table - (NIL (155 219 227)) 
Adding :FINCSTP to table - (NIL (217 247)) 
Adding :FIMUL to table - ((mem32) (218 /1)) 
Adding :FIMUL to table - ((mem16) (222 /1)) 
Adding :FISTP to table - ((mem64) (223 /7)) 
Adding :FISTP to table - ((mem32) (219 /3)) 
Adding :FISTP to table - ((mem16) (223 /3)) 
Adding :FIST to table - ((mem32) (219 /2)) 
Adding :FIST to table - ((mem16) (223 /2)) 
Adding :FILD to table - ((mem64) (223 /5)) 
Adding :FILD to table - ((mem32) (219 /0)) 
Adding :FILD to table - ((mem16) (223 /0)) 
Adding :FIDIVR to table - ((mem32) (218 /7)) 
Adding :FIDIVR to table - ((mem16) (222 /7)) 
Adding :FIDIV to table - ((mem32) (218 /6)) 
Adding :FIDIV to table - ((mem16) (222 /6)) 
Adding :FICOMP to table - ((mem32) (218 /3)) 
Adding :FICOMP to table - ((mem16) (222 /3)) 
Adding :FICOM to table - ((mem32) (218 /2)) 
Adding :FICOM to table - ((mem16) (222 /2)) 
Adding :FIADD to table - ((mem32) (218 /0)) 
Adding :FIADD to table - ((mem16) (222 /0)) 
Adding :FFREEP to table - ((fpureg) (223 192 +r)) 
Adding :FFREE to table - ((fpureg) (221 192 +r)) 
Adding :FEMMS to table - (NIL (15 14)) 
Adding :FDIVRP to table - ((fpureg ST0) (222 240 +r)) 
Adding :FDIVRP to table - ((fpureg) (222 240 +r)) 
Adding :FDIVP to table - ((fpureg ST0) (222 248 +r)) 
Adding :FDIVP to table - ((fpureg) (222 248 +r)) 
Adding :FDIVR to table - ((fpureg ST0) (220 240 +r)) 
Adding :FDIVR to table - ((fpureg) (220 240 +r)) 
Adding :FDIVR to table - ((ST0 fpureg) (216 248 +r)) 
Adding :FDIVR to table - ((fpureg) (216 248 +r)) 
Adding :FDIVR to table - ((mem64) (220 /0)) 
Adding :FDIVR to table - ((mem32) (216 /0)) 
Adding :FDIV to table - ((fpureg ST0) (220 248 +r)) 
Adding :FDIV to table - ((fpureg) (220 248 +r)) 
Adding :FDIV to table - ((ST0 fpureg) (216 240 +r)) 
Adding :FDIV to table - ((fpureg) (216 240 +r)) 
Adding :FDIV to table - ((mem64) (220 /6)) 
Adding :FDIV to table - ((mem32) (216 /6)) 
Adding :FNENI to table - (NIL (219 224)) 
Adding :FENI to table - (NIL (155 219 224)) 
Adding :FNDISI to table - (NIL (219 225)) 
Adding :FDISI to table - (NIL (155 219 225)) 
Adding :FDECSTP to table - (NIL (217 246)) 
Adding :FCOS to table - (NIL (217 255)) 
Adding :FCOMIP to table - ((ST0 fpureg) (223 240 +r)) 
Adding :FCOMIP to table - ((fpureg) (223 240 +r)) 
Adding :FCOMI to table - ((ST0 fpureg) (219 240 +r)) 
Adding :FCOMI to table - ((fpureg) (219 240 +r)) 
Adding :FCOMPP to table - (NIL (222 217)) 
Adding :FCOMP to table - ((ST0 fpureg) (216 216 +r)) 
Adding :FCOMP to table - ((fpureg) (216 216 +r)) 
Adding :FCOMP to table - ((mem64) (220 /3)) 
Adding :FCOMP to table - ((mem32) (216 /3)) 
Adding :FCOM to table - ((ST0 fpureg) (216 208 +r)) 
Adding :FCOM to table - ((fpureg) (216 208 +r)) 
Adding :FCOM to table - ((mem64) (220 /2)) 
Adding :FCOM to table - ((mem32) (216 /2)) 
Adding :FCMOVNU to table - ((ST0 fpureg) (219 216 +r)) 
Adding :FCMOVNU to table - ((fpureg) (219 216 +r)) 
Adding :FCMOVNBE to table - ((ST0 fpureg) (219 208 +r)) 
Adding :FCMOVNBE to table - ((fpureg) (219 208 +r)) 
Adding :FCMOVNE to table - ((ST0 fpureg) (219 200 +r)) 
Adding :FCMOVNE to table - ((fpureg) (219 200 +r)) 
Adding :FCMOVNB to table - ((ST0 fpureg) (219 192 +r)) 
Adding :FCMOVNB to table - ((fpureg) (219 192 +r)) 
Adding :FCMOVU to table - ((ST0 fpureg) (218 216 +r)) 
Adding :FCMOVU to table - ((fpureg) (218 216 +r)) 
Adding :FCMOVBE to table - ((ST0 fpureg) (218 208 +r)) 
Adding :FCMOVBE to table - ((fpureg) (218 208 +r)) 
Adding :FCMOVE to table - ((ST0 fpureg) (218 200 +r)) 
Adding :FCMOVE to table - ((fpureg) (218 200 +r)) 
Adding :FCMOVB to table - ((ST0 fpureg) (218 192 +r)) 
Adding :FCMOVB to table - ((fpureg) (218 192 +r)) 
Adding :FNCLEX to table - (NIL (219 226)) 
Adding :FCLEX to table - (NIL (155 219 226)) 
Adding :FCHS to table - (NIL (217 224)) 
Adding :FBSTP to table - ((mem80) (223 /6)) 
Adding :FBLD to table - ((mem80) (223 /4)) 
Adding :FADDP to table - ((fpureg ST0) (222 192 +r)) 
Adding :FADDP to table - ((fpureg) (222 192 +r)) 
Adding :FADD to table - ((fpureg ST0) (220 192 +r)) 
Adding :FADD to table - ((fpureg) (220 192 +r)) 
Adding :FADD to table - ((ST0 fpureg) (216 192 +r)) 
Adding :FADD to table - ((fpureg) (216 192 +r)) 
Adding :FADD to table - ((mem64) (220 /0)) 
Adding :FADD to table - ((mem32) (216 /0)) 
Adding :FABS to table - (NIL (217 225)) 
Adding :F2XM1 to table - (NIL (217 240)) 
Adding :ENTER to table - ((imm imm) (200 iw ib)) 
Adding :EMMS to table - (NIL (15 119)) 
Adding :DIVSS to table - ((xmm1 xmm2/mem32) (243 15 94 /r)) 
Adding :DIVSD to table - ((xmm1 xmm2/mem64) (242 15 94 /r)) 
Adding :DIVPS to table - ((xmm1 xmm2/mem128) (15 94 /r)) 
Adding :DIVPD to table - ((xmm1 xmm2/mem128) (102 15 94 /r)) 
Adding :DIV to table - ((r/m32) (o32 247 /6)) 
Adding :DIV to table - ((r/m16) (o16 247 /6)) 
Adding :DIV to table - ((r/m8) (246 /6)) 
Adding :DEC to table - ((r/m32) (o32 255 /1)) 
Adding :DEC to table - ((r/m16) (o16 255 /1)) 
Adding :DEC to table - ((r/m8) (254 /1)) 
Adding :DEC to table - ((reg32) (o32 72 +r)) 
Adding :DEC to table - ((reg16) (o16 72 +r)) 
Adding :DAS to table - (NIL (47)) 
Adding :DAA to table - (NIL (39)) 
Adding :CVTTSD2SI to table - ((reg32 xmm/mem32) (243 15 44 /r)) 
Adding :CVTTSD2SI to table - ((reg32 xmm/mem64) (242 15 44 /r)) 
Adding :CVTTPS2PI to table - ((mm xmm/mem64) (15 44 /r)) 
Adding :CVTTPS2DQ to table - ((xmm1 xmm2/mem128) (243 15 91 /r)) 
Adding :CVTTPD2PI to table - ((mm xmm/mem128) (102 15 44 /r)) 
Adding :CVTTPD2DQ to table - ((xmm1 xmm2/mem128) (102 15 230 /r)) 
Adding :CVTSS2SI to table - ((reg32 xmm/mem32) (243 15 45 /r)) 
Adding :CVTSS2SD to table - ((xmm1 xmm2/mem32) (243 15 90 /r)) 
Adding :CVTSI2SS to table - ((xmm r/m32) (243 15 42 /r)) 
Adding :CVTSI2SD to table - ((xmm r/m32) (242 15 42 /r)) 
Adding :CVTSD2SS to table - ((xmm1 xmm2/mem64) (242 15 90 /r)) 
Adding :CVTSD2SI to table - ((reg32 xmm/mem64) (242 15 45 /r)) 
Adding :CVTPS2PI to table - ((mm xmm/mem64) (15 45 /r)) 
Adding :CVTPS2PD to table - ((xmm1 xmm2/mem64) (15 90 /r)) 
Adding :CVTPS2DQ to table - ((xmm1 xmm2/mem128) (102 15 91 /r)) 
Adding :CVTPI2PS to table - ((xmm mm/mem64) (15 42 /r)) 
Adding :CVTPI2PD to table - ((xmm mm/mem64) (102 15 42 /r)) 
Adding :CVTPD2PS to table - ((xmm1 xmm2/mem128) (102 15 90 /r)) 
Adding :CVTPD2PI to table - ((mm xmm/mem128) (102 15 45 /r)) 
Adding :CVTPD2DQ to table - ((xmm1 xmm2/mem128) (242 15 230 /r)) 
Adding :CVTDQ2PS to table - ((xmm1 xmm2/mem128) (15 91 /r)) 
Adding :CVTDQ2PD to table - ((xmm1 xmm2/mem64) (243 15 230 /r)) 
Adding :CPUID to table - (NIL (15 162)) 
Adding :COMISS to table - ((xmm1 xmm2/mem32) (102 15 47 /r)) 
Adding :COMISD to table - ((xmm1 xmm2/mem64) (102 15 47 /r)) 
Adding :CMPXCHG8B to table - ((mem) (15 199 /1)) 
Adding :CMPXCHG486 to table - ((r/m32 reg32) (o32 15 167 /r)) 
Adding :CMPXCHG486 to table - ((r/m16 reg16) (o16 15 167 /r)) 
Adding :CMPXCHG486 to table - ((r/m8 reg8) (15 166 /r)) 
Adding :CMPXCHG to table - ((r/m32 reg32) (o32 15 177 /r)) 
Adding :CMPXCHG to table - ((r/m16 reg16) (o16 15 177 /r)) 
Adding :CMPXCHG to table - ((r/m8 reg8) (15 176 /r)) 
Adding :CMPORDSS to table - ((xmm1 xmm2/mem32) (243 15 194 /r 7)) 
Adding :CMPNLESS to table - ((xmm1 xmm2/mem32) (243 15 194 /r 6)) 
Adding :CMPNLTSS to table - ((xmm1 xmm2/mem32) (243 15 194 /r 5)) 
Adding :CMPNEQSS to table - ((xmm1 xmm2/mem32) (243 15 194 /r 4)) 
Adding :CMPUNORDSS to table - ((xmm1 xmm2/mem32) (243 15 194 /r 3)) 
Adding :CMPLESS to table - ((xmm1 xmm2/mem32) (243 15 194 /r 2)) 
Adding :CMPLTSS to table - ((xmm1 xmm2/mem32) (243 15 194 /r 1)) 
Adding :CMPEQSS to table - ((xmm1 xmm2/mem32) (243 15 194 /r 0)) 
Adding :CMPSS to table - ((xmm1 xmm2/mem32 imm8) (243 15 194 /r ib)) 
Adding :CMPORDSD to table - ((xmm1 xmm2/mem64) (242 15 194 /r 7)) 
Adding :CMPNLESD to table - ((xmm1 xmm2/mem64) (242 15 194 /r 6)) 
Adding :CMPNLTSD to table - ((xmm1 xmm2/mem64) (242 15 194 /r 5)) 
Adding :CMPNEQSD to table - ((xmm1 xmm2/mem64) (242 15 194 /r 4)) 
Adding :CMPUNORDSD to table - ((xmm1 xmm2/mem64) (242 15 194 /r 3)) 
Adding :CMPLESD to table - ((xmm1 xmm2/mem64) (242 15 194 /r 2)) 
Adding :CMPLTSD to table - ((xmm1 xmm2/mem64) (242 15 194 /r 1)) 
Adding :CMPEQSD to table - ((xmm1 xmm2/mem64) (242 15 194 /r 0)) 
Adding :CMPSD to table - ((xmm1 xmm2/mem64 imm8) (242 15 194 /r ib)) 
Adding :CMPSD to table - (NIL (o32 167)) 
Adding :CMPSW to table - (NIL (o16 167)) 
Adding :CMPSB to table - (NIL (166)) 
Adding :CMPORDPS to table - ((xmm1 xmm2/mem128) (15 194 /r 7)) 
Adding :CMPNLEPS to table - ((xmm1 xmm2/mem128) (15 194 /r 6)) 
Adding :CMPNLTPS to table - ((xmm1 xmm2/mem128) (15 194 /r 5)) 
Adding :CMPNEQPS to table - ((xmm1 xmm2/mem128) (15 194 /r 4)) 
Adding :CMPUNORDPS to table - ((xmm1 xmm2/mem128) (15 194 /r 3)) 
Adding :CMPLEPS to table - ((xmm1 xmm2/mem128) (15 194 /r 2)) 
Adding :CMPLTPS to table - ((xmm1 xmm2/mem128) (15 194 /r 1)) 
Adding :CMPEQPS to table - ((xmm1 xmm2/mem128) (15 194 /r 0)) 
Adding :CMPPS to table - ((xmm1 xmm2/mem128 imm8) (15 194 /r ib)) 
Adding :CMPORDPD to table - ((xmm1 xmm2/mem128) (102 15 194 /r 7)) 
Adding :CMPNLEPD to table - ((xmm1 xmm2/mem128) (102 15 194 /r 6)) 
Adding :CMPNLTPD to table - ((xmm1 xmm2/mem128) (102 15 194 /r 5)) 
Adding :CMPNEQPD to table - ((xmm1 xmm2/mem128) (102 15 194 /r 4)) 
Adding :CMPUNORDPD to table - ((xmm1 xmm2/mem128) (102 15 194 /r 3)) 
Adding :CMPLEPD to table - ((xmm1 xmm2/mem128) (102 15 194 /r 2)) 
Adding :CMPLTPD to table - ((xmm1 xmm2/mem128) (102 15 194 /r 1)) 
Adding :CMPEQPD to table - ((xmm1 xmm2/mem128) (102 15 194 /r 0)) 
Adding :CMPPD to table - ((xmm1 xmm2/mem128 imm8) (102 15 194 /r ib)) 
Adding :CMP to table - ((EAX imm32) (o32 61 id)) 
Adding :CMP to table - ((AX imm16) (o16 61 iw)) 
Adding :CMP to table - ((AL imm8) (60 ib)) 
Adding :CMP to table - ((r/m32 imm8) (o32 131 /0 ib)) 
Adding :CMP to table - ((r/m16 imm8) (o16 131 /0 ib)) 
Adding :CMP to table - ((r/m32 imm32) (o32 129 /0 id)) 
Adding :CMP to table - ((r/m16 imm16) (o16 129 /0 iw)) 
Adding :CMP to table - ((r/m8 imm8) (128 /0 ib)) 
Adding :CMP to table - ((reg32 r/m32) (o32 59 /r)) 
Adding :CMP to table - ((reg16 r/m16) (o16 59 /r)) 
Adding :CMP to table - ((reg8 r/m8) (58 /r)) 
Adding :CMP to table - ((r/m32 reg32) (o32 57 /r)) 
Adding :CMP to table - ((r/m16 reg16) (o16 57 /r)) 
Adding :CMP to table - ((r/m8 reg8) (56 /r)) 
Adding :CMC to table - (NIL (245)) 
Adding :CLFLUSH to table - ((mem) (15 174 /7)) 
Adding :CLTS to table - (NIL (15 6)) 
Adding :CLI to table - (NIL (250)) 
Adding :CLD to table - (NIL (252)) 
Adding :CLC to table - (NIL (248)) 
Adding :CDQ to table - (NIL (o32 153)) 
Adding :CWD to table - (NIL (o16 153)) 
Adding :CWDE to table - (NIL (o32 152)) 
Adding :CBW to table - (NIL (o16 152)) 
Adding :CALL to table - ((r/m32) (o32 255 /2)) 
Adding :CALL to table - ((r/m16) (o16 255 /2)) 
Adding :CALL to table - ((mem32) (o32 255 /3)) 
Adding :CALL to table - ((mem16) (o16 255 /3)) 
Adding :CALL to table - ((imm:imm32) (o32 154 id iw)) 
Adding :CALL to table - ((imm:imm16) (o16 154 iw iw)) 
Adding :CALL to table - ((imm) (232 rw/rd)) 
Adding :BTS to table - ((r/m32 imm) (o32 15 186 /5 ib)) 
Adding :BTS to table - ((r/m16 imm) (o16 15 186 /5 ib)) 
Adding :BTS to table - ((r/m32 reg32) (o32 15 171 /r)) 
Adding :BTS to table - ((r/m16 reg16) (o16 15 171 /r)) 
Adding :BTR to table - ((r/m32 imm8) (o32 15 186 /6 ib)) 
Adding :BTR to table - ((r/m16 imm8) (o16 15 186 /6 ib)) 
Adding :BTR to table - ((r/m32 reg32) (o32 15 179 /r)) 
Adding :BTR to table - ((r/m16 reg16) (o16 15 179 /r)) 
Adding :BTC to table - ((r/m32 imm8) (o32 15 186 /7 ib)) 
Adding :BTC to table - ((r/m16 imm8) (o16 15 186 /7 ib)) 
Adding :BTC to table - ((r/m32 reg32) (o32 15 187 /r)) 
Adding :BTC to table - ((r/m16 reg16) (o16 15 187 /r)) 
Adding :BT to table - ((r/m32 imm8) (o32 15 186 /4 ib)) 
Adding :BT to table - ((r/m16 imm8) (o16 15 186 /4 ib)) 
Adding :BT to table - ((r/m32 reg32) (o32 15 163 /r)) 
Adding :BT to table - ((r/m16 reg16) (o16 15 163 /r)) 
Adding :BSWAP to table - ((reg32) (o32 15 200 +r)) 
Adding :BSR to table - ((reg32 r/m32) (o32 15 189 /r)) 
Adding :BSR to table - ((reg16 r/m16) (o16 15 189 /r)) 
Adding :BSF to table - ((reg32 r/m32) (o32 15 188 /r)) 
Adding :BSF to table - ((reg16 r/m16) (o16 15 188 /r)) 
Adding :BOUND to table - ((reg32 mem) (o32 98 /r)) 
Adding :BOUND to table - ((reg16 mem) (o16 98 /r)) 
Adding :ARPL to table - ((r/m16 reg16) (99 /r)) 
Adding :ANDPS to table - ((xmm1 xmm2/mem128) (15 84 /r)) 
Adding :ANDPD to table - ((xmm1 xmm2/mem128) (102 15 84 /r)) 
Adding :ANDNPS to table - ((xmm1 xmm2/mem128) (15 85 /r)) 
Adding :ANDNPD to table - ((xmm1 xmm2/mem128) (102 15 85 /r)) 
Adding :AND to table - ((EAX imm32) (o32 37 id)) 
Adding :AND to table - ((AX imm16) (o16 37 iw)) 
Adding :AND to table - ((AL imm8) (36 ib)) 
Adding :AND to table - ((r/m32 imm8) (o32 131 /4 ib)) 
Adding :AND to table - ((r/m16 imm8) (o16 131 /4 ib)) 
Adding :AND to table - ((r/m32 imm32) (o32 129 /4 id)) 
Adding :AND to table - ((r/m16 imm16) (o16 129 /4 iw)) 
Adding :AND to table - ((r/m8 imm8) (128 /4 ib)) 
Adding :AND to table - ((reg32 r/m32) (o32 35 /r)) 
Adding :AND to table - ((reg16 r/m16) (o16 35 /r)) 
Adding :AND to table - ((reg8 r/m8) (34 /r)) 
Adding :AND to table - ((r/m32 reg32) (o32 33 /r)) 
Adding :AND to table - ((r/m16 reg16) (o16 33 /r)) 
Adding :AND to table - ((r/m8 reg8) (32 /r)) 
Adding :ADDSS to table - ((xmm1 xmm2/mem32) (243 15 88 /r)) 
Adding :ADDSD to table - ((xmm1 xmm2/mem64) (242 15 88 /r)) 
Adding :ADDPS to table - ((xmm1 xmm2/mem128) (15 88 /r)) 
Adding :ADDPD to table - ((xmm1 xmm2/mem128) (102 15 88 /r)) 
Adding :ADD to table - ((EAX imm32) (o32 5 id)) 
Adding :ADD to table - ((AX imm16) (o16 5 iw)) 
Adding :ADD to table - ((AL imm8) (4 ib)) 
Adding :ADD to table - ((r/m32 imm8) (o32 131 /0 ib)) 
Adding :ADD to table - ((r/m16 imm8) (o16 131 /0 ib)) 
Adding :ADD to table - ((r/m32 imm32) (o32 129 /0 id)) 
Adding :ADD to table - ((r/m16 imm16) (o16 129 /0 iw)) 
Adding :ADD to table - ((r/m8 imm8) (128 /0 ib)) 
Adding :ADD to table - ((reg32 r/m32) (o32 3 /r)) 
Adding :ADD to table - ((reg16 r/m16) (o16 3 /r)) 
Adding :ADD to table - ((reg8 r/m8) (2 /r)) 
Adding :ADD to table - ((r/m32 reg32) (o32 1 /r)) 
Adding :ADD to table - ((r/m16 reg16) (o16 1 /r)) 
Adding :ADD to table - ((r/m8 reg8) (0 /r)) 
Adding :ADC to table - ((EAX imm32) (o32 21 id)) 
Adding :ADC to table - ((AX imm16) (o16 21 iw)) 
Adding :ADC to table - ((AL imm8) (20 ib)) 
Adding :ADC to table - ((r/m32 imm8) (o32 131 /2 ib)) 
Adding :ADC to table - ((r/m16 imm8) (o16 131 /2 ib)) 
Adding :ADC to table - ((r/m32 imm32) (o32 129 /2 id)) 
Adding :ADC to table - ((r/m16 imm16) (o16 129 /2 iw)) 
Adding :ADC to table - ((r/m8 imm8) (128 /2 ib)) 
Adding :ADC to table - ((reg32 r/m32) (o32 19 /r)) 
Adding :ADC to table - ((reg16 r/m16) (o16 19 /r)) 
Adding :ADC to table - ((reg8 r/m8) (18 /r)) 
Adding :ADC to table - ((r/m32 reg32) (o32 17 /r)) 
Adding :ADC to table - ((r/m16 reg16) (o16 17 /r)) 
Adding :ADC to table - ((r/m8 reg8) (16 /r)) 
Adding :AAM to table - ((imm) (212 ib)) 
Adding :AAM to table - (NIL (212 10)) 
Adding :AAD to table - ((imm) (213 ib)) 
Adding :AAD to table - (NIL (213 10)) 
Adding :AAS to table - (NIL (63)) 
Adding :AAA to table - (NIL (55)) 
Adding :|J0 NEAR| to table - ((imm) (15 128 rw/rd)) 
Adding :|JNO NEAR| to table - ((imm) (15 129 rw/rd)) 
Adding :|JB NEAR| to table - ((imm) (15 130 rw/rd)) 
Adding :|JC NEAR| to table - ((imm) (15 130 rw/rd)) 
Adding :|JNAE NEAR| to table - ((imm) (15 130 rw/rd)) 
Adding :|JAE NEAR| to table - ((imm) (15 131 rw/rd)) 
Adding :|JNB NEAR| to table - ((imm) (15 131 rw/rd)) 
Adding :|JNC NEAR| to table - ((imm) (15 131 rw/rd)) 
Adding :|JE NEAR| to table - ((imm) (15 132 rw/rd)) 
Adding :|JZ NEAR| to table - ((imm) (15 132 rw/rd)) 
Adding :|JNE NEAR| to table - ((imm) (15 133 rw/rd)) 
Adding :|JNZ NEAR| to table - ((imm) (15 133 rw/rd)) 
Adding :|JBE NEAR| to table - ((imm) (15 134 rw/rd)) 
Adding :|JNA NEAR| to table - ((imm) (15 134 rw/rd)) 
Adding :|JA NEAR| to table - ((imm) (15 135 rw/rd)) 
Adding :|JNBE NEAR| to table - ((imm) (15 135 rw/rd)) 
Adding :|JS NEAR| to table - ((imm) (15 136 rw/rd)) 
Adding :|JNS NEAR| to table - ((imm) (15 137 rw/rd)) 
Adding :|JP NEAR| to table - ((imm) (15 138 rw/rd)) 
Adding :|JPE NEAR| to table - ((imm) (15 138 rw/rd)) 
Adding :|JNP NEAR| to table - ((imm) (15 139 rw/rd)) 
Adding :|JPO NEAR| to table - ((imm) (15 139 rw/rd)) 
Adding :|JL NEAR| to table - ((imm) (15 140 rw/rd)) 
Adding :|JNGE NEAR| to table - ((imm) (15 140 rw/rd)) 
Adding :|JGE NEAR| to table - ((imm) (15 141 rw/rd)) 
Adding :|JNL NEAR| to table - ((imm) (15 141 rw/rd)) 
Adding :|JLE NEAR| to table - ((imm) (15 142 rw/rd)) 
Adding :|JNG NEAR| to table - ((imm) (15 142 rw/rd)) 
Adding :|JG NEAR| to table - ((imm) (15 143 rw/rd)) 
Adding :|JNLE NEAR| to table - ((imm) (15 143 rw/rd)) 
Adding :J0 to table - ((imm) (112 rb)) 
Adding :JNO to table - ((imm) (113 rb)) 
Adding :JB to table - ((imm) (114 rb)) 
Adding :JC to table - ((imm) (114 rb)) 
Adding :JNAE to table - ((imm) (114 rb)) 
Adding :JAE to table - ((imm) (115 rb)) 
Adding :JNB to table - ((imm) (115 rb)) 
Adding :JNC to table - ((imm) (115 rb)) 
Adding :JE to table - ((imm) (116 rb)) 
Adding :JZ to table - ((imm) (116 rb)) 
Adding :JNE to table - ((imm) (117 rb)) 
Adding :JNZ to table - ((imm) (117 rb)) 
Adding :JBE to table - ((imm) (118 rb)) 
Adding :JNA to table - ((imm) (118 rb)) 
Adding :JA to table - ((imm) (119 rb)) 
Adding :JNBE to table - ((imm) (119 rb)) 
Adding :JS to table - ((imm) (120 rb)) 
Adding :JNS to table - ((imm) (121 rb)) 
Adding :JP to table - ((imm) (122 rb)) 
Adding :JPE to table - ((imm) (122 rb)) 
Adding :JNP to table - ((imm) (123 rb)) 
Adding :JPO to table - ((imm) (123 rb)) 
Adding :JL to table - ((imm) (124 rb)) 
Adding :JNGE to table - ((imm) (124 rb)) 
Adding :JGE to table - ((imm) (125 rb)) 
Adding :JNL to table - ((imm) (125 rb)) 
Adding :JLE to table - ((imm) (126 rb)) 
Adding :JNG to table - ((imm) (126 rb)) 
Adding :JG to table - ((imm) (127 rb)) 
Adding :JNLE to table - ((imm) (127 rb)) 
Adding :SET0 to table - ((r/m8) (15 144 /2)) 
Adding :SETNO to table - ((r/m8) (15 145 /2)) 
Adding :SETB to table - ((r/m8) (15 146 /2)) 
Adding :SETC to table - ((r/m8) (15 146 /2)) 
Adding :SETNAE to table - ((r/m8) (15 146 /2)) 
Adding :SETAE to table - ((r/m8) (15 147 /2)) 
Adding :SETNB to table - ((r/m8) (15 147 /2)) 
Adding :SETNC to table - ((r/m8) (15 147 /2)) 
Adding :SETE to table - ((r/m8) (15 148 /2)) 
Adding :SETZ to table - ((r/m8) (15 148 /2)) 
Adding :SETNE to table - ((r/m8) (15 149 /2)) 
Adding :SETNZ to table - ((r/m8) (15 149 /2)) 
Adding :SETBE to table - ((r/m8) (15 150 /2)) 
Adding :SETNA to table - ((r/m8) (15 150 /2)) 
Adding :SETA to table - ((r/m8) (15 151 /2)) 
Adding :SETNBE to table - ((r/m8) (15 151 /2)) 
Adding :SETS to table - ((r/m8) (15 152 /2)) 
Adding :SETNS to table - ((r/m8) (15 153 /2)) 
Adding :SETP to table - ((r/m8) (15 154 /2)) 
Adding :SETPE to table - ((r/m8) (15 154 /2)) 
Adding :SETNP to table - ((r/m8) (15 155 /2)) 
Adding :SETPO to table - ((r/m8) (15 155 /2)) 
Adding :SETL to table - ((r/m8) (15 156 /2)) 
Adding :SETNGE to table - ((r/m8) (15 156 /2)) 
Adding :SETGE to table - ((r/m8) (15 157 /2)) 
Adding :SETNL to table - ((r/m8) (15 157 /2)) 
Adding :SETLE to table - ((r/m8) (15 158 /2)) 
Adding :SETNG to table - ((r/m8) (15 158 /2)) 
Adding :SETG to table - ((r/m8) (15 159 /2)) 
Adding :SETNLE to table - ((r/m8) (15 159 /2)) 
Adding :CMOV0 to table - ((reg32 r/m32) (o32 15 64 /r)) 
Adding :CMOVNO to table - ((reg32 r/m32) (o32 15 65 /r)) 
Adding :CMOVB to table - ((reg32 r/m32) (o32 15 66 /r)) 
Adding :CMOVC to table - ((reg32 r/m32) (o32 15 66 /r)) 
Adding :CMOVNAE to table - ((reg32 r/m32) (o32 15 66 /r)) 
Adding :CMOVAE to table - ((reg32 r/m32) (o32 15 67 /r)) 
Adding :CMOVNB to table - ((reg32 r/m32) (o32 15 67 /r)) 
Adding :CMOVNC to table - ((reg32 r/m32) (o32 15 67 /r)) 
Adding :CMOVE to table - ((reg32 r/m32) (o32 15 68 /r)) 
Adding :CMOVZ to table - ((reg32 r/m32) (o32 15 68 /r)) 
Adding :CMOVNE to table - ((reg32 r/m32) (o32 15 69 /r)) 
Adding :CMOVNZ to table - ((reg32 r/m32) (o32 15 69 /r)) 
Adding :CMOVBE to table - ((reg32 r/m32) (o32 15 70 /r)) 
Adding :CMOVNA to table - ((reg32 r/m32) (o32 15 70 /r)) 
Adding :CMOVA to table - ((reg32 r/m32) (o32 15 71 /r)) 
Adding :CMOVNBE to table - ((reg32 r/m32) (o32 15 71 /r)) 
Adding :CMOVS to table - ((reg32 r/m32) (o32 15 72 /r)) 
Adding :CMOVNS to table - ((reg32 r/m32) (o32 15 73 /r)) 
Adding :CMOVP to table - ((reg32 r/m32) (o32 15 74 /r)) 
Adding :CMOVPE to table - ((reg32 r/m32) (o32 15 74 /r)) 
Adding :CMOVNP to table - ((reg32 r/m32) (o32 15 75 /r)) 
Adding :CMOVPO to table - ((reg32 r/m32) (o32 15 75 /r)) 
Adding :CMOVL to table - ((reg32 r/m32) (o32 15 76 /r)) 
Adding :CMOVNGE to table - ((reg32 r/m32) (o32 15 76 /r)) 
Adding :CMOVGE to table - ((reg32 r/m32) (o32 15 77 /r)) 
Adding :CMOVNL to table - ((reg32 r/m32) (o32 15 77 /r)) 
Adding :CMOVLE to table - ((reg32 r/m32) (o32 15 78 /r)) 
Adding :CMOVNG to table - ((reg32 r/m32) (o32 15 78 /r)) 
Adding :CMOVG to table - ((reg32 r/m32) (o32 15 79 /r)) 
Adding :CMOVNLE to table - ((reg32 r/m32) (o32 15 79 /r)) 
Adding :CMOV0 to table - ((reg16 r/m16) (o16 15 64 /r)) 
Adding :CMOVNO to table - ((reg16 r/m16) (o16 15 65 /r)) 
Adding :CMOVB to table - ((reg16 r/m16) (o16 15 66 /r)) 
Adding :CMOVC to table - ((reg16 r/m16) (o16 15 66 /r)) 
Adding :CMOVNAE to table - ((reg16 r/m16) (o16 15 66 /r)) 
Adding :CMOVAE to table - ((reg16 r/m16) (o16 15 67 /r)) 
Adding :CMOVNB to table - ((reg16 r/m16) (o16 15 67 /r)) 
Adding :CMOVNC to table - ((reg16 r/m16) (o16 15 67 /r)) 
Adding :CMOVE to table - ((reg16 r/m16) (o16 15 68 /r)) 
Adding :CMOVZ to table - ((reg16 r/m16) (o16 15 68 /r)) 
Adding :CMOVNE to table - ((reg16 r/m16) (o16 15 69 /r)) 
Adding :CMOVNZ to table - ((reg16 r/m16) (o16 15 69 /r)) 
Adding :CMOVBE to table - ((reg16 r/m16) (o16 15 70 /r)) 
Adding :CMOVNA to table - ((reg16 r/m16) (o16 15 70 /r)) 
Adding :CMOVA to table - ((reg16 r/m16) (o16 15 71 /r)) 
Adding :CMOVNBE to table - ((reg16 r/m16) (o16 15 71 /r)) 
Adding :CMOVS to table - ((reg16 r/m16) (o16 15 72 /r)) 
Adding :CMOVNS to table - ((reg16 r/m16) (o16 15 73 /r)) 
Adding :CMOVP to table - ((reg16 r/m16) (o16 15 74 /r)) 
Adding :CMOVPE to table - ((reg16 r/m16) (o16 15 74 /r)) 
Adding :CMOVNP to table - ((reg16 r/m16) (o16 15 75 /r)) 
Adding :CMOVPO to table - ((reg16 r/m16) (o16 15 75 /r)) 
Adding :CMOVL to table - ((reg16 r/m16) (o16 15 76 /r)) 
Adding :CMOVNGE to table - ((reg16 r/m16) (o16 15 76 /r)) 
Adding :CMOVGE to table - ((reg16 r/m16) (o16 15 77 /r)) 
Adding :CMOVNL to table - ((reg16 r/m16) (o16 15 77 /r)) 
Adding :CMOVLE to table - ((reg16 r/m16) (o16 15 78 /r)) 
Adding :CMOVNG to table - ((reg16 r/m16) (o16 15 78 /r)) 
Adding :CMOVG to table - ((reg16 r/m16) (o16 15 79 /r)) 
Adding :CMOVNLE to table - ((reg16 r/m16) (o16 15 79 /r)) 
NIL
CL-USER> (cl-x86-asm::make-segment "text" :segment-type 'data-segment :set-to-current t)
; Evaluation aborted
CL-USER> (cl-x86-asm::make-segment "text" :segment-type 'cl-x86-asm::data-segment :set-to-current t)
#
CL-USER> (cl-x86-asm::assemble-forms :AAD :RET)
Looking up instruction AAD
Found instruction AAD
Looking up instruction RET
Found instruction RET
(NIL NIL)
CL-USER>

meta-meta-programming

2006-12-09T14:33:00.000Z

Strictly for laughs, and partly for performance: a bit of meta-meta-programming.



;; make #{ .. } notation become a short hand for (values ...)
(defun |#{-reader| (stream char arg)
   (declare (ignore char arg))
    `(values ,@(read-delimited-list #\} stream t)))

(set-dispatch-macro-character #\# #\{ #'|#{-reader|) 
(set-macro-character #\} (get-macro-character #\) nil))

(defmacro make-tuple-struct (&key type-name  tuple-type tuple-default-value elements)
  "Create a structure in the form needed for tuple / packing
unpacking. All fields should have the same type and default value."
  `(defstruct ,type-name 
     ,@(loop
     for element in elements
     collect (list element tuple-default-value :type tuple-type))))

;; test code
(make-tuple-struct :type-name vector2d   :tuple-type single-float :tuple-default-value 0.0 :elements (x y))
(make-tuple-struct :type-name vector3d   :tuple-type single-float :tuple-default-value 0.0 :elements (x y z))
(make-tuple-struct :type-name vector4d   :tuple-type single-float :tuple-default-value 0.0 :elements (x y z w))
(make-tuple-struct :type-name quaternion :tuple-type single-float :tuple-default-value 0.0 :elements (x y z w))
(make-tuple-struct :type-name color      :tuple-type single-float :tuple-default-value 0.0 :elements (r g b a))


(defmacro with-gensyms (syms &body body)
  `(let ,(mapcar #'(lambda (s) `(,s (gensym)))
   syms)
     ,@body))

(defmacro make-tuple-unpacker (&key type-name elements)
  "Create an unpacker function such as (vector? vector4d) that takes an instance
of a struct and unpacks it to tuples (aka multiple values)"
  (labels
      ((make-macro-name (type-name)
  (intern (concatenate 'string 
         (symbol-name type-name)
         "?")))
       (make-element-names (elements)
  (mapcar #'(lambda (x) 
       (find-symbol  
        (concatenate 'string 
       (symbol-name type-name) "-" 
       (symbol-name x))))
   elements)))
    `(defmacro ,(make-macro-name type-name) (packed-tuple)
      (let ((packed-tuple-sym (gensym)))
 `(let
     ((,packed-tuple-sym ,packed-tuple))
    (values ,@(loop 
   for element-name in (quote ,(make-element-names elements))
   collect (list element-name packed-tuple-sym))))))))

       


(make-tuple-unpacker :type-name vector2d :elements (x y))
(make-tuple-unpacker :type-name vector3d :elements (x y z))
(make-tuple-unpacker :type-name vector4d :elements (x y z w))
(make-tuple-unpacker :type-name quaternion :elements (x y z w))
(make-tuple-unpacker :type-name color  :elements (r g b a))

;; to do - not entirely sure if this is wise/neeed
;; is anything evaluated more than once? I lost track
(defmacro make-with-tuple (&key type-name)
  "Create a macro that can be used to bind members of the tuples struct to symbols
   to symbols e-g (with-vector thing-vec (x y z w) &body forms)"
  (labels 
      ((make-unpacker-name (type-name)
  (intern (concatenate 'string 
         (symbol-name type-name)
         "?")))
       (make-macro-name (type-name)
  (intern (concatenate 'string 
         "WITH-"
         (symbol-name type-name)))))
       `(defmacro ,(make-macro-name type-name) (tuple element-syms &body forms)
   `(multiple-value-bind
   ,(loop 
       for element-sym in element-syms 
       collect element-sym)
        (,',(make-unpacker-name type-name) ,tuple)
      ,@forms))))

(make-with-tuple :type-name vector2d)
(make-with-tuple :type-name vector3d)
(make-with-tuple :type-name vector4d)
(make-with-tuple :type-name quarternion)
(make-with-tuple :type-name color)

(defmacro make-tuple-packer (&key type-name elements)
  "Create a tuple-name! macro for packing multiple values into 
   a tuple struct. eg (vector! up #{ 0.0 1.0 0.0 })"
  (labels 
      ((make-packer-name (type-name)
  (intern (concatenate 'string 
         (symbol-name type-name)
         "!")))
       (make-element-names (elements)
  (mapcar #'(lambda (x) 
       (find-symbol  
        (concatenate 'string 
       (symbol-name type-name) "-" 
       (symbol-name x))))
   elements)))
    `(defmacro ,(make-packer-name type-name) (target-sym tuple-values)
       (let* ((element-name-list ',(make-element-names elements))     
       (varlist (mapcar #'(lambda (x) (gensym (symbol-name x))) element-name-list)))
  `(multiple-value-bind  
  ,(mapcar #'(lambda (x) x) varlist)
       ,tuple-values
   (progn  ,@(mapcar #'(lambda (p v) `(setf (,p ,target-sym) ,v)) element-name-list varlist)))))))

(make-tuple-packer :type-name vector2d   :elements (x y))
(make-tuple-packer :type-name vector3d   :elements (x y z))
(make-tuple-packer :type-name vector4d   :elements (x y z w))
(make-tuple-packer :type-name quaternion :elements (x y z w))
(make-tuple-packer :type-name color      :elements (r g b a))

(defparameter *blue* (make-color  :b 1.0))
(defparameter *transparent-blue* (make-color :b 1.0 :a 0.5))
(defparameter *red* (make-color  :r 1.0))
(defparameter *yellow* (make-color :r 1.0 :g 1.0))
(with-color *yellow* (yr yg yb ya) (format t "Yellow ~A ~A ~A ~A " yr yg yb ya))

;; change yellow to white
(color! *yellow*  #{ 1.0 1.0 1.0 0.0 })

(with-color *yellow* (yr yg yb ya) (format t "Yellow ~A ~A ~A ~A " yr yg yb ya))

;; confirm change
(color? *yellow*)

(defmacro make-tuple-type (tuple-name &key tuple-element-type tuple-default-value elements)
  "Create a tuple type in one swoosh with all the support macros for it"
  `(progn
    (make-tuple-struct :type-name ,tuple-name
        :tuple-type ,tuple-element-type 
        :tuple-default-value ,tuple-default-value
        :elements  ,elements )
    (make-tuple-unpacker :type-name ,tuple-name :elements ,elements)
    (make-with-tuple :type-name ,tuple-name)
    (make-tuple-packer :type-name ,tuple-name :elements ,elements)))

(make-tuple-type pixel :tuple-element-type (unsigned-byte 8) :tuple-default-value 0 :elements (b r g a))

make-tuple-type is a macro that invokes a set of macros that invoke macros. I hope to be able to build on this to get together a decent 3d-game/spatial-math collection of lisp code. Now I have to think about how exactly I want transforms to work. I'm tempted to code them as scale-rotate-translate rather than a straight matrix.

A POD polymorphic object

2006-08-28T00:23:00.000+01:00

Impossible, you cry: POD is POD and virtual functions are virtual functions and nary the twain shall meet! More sophisticated readers among you might assume this is a rehash of static polymorphism, but this is not so. I have a POD struct that can be used nonhomegenously in a container, and support run-time polymorphism. Without further ado, here is the code..

simple.h



enum eEngineObjectKind
{
   eMeshObject = 0,
   eSkeletonObject,
   nEngineObjectKinds
};

typedef float t_TRANSFORM[16];


typedef void (*UpdateFunctionPtr)(float time_delta);

extern UpdateFunctionPtr update_jump_table[nEngineObjectKinds];

template <typename T> class EngineObject
{
   private:
      T* object_data;
      enum eEngineObjectKind kind;
      
   public:
      void init_object()
      {
         kind = T::object_kind;  
         update_jump_table[kind] = T::object_update_fn;
         object_data = new T(); // or T::allocate_object
      };
      
      void update_object(float time_delta)
      {
         update_jump_table[kind](time_delta);
      }
};

template <> class EngineObject<void>
{
  private:
   void *object_data;
   eEngineObjectKind kind;

  public:
   void *getData() 
   {
      return object_data;
   }

   eEngineObjectKind getKind()
   {
      return kind;
   }

   void update_object(float time_delta)
   {
      update_jump_table[kind](time_delta);
   }

};

class EngineMeshData
{
  public:
   static  eEngineObjectKind object_kind; 
   static  UpdateFunctionPtr object_update_fn;

   static void UpdateMesh(float time_delta);

};

class EngineSkeletonData
{
  public:
   static  eEngineObjectKind object_kind; 
   static  UpdateFunctionPtr object_update_fn;

   static void UpdateSkeleton(float time_delta);

};

typedef EngineObject<EngineMeshData> EngineMeshObject;
typedef EngineObject<EngineSkeletonData> EngineSkeletonObject;

simple.cpp



#include <iostream>
#include "simple.h"

/**
 * pseudo - vtable !
 */
UpdateFunctionPtr update_jump_table[nEngineObjectKinds];

/**
 * skeleton defintions
 */
enum eEngineObjectKind EngineSkeletonData::object_kind = eSkeletonObject;

void EngineSkeletonData::UpdateSkeleton(float time_delta)
{
   std::cout << "Update Skeleton\n";
}

UpdateFunctionPtr EngineSkeletonData::object_update_fn = EngineSkeletonData::UpdateSkeleton;

/**
 * mesh defintions
 */
enum eEngineObjectKind EngineMeshData::object_kind = eMeshObject;

void EngineMeshData::UpdateMesh(float time_delta)
{
   std::cout << "Update Mesh\n";
}

UpdateFunctionPtr EngineMeshData::object_update_fn = EngineMeshData::UpdateMesh;




EngineObject<void> world[2];

int main (int argc, char *argv[])
{
   EngineSkeletonObject *skeleton = new(world) EngineSkeletonObject();
   skeleton->init_object();

   EngineMeshObject *mesh = new(world+1) EngineMeshObject();
   mesh->init_object();

   world[0].update_object(1.0f);
   world[1].update_object(1.0f);
   
};

The autoconf dance..

2006-08-21T09:54:00.000+01:00

It goes like this: .in and out....

aclocal -> aclocal.m4
autoheader -> config.h
autoconf -> configure
automake -> Makefile.ac -> Makefile.in
configure -> Makefile.in -> Makefile

Then make finally builds it....

Etags

2006-07-28T01:40:00.000+01:00

Nice as Emacs is for editing languages like Lisp, Lua or Python, I've never been 100% happy with it for C/C++ until now. I finally got my etags setup right. The trick is to do:

find /usr/include -name '*.h' | etags --declarations --no-globals

in your home directory and use the --include option of etags to include the generated TAG file in your home directory in your project TAG files.

This means you have a handy dictinonary you can use up to look up the function prototypes and macros in your system includes, which is something I have been missing a lot. Just looking at the function prototype itself is much better for jogging memory while in the zone, rather than having to hunt it down in a manual..

Python style tuples in Lisp

2006-05-07T18:20:00.000+01:00

It's easy to extend Lisp to handle python-style tuples. This is all it takes:


(defun |#{-reader| (stream char arg)
   (declare (ignore char arg))
    `(values ,@(read-delimited-list #\} stream t)))

(set-dispatch-macro-character #\# #\{ #'|#{-reader|)
(set-macro-character #\} (get-macro-character #\) nil))

It installs a despatching macro in the readtable - so that when the reader encounters the #{ sequence it reads it up to the } terminating character, then splices it into a (values ...) form.

You can do neat things like (setf #{x y z} #{ 1.2 3.0 3.0 }) to do tuple assignment with no further work - it all falls out of the standard behaviour of Common Lisp.

What I'm wondering, now is if it's possible to combine readtable hacks with regular expressions to implement a lexical parser for an entirely different language without leaving Lisp. I guess it is, but I haven't got a project with a use for it. Yet.

Ludum Dare

2006-05-01T16:35:00.000+01:00

Things I learnt on the Ludum Dare.

Even on a 48 hour schedule, after you have done 90% of your game, you still have the other 90% to do - gameplay tweaking.
There are some things I need to learn more about - pixel art, and audio coding. My finished game had no audio.
You can't mix 2D SDL content (menus) and 3D opengl content easily. Although the SDL does let you flip between the modes easily.
Steel Bank Common Lisp is not ready for prime-time application delivery on Win32. Although it is very close.
I can code about 2x as fast in Lisp with SLIME vs C++.
I can still write games.

Microsoft

2006-04-26T11:19:00.000+01:00

Since Microsoft are currently telling the world what a nice monster they are and how evil and arbitary the EU Competition supremos are, I think it's time to look back to when there actually was some freedom and choice in the software world - just before the appearance of Win 3.1, when you could choose between DR-DOS or MS-DOS, and how Microsoft killed that competition.

EDIT: The link mysteriously died. There don't seem to be too many copies of this doc floating on the web for some reason. Minds more paranoid than I may speculate

The rest, as they say, is history. There is just one thing I'd like to know: Who WAS AARD?

Frame zero is a mythical creature.

2006-04-06T07:44:00.000+01:00

I've decided that the entire last post was a result of semantic confusion. Keyframes and frames are different things; a frame is a measure of elapsed time, and a keyframe is a sample of animation at an instant in time, so it makes perfect sense to say an animation with four sampled keyframes actually has three frames; because frames are just seconds in disguise, just another way of expressing the elapsed time. The trick is to keep t accurate and all you have left is interpolation.

Frame zero. It drives me nuts.

2006-04-05T15:44:00.000+01:00

What am I talking about? Well, for the sake of argument, lets suppose I have a 4 - frame, keyframed animation, with the simulation and the renderer stepped at 1/30sec per frame. The artist sees 4 frames in Maya/Max/Blender/WhizzosAtomicModeller


t
+-----------+-----------+-----------+------------+
|           |           |           |            |
+-----------+-----------+-----------+------------+
0           1           2           3            4

To play a complete animation, we have to render at 5 intervals, starting with t=0 and ending with t=4. Great, so thats what you do, after all, the artists want to see *all* of their lovely animation, right?

So along comes someone else, actually observing the behavior of the animation and says "hey, our x frame animation is playing over x+1 frames", and the guy/thing/car is overshooting their turn/cutscene spot/fov

At this point a number of things can happen.

1> We rejig the logic/calling order so that animation_update() always gets called before animation_render() and we never see the t=0 frame. Everything seems right. There's no "unstated state", the animation is always playing - that has to be right, no? Er..as along as none of the more bright artists realize and get upset (rightly) that they are losing a frame of their lovingly hand-crafted animation every time.

2> We add one to the number of frames of animation every time the AI asks what the frame count is going to be. Velocities, etc get scaled accordingly. This can annoy AI people, if things take a frame longer than they think they will, especially when doing things like cornering. The API/Interface has to be bulletproof.

3> The opposite of 1>. Have every animation signal its desire to terminate a frame before the end and never play t=4 except either to hold a pose, or blended in with another animation that is transitioning in.

I've worked in shops that have used each. My personal preference is probably 3, but I've met people quite vehement about 1. I have never had the chutzpah to pull 2, myself, but I've seen people do it successfully.

Before I write yet another animation engine (properly, this time, I always tell myself!) I'd like to sound out the opinions of the crowd. Anyone have any strong arguments pro and con for any of these three?

Amazon Web Services With Lisp

2006-04-01T22:44:00.000+01:00

I've just had a nice day banging my head on the wall trying to figure out why I can't talk to amazon web services with cl-trivial-http. Turns out that trivial-http doesn't actually implement HTTP to the letter. GET is supposed to send the local path and not the full URL to the server.

When you send Amazon the local path instead of the full URL, it wants to play. Just for reference, here is my test code. Hope it helps someone...


;; load up requirements
(asdf:oos 'asdf:load-op 'trivial-sockets)
(asdf:oos 'asdf:load-op 'trivial-http)
(asdf:oos 'asdf:load-op 's-xml)

;; Define parts of the REST request.
(defparameter *baseurl* "http://webservices.amazon.com/onca/xml")
(defparameter *service* "AWSECommerceService")
(defparameter *accesskeyid* "098CMPJ4AGZ7C6T1DHG2") 
(defparameter *operation* "ItemSearch")
(defparameter *searchindex* "Books")
(defparameter *default-response-group* "Request,Small")


(defparameter *search-indexes* '( "Apparel" "Automotive"  "Baby"  "Beauty"  "Blended"  "Books"  "Classical"  "DigitalMusic"  "DVD"  "Electronics"  "ForeignBooks"  "GourmetFood"  "HealthPersonalCare"  "Hobbies"  "HomeGarden"  "Jewelry"  "Kitchen"  "Magazines"  "Merchants"  "Miscellaneous"  "Music"  "MusicalInstruments"  "MusicTracks"  "OfficeProducts"  "OutdoorLiving"  "PCHardware"  "PetSupplies"  "Photo"  "Restaurants"  "Software"  "SoftwareVideoGames"  "SportingGoods"  "Tools"  "Toys"  "VHS"  "Video"  "VideoGames"  "Wireless"  "WirelessAccessories" ) )

(defparameter *response-groups* '( "Accessories" "BrowseNodeInfo" "BrowseNodes" "Cart" "CartNewReleases" "CartTopSellers" "CartSimilarities" "CustomerFull" "CustomerInfo" "CustomerLists" "CustomerReviews" "EditorialReview" "Help" "Images" "ItemAttributes" "ItemIds" "Large" "ListFull" "ListInfo" "ListItems" "ListmaniaLists" "ListMinimum" "Medium" "NewReleases" "OfferFull" "Offers" "OfferSummary" "Request" "Reviews" "SalesRank" "SearchBins" "Seller" "SellerListing" "Similarities" "Small" "Subjects" "TopSellers" "Tracks" "TransactionDetails" "VariationMinimum" "Variations" "VariationImages" "VariationSummary" ))


(defun append-parameter-to-url (url name value)
  (let ((result 
  (concatenate 'string url "&" name "=" (trivial-http:escape-url-query value)))) 
    result))

(defun make-amazon-item-search-url (search-index &key keywords power title author item-page (response-group *default-response-group*))
  (if (not (member search-index *search-indexes* :test #'string=))
      (error "~A is not a valid search index" search-index)
      (let ((result 
      (concatenate 'string 
     *baseurl* "?Service=" *service* "&AWSAccessKeyId=" *accesskeyid* 
     "&Operation=ItemSearch&SearchIndex="  search-index "&ResponseGroup=" response-group
     "&ContentType=text%2Fxml&Version=2005-03-23")))
 (if keywords 
     (setf result (append-parameter-to-url result "Keywords" keywords)))
 (if author 
     (setf result (append-parameter-to-url result "Author" author)))
 (if title  
     (setf result (append-parameter-to-url result "Title" author)))
 (if power 
     (setf result (append-parameter-to-url result "Power" power)))
 (if item-page 
     (setf result (append-parameter-to-url result "ItemPage" item-page))) 
 result))) 
   


(defun url-path (url)
  (assert (string-equal url "http://" :end1 7))
  (let ((path-start (or (position #\/ url :start 7) (length url))))
    (subseq url path-start (length url))))
  

(defun amazon-http-get (url)
  (let* ((host (thttp::url-host url))
         (port (thttp::url-port url))
         (stream (trivial-sockets:open-stream host port)))
    (format stream "GET ~A HTTP/1.0~AHost: ~A~AUser-Agent: Trivial HTTP for Common Lisp~A~A"
     (url-path url) thttp::+crlf+ host thttp::+crlf+ thttp::+crlf+ thttp::+crlf+)
    (force-output stream)
    (list
     (thttp::response-read-code stream)
     (thttp::response-read-headers stream)
     stream)))

(defun test-amazon ()
  (destructuring-bind (response headers http-stream)
      (amazon-http-get (make-amazon-item-search-url "Books" :keywords "Lisp" :item-page "25"))
    (if (not (= response 200))
 (error  "response ~A  from server" response)
 (progn 
   (format t "response ~A~%" response)
   (format t "headers ~A~%" headers)
   (loop for line = (read-line http-stream nil nil)
  while line do (format t "~A%" line))))))

SDL and curses

2006-03-21T22:10:00.000Z

Curses is an ancient API for doing terminal I/O. SDL is a modern graphics library, nice and platform independent for talking to framebuffers, keyboards and other devices used in games. SDL_ttf is an extra library that lets you render TTF characters on an SDL framebuffer.

I've combined the three into one. I have a the beginnings of a curses-compatible library that renders to an SDL frambebuffer. It works well enough now for you to be able to play the Omega Roguelike in a window - see the screenshot. Hopefully it will become a way to rescue and make platform - independent old curses bound - apps. Expect it to hit Sourceforge in a few days.

Why my Java is lukewarm

2006-03-15T08:05:00.001Z

I loved this recent post from Bill Clementsons blog. It finally made me realise why Java drives me nuts. It's simple: the observation is made that C is ideal for programming a von-Neumann machine - it's a light abstraction of it's capabilities into human readable language - flow of control keywords, and a strong set of arithmetic operators take care of the CPU and ALU. It interfaces well with the host O/S because the host O/S is itself written in C, and it just treats memory as a huge flat, address space. Indirection is achieved via function pointers, so we can treat functions as first-class objects, sort of.

Lisp is at the other end, it's deeply emmeshed in the Lambda calculus wich appears to be an elegant model of computation - don't quote me on that, though, I'm only just beginning to learn this. However, the upshot is that it has powers of abstraction that leave other languages panting.

And Java. Well, Java. Java seems to be all about the notion of the object; at it's root, the absract data type. We lose the ease of interaction with the von-Neumann architecture that we gain with C, in return for this object abstraction and a huge class library. It almost pulls it off. Guy Steele called it "halfway to Lisp" but I think that was being generous. It's more like a third of the way to Lisp, given the lack of flexibility in constructing abstractions. Generics might even the balance a bit, I'm not yet sure: however, as they are not a compile - time construct, I doubt it.

Sometimes it's good to be freed from the von-Neumann architecture: but I'm not convinced that the object abstraction, on its own is enough. Interfaces are a poor substitute for first class functions and closures. It must be said that a disciplined programmer can do the bookkeeping needed by C without thinking, too much. All pointers need to be set to NULL in debug after being free'd(). Pointers that are going to point to something dynamically allocated must be initalised to NULL: usually this is enclosed in a suitable macro. There are perfectly good tools likeValgrind and Dev-Partner for tracking memory usage. Modern architectures make the dangling pointer/memory issue a thing of the past. If the tools availble are properly used.

I find Java excels where objects excel: constructing models of real-world processes where objects map nicely to concrete entities: GUI's are a good example. When you are dealing with a more amorphous problem, Java is suicide. There is a reason why the OO 101 courses always tend to show students GUI code as an example, or simple simulations. Those are the problems that classically, objects were designed to solve, and they solve them well.

In short, Java reminds me of Pascal; a language with training wheels that give you just enough power to write a decent program, but not enough to give you the rope to tie yourself in knots. In some environments, this would be an excellent thing, but I've been ruined forever by Lisp. Java will always be my fourth choice, after Lisp, C++ and C.

I know what I'm missing. Sniff.

Microsoft Out - Surreals Dali

2006-03-13T03:28:00.000Z

I've just been coding a small C++ Windows Forms app in Visual Studio Express .NET. It was the most surreal experience I've had for some time, let me tell you! Firstly, VSE 2005 emulates emacs, secondly C++ was my choice of language for coding a .NET app.

Editing using Emacs keystrokes in such a familiar environment, using a language that was almost, but not really C++ gave me a situation where I was seeing old habits and patterns appear in completely unfamiliar places. Every 5 mins I just had to pause and let the "what the hell?" feeling wash over me.

Still, I did get that app coded eventually, and it *was* easier than MFC. It only took Redmond eight (or was it 12?) years to improve on that..although to be fair, comparing the result of this exercise to a MFC 1.0 app is like comparing a light saber to a rusty tin-opener.

Quietness

2006-03-12T20:10:00.000Z

Yes, it's been quiet, here recently, but that's because I have been actually, you know, coding. Mostly I've been concentrating on the simple but useful: a mud client in Common Lisp that's stood as a good introduction to Common Lisp streams, and have been once more attempthing to rescue a few long abandoned but fairly amusing roguelike games by writing a version of curses that targets an SDL window. Nearly there. Just one more horrible implementation detail to work out.

Genetic Programming

2006-02-27T17:36:00.000Z

John Kozaformalized the use of LISP S-Expressions as the representation of Choice for Genetic Programming. Lisp S-expressions map directly onto a parse tree, which can be manipulated via the usual methods of tree modification. Functions that accept zero arguments or constants (quoted or otherwise are terminals) and other functions are non-terminals.

The standard GP algorithm takes five inputs.

a set of terminal functions, T
a set of non-terminal functions, NT
a set of control parameters P
a fitness funtion, f(x)
a termination criterion t

Contained in the set of control parameters are

n - the initial number of S-expressions
Di - the initial maximum depth of nesting of an S-Expression
Pr - probability of reproduction of a fit individual
Pc - probablility of recombination of a fit individual
Pm - probabiliy of mutation of a fit indivudual
Dc - maximum depth of nesting of an S-Expression during a run

The standard algorithm runs a follows

(setf *generation-count* 0)
(setf *current-population* (random-experssions :count n :nesting Di :terminals T :non-terminals TF))
(set *current-fitness* (loop for individial in *current-population* collect (fitness individual))
Filter the current population by fitness, producing a new individual by a randomly chosen method.
(setf *current-population* *new-population*)
(until t)

Fitness is usually measured by standardzed fitness where the fittest indvidiual has a fitness of zero. Reproduction is a asexual copy, mutation is asxual copying with reandom errors, and crosover is splicing together two infvidials from one half of each individial, the splice point being arbitarily chosen. It is important that the union of T and NT (called C) is sufficent to solve the target problem, and that all the functions accept and return arguments of the same type.

Intresting Lisp Factoid of the Day

2006-02-24T08:49:00.000Z

You can put docstrings in Lambda expressions. Whee, just what I always wanted!

((lambda (x) "This is documented" (format t "~A" x)) 
1

More on Cooperatives

2006-02-21T15:09:00.000Z

Of course, my recent ramblings on co-operatives only echo a train of thought someone , somewhere else has had and put into action: take a look at the SelectParks co-operative. At least I know I'm not going crazy, now.

More Lisp on Gentoo

2006-02-05T17:01:00.000Z

The sbcl-cvs ebuild turned out to be a good example of the pitfalls awaiting the CVS ebuilder. Recently the contrib/systems directory was removed from sbcl cvs as Win32 doesn't do symlinks. Unfortunately, the plain-vanilla Gentoo asdf ebuild still wanted them, so when you loaded up Slime it complained it couldn't find SB-BSD-SOCKETS.

The solution was to create the symlinks as part of the ebuild. Slime now works with it..Here's the new ebuild. It needs to live in /usr/local/portage/dev-lisp and you need PORTDIR_OVERLAY="/usr/local/portage" in your make.conf.

Edit: perhaps I should also warn you that this ebuild uses cmucl to compile sbcl and will pull that in, too.

Lisp on Gentoo

2006-02-02T07:04:00.000Z

One thing about Lisp is that releases of packages tend to be infrequent: for instance Gentoo's cl-mcclim is ancient, and doesn't compile with the *unmasked* sbcl (.94) in portage. Advice on #lisp is that many asdf packages should be pulled from CVS rather than messing about with distro packages. One nice thing about Gentoo is that you can write ebuild scripts that pull distro packages straight from CVS, so I'm going to write a few ebuilds for myself and publish them here to save a few people time. First off is the SBCL CVS ebuild.

The Independent Game Developers Co-operative

2006-01-27T08:40:00.000Z

Many developers are fond of excorciating the current state of the games industry, bemoaning how broken the current publisher - developer model is, and are looking for a more sane alternative that concentrates on the quality of the games themselves. At least three times in my career I've experienced the tension between the need for a publically owned company to maximise profit for its shareholders and the desire of game developers just to keep working on a game, until it reaches the quality threshold they are comfortable with putting their name to. Realistically, there is no way that this is going to get resolved in favour of the developers. I've accepted that as part of working in the industry; if you need the results for this quarter, you need the results for this quarter and that's how it is.

However, there *is* a positive alternative if there are enough people brave enough, out there. A co-operative. The whole essence of a co-operative is the opposite of a company. Members own shares, and the co-operative exists to provide services or goods to the members in the most effective possible way. For an up-to date example, see the Tech Co-op in Canada.

Off the top of my head, this is how I see it working:

I'd envisage a game developers co-op working as two-coperatives: first there would be a gamers service co-op and secondly there would be a smaller game developers workers co-op, the membership of the first driving the second. The reaons for this are that the membership of the gamers co-op would be open to anyone on the internet. Membership would get you regular mailed game CD's for at least a year, then these would be provided thereafter for a small subscription fee. The gamer as a member of the co-operative would be able to pitch ideas and designs to the developers-cooperative, get technical support, game server hosting, and other services to be identified.

The game developers co-operative would provide or sell services to the gamers co-op at a preferential rate, but would also engage in marketing and distribution efforts on behalf of it's members. This would enable an otherwise less affluent group of developers to talk directly to publishers and get access to platforms it would otherwise not have access to. Revenue would be ploughed back into the memebers projects.

These are only tentative back of the envelope thoughts; the main point is that with the reach of the internet, a co-operative has the potential be a much larger, more effective organisation than before. The inherent problems with such a proposal - no one reaching any agreement - have to be dealt with by careful sturcturing of the co-operative.

It's time for me to do more research..

Oracle XE on Gentoo

2006-01-08T14:22:00.000Z

Installing Oracle Express Edition on Gentoo Linux was both easy and hard. It's the usual case of synthesising bits and peices off the web: the system tweaking you have to do pre-install is well documented here; then you need a portage overlay, as documented here, and then you can use the ebuild from this thread to install it.

Once it's up and running getting emacs to talk to it is a peice of cake. You need to customise the oracle-sql program to point to the installed sqlplus binary, and you need to source oracle_env.sh from the config directory..then launch emacs and connect.

It took some work, but it's *much* better than using a bare sql plus instance and notepad in Windows. I can develop my SQL in a similar style to my Lisp, sending fragments to a running instance via C-c C-r, which is the absolute minimum I am coming to expect of any language.

Lets try plugging this into this...

2005-12-18T12:41:00.000Z

My last two assignments (Java, Web coding) were very straightforward and boring, so I've decided to make my life interesting by using a combination of Oracle 10g Express, CLSQL, and Gentoo Linux for my database assignment. Neither officially supports any of the others, but they should fit together. Let's see...

Lisp software renderer

2005-12-18T12:38:00.000Z

My pet Lisp project has been languishing on my laptop recently; I've had a fiddle with the Linux Framebuffer Device interface, and it's occured to me I might more usefully bind to that than the PTC library. Potentially it could be a non X based graphical backend to the McCLIM. Someone is already working on an Open GL backend and that code could map over quite nicely...the fonts would be some kind of awful hack, though...

Bitmap Fonts, Java, Wingdings and Unicode

2005-11-27T16:58:00.000Z

After my brush with the script-fu I thought I'd go back to basics and do the bitmap font creator as a Java app. I have whipped up this app for knocking up old school bitmap fonts. The gradient fills haven't really surrvived Pay attention to the picture, as it shows at what code points to find the Wingdings glyphs in the Unicode set. It's not 0..255, as has puzzled many Java coders before!

Bitmap fonts and the script-fu.

2005-11-17T15:14:00.000Z

Despite my rant against script-fu, it must be acknowlgeded it's highly useful for getting game art knocked out in double quick time for example, bitmap fonts. Here's a script that can knock one up in a jiffy - it's just a sligtly modified version of a standard script. I'm somewhat dismayed by the size of the .png file.

Script-fu

2005-11-16T10:21:00.000Z

Today I delved into the realm of Gimp, SIOD, Script-fu; and let me tell you it's the least productive environment I've hit since the ZX81. I mean (set! variable value) is your assignment operator, so like a good lisp monkey I try (set! (aref string 1) "A"). Does that work? No. You use something called (aset string 1 65) why doesn't it have a bang, eh?

So, I want to create an array. Now I created a list with make-list, so, of course, I want to use make-array. No? Gotcha again! It's cons-array. Arrgh!

Add that to the fact that pressing the escape key closes the script-fu console window; which is something I do quite a lot, as it's hardwired into me that Escape means "clear the input" and that the documentation is just a scrappy list of functions that makes it hard to find what you need, that's a recipie for a very frustrating morning. The tragedy is that this is going to be some peoples first exposure to a lisp-like language..it could be so much better; the scintilla component could have been embedded in, there could be a much better tutorial and reference; but I guess someone would have to be paid for that..

Sony are in so much trouble..

2005-11-14T09:46:00.000Z

This story just runs and runs. Not only do Sony release a rootkit that installs itself onto Windows PC's without telling people, and get discovered, it turns out that the rootkit is a GPL violation! This one is going to run and run...are Sony trying to replace Microsoft as the Evil Empire? They seem to be taking a pretty good shot at it!

Package du Jour: Dia

2005-11-07T20:07:00.000Z

I've been playing with Dia and been moderately impressed with what I've found. I've been using it as part of my course; being able to export to .pngs is good. It's happy with a wide range of diagrams: mostly I am using it for entity relationship diagrams and UML. There's even a uml to code generator for it which I intend to try using for my Java assignment. While I can't say it's as good as Visio (when did that become part of Microsoft Office), it's a cheap way for students to explore UML and "good enough" for most small projects, and it has an interesting quirky diagram set: isometric game tiles - houses, railways, fields - which can be used to layout a small toy town. It might even be a game prototyping tool one day; with the right tileset..

Change of Direction

2005-11-07T08:55:00.000Z

It might seem strange to some people that I have recently left Reflections and decided to enroll on a Masters degree course; it's a strange thing to do at 38 years of age. Even stranger, the Masters course is not strictly games-oriented. Well it's not as big a jump into the unknown as it looks: many of the new mobile platforms use Java, databases are increasingly important - both as repositories for the huge number of assets used in game development, and for the backend of MMPORG's as well as their more humble play-by-web cousins.

The web itself is probably the most interesting platform around today: it's a mass medium based on a mishmash of standards and technologies that can be bent to do almost everything; a giant laboratory free from the restrictions of proprietary console platform development.

I'm beginning to suspect a much better (as in scalable, among other things) platform for games development can be assembled out of some of the emergent technologies available now; a distributed, social system capable of handling vast amounts of assets, and large numbers of distributed collaborators. It's my intention to try and assemble a platform capable of this, and offer it as a model for further research.

It's also my intention to learn as much as possible in a short time whithout my brain exploding; as this is the most challenging course my local university has to offer, that might be hard. Still, onwards...

More newbie thoughts on Lisp

2005-10-13T14:29:00.000+01:00

It's become obvious with the code I've been writing recently that Lisp's strength and weaknesses are all tied to it's lack of syntax. The fact it has very little in the way of syntax leads to a combinatorial explosion - there are an almost infinite number of ways to do simple things: it makes me wonder if the whole purpose of strong syntax in languages isn't simply to prevent this, and guide the energies of programmers into productive channels. It certainly was the case in C and Fortran where syntax was carefully constructed to enable mapping high level language to machine instructions a straightforward transformation.

However the lack of syntax has to be an achilles heel: the huge number of idioms that could be applied to simple programs means no two coders are going to write anything neccesarily similar. I'm assming the full set of coders of all levels of competence here. I expect a smaller set of seasoned coders would converge on similar solutions given similar problems. Which makes it a devastating weapon in the hands of a sesoned coder, but probably in a team of mixed abilities it would lead to much higher communication oveheads.

Project Madness

2005-10-06T15:01:00.000+01:00

I simply have to back off, I'm trying to do too many bloody things at once.

Here's my long list

Get deeply enought into web/database tech to get a small play-by-web game running.

Update the Omega rougelike game for the SDL & modern multiplatform code.

Update Blah, a roguelike skeleton that fell off the net many moons ago, with SDL graphics and Lua scripting.

Finish the LISP software renderer.

Create a tool for parsing C into sexp's with an eye to auto-generating UFFI or CFFI bindings.

Some unspecified Java app, just to keep my hand in : possibly a Blogger to Live-Journal migration tool.

Some more games that have been bubbling under the radar for what seems like years.

Lunch with Laura - a graphic novel. Nothing to do with coding, but it competes for time.

Clearly, something has to give, somewhere..

XEmacs Wins

2005-09-08T16:59:00.000+01:00

Mostly because you can configure it seven hundred ways to Sunday, and after lots of fiddling I arrived at an init.el I kind of liked. It has room for improvement. It probably shouldn't rely on cscope for tagging, becasue that's platform specific. It probably should fall back on plain old tags. Onwards to do some actual coding then: programmers are the only people who can get so preoccupied with sharpening an axe they forget about the damn tree.

Grand Text Editor

2005-09-07T11:23:00.000+01:00

I find myself prevaricating between editors. I know I have to pick one and stick to it, but I can't make up my mind which. I've narrowed it down to a few promising candidates, all cross-platform.

Emacs.

XEmacs is pretty much *the* editor if I want to code in Lisp, as it has Slime, one of the most interactive and potentially productive programming environments I've ever seen. The Emacs Code Browser gives me IDE-like organisation and navigation. It integrates nicely with gdb and the shell. The con side is that the tagging is poor, and requiring more than three keystrokes to do anything useful makes it difficult and "slow;" feeling to work with. It's so configurable it's difficult to zero in on a single working style with it. The learning curve seems endless.

Gvim.

Vi - Improved. Another editing heavyweight, and the keystrokes are both brief and seared into my brain as I've been exposed to it on and off throughout my career. Frankly, if it wasn't for the amount of Lisp I do, it'd be my editor of choice. It doesn't have anything like ECB - but it does have sessions - a collection of settings that can be quickly saved and restarted. Which is fine for keeping track of different projects. It also as a huge collection of scripts and customisations, like Emacs..The keyword completion is wicked, but it's not context sensitive like Intellisence.

JEdit.

JEdit is another contender. It handles sessions and tags pretty much as well as Vi and XEmacs do. It's set of plugins are not as comprehensive as vim or XEmacs, but there's enough for the job. It's main benefit is a more modern gui and a slicker feel. Comfort is an important factor. The plugins are very Java-centric, and I suspect this editor would be a powerhouse for a Java coder, but I'm not so sure about how it would pan out for a C++/Lisp coder.

Visual Slick Edit.

The only commercial editor of the bunch, and the slickest. It intelligently does completion of structure and class members, parameter lists, and does incremental tagging in the background: as a result I'm more productive when coding in C/C++ with this editor. It gave me a real competitive advantage over my Visual Studio bound colleagues back in the days of Visual Studio 6. Although they have since caguht up. It can handle Python and there is a script for Lisp support on the website, which I haven't tried.Lack of Lisp is a major minus, otherwise this would ne a no-brainer. Although, perhaps I could use this in conjunction with the LispWorks IDE.

So which one do I pick? They all have something I want, and they all miss something else. Can anyone spot anything I've missed? Some plugin or mode that would give one an advantage over the other? Shorter XEmacs keystrokes? Intellisense for vim or JEdit? A good Lisp mode for Visual Slick Edit?

Goodbye Slackware

2005-09-05T20:21:00.000+01:00

One of the first things I've done with my newfound freedom since leaving Reflections is to review all my Linux installs. For a long time I've been soldiering on with the redoubtable Slackware. However, I resolved to give Debian a try, and frankly I'm amazed by what I've seen. Compared to Slackware install was fast, friendly and trouble-free: network, video, and sound were all auto-detected, and the graphical login came up first time.

Gnome is gorgeous, too, all point and click and "just works". Even this post came straight from the desktop blogging tool, rather than via Firefox.

Every time I revisit a mainstream distro, I'm amazed by the progress. Frankly, if something like this came pre-installed, damn few people would touch a Windows PC. Mind you, Steve Jobs has probably recently come to the same conclusion, so there maybe hope, yet...meanwhile, it's back to my Lisp rendering follies, I guess.

Lisp, the language that does your coding for you..

2005-06-18T10:40:00.000+01:00

Well, not quite - but almost. After reading Rogue Malcontents nifty post where he uses macros to wrap simple-arrays with structure - like syntax (very handy for interacting with APIs like OpenGL), I went back and looked at my code with a fresh eye. I found I was writing lots of forms like this :-


(red (get-red p0) (funcall red-interpolator))
(blue (get-blue p0) (funcall blue-interpolator))
(green (get-green p0) (funcall green-interpolator))
(alpha (get-alpha p0) (funcall alpha-interpolator))

..where the same form was wrapped around each colour channel of a pixel. So I thought "Hmm, time for a macro". My first attempt was something like this:

(defmacro with-pixel-colour-list (body)
  (list 
     `list 
   (replace-symbol 'get-pixel 'get-red body)
   (replace-symbol 'get-pixel 'get-blue body)
   (replace-symbol 'get-pixel 'get-green body)
   (replace-symbol 'get-pixel 'get-alpha body)))

Where replace-symbol was a utility function of my own devising which car'd its way through a form, replacing a matching symbol as it went - given here for completeness. So the form fed to with-pixel-colour list gets replicated four times - the first time with the get-pixel call replaced with a get-red call, the second time get-pixel replaced by a get-green call, and so forth. So I only have to write one form once, rathte than four times, and the compiler does the rest of the work for me, macro-expanding the code before compiling it.

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defun replace-symbol (sym1 sym2 list)
 (cond 
   ((null list)
    nil)
   ((null (car list))
    (replace-symbol sym1 sym2 (cdr list)))
   ((symbolp (car list)) 
    (if (string= (symbol-name sym1) (symbol-name (car list)))
     (cons sym2 (replace-symbol sym1 sym2 (cdr list)))
     (cons (car list) (replace-symbol sym1 sym2 (cdr list)))))
   ((listp (car list))
    (cons (replace-symbol sym1 sym2 (car list))
    (replace-symbol sym1 sym2 (cdr list))))
   (t (cons
    (car list)
    (replace-symbol sym1 sym2 (cdr list)))))))

So, (with-pixel-colours *my-pixel*) expands nicely to (LIST (GET-RED *MY-PIXEL*) (GET-BLUE *MY-PIXEL*) (GET-GREEN *MY-PIXEL*) (GET-ALPHA *MY-PIXEL*)) and I can write things like:

(defun sum-colours (pixel)
  (apply #'+ (with-pixel-colours (get-pixel pixel))))

(setf *my-pixel* (make-pixel 1 1 1 0))

(sum-colours *my-pixel*)

Fantastic - but there has to be a wider application than this - so my next task was to generalise it a bit. More in the next post. :)

I do get the feeling I'm re-inventing a well known technique, as I'm a newbie, and this kind of thing is just too useful. Any experienced Lisp coders care to comment?

Ion Drive

2005-05-31T00:06:00.000+01:00

I've never found a window manager I've been 100% happy with - KDE and Gnome are far to slow to live on my old P600 Laptop, Afterstep, while asethetically pleasing, had too many menus, too many different feels and options and and I never could settle on a consistent set. Ratpoison was my most recent discovery, and while I liked it for it's simplicity, it was a bit too simple - it handled modal dialogs like mozillas download manager dialog badly - putting them in a whole window. At last I've discovered Ion - a tad more sophisticated than Ratpoison, but not much, so it still responds instantly on a clapped out laptop. It just handles dialogs much better, and works on the same principe - you should be able to treat your window manager in exactly the same way as you treat your text editor window - by having multiple windows and frames you can split, delete, create, and traverse between via simple keystrokes. If you dislike mice, it's worth giving it a try..

The only problem is -- there will never be a Windows version. It'd be interesting to see what a Mac user would make of it, though..

And now colour it in..

2005-05-15T21:19:00.000+01:00

Added coloured tris to my renderer yesterday - it's coming along nicely. Started out as a "learn lisp" exercise, but now it's taking on a life of it's own.

Dynamic game difficulty adjustment.

2005-05-02T13:52:00.000+01:00

Some thoughts after reading The Psychology Behind Games by Anders Hejdenberg.

Should a game adjust it's difficulty level based on the players observed ability in the game? Possibly, but it's an artificial device. Response to changes in the players ability should probably err on the cautious side when making the game easy and on the converse side when making the game harder. It's important to have player profiles, too. Visual feedback of the current setting and a manual override would be nice, too. Some people don't want things to be too easy and for the game to "surrender", but other people would use such a mechanism to cheat, or just plain want to go through the game quickly.

Feedback and control are the watchwords, as ever.

Brand new Baby Bouncing Triangle

2005-04-24T17:13:00.000+01:00

At last cl-ptc (the Lisp software renderer) plots a nice, clean triangle, after weeks of fiddling around with interpolator functions, it's a relief. It's my first ever time as a lisp, so I'm proud to present my first ever bit of Lisp porn..

Lisp gets it right

2005-04-24T14:28:00.000+01:00

After playing with lots of different methods of linearly interpolating the edges of triangles (well, 3 - DDA, MAI, & Bressenham) in Lisp, I settled for the straight add the gradient to the minor axis. Madness, I hear you say - not really, because Lisp doesn't represent the result of integer division as a float, but as a pair of integers that represent a ratio, so even doing it this way means I can reserve the FPU for perspective - correct texture mapping the way Intel intended. Obviously, the representation of this ratio is implementation dependent, but I'd really hope that in an implemenation with 32 bit fixnums, the ratio is expressed as a 64 bit fixed point integer..of course it's also probably possible to get LISP to use 16 bit integers for coordinates and 32 bit integers for the ratios, but I haven't got that far into the type sysetem, yet.

Lisp Software Renderer, Redux

2005-04-15T21:02:00.000+01:00

Of course, it's impossible to leave a challenge I got so close to completing, and so I dust off the Lisp software renderer and return to the fray. I've had to grapple a bit with ASDF and learnt the hard way why upper case file names and lower case package names don't mix. Also, trying to write a tail-recursive Bressenham was interesting..only a few more bugs to wrinkle out and it can hit common-lisp.net.

Then I can go onto the freenode #lisp channel and get a critique, I hope. 123 notes at an (optimize (speed 3)) sounds like there's still a lot of work ahead..

CL-Ncurses

2005-02-21T11:58:00.000Z

I was playing with this at the weekend. And it's a nice solution for whipping up testbeds for simulations that can get away with a simple text interface. The trouble is it needs a bit of work, and the maintainer has dissapeared...

I'd really like to submit a patch but there doesn't seem to be any point. I wish there was some kind of policy on common-lisp.net for dealing with such orphaned projects. The same as with sourceforge, I guess.

LISP Software Renderer RIP

2005-02-14T13:52:00.000Z

I gave up on my quest to write a software renderer in Lisp - I got as far as creating nice antialiased clipped lines, but was driven to the conclusion that the only sane language for such a beast is assembler...even C doesn't get quite close enough to the metal without generous helpings of inline assembler - which kind of misses the point..

I did discover that a LISP compiler with a decent static type system, vectorisation, SSE/SIMD support, and inline assembler could do just about as good a job as C. Trouble is, there's no LISP system like that in existence. There's at least two good open source Lisps that could be persuaded to do it, though..

Debug versus Release builds

2005-01-31T13:11:00.000Z

This applies to fairly strongly and/or statically typed languages only, obviously:

The way I think of it, the difference between release and debug is the difference between trying to fly a plane with no instruments at all, and a possibly dodgy engine that won't neccessarily give you any warning that it's about to burn, versus a nice modern jet with thoroughly checked over engines and wiring, a full array of instrumentation and autopilots for everything you could possibly need.

Now - it's your backside in the plane - which do you want to fly?

Visual Studio and Standard Environments.

2005-01-26T18:58:00.000Z

Just what is it that people see in it? Working with it as an editor is like swimming through treacle. Without the Visual Assist plugin it's auto completion is limited and without lengthy compile times, it can't manage to tag a project well. You can only really edit three languages with it, and use only the hand full of source code control systems that implement a Microsoft API. It's scripting facilities are ripe for viral attack, and poor tools for automation.

The wizards to help programmers who don't know how to do basic things ignore their ignorance, though. I'm just a little pissed off about this "standard environment" that' s been imposed on everybody at work. The a component of the last "standard environment" was the slowest and most broken source control system I've ever worked with.

When carrying 500kilo weights is the standard environment for the Olympic High Jump, then all this will make sense. I think. Standard environments might be great for managers as they reduce programmers to the lowest common interchangable denominaters, but for programmers looking for an edge and a chance to develop great software, they are a positive handicap.

Somewhere there is a cutoff point where staying within the standard environment becomes ultimately more punishing than the leap forward out of it. I just hope I can recognise that point.

Progress with Lisp

2005-01-25T01:08:00.000Z

So far my initial enthusiasm for LISP is wearing off a bit. I can see it's practical potential, but the main upshot of my learning it, so far is that I've switched to Emacs from Vi.

Perhaps my problem is that I'm just put off by the constant fiddling needed with free Linux implementations and the unavailabilty of a good free as in beer Win32 implementation. I miss the ease of integration with a lot of useful libraries I'm used to working with in both Python & C++, as well as all the new idioms I have to absorb.

I can see the language can do things that Python only vaguely aspires to, though. I'm just not sure that in the cases when I don't need the extra grunt of Lisp that I'll be able to prototype as rapidly as I could in Python.

More Fun With Dungeon Generation

2005-01-18T16:40:00.000Z

Much improved. Doesn't guarantee interconnection, though,


############               ####       ## ###  ##################

############               ####        # ##   ##################

                          ####                   ##############

### ##                 #   ####        #          ##############

### ########           #   #######  #             ##############

   ########          ##  ######                  ##############

############# #          ####      ###           ##############

  ########### #      #   ####          ##        ##############

# ###########    # ###   ################        ##############

#                #       ################        ##############

#  #########     #####   ######################################

   #########     ##      ######################################

#   #########    ##  #  ########################################

#   ###########  ## ##       ###################################

# # ###########          ### ###################################

    ##########     ######## ###################################

####  ###################### ###################################

##### ###################### ###################################

##### ###################### ###################################

##### ###################### ###################################

     ###################### ###################################

# ########################## ###################################

# #####################      ###################################

# #####################    #####################################

# ######################## #####################################

# #####      ############# #####################################

# #####      ####            ###################################

# #####      #### # ######## ###################################

#                            ###################################

            ####     ##########################################

            ######## #                   ######################

# #### #### #########   ################# ######################

      #### ############################# ######################

#           ######    ################### ######################

# ################ ## ################### ######################

 ################ ## ################### ######################

################# ## ################### ######################

   ############## ## ################### ######################

### ##############    ###################   ####################

### ################  ##################### ####################

### ################  ##################### ####################

### ################  ##################### ####################

### ################  ####  ############### ####################

### ################  ####  ############### ####################

### ################  ##    ############### ####################

### #################    ## #########       ####################

### ################# ##### ######### ##########################

### #################           ##### ##########################

### ###################### ###    ### ##########################

### ###################### ###    ### ##########################

#   ###################### ###        ##########################

 ######################## ###              ####################

    ##################### ### ############ #######  ###########

 ## ##################### ### ############          ###########

#  # ##################### ### ############    ## ##  ##########

## # #####################     ############ ## ## ### ##########

##   #####################  ############### ## ## ### ##########

################                ########### ## ## ### ##########

#########    ### #######        ########### ## #      ##########

#########    ### #######        ########### ##    ##  ##########

#########    #   #######        ########### ##    ##    ########

#########       ##########  #  ##########         ## ## ########

#########    ##             #  ##########  ######    ## ########

#########    ## #############  #################################




import Numeric

import whrandom

import math



class Burrower:

   def __init__(self, x, y, lifetime = 0, dx = 0, dy = 0):

       self.data = [ x, y, lifetime, dx, dy ]





   def burrower_is_dead(self):

       return self.data[2] == -1



   def kill_burrower(self):

       self.data[2] = -1



   def tick_burrower(self,b):

       self.data[2] = self.data[2] + 1



   def pick_random_motion(self, allow_diagonals):

       motion = whrandom.randrange(0,3)

       if motion == 0:

           dx =    - 1

           dy = self.data[4]

           if not allow_diagonals:

               dy = 0

       elif motion == 1:

           dx = 1

           if not allow_diagonals:

              dy = 0

       elif motion == 2:

           dy = -1

           if not allow_diagonals:

               dx = 0

       elif motion == 3:

           dy = 1

           if not allow_diagonals:

               dx = 0

       # don't double back on yourself

       if dx == -self.data[3] and dy == self.data[4]:

           dy = dx

           dx = self.data[4]

       if dy == -self.data[4] and dx == self.data[3]:

           dx = dy

           dy = self.data[3]

       self.data[3] = dx

       self.data[4] = dy



   def clip_burrower(self, minx, miny, maxx, maxy):

       if self.data[0] < minx:

           self.data[0] = minx

       if self.data[0] > maxx:

           self.data[0] = maxx

       if self.data[1] < miny:

           self.data[1] = miny

       if self.data[1] > maxy:

           self.data[1] = miny



   def un_move_burrower(self, minx, miny, maxx, maxy, allow_diagonals):

       self.data[0] = self.data[0] - self.data[3]

       self.data[1] = self.data[1] - self.data[4]

       self.clip_burrower(minx, miny, maxx, maxy)

       self.pick_random_motion(allow_diagonals)



   # move the burrower one cell, carving as you go along

   # to do  rather than randomly pick a direction, randomly *change* a direction (more control of twistiness, etc)

   def move_burrower(self, minx, miny, maxx, maxy, changeprob, allow_diagonals):

       if whrandom.random() < changeprob:

           self.pick_random_motion(allow_diagonals)

       # am i dead ? if so I should be concenrating on a nice firm rigor mortis

       if self.burrower_is_dead():

           return

       self.data[0] = self.data[0] + self.data[3]

       self.data[1] = self.data[1] + self.data[4]

       if self.data[0] < minx:

           self.data[0] = 0

           self.data[3] = 1

       if self.data[1] < miny:

           self.data[1] = 0

           self.data[4] = 1

       if self.data[0] > maxx:

           self.data[0] = maxx

           self.data[3] = -1

       if self.data[1] > maxy:

           self.data[1] = maxy

           self.data[4] = -1

       return



class Dungeon:

   TileIdNumber = { "granite" : 0 , "room" : 1, "corridor" : 2 }



   def __init__(self,  width, depth):

       self.tiles = Numeric.zeros((width, depth))

       self.width = width

       self.depth = depth

       self.room_centres = [ ]



   def room_too_close(self, x, y, min_room_distance):

       for r in self.room_centres:

           dx = r[0] - x

           dy = r[1] - y

           dist = math.sqrt(x * x + y * y)

           if (dist < min_room_distance):

               return True

       return False



   def burrower_room_create(self, b, broom_prob, max_room_width, max_room_depth, min_room_distance, burrower_index):

       # we have a room

       if whrandom.random() > broom_prob:

           return 0

       room_width = whrandom.randrange(max_room_width / 2) + 1

       room_depth = whrandom.randrange(max_room_depth / 2) + 1

       if self.room_too_close(b.data[0], b.data[1], min_room_distance):

           return 0

       self.room_centres.append((b.data[0], b.data[1]))

       for x in range (b.data[0] - room_width, b.data[0] + room_width):

           for y in range (b.data[1] - room_depth, b.data[1] + room_depth):

               if (x >= 0) and (x < self.width) and (y >= 0) and (y < self.depth):

                   self.tiles[x][y] = burrower_index

       return 1



   def burrower_birth(self,bbirth_prob):

       return whrandom.random() < bbirth_prob



   def baby_burrower(self, b):

       return Burrower(b.data[0] + whrandom.randrange(2), b.data[1] + whrandom.randrange(2), 0, 0, 0)



   def print_dungeon(self):

       for y in range(0,self.depth):

           s = ""

           for x in range(0,self.width):

               if self.tiles[x][y] == Dungeon.TileIdNumber["granite"]:

                   s = s + "#"

               else:

                   s = s + " "

           print s

   #

   # burrowers start on one side of the level, on each turn they can either split (birth prob),

   # create a room (die), have a max lifetime, and the algo terminates when room_count is reached

   #

   def generate(self, burrower_total, room_total, birth_prob, turn_prob, room_prob, lifetime, max_room_width, max_room_depth, min_room_distance, allow_diagonals):

       # set up burrowers

       burrowers = []

       for i in range(0,burrower_total):

           side = whrandom.randrange(0,4)

           if side == 0:

               burrower = Burrower( 0, whrandom.randrange(0, self.depth) , 0, 1, 0 )

           elif side == 1:

               burrower = Burrower( self.width-1, whrandom.randrange(0, self.depth) , -1, 0, 0 )

           elif side == 2:

               burrower = Burrower( whrandom.randrange(0,self.width), 0, 0, 0, 1 )

           else:

               burrower = Burrower( whrandom.randrange(0,self.width), self.depth-1 , 0, 0, -1 )

           burrowers.append(burrower)

       room_count = 0

       burrower_alive = True

       i = 0

       while burrower_alive:

           print "Generation " , i

           print "Rooms # ", room_count

           print "Burrowers ", len(burrowers)

           self.print_dungeon()

           print

           burrower_alive = False

           birth_list = []

           burrower_index = 1

           for b in burrowers:

               if not b.burrower_is_dead():

                   burrower_alive = True

                   b.move_burrower(0, 0, self.width-1, self.depth-1, turn_prob, allow_diagonals)

                   # if the burrower reaches another corridor, kill it

                   burrower_tile = self.tiles[b.data[0]][b.data[1]]

                   if (burrower_tile != Dungeon.TileIdNumber["granite"]) and (burrower_tile != burrower_index):

                       b.un_move_burrower(0,0, self.width-1, self.depth-1, allow_diagonals)

                       b.data[2] = b.data[2] + 1

                       if b.data[2] > lifetime:

                           b.kill_burrower()

                   self.tiles[b.data[0]][b.data[1]] = burrower_index

                   if self.burrower_birth(birth_prob):

                       birth_list.append(self.baby_burrower(b))

                   room_count = room_count + self.burrower_room_create(b, room_prob, max_room_width, max_room_depth, min_room_distance, burrower_index)

               burrower_index = burrower_index + 1

           if birth_list:

               burrowers.extend(birth_list)

           if room_count >= room_total:

               birth_prob = 0.0

               room_prob = 0.0

           i = i + 1

       return



if __name__=="__main__":

   dungeon = Dungeon(64,64)

   dungeon.generate(16, # burrower total

                    12, # room total

                    0.009, # birth probability

                    0.25, # turn probability

                    0.03, # room probability

                    2, # lifetime (max non self - hits allowwd)

                    9,  # max_room_depth

                    9, # max room width

                    6, # min room distance

                    False)

Fun With Dungeon Generation

2005-01-13T13:39:00.000Z

One of the more preinnal topics of roguelike game design, or general dungeon cralws is "How do I generate that funky dungeon procedurally?". There's an unbelievable number of algorithms, but this one is my favourite...


import Numeric

import whrandom



class Burrower:

   def __init__(self, x, y, lifetime = 0, dx = 0, dy = 0):

       self.data = [ x, y, lifetime, dx, dy ]



   def burrower_is_dead(self):

       return self.data[2] == -1



   def kill_burrower(self):

       self.data[2] = -1



   def tick_burrower(self,b):

       self.data[2] = self.data[2] + 1



   def pick_random_motion(self, allow_diagonals):

       motion = whrandom.randrange(0,3)

       if motion == 0:

           self.data[3] =  - 1

           if not allow_diagonals:

               self.data[4] = 0

       elif motion == 1:

           self.data[3] = 1

           if not allow_diagonals:

               self.data[4] = 0

       elif motion == 2:

           self.data[4] = -1

           if not allow_diagonals:

               self.data[3] = 0

       elif motion == 3:

           if not allow_diagonals:

               self.data[3] = 0

           self.data[4] = 1





   # move the burrower one cell, carving as you go along

   # to do  rather than randomly pick a direction, randomly *change* a direction (more control of twistiness, etc)

   def move_burrower(self, minx, miny, maxx, maxy, changeprob, allow_diagonals):

       if whrandom.random() < changeprob:

           self.pick_random_motion(allow_diagonals)

       # am i dead ? if so I should be concenrating on a nice firm rigor mortis

       if self.burrower_is_dead():

           return

       self.data[0] = self.data[0] + self.data[3]

       self.data[1] = self.data[1] + self.data[4]

       if self.data[0] < minx:

           self.data[0] = 0

           self.data[3] = 1

       if self.data[1] < miny:

           self.data[1] = 0

           self.data[4] = 1

       if self.data[0] > maxx:

           self.data[0] = maxx

           self.data[3] = -1

       if self.data[1] > maxy:

           self.data[1] = maxy

           self.data[4] = -1

       # up lifetime count

       self.data[2] = self.data[2] + 1

       return



class Dungeon:

   TileIdNumber = { "granite" : 0 , "empty" : 1, "corridor" : 2 }



   def __init__(self,  width, depth):

       self.tiles = Numeric.zeros((width, depth))

       self.width = width

       self.depth = depth







   # die, maybe, if lifetime expired, die with a whimper,

   # else die with a bang and create a room

   # returns count of rooms created so we can track them

   # to do : probability of generating "special" rooms?

   #

   def burrower_death(self, b, bdeath_prob, lifetime, max_room_width, max_room_depth):

       result = 0

       # if out of time, just die quietly

       if b.data[2] > lifetime:

           b.kill_burrower()

       # if random chance of death turns up, burst into a room

       if whrandom.random() < bdeath_prob:

           # we have a room

           room_width = whrandom.randrange(max_room_width / 2) + 1

           room_depth = whrandom.randrange(max_room_depth / 2) + 1

           for x in range (b.data[0] - room_width, b.data[0] + room_width):

               for y in range (b.data[1] - room_depth, b.data[1] + room_depth):

                   if (x >= 1) and (x < self.width-1) and (y >= 1) and (y < self.depth-1):

                       self.tiles[x][y] = Dungeon.TileIdNumber["empty"]

#           b.kill_burrower()

           result = 1

       return result



   def burrower_birth(self,bbirth_prob):

       return whrandom.random() < bbirth_prob



   def baby_burrower(self, b):

       return Burrower(b.data[0] + whrandom.randrange(2), b.data[1] + whrandom.randrange(2), 0, 0, 0)



   def print_dungeon(self):

       for y in range(0,self.depth):

           s = ""

           for x in range(0,self.width):

               if self.tiles[x][y] == Dungeon.TileIdNumber["granite"]:

                   s = s + "#"

               else:

                   s = s + " "

           print s

   #

   # burrowers start on one side of the level, on each turn they can either split (birth prob),

   # create a room (die), have a max lifetime, and the algo terminates when room_count is reached

   #

   def generate(self, burrower_total, room_total, birth_prob, death_prob, turn_prob, lifetime, max_room_width, max_room_depth, allow_diagonals):

       # set up burrowers

       burrowers = []

       for i in range(0,burrower_total):

           side = whrandom.randrange(0,4)

           if side == 0:

               burrower = Burrower( 0, whrandom.randrange(0, self.depth) , 0, 1, 0 )

           elif side == 1:

               burrower = Burrower( self.width-1, whrandom.randrange(0, self.depth) , -1, 0, 0 )

           elif side == 2:

               burrower = Burrower( whrandom.randrange(0,self.width), 0, 0, 0, 1 )

           else:

               burrower = Burrower( whrandom.randrange(0,self.width), self.depth-1 , 0, 0, -1 )

           burrowers.append(burrower)

       room_count = 0

       burrower_alive = True

       i = 0

       while burrower_alive:

           print "Generation " , i

           print "Rooms # ", room_count

           self.print_dungeon()

           print

           burrower_alive = False

           birth_list = []

           for b in burrowers:

               if not b.burrower_is_dead():

                   burrower_alive = True

               b.move_burrower(0, 0, self.width-1, self.depth-1, turn_prob, allow_diagonals)

               if (self.tiles[b.data[0]][b.data[1]] == Dungeon.TileIdNumber["corridor"]):

                   b.kill_burrower()

               self.tiles[b.data[0]][b.data[1]] = Dungeon.TileIdNumber["corridor"]

               if self.burrower_birth(birth_prob):

                   birth_list.append(self.baby_burrower(b))

               room_count = room_count + self.burrower_death(b, death_prob, lifetime, max_room_width, max_room_depth)

           if birth_list:

               burrowers.extend(birth_list)

           if room_count == room_total:

               birth_prob = 0

               death_prob = 0

       return



if __name__=="__main__":

   dungeon = Dungeon(64,32)

   dungeon.generate(16, 32, 0.01, 0.005, 0.05, 1024, 16, 16, False)