[DonaldFisk]

I wrote my own Lisp. The virtual machine, which is a stack machine, is written in C. The interpreter, which runs until the system compiles itself, is written in C, but makes heavy use of C macros. The rest of the code, including the compiler, is in Lisp.

Code in the interpreter is directly converted to byte code, e.g. the macro Car generates the virtual machine instruction Car, rather than executing the code for car. The alternative would have been to generate byte code by hand, would have been error-prone. Here's the code for cons and let:

    Define("cons", 2)
      Local1 Local2 Cons Ret
    Termin

    DefineF("let")
      Local1 Car
      Local2 /* initialize new env */
      Prog(1)
      Ret

      Params(2)
      Until Local1 Null Do
        Local1 Caar /* var */
        Local1 Cadar Free12 Call("eval") /* val in old env */
        Local2 /* env */
        ACons
        SetLocal2 Pop /* update new env */
        PopLocal1
      Od
      Free11 Cdr Local2 Call("progn") /* use new env */
      Ret
    Termin

It is actually C, with heavy use of macros. But it can be read as Reverse Polish Lisp. It can also be thought of as a Lispy Forth.

[rs23296008n1]

Interesting approach. maybe develop it further into a JIT arrangement or a library builder.

Brainf*ck is another classic.