Compiler from Racket to JavaScript.




Prerequisite: Racket 5.1.1.  The majority of the project is written
Typed Racket, and I highly recommend you use a version of Racket
that's at least 5.1.1; otherwise, compilation may take an unusual
amount of time.



======================================================================

Architecture:

The basic idea is to reuse most of the Racket compiler infrastructure.
The underlying Racket compiler will produce bytecode from Racket
source, and perform macro expansion and module-level optimizations for
us.  We will parse that bytecode using the compiler/zo-parse
collection to get an AST, compile that to an intermediate language,
and finally assemble JavaScript.


                 AST          IL                     JS
 bytecode.rkt ----------> compiler.rkt --------> assembler.rkt ------->
    (todo)


The IL is intended to be translated straightforwardly.  We currently
have an assembler to JavaScript, as well as a simulator
(simulator.rkt).  The simulator allows us to test the compiler in a
controlled environment.



======================================================================

bytecode.rkt

dyoo is currently working on bytecode.rkt.  Not done yet.  This is
intended to reuse the Racket compiler to produce the AST structures
defined in compiler/zo-parse.



For the moment there's a hacky parser in parse.rkt that produces the
AST expression structures that are consumed by the rest of the system.




======================================================================

compiler.rkt translates the AST to the intermediate language.  The
compiler is similar to that of the register compiler in Structure and
Interpretation of Computer Programs:

    http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-35.html#%_sec_5.5

but with some significant modifications.  Since this is a stack
machine, we don't need any of the register-saving infrastructure in
the original compiler.  We also need to support slightly different
linkage structures, since we want to support multiple value contexts.
We're trying to generate code that works effectively on a machine like
the one described in:

    http://plt.eecs.northwestern.edu/racket-machine/




The intermediate language is defined in il-structs.rkt, and a
simulator for the IL in simulator.rkt.  See test-simulator.rkt to see
the simulator in action, and test-compiler.rkt to see how the output
of the compiler can be fed into the simulator.



The assumed machine is a stack machine with the following atomic
registers:

    val: value
    proc: procedure
    argcount: number of arguments

and two stack registers:

    env: environment stack
    control: control stack



======================================================================


The JavaScript assembler is playing a few tricks to make things like
tail calls work:


   * Each basic block is translated to a function taking a MACHINE
     argument.

   * Every GOTO becomes a function call.

   * The head of each basic-blocked function checks to see if we
     should trampoline
     (http://en.wikipedia.org/wiki/Trampoline_(computers))

   * We support a limited form of computed jump by assigning an
     attribute to the function corresponding to a return point.  See
     the code related to the LinkedLabel structure for details.


Otherwise, the assembler is fairly straightforward.  It depends on
library functions defined in runtime.js.  As soon as the compiler
stabilizes, we will be pulling in the runtime library in Moby Scheme
into this project.


The assembled output distinguishes between Primitives and Closures.
Primitives are only allowed to return single values back, and are not
allowed to do any higher-order procedure calls.  Closures, on the
other hand, have full access to the machine, but they are responsible
for calling the continuation and popping off their arguments when
they're finished.




======================================================================

Tests

The test suite in test-all.rkt runs the test suite.  You'll need to
run this on a system with a web browser, as the suite will evaluate
JavaScript and make sure it is producing values.  A bridge module
browser-evaluate.rkt brings up a temporary web server that allows us
to pass values between Racket and the JavaScript evaluator on the
browser.