The goal of the MABWA Project is to produce an implementation of PyFL that is much faster than the current lazy interpreter, that repeatedly decodes the expression tree. The current interpreter produces Basic PyFL, with all the advanced features (like while loops) implemented by translation. Our strategy is to translate Basic PyFL into the machine language for a FORTH-like stack-based abstract machine.

The MABWA Machine  [-]

The MABWA machine has a conventional FORTH like design, with a reverse polish instruction language. To add 2 and 3 you push 2 then 3 on the implicit value stack, then execute the add instruction that pops the top two elements of the stack, adds them, then pushes the result on the stack.

Suppose that the original Basic PyFL expression is

  sqrt(if x>y then x*x-y*y else y**2-x**2 fi)

then this is compiled into the MABWA assembly language

  begin
   load x
   duplicate
   multiply
   load y
   duplicate
   multiply
   subtract
  end
  begin
   load y
   literal 2
   power
   load x
   literal 2
   power
   subtract
  end
  load x
  load y
  less
  if
  squareroot

(For illustrative purposes I used two different ways to compute squares.)

Code Blocks [+]

The 'commands' begin and end delimit code blocks, sequences of instructions that will be manipulated but not immediately executed. The MABWA machine pushes these two blocks onto the stack when it encounters them. They become the top two elements of the stack.

The MABWA Assembler [+]

The next stage is to assemble the MABWA code into machine language. The result is still text, but at a lower level and more concise. For example, addition is denoted by "+", and load becomes three instructions.

Evaluation of Variables  [+]

The pseudo-instruction " causes the name of the variable (a string) to be pushed on the stack without being examined (as an instruction). Then the instruction $ looks up the definition of the variable - a code block (not shown) which is then executed.

Function Calls [+]

Environments come into play during evaluation of function calls. There are two environments, the environment in which the function was called and that in which it was defined. The body of the function is evaluated in the defining environment but the actuals are evaluated in the calling environment.

  We plan to write a test interpreter in Python to check out the logic. But for speed, the ultimate goal, we'll use Apple's Swift.