# Brainfuck2Scheme

A simple compiler from Brainfuck to R5RS. The compiler will output a Scheme
list that is a lambda with three arguments:

* `data`: The data vector.
* `dptr`: The initial data pointer.
* `debugger`: Debugger function

To turn the list into an executable Scheme function, just give it to
`eval`. `(execute scheme len)` will run the Scheme code in `scheme`
with a data vector of length `len`.

This dialect of Brainfuck supports `#` to call the `debugger` procedure
with `data` and `dptr` as arguments.

Since Brainfuck programs become Scheme procedures, you can modularize
Brainfuck code and (ab)use the debugger for things like procedure calls
and foreign libraries.

## How It Works

Brainfuck is a very simple Harvard architecture computer. The data is
stored as a vector `data` and the data pointer is an integer `dptr`.
The big idea is that all the code is compiled to a big lambda form, but
there are some wrinkles due to jumps.

Data access brainfuck instructions are translated like

* `+` -> `(vector-set! data dptr (+ 1 (vector-ref data dptr)))`
* `-` -> `(vector-set! data dptr (+ -1 (vector-ref data dptr)))`
* `>` -> `(set! dptr (+ dptr 1))`
* `<` -> `(set! dptr (- dptr 1))`
* `.` -> `(display (vector-ref data dptr))`
* `,` -> `(vector-set! data dptr (read-char))`
* `#` -> `(debugger data dptr)`

Branches are trickier. Basically, all code that will be executed in a block
is in a lambda. Given `[code...]`, the `code...` will be compiled to a
lambda in a `letrec`, with a conditional at the end that will tail-call the
lambda if the current data pointer is not zero.

The transformation then goes like

`[ CODE ... ] REST ...` ->

    (letrec ((between (lambda ()
                        (TRANSLATE CODE ...)
                        (if (not (zero? (vector-ref data dptr)))
                            (between)))))
      (if (not (zero? (vector-ref data dptr)))
          (between)))
    (TRANSLATE REST ...)

where `(TRANSLATE CODE ...)` translates `CODE` to Scheme instructions
like above.