Brainfuck2Scheme

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

• data: The data vector.
• dptr: The initial data pointer.

To turn the list into an executable Scheme function, just give it to eval.

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))

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.