Sub Ubi

With Brooke’s help, we now have a Scheme compiler that can take a small program

(for example, the Scheme program ’75′), and expand it into an executable Forth

program approximately 2.5K in size. Keep in mind, that Scheme program (the number

’75′) is CPSed in the final output; it’s tail recursive, guaranteed!

But the important thing: IT WORKS! . . . → Read More: Phase I Complete

It compiles to Forth code, and that code is syntactically correct.

Granted, the Forth code doesn’t run. A few things jump out from initial testing:

I have no idea how to go about debugging a Forth program.

I really don’t want this compiler to have to run past register allocation

just to compile to . . . → Read More: Does it have to be semantically correct?

It wasn’t an infinte loop. When writing a ‘meta-circular compiler,’ so to speak,

you have to be careful where the language of the compiler begins and your

implementation ends. In particular, there are some macros that (under Chez Scheme)

implement the semantics of the predicate ‘begin?’ for the last few passes of the compiler.

These same macros do not work . . . → Read More: Success!

The “silliness holding up the Scheme compiler” is a difference between Chez and MzScheme

regarding when macros are expanded and top-level defines are expanded into the namespace.

While I’m confident there is good reason for separating out the stages of definition and

macro expansion, it is frustrating, because things that work in Chez _don’t_ work in Mz, . . . → Read More: Silliness == Two Schemes

I’m tying all the passes together, and right now the compiler isn’t even generating good C code.

The bootstrapping code provides a “heap” and “stack” for us to play with (a couple of character arrays),

and provides some rudimentary bounds and alignment checking. All the code being produced right now

right now violates the alignment conditions we have on . . . → Read More: Grr