mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-06-24 12:20:20 +02:00
Code Activity

added documenting comments to the brainfuck compiler and mention it in the VM documentation.

Browse source 
* doc/ref/compiler.texi: Mention the new brainfuck compiler as an example.
* module/language/brainfuck/compile-scheme.scm: Add a lot of documentation comments.
* module/language/brainfuck/parse.scm: Ditto.
* module/language/brainfuck/spec.scm: Ditto.
This commit is contained in:
Daniel Kraft 2009-05-23 09:58:54 +02:00 • committed by Andy Wingo
parent 6370a6ad25
commit e63d888ef6
4 changed files with 124 additions and 5 deletions
Download patch file Download diff file Expand all files Collapse all files

60
module/language/brainfuck/compile-scheme.scm
View file

@ -22,8 +22,36 @@
(define-module (language brainfuck compile-scheme)
#:export (compile-scheme))
; Compilation of Brainfuck to Scheme is pretty straight-forward. For all of
; brainfuck's instructions, there are basic representations in Scheme we
; only have to generate.
;
; Brainfuck's pointer and data-tape are stored in the variables pointer and
; tape, where tape is a vector of integer values initially set to zero. Pointer
; starts out at position 0.
; Our tape is thus of finite length, with an address range of 0..n for
; some defined upper bound n depending on the length of our tape.
; Define the length to use for the tape.
(define tape-size 30000)
; This compiles a whole brainfuck program. This constructs a Scheme code like:
; (let ((pointer 0)
; (tape (make-vector tape-size 0)))
; (begin
; <body>
; (write-char #\newline)))
;
; So first the pointer and tape variables are set up correctly, then the
; program's body is executed in this context, and finally we output an
; additional newline character in case the program does not output one.
;
; TODO: Find out and explain the details about env, the three return values and
; how to use the options. Implement options to set the tape-size, maybe.
(define (compile-scheme exp env opts)
(values
`(let ((pointer 0)
@ -36,6 +64,12 @@
env
env))
; Compile a list of instructions to get a list of Scheme codes. As we always
; strip off the car of the instructions-list and cons the result onto the
; result-list, it will get out in reversed order first; so we have to (reverse)
; it on return.
(define (compile-body instructions)
(let iterate ((cur instructions)
(result '()))
@ -44,28 +78,50 @@
(let ((compiled (compile-instruction (car cur))))
(iterate (cdr cur) (cons compiled result))))))
; Compile a single instruction to Scheme, using the direct representations
; all of Brainfuck's instructions have.
(define (compile-instruction ins)
(case (car ins)
; Pointer moval >< is done simply by something like:
; (set! pointer (+ pointer +-1))
((<bf-move>)
(let ((dir (cadr ins)))
`(set! pointer (+ pointer ,dir))))
; Cell increment +- is done as:
; (vector-set! tape pointer (+ (vector-ref tape pointer) +-1))
((<bf-increment>)
(let ((inc (cadr ins)))
`(vector-set! tape pointer (+ (vector-ref tape pointer) ,inc))))
; Output . is done by converting the cell's integer value to a character
; first and then printing out this character:
; (write-char (integer->char (vector-ref tape pointer)))
((<bf-print>)
'(write-char (integer->char (vector-ref tape pointer))))
; Input , is done similarly, read in a character, get its ASCII code and
; store it into the current cell:
; (vector-set! tape pointer (char->integer (read-char)))
((<bf-read>)
'(vector-set! tape pointer (char->integer (read-char))))
; For loops [...] we use a named let construction to execute the body until
; the current cell gets zero. The body is compiled via a recursive call
; back to (compile-body).
; (let iterate ()
; (if (not (= (vector-ref! tape pointer) 0))
; (begin
; <body>
; (iterate))))
((<bf-loop>)
`(let iter ()
`(let iterate ()
(if (not (= (vector-ref tape pointer) 0))
(begin
,@(compile-body (cdr ins))
(iter)))))
(iterate)))))
(else (error "unknown brainfuck instruction " (car ins)))))