[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]



Remember how we were talking about the possibility of compiling into C to
simplify porting efforts?  Well, I've had a few more ideas along those
lines.  We merge this idea with the byte-code interpreter idea, and just
compile the byte-code interpreter into C and byte compile everything else.
We distribute C code for the run-time system, the byte-code interpreter,
and the loader.  We distribute machine independent (byte-code) fasls for
everything else.  Then you can bring the system up by just compiling some C
code and running worldload.  If we have a native compiler for your
architecture, you could load that backend instead of the byte-code backend
and recompile everything native.  If not, you would just keep using the
byte-code compiler.

Porting would now consist of just modifying runtime support instead of
writing a full compiler backend.  You could still write the compiler
backend, but you could bring the system up using the byte-code compiler
first, so you wouldn't have to bootstrap from some other machine.

The interpreter could just be the byte-code compiler with all optimizations
turned off and debug-info forced to full.

Having C code manipulate Lisp objects makes GCing during an interrupt
handler difficult (well, I'm tempted to say impossible, but what I really
mean is that I haven't thought of any way to do it).

What do you think?