1 / 40

eMDL - PowerPoint PPT Presentation

  • Uploaded on

eMDL. Extended Motion Description Language. EMDL vs. MDL. MDL classic. Syntax: line x1, y1, z1, x2, y2, z2 Box x, y, z, dx, dy, dz sphere x, y, z, r move x, y, z [knob]. EMDL. Simple Object Oriented Robust Supports Animation. # delcare filename filename sample_syntax;

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'eMDL' - jin

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript


Extended Motion Description Language

Mdl classic
MDL classic

  • Syntax:

    • line x1, y1, z1, x2, y2, z2

    • Box x, y, z, dx, dy, dz

    • sphere x, y, z, r

    • move x, y, z [knob]


  • Simple

  • Object Oriented

  • Robust

  • Supports Animation

Sample syntax

# delcare filename

filename sample_syntax;

# fucntion definiitions

function ears {







function moveout {

move sphere3 <0,50,0>;




#more function definitions

function moveback {





function movesideways {





function moveup {





Sample Syntax

Sample syntax 2

# main body

set sphere1 as sphere <150,150,150,50>;

set sphere2 as sphere <100,100,100,100>;

set sphere3 as sphere <100,100,100,100>;

hide sphere2;

hide sphere3;


funct ears;

repeat <2>{funct moveout;};

repeat <2>{funct moveback;};

repeat <2>{funct movesideways;};

repeat <2>{funct moveup;};

Sample Syntax (2)

Structure of emdl
Structure of eMDL

  • Filename Specification

  • Function Declarations

  • Variable Declarations

  • Main Body

Filename specification
Filename Specification

  • Allows users to chose the filename for all MDL files that will be output

  • Must be the first line of the eMDL script

  • Optional : if not included, then the program will default to outputting tmp.mdl files.

Filename specification 2
Filename Specification (2)

  • Example :

    filename mdlTest;

  • Will result in all outputted MDL files named mdlTest<number>.mdl

  • <number> is enumerated based on how many times the save function was called in the code.

Function declarations
Function Declarations

  • If you want to create any functions, they must be declared and defined in the second section.

  • eMDL supports macro style functions with no parameters

  • Every function must have a unique identifier.

Function declarations 2
Function Declarations (2)

  • Function declarations consist of the keyword “function” followed by the identifying name

  • The function body is enclosed in curly braces and can contain of any combination of pre or user defined functions, assignments, or repeat clauses.

Function declarations 3
Function Declarations (3)

  • Example :

    function move50 {

    repeat <3> {

    move sphere1 <0, 50, 0>;

    move box2 <0, -50, 0>;




Variable declarations
Variable Declarations

  • Must occur between the function declarations and the main body

  • All variables have a global scope.

  • Each variable must have its own unique identifier.

  • Five types of variables.

Variable types
Variable Types

  • Integer

    set <name> as integer <value>

  • Box

    set <name> as box <x, y, z, dx, dy, dz>

  • Line

    set <name> as line <x, y, z, x2, y2, z2>

  • Sphere

    set <name> as sphere <x, y, z, r>

  • Torus

    set <name> as torus <x, y, z, r, R>

Main body
Main Body

  • This is where the actual graphic manipulations occur

  • Any variable declared previously can be changed and moved

Main body 2
Main Body (2)

  • Users may:

    • Utilize assignment statements

    • Call predefined functions

    • Call user defined functions

    • Create repeat blocks

    • Remove a variable

    • Save the current state to an MDL file

Details of our compiler1
Details of our Compiler

  • Lexer – splits code into tokens.

  • Parser – creates an AST.

  • TreeWalker – generates mdl Code

  • mdlParser – mdl Parser generates gif images. (compiled in C)


  • Lexer splits emdl code into tokens.

  • Some common tokens are:

    • INT

    • ID, which can be variable names and function names.


  • Parser makes an Abstract Syntax Tree out of the stream of tokens that the Lexer outputs.

    • Syntax is checked here.

    • The AST is designed and created here in the most efficient way for static semantic analysis to take place.


  • TreeWalker performs the static semantic analysis, as well as the code generation.

  • A linked list is created to hold all global variables.

  • The object in linked list knows what type of object the variable is, and all of its parameters.


  • A copy of the AST is made before we walk through the function declarations.

  • This is to facilitate function calls.

  • Each function call creates a copy of the this tree and call a treeWalker function on this tree.

  • Since our functions act like macros, the function body is just a sequential continuation of our code.


  • mdlParser is a binary executable that is compiled in C.

  • It asks the user for the names of an mdl file, and the name of the image file to be created.

  • It then outputs an image file for the given mdl file.

Comparison between emdl and mdl
Comparison between emdl and mdl

  • One of the main reasons for the creation of this language was to extend mdl so that we could make the coding tighter and cleaner.

  • For the demo you had seen earlier, one emdl file created 9 separate mdl files, which created 9 separate image files.

Comparison between emdl and mdl1
Comparison between eMDL and mdl

  • Now if we had wanted to run the same animation, but with the two outside spheres being farther away from the interior sphere, I would only need to change on line in emdl.

  • But to do the same change in mdl would require us to modify all 9 of the mdl files that created this animation.


  • Tested during and after development.

During development
During Development

  • Ran two test files when each new functionality was implemented.

    • One that ought to work

    • One that ought not and give errors

  • Didn’t always include all possible formations of newly implemented statements.

After development
After Development

  • Created suite of test cases

    • Tested all legal formations of statements.

    • Tested for what we predicted to be common syntactic and semantic mistakes.

Lessons learned
Lessons Learned

  • Compilers are harder to make than you might think.

  • Perpetual debugging and error-checking, since errors can and did crop up in the simplest functions.