Script Parsing

I started to work on an animation class for Tide, just to do simple stuff, then I thought, I should really use a script to do this stuff...which got me on the idea of a script parser, and this is what I came up with...

This is a sample block of an animation sequence script:

begin();

atTime( 0 );		// Time is 0 miliseconds, the object was just put into the world
position( 0, 0, 0 );	// It is at position (0,0,0) in (x,y,z)
rotX( 0, 1 );		// Rotation 0 degrees, but it is increasing
			// Second argument is 1 if increasing 1 if decreasing 0 if neither
rotY( 0, 0 );		// No Y rotation either, and it's not moving
rotZ( 0, 0 );		// No Z rotation

atTime( 300 );		// Time is now 300 miliseconds after the object was started
position( 0, 0, -50 );	// Position is 50 along the Z axis 
rotX( 0, 0 );		// The object rotated 360 degrees and is now back to 0
rotY( 0, 0 );
rotZ( 0, 0 );

end();

Ok, this is a real basic script that pretty much makes an object move 50 degrees backwards along the Z axis over 3 seconds, while rotating 360 degrees. So it's spinning pretty fast and moving backwards pretty fast. Now, the animation controller will divide the movement and rotation by how many milliseconds it will be animated for, and get how much it should increment it each time. Easy to parse, but the parser will have to be able to do difficult things too. Example:

if( foo && bar ) {
	if( ( foo == 5 ) || !bar ) {
		makeItStop();
	}
}

This is how the parser will do things. It sees the 'if' block, and then creates an expression tree that will look like this:
&&
/ \
foo bar

Now what this means, is an expression tree, with a left pointer to another expression tree, that holds the data "foo" and has null pointers, and a right pointer to a expression tree that has the data "bar" and has null pointers, this signifies that it is a leaf. It then looks at what is next, because it is a { it will evaluate the expression tree, if it is true, it will push the expression tree onto a stack, which signifies that it is now within another level of code blocks. This may seem weird, but look at the case if it was a while loop, it would store that expression tree, so that for each iteration, it could re-evaluate the tree and decide to continue or not. Back to the example, it sees another if block, and builds an expression tree that looks like so:
||
/ \
/ \
== !
/ \ \
foo 5 bar

It then evaluates the block, if it's true, it pushes the block onto the stack. And comes to the function call, so it calls the function, then it sees a }, and pops the stack (because it's an if block, if it was while, or what not, it would iterate) it sees another } so it pops the stack again...and there you have it.

Let me know what you think.