This project implements a simple bytecode virtual machine, assembler,
and self-hosting compiler for a scheme-like high-level langauge. It is
intended as a vehicle for playing with ideas in bytecode interpreting
and compilation.  It is not intended for any sort of real or
production use.  

To build the project,  simply type 
    $ make

You will need gcc installed as well as GNU guile, a scheme
implementation used to bootstrap the compiler.  

This will build the following products:

    interpreter:       the standard bytecode interpreter.

    trace_interpreter: a version of the bytecode interpreter that
   		       prints a log describing the machine state as
     		       each instruction is executed

    assembler:         the assembler for building executable bytecode
    		       files from bytecode assembly files.
 
    schemer.bytecode:  the scheme-like language compiler, built from
    		       its own image, that can be run using the
    		       interpreter.
    
A bytecode program can be run using either the regular or tracing
interpreter as:
    $ ./[trace-]interpreter program.bytecode

To use the compiler, a source program should be directed into the
interpreter's standard input, the bytecode assembly will be written to
standard output:

    $ ./interpreter schemer.bytecode < program.sch > program.asm

To assemble the compiled program into executable bytecode, send it as
input to the assembler command:

    $ ./assembler <program.asm >program.bytecode

Note: The interpreter does not provide any standard-error like output
stream, so the compiler will write its error messages to standard-out
which will confuse the assembler and lead to bizarre error messages.