├── .gitignore
├── 0.sf
├── 1.sf
├── 2.sf
├── 3.sf
├── 4.sf
├── 5.sf
├── 6.sf
├── 7.sf
├── LICENSE
├── README.md
├── c.sf
├── c.ss
├── doc
├── ch1.html
├── ch2.html
├── ch3.html
├── ch4.html
├── ch5.html
├── ch6.html
├── ch7.html
├── ch8.html
├── intro.html
├── ioe.html
└── toc.html
├── examples
├── compiled
│ ├── hello.c
│ ├── rk.c
│ ├── s4iof.c
│ ├── s5iof.c
│ ├── siof.c
│ ├── stak.c
│ ├── tak.c
│ ├── tfun.c
│ ├── tlib.c
│ └── tmain.c
├── hello.sf
├── rk.sf
├── s4iof.sf
├── s5iof.sf
├── siof.sf
├── stak.sf
├── tak.sf
├── tfun.sf
├── tlib.sf
└── tmain.sf
├── fixpoint
├── 0.c
├── 1.c
├── 2.c
├── 3.c
├── 4.c
├── 5.c
├── 6.c
├── 7.c
└── c.c
├── int
├── README.md
├── intl.sf
├── intm.sf
├── ints.sf
├── scheme
│ ├── README.md
│ ├── base.sld
│ ├── case-lambda.sld
│ ├── char.sld
│ ├── complex.sld
│ ├── cxr.sld
│ ├── eval.sld
│ ├── file.sld
│ ├── inexact.sld
│ ├── lazy.sld
│ ├── load.sld
│ ├── process-context.sld
│ ├── r5rs-null.sld
│ ├── r5rs.sld
│ ├── read.sld
│ ├── repl.sld
│ ├── time.sld
│ └── write.sld
└── tests
│ ├── README.md
│ ├── intl-tests.s
│ ├── intm-tests.s
│ └── ints-tests.s
├── lib
├── README.md
├── libl.sf
├── libm.sf
├── libs.sf
├── libxs.sf
└── libxxs.sf
├── misc
└── lambda-sunrise.png
└── tests
├── Makefile
├── README
├── helpers.sf
├── tests-a.sf
├── tests-b.sf
├── tests-c.sf
├── tests-d.sf
├── tests-e.sf
├── tests-f.sf
├── tests-g.sf
├── tests-h.sf
├── tests-i.sf
├── tests-l.sf
└── tests-m.sf
/.gitignore:
--------------------------------------------------------------------------------
1 | fixpoint/sfc
2 | /platforms
3 | save
4 |
--------------------------------------------------------------------------------
/5.sf:
--------------------------------------------------------------------------------
1 |
2 | ; #F, part 5: SFC post-CPS passes
3 |
4 | ; Copyright (C) 2007 by Sergei Egorov, All Rights Reserved.
5 | ;
6 | ; This code is derived from the "90 minute Scheme to C compiler" presented at the
7 | ; Montreal Scheme/Lisp User Group on October 20, 2004. The original code was
8 | ; Copyright (C) 2004 by Marc Feeley, All Rights Reserved.
9 |
10 | #fload "0.sf"
11 | #fload "3.sf"
12 | ; also refers to typecheck-prim-ctype
13 |
14 | ;------------------------------------------------------------------------------
15 |
16 | ; CPS conversion
17 |
18 | ; See Ch.8 of @book{
19 | ; author = "Daniel P. Friedman and Christopher T. Haynes and Mitchell Wand"
20 | ; title = "Essentials of programming languages (2nd ed.)"
21 | ; year = "2001"
22 | ; isbn = "0-262-06217-8"
23 | ; publisher = "The MIT Press"
24 | ; }
25 |
26 | (define (cps-convert exp)
27 |
28 | (define (cps-complex exp kexp)
29 | (variant-case exp
30 | [gvarassign-exp (id exp)
31 | (cps-one exp
32 | (lambda (val)
33 | (app-exp kexp
34 | (list (noreturn-exp) (gvarassign-exp id val)))))]
35 | [if-exp (test-exp then-exp else-exp)
36 | (let ([xform
37 | (lambda (kexp)
38 | (cps-one test-exp
39 | (lambda (test)
40 | (if-exp test
41 | (cps then-exp kexp)
42 | (cps else-exp kexp)))))])
43 | (if (var-exp? kexp) ; prevent combinatorial explosion
44 | (xform kexp)
45 | (let ([k (lexical-id 'k)])
46 | (let-exp (list k) (list kexp) (xform (var-exp k))))))]
47 | [primapp-exp (effect prim rands)
48 | (cps-list rands
49 | (lambda (args)
50 | (app-exp kexp
51 | (list (noreturn-exp) (primapp-exp effect prim args)))))]
52 | [fix-exp (ids lams body)
53 | (fix-exp ids (map cps-simple lams)
54 | (cps body kexp))]
55 | [degenerate-let-exp (body)
56 | (cps body kexp)]
57 | [begin-exp (exp1 exp2)
58 | (cps exp1
59 | (lambda-exp (list (lexical-id 'ek) (lexical-id begin-id-symbol))
60 | (cps exp2 kexp)))]
61 | [let-exp (ids rands body)
62 | (cps-list rands
63 | (lambda (vals)
64 | (let-exp ids vals (cps body kexp))))]
65 | [app-exp (rator rands)
66 | (cps-list (cons rator rands)
67 | (lambda (fn+args)
68 | (app-exp (car fn+args) (cons kexp (cdr fn+args)))))]
69 | [letcc-exp (id body)
70 | (let-exp (list id) (list kexp)
71 | (cps body (var-exp id)))]
72 | [withcc-exp (cont-exp exp)
73 | (cps-one cont-exp
74 | (lambda (kexp) (cps exp kexp)))]))
75 |
76 | (define (cps-simple? exp)
77 | (variant-case exp
78 | [var-exp (id) #t]
79 | [gvarassign-exp (id exp)
80 | (cps-simple? exp)]
81 | [if-exp (test-exp then-exp else-exp)
82 | (andapp cps-simple? test-exp then-exp else-exp)]
83 | [primapp-exp (effect prim rands)
84 | (andmap cps-simple? rands)]
85 | [lambda-exp (ids body) #t]
86 | [fix-exp (ids lams body)
87 | (cps-simple? body)]
88 | [degenerate-let-exp (body)
89 | (cps-simple? body)]
90 | [begin-exp (exp1 exp2)
91 | (and (cps-simple? exp1) (cps-simple? exp2))]
92 | [let-exp (ids rands body)
93 | (and (andmap cps-simple? rands) (cps-simple? body))]
94 | [app-exp (rator rands) #f]
95 | [letcc-exp (id body) #f]
96 | [withcc-exp (cont-exp exp) #f]))
97 |
98 | (define (cps-simple exp)
99 | (variant-case exp
100 | [var-exp (id) exp]
101 | [gvarassign-exp (id exp)
102 | (gvarassign-exp id (cps-simple exp))]
103 | [if-exp (test-exp then-exp else-exp)
104 | (if-exp (cps-simple test-exp)
105 | (cps-simple then-exp)
106 | (cps-simple else-exp))]
107 | [primapp-exp (effect prim rands)
108 | (let loop ([rands rands] [ids '()] [vals '()] [exps '()])
109 | (if (null? rands)
110 | (let-exp ids vals
111 | (primapp-exp effect prim (reverse exps)))
112 | (let ([rand (cps-simple (car rands))])
113 | (if (var-exp? rand) ; or literal?
114 | (loop (cdr rands) ids vals (cons rand exps))
115 | (let ([tmp (lexical-id 'tmp)])
116 | (loop (cdr rands) (cons tmp ids) (cons rand vals)
117 | (cons (var-exp tmp) exps)))))))]
118 | [lambda-exp (ids body)
119 | (let ([k (lexical-id 'k)])
120 | (lambda-exp (cons k ids) (cps body (var-exp k))))]
121 | [fix-exp (ids lams body)
122 | (fix-exp ids (map cps-simple lams) (cps-simple body))]
123 | [degenerate-let-exp (body)
124 | (cps-simple body)]
125 | [begin-exp (exp1 exp2)
126 | (begin-exp (cps-simple exp1) (cps-simple exp2))]
127 | [let-exp (ids rands body)
128 | (let-exp ids (map cps-simple rands) (cps-simple body))]))
129 |
130 | (define (cps exp kexp)
131 | (if (cps-simple? exp)
132 | (app-exp kexp (list (noreturn-exp) (cps-simple exp)))
133 | (cps-complex exp kexp)))
134 |
135 | (define (cps-list exps inner)
136 | (cond
137 | [(null? exps) (inner '())]
138 | [(cps-simple? (car exps))
139 | (cps-list (cdr exps) ;=>
140 | (lambda (new-exps)
141 | (inner (cons (cps-simple (car exps)) new-exps))))]
142 | [else
143 | (let ([r (lexical-id 'r)])
144 | (cps (car exps)
145 | (lambda-exp (list (lexical-id 'ek) r)
146 | (cps-list (cdr exps)
147 | (lambda (new-exps)
148 | (inner (cons (var-exp r) new-exps)))))))]))
149 |
150 | (define (cps-one exp inner)
151 | (if (cps-simple? exp)
152 | (inner (cps-simple exp))
153 | (let ([r (lexical-id 'r)])
154 | (cps exp
155 | (lambda-exp (list (lexical-id 'ek) r)
156 | (inner (var-exp r)))))))
157 |
158 | (define (noreturn-exp)
159 | (primapp-exp (no-effect) "ktrap()" '()))
160 |
161 | (cps exp
162 | (let ([r (lexical-id 'r)])
163 | (lambda-exp (list (lexical-id 'ek) r)
164 | (halt-exp (var-exp r))))))
165 |
166 |
167 | ;------------------------------------------------------------------------------
168 |
169 | ; Lambda lifting
170 |
171 | ; See @inproceedings{
172 | ; key = "Cli:94"
173 | ; author = "William D. Clinger and Lars Thomas Hansen"
174 | ; title = "Lambda, the ultimate label, or a simple optimizing compiler for
175 | ; Scheme"
176 | ; booktitle = "Proceedings of the 1994 ACM conference on LISP and Functional
177 | ; Programming"
178 | ; year = "1994"
179 | ; pages = "128-139"
180 | ; url = "http://www.acm.org/pubs/citations/proceedings/lfp/182409/p128-clinger/"
181 | ; }
182 | ; and @article{
183 | ; key = "danvy-schultz:tcs2000"
184 | ; author = "Olivier Danvy and Ulrik Pagh Schultz"
185 | ; title = "Lambda-Dropping: Transforming Recursive Equations into Programs
186 | ; with Block Structure"
187 | ; journal = "Theoretical Computer Science"
188 | ; volume = "Volume 248/1-2"
189 | ; month = "November"
190 | ; year = "2000"
191 | ; url = "http://www.daimi.au.dk/~ups/papers/tcs00.ps.gz"
192 | ; url = "http://www.daimi.au.dk/~ups/papers/tcs00.pdf"
193 | ; }
194 |
195 | (define (lambda-lift exp)
196 |
197 | (define top-ids '())
198 | (define top-lams '())
199 |
200 | (define (extra-vars id* lam*) ; => vars*
201 | (define (called-lam-indices lamfvs)
202 | (map (lambda (id) (posq id id*))
203 | (intersectionq lamfvs id*)))
204 | (define (lam-free-outs lamfvs)
205 | (setdiffq lamfvs id*))
206 | (define (make-step-fn lamcalls lamfovs)
207 | (lambda (av) ; av -> a
208 | (reduce-left (lambda (i a) (unionq a (vector-ref av i)))
209 | lamfovs lamcalls)))
210 | (let ([lamfvs* (map exp->free-lexvars lam*)] [n (length id*)])
211 | (let ([lamcalls* (map called-lam-indices lamfvs*)]
212 | [lamfovs* (map lam-free-outs lamfvs*)])
213 | (let ([av (make-vector n '())]
214 | [fv (list->vector (map make-step-fn lamcalls* lamfovs*))])
215 | (vector->list ; => vars*
216 | (let loop ([i 0] [wrap? #f])
217 | (if (= i n) (if wrap? (loop 0 #f) av)
218 | (let ([next-a ((vector-ref fv i) av)] [prev-a (vector-ref av i)])
219 | (if (seteq? next-a prev-a) (loop (+ i 1) wrap?)
220 | (begin (vector-set! av i next-a) (loop (+ i 1) #t)))))))))))
221 |
222 | (define (curry-lam lam xvars tid)
223 | (curry-exp tid ; no xvars? don't eta-reduce!
224 | (map rename-id (lambda-exp->ids lam))
225 | (map var-exp xvars)))
226 |
227 | (define (lift-lam lam xvars id* lam* xvars* tid*)
228 | (variant-case lam
229 | [lambda-exp (ids body)
230 | (lambda-exp (append ids xvars)
231 | (let-exp id* (map curry-lam lam* xvars* tid*)
232 | (lift body)))]))
233 |
234 | (define (lift-lams id* lam* body)
235 | (let ([tid* (map (lambda (id) (label-id (id->symbol id))) id*)]
236 | [xvars* (extra-vars id* lam*)])
237 | (define (float-lam lam xvars tid)
238 | (let ([tlam (lift-lam lam xvars id* lam* xvars* tid*)])
239 | (set! top-ids (cons tid top-ids))
240 | (set! top-lams (cons tlam top-lams))))
241 | (for-each float-lam lam* xvars* tid*)
242 | (let-exp id* (map curry-lam lam* xvars* tid*)
243 | (lift body))))
244 |
245 | (define (lift exp)
246 | (variant-case exp
247 | [var-exp (id) exp]
248 | [gvarassign-exp (id exp)
249 | (gvarassign-exp id (lift exp))]
250 | [if-exp (test-exp then-exp else-exp)
251 | (if-exp (lift test-exp) (lift then-exp) (lift else-exp))]
252 | [primapp-exp (effect prim rands)
253 | (primapp-exp effect prim (map lift rands))]
254 | [let-exp (ids rands body)
255 | (let-exp ids (map lift rands) (lift body))]
256 | [app-exp (rator rands)
257 | (app-exp (lift rator) (map lift rands))]
258 | [lambda-exp (ids body)
259 | (let ([l (lexical-id 'l)])
260 | (lift-lams (list l) (list exp) (var-exp l)))]
261 | [fix-exp (ids lams body)
262 | (lift-lams ids lams body)]))
263 |
264 | (let ([top-body (lift exp)])
265 | (fix-exp top-ids top-lams
266 | top-body)))
267 |
268 |
269 | ;------------------------------------------------------------------------------
270 |
271 | ; Values unboxing
272 |
273 | (define (unbox-values exp)
274 |
275 | (define (unbox-ctype-test test-exp then-exp k ek)
276 | (or (and (primapp-exp? test-exp)
277 | (let ([rands (primapp-exp->rands test-exp)])
278 | (and (= (length rands) 1)
279 | (let ([rand (car rands)])
280 | (and (var-exp? rand)
281 | (let ([id (var-exp->id rand)])
282 | (let ([ctype (var-unboxed-ctype-in-exp id then-exp)])
283 | (and ctype (not (member ctype '("obj" "void")))
284 | (> (var-reference-count id then-exp) 1)
285 | (equal? ctype (typecheck-prim-ctype (primapp-exp->prim test-exp)))
286 | (k id ctype)))))))))
287 | (ek)))
288 |
289 | (define (var-unboxed-ctype id body rand)
290 | (let ([b-ctype (var-unboxed-ctype-in-exp id body)])
291 | (and b-ctype (not (member b-ctype '("obj" "void")))
292 | (let ([r-ctype (exp-ctype rand '())]) ; look for obvious cases
293 | (and r-ctype (not (member r-ctype '("obj" "void")))
294 | (string=? b-ctype r-ctype)
295 | r-ctype)))))
296 |
297 |
298 | (define (unbox-vals exp substs)
299 |
300 | (define (uv exp)
301 | (variant-case exp
302 | [var-exp (id)
303 | (cond [(assq id substs) => cdr] [else exp])]
304 | [gvarassign-exp (id exp)
305 | (gvarassign-exp id (uv exp))]
306 | [if-exp (test-exp then-exp else-exp)
307 | (unbox-ctype-test test-exp then-exp ;=>>
308 | (lambda (id ctype)
309 | (if-exp
310 | (uv test-exp)
311 | (let ([cid (cvar-id (id->symbol id) ctype)])
312 | (let-exp (list cid) (list (var-exp id))
313 | (unbox-vals then-exp
314 | (cons (cons id (var-exp cid)) substs))))
315 | (uv else-exp)))
316 | (lambda ()
317 | (if-exp (uv test-exp) (uv then-exp) (uv else-exp))))]
318 | [degenerate-let-exp (body)
319 | (uv body)]
320 | [let-exp (ids rands body)
321 | (let loop ([in-ids ids] [in-rands (map uv rands)]
322 | [out-ids '()] [out-rands '()] [substs substs])
323 | (if (null? in-ids)
324 | (let-exp out-ids out-rands (unbox-vals body substs))
325 | (let ([id (car in-ids)] [rand (car in-rands)])
326 | (cond [(var-unboxed-ctype id body rand) =>
327 | (lambda (ctype)
328 | (let ([cid (cvar-id (id->symbol id) ctype)])
329 | (loop (cdr in-ids) (cdr in-rands)
330 | (cons cid out-ids) (cons rand out-rands)
331 | (cons (cons id (var-exp cid)) substs))))]
332 | [else (loop (cdr in-ids) (cdr in-rands)
333 | (cons id out-ids) (cons rand out-rands) substs)]))))]
334 | [primapp-exp (effect prim rands)
335 | (primapp-exp effect prim (map uv rands))]
336 | [app-exp (rator rands)
337 | (app-exp (uv rator) (map uv rands))]
338 | [fix-exp (ids lams body)
339 | (fix-exp ids (map uv lams) (uv body))]
340 | [lambda-exp (ids body)
341 | (let loop ([in-ids ids] [out-ids '()] [out-rands '()] [substs substs])
342 | (if (null? in-ids)
343 | (if (null? out-ids)
344 | (lambda-exp ids (uv body))
345 | (lambda-exp ids
346 | (let-exp out-ids out-rands (unbox-vals body substs))))
347 | (let ([id (car in-ids)])
348 | (cond [(and (> (var-reference-count id body) 1)
349 | (var-unboxed-ctype-in-exp id body)) =>
350 | (lambda (ctype)
351 | (let ([cid (cvar-id (id->symbol id) ctype)])
352 | (loop (cdr in-ids) (cons cid out-ids)
353 | (cons (var-exp id) out-rands)
354 | (cons (cons id (var-exp cid)) substs))))]
355 | [else (loop (cdr in-ids) out-ids out-rands substs)]))))]))
356 |
357 | (uv exp))
358 |
359 | (unbox-vals exp '()))
360 |
361 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | BSD 3-Clause License
2 |
3 | Copyright (c) 2019, false-schemers
4 | All rights reserved.
5 |
6 | Redistribution and use in source and binary forms, with or without
7 | modification, are permitted provided that the following conditions are met:
8 |
9 | 1. Redistributions of source code must retain the above copyright notice, this
10 | list of conditions and the following disclaimer.
11 |
12 | 2. Redistributions in binary form must reproduce the above copyright notice,
13 | this list of conditions and the following disclaimer in the documentation
14 | and/or other materials provided with the distribution.
15 |
16 | 3. Neither the name of the copyright holder nor the names of its
17 | contributors may be used to endorse or promote products derived from
18 | this software without specific prior written permission.
19 |
20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
24 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
26 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
27 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
28 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 |
--------------------------------------------------------------------------------
/c.ss:
--------------------------------------------------------------------------------
1 |
2 | ; SFC (#F Scheme to C compiler) -- esl
3 |
4 | ; Chez bootstrap code
5 |
6 | (define construct-name
7 | (lambda (template-id . args)
8 | (datum->syntax-object template-id
9 | (string->symbol
10 | (apply string-append
11 | (map (lambda (x)
12 | (if (string? x)
13 | x
14 | (symbol->string (syntax-object->datum x))))
15 | args))))))
16 |
17 | (define-syntax define-variant
18 | (lambda (x)
19 | (syntax-case x ()
20 | [(_ name (field0 ...))
21 | (with-syntax
22 | ([constructor (construct-name (syntax name) (syntax name))]
23 | [predicate (construct-name (syntax name) (syntax name) "?")]
24 | [(reader ...)
25 | (map (lambda (field)
26 | (construct-name (syntax name) (syntax name) "->" field))
27 | (syntax (field0 ...)))]
28 | [count (length (syntax (name field0 ...)))])
29 | (with-syntax
30 | ([(index ...)
31 | (let f ([i 1])
32 | (if (= i (syntax-object->datum (syntax count)))
33 | '()
34 | (cons i (f (1+ i)))))])
35 | (syntax
36 | (begin
37 | (define constructor
38 | (lambda (field0 ...)
39 | (vector 'name field0 ...)))
40 | (define predicate
41 | (lambda (object)
42 | (and (vector? object)
43 | (= (vector-length object) count)
44 | (eq? (vector-ref object 0) 'name))))
45 | (define reader
46 | (lambda (object)
47 | (vector-ref object index)))
48 | ...))))])))
49 |
50 | (define-syntax variant-case
51 | (lambda (x)
52 | (syntax-case x (else)
53 | [(_ var) (syntax (error 'variant-case "no clause matches ~s" var))]
54 | [(_ var (else exp1 exp2 ...)) (syntax (begin exp1 exp2 ...))]
55 | [(_ exp clause ...)
56 | (not (identifier? (syntax exp)))
57 | (syntax (let ([var exp]) (_ var clause ...)))]
58 | [(_ var (name (field ...) exp1 exp2 ...) clause ...)
59 | (with-syntax
60 | ([predicate (construct-name (syntax name) (syntax name) "?")]
61 | [(reader ...)
62 | (map (lambda (fld)
63 | (construct-name (syntax name) (syntax name) "->" fld))
64 | (syntax (field ...)))])
65 | (syntax
66 | (if (predicate var)
67 | (let ([field (reader var)] ...) exp1 exp2 ...)
68 | (_ var clause ...))))])))
69 |
70 |
71 | (define-syntax define-inline
72 | (syntax-rules ()
73 | [(_ (id . args) . body) (define (id . args) . body)]
74 | [(_ id val) (define id val)]))
75 |
76 | (define-syntax define-integrable
77 | (syntax-rules ()
78 | [(_ (id . args) . body) (define (id . args) . body)]
79 | [(_ id val) (define id val)]))
80 |
81 |
82 | (define (argv->list argv) argv)
83 |
84 | (define current-error-port current-output-port)
85 |
86 | (define eof-object
87 | (let ([eof (read-char (open-input-string ""))])
88 | (lambda () eof)))
89 |
90 | (define (sfc . args)
91 | (main (cons "sfc-bootstrap" args)))
92 |
93 | (for-each load '("1.sf" "2.sf" "3.sf" "4.sf" "5.sf" "6.sf" "7.sf" "c.sf"))
94 |
95 | (printf "; now you may run~%; ~s~%; to generate .c files~%"
96 | '(sfc "-v" "0.sf" "1.sf" "2.sf" "3.sf" "4.sf" "5.sf" "6.sf" "7.sf" "c.sf"))
97 |
--------------------------------------------------------------------------------
/doc/ch1.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | 1. Syntax and semantics
6 |
29 |
36 |
37 |
38 |
39 |
49 |
50 |
51 |
52 |
53 |
1. Syntax and semantics
54 |
55 |
1.1. Syntax
56 |
57 |
Lorem ipsum, quia dolor sit, amet, consectetur, adipisci velit, sed quia non numquam
58 | eius modi tempora incidunt, ut labore et dolore magnam aliquam quaerat voluptatem.
59 |
60 |
1.2. Semantics
61 |
62 |
Lorem ipsum, quia dolor sit, amet, consectetur, adipisci velit, sed quia non numquam
63 | eius modi tempora incidunt, ut labore et dolore magnam aliquam quaerat voluptatem.
64 |
65 |
66 |
52 |
53 |
54 |
2. Notation and terminology
55 |
56 |
2.1. Entry format
57 |
58 |
The chapters describing bindings in the standard environment,
59 | system interface, and command-line interface are organized into
60 | entries. Each entry begins with a header line that usually includes
61 | the name of the form or a feature in monospace font within
62 | a template for its use. The names of the arguments or syntactic
63 | components of the form are italicized. A notation such as
64 |
65 |
thing1 …
66 |
67 |
indicates zero or more occurences of thing. Thus
68 |
69 |
thing1 thing2 …
70 |
71 |
indicates at least one thing. At the right of the header
72 | line one of the following categories will appear:
73 |
74 |
75 | | syntax |
76 | | procedure |
77 | | standard prelude typedef |
78 | | standard prelude #define |
79 | | runtime host variable |
80 | | command line utility |
81 |
82 |
83 |
An entry of a “syntax” category describes a syntactic
84 | class of forms, usually identified by a keyword. The header line for
85 | a syntactic class gives a template for the use of the form, with the
86 | components of the form designated by syntactic variables. Syntactic
87 | variables should be understood to denote other forms.
88 |
89 |
If the category of an entry is “procedure”, then the
90 | entry describes a procedure, and the header line gives a template
91 | for a call to the procedure. The italicized names in the template
92 | denote the arguments to the procedure.
93 |
94 |
95 |
96 |
2.2. Evaluation examples
97 |
98 |
...
99 |
100 |
111 |
53 |
54 |
5. Definitions
55 |
56 |
Modern Schemes feature a complicated mechanism of assembling a set of top-level or
57 | local bindings by transforming a program or a body
58 | into a sequence of global assignments or mutually recursive bindings. This transformation
59 | is too complex to be performed by a syntax-rules based macroexpander, so a minimal
60 | set of constructs for scopes and definitions is provided in the core language.
61 |
62 |
63 | (define variable expression) | syntax |
64 | (define-syntax keyword datum) | syntax |
65 | (begin definition …) | syntax |
66 |
67 |
68 |
Definitions are valid in some, but not all, contexts where expressions are allowed. They are valid
69 | only at the top level of a compilation unit and at the beginning of a syntax-lambda form.
70 | A definition is not an expression and has no value.
71 |
72 |
5.1. Top level definitions
73 |
74 |
At the top level of a compilation unit, a definition
75 |
76 | (define variable expression)
77 |
78 |
has essentially the same effect as the assignment expression
79 |
80 | (set! variable expression)
81 |
82 |
if variable is bound in the compilation unit. If variable
83 | is not bound, then the definition will bind variable to a new location
84 | before performing the assignment. In #F, all compilation units share a single
85 | global namespace, so variables bound at the top-level in one unit are visible in
86 | all other units. It is an error to bind a variable in more than one compilation unit
87 | of the program. It is also an error to reference a variable which is not bound in
88 | any compilation units constituting a program.
89 |
90 |
During the macroexpansion of the program a top level definition of the form
91 |
92 | (define-syntax keyword datum)
93 |
94 |
extends the top-level syntactic environment by binding keyword
95 | (an identifier) to the result of the expansion of datum in the
96 | original syntactic environment.
97 |
98 |
99 |
5.2. Internal definitions
100 |
101 |
Definitions may Adjacent definitions at the beginning of a syntax-lambda ...
102 |
103 |
Note: All traditional forms with implicit body are constructed as macros which
104 | use syntax-lambda to scope definitions. Traditional forms are available in base library.
105 |
106 |
107 |
108 |
58 |
59 |
60 |
8. Writing primitives in C
61 |
62 |
The #F compiler can be seen as a macroassembler which pieces together and
63 | interconnects fragments of C code. These fragments originate as inline C
64 | expressions in #F code, in the same way some C compilers allow embedding
65 | fragments of assembly code. While inline C expressions can appear anywhere
66 | a regular expression appears, they usually are confined to library code. In
67 | this regard
68 |
69 |
8.1. Inline C expressions
70 |
71 |
An inline C expressions consists of a keyword identifying the expression,
72 | followed by a code template and zero or more argument expressions.
73 | Keywords encode the information of side effects and allocation performed
74 | by the code in the template, allowing the compiler to classify the resulting
75 | expressions for code optimization phases.
76 |
77 |
78 |
79 |
80 | (%prim code expression1 …) | syntax |
81 | (%prim* code expression1 …) | syntax |
82 | (%prim? code expression1 …) | syntax |
83 | (%prim! code expression1 …) | syntax |
84 | (%prim?! code expression1 …) | syntax |
85 | (%prim*? code expression1 …) | syntax |
86 | (%prim*! code expression1 …) | syntax |
87 | (%prim*?! code expression1 …) | syntax |
88 |
89 |
90 |
A code template is either a literal string enclosed in double quotes or a
91 | parenthesized sequence of code templates. A parenthesized sequence is equivalent
92 | to a string obtained by the concatenation of its content strings; it is supported
93 | to simplify generation of primitive forms by macroexpansion.
94 |
95 |
96 |
Keywords of inline C expressions encode a combination of three properties:
97 |
98 |
99 | | * | allocates from garbage-collectible heap |
100 | | ! | has side effects other than allocation |
101 | | ? | observes side effects |
102 |
103 |
104 |
In a mutable vector library, make-vector could serve as a good example
105 | of * primitive (allocates from the heap), vector-set! as
106 | ! primitive (produces side effects thet might affect the results
107 | and/or effects of other expressions), and vector-ref as ?
108 | primitive (does not allocate or produce side effects, but its result is affected
109 | by other expressions that may modify the vector). Primitive code can
110 | exibit any combination of these properties, so there are eight keywords
111 | to cover all possible combinations.
112 |
113 |
#F compiler classifies primitives into categories based on their
114 | referential transparency, ability to cause garbage collection, and
115 | suitability for dead code elimination.
116 |
117 |
The %prim keywords marks the referentially transparent code;
118 | referentially transparent (RT) expressions always produce the same value
119 | given the same arguments, allowing for many compiler optimizations.
120 | All other keywords mark the code as not referentially transparent:
121 |
122 |
123 | | RT | %prim |
124 | | not RT | %prim* %prim? %prim!
%prim?! %prim*? %prim*! %prim*?! |
125 |
126 |
127 |
Primitives that never allocate from garbage-collected heap do not
128 | trigger garbage collection (GC), opening possibilities for some
129 | interesting compiler optimizations (#F compiler can use C calling
130 | mechanism for certain GC-safe procedures). Primitives that have no
131 | side effects and which values are not used are subject to dead code
132 | elimination (DCE). The keywords for inline C expressions are
133 | split between these categories as follows:
134 |
135 |
136 | | | DCE safe | DCE unsafe |
137 | | GC safe | %prim %prim? | %prim! %prim?! |
138 | | GC unsafe | %prim* %prim*? | %prim*! %prim*?! |
139 |
140 |
141 |
Note: inline C code that reads from files should
142 | be tagged by %prim?! keyword because such code affects the file
143 | read pointer and depends on the effects of previous reads.
144 |
145 |
146 |
156 |
157 |
158 |
51 |
52 |
53 |
introduction
54 |
55 |
#F (False Scheme) is a minimalist Scheme implementation tailored to
56 | the needs of practical programmers comfortable with both Scheme and C and
57 | willing to spend some additional effort in order to build a system that
58 | fits their needs better than any existing Scheme with an FFI interface.
59 | The implementation is based on a (reduced)Scheme-to-C compiler with no
60 | knowledge of any data types and a stripped down set of syntactic forms,
61 | that includes a few basic expression types, a flexible mechanism for
62 | extending the language by combining fragments of C code, and an extended
63 | version of R5RS macro system which doubles as a compiler
64 | backend.
65 |
66 |
Backround
67 |
Henry Baker in his Critique of DIN Kernel Lisp Definition Version 1.2
68 | [1]
69 | laid down the desiderata for a Kernel language:
70 |
71 |
72 | Presumably, a kernel language is a minimal language on top
73 | of which a larger language can be built. Since its primary function
74 | is being an implementation language for function libraries and a target language
75 | for macros, a Kernel language need not be particularly “user-friendly”
76 | or provide a lot of flexibility in its interface. Although it is desirable,
77 | a Kernel language does not have to be a strict subset of the full language,
78 | since some of its features may not be visible in the full language.
79 | A Kernel language should be simpler and more efficient to implement than
80 | the full language, however, to avoid an abstraction inversion,
81 | in which a simpler notion is defined in terms of more complex notions.
82 |
83 |
Later, he adds:
84 |
85 |
86 | Preserving a small definition for DKLisp requires that the standard
87 | ruthlessly eliminate non-primitive notions to focus on simple, efficient,
88 | modular primitives from which the rest of a Lisp system can be easily and
89 | efficiently constructed. In other words, DKLisp primitives must be chosen
90 | not for their ability keep a user program small, but for their ability to
91 | keep an implementation small and fast.
92 |
93 |
Baker's 15-year-old program echoes the central design principle of Scheme
94 | (“removing the weaknesses and restrictions…”) but goes
95 | farther, arguing for a smaller language with greater emphasis on implementation
96 | efficiency and language cleanliness. This approach harmonizes with the modern
97 | trend toward smaller domain-specific languages (DSLs) which do one specific thing
98 | but do it well. Building a DSL atop of a kernel language allows the designer
99 | to concentrate on what is needed for the task at hand, eliminating
100 | excess baggage.
101 |
102 |
Libraries and FFIs
103 |
104 |
In recent years it became more and more obvious that in order to be
105 | able to construct a large system around a simple kernel, the kernel has
106 | to provide an access to low-level system interfaces and libraries. It is
107 | no longer reasonable to expect that every new language will get its own
108 | implementation of regular expressions, an XML parser, a PDF writer, even
109 | though all of them can be implemented from scratch on top of a minimal
110 | number/string/list set of primitives. The situation is even worse when
111 | it comes to system interfaces (interprocess comunications, networking
112 | etc.) — they can only be built on top of a foreign
113 | function interface (FFI).
114 |
115 |
FFIs, as they are implemented in traditional Lisp/Scheme systems,
116 | rely on a complex set of data conversion rules, dynamic code generation
117 | and other platform-specific methods of getting access to the underlying application
118 | binary interface (ABI). Although a lot of effort has been spent on
119 | hiding the internal complexity of the interface from the user and handling
120 | platform-dependent calling conventions, FFIs remain fragile because many
121 | programmatic interfaces are are portable only on a source code level
122 | (and thus should be qualified as APIs, not ABIs).
123 |
124 |
What an ideal FFI can look like is demonstrated by C++. All that
125 | is needed to call C functions from C++ is to wrap their prototypes in
126 | extern "C" {} to prevent name mangling. The
127 | resulting C++ program is (almost) as portable as if it were written in
128 | C directly.
129 |
130 |
#F, being built around a Scheme-to-C compiler, is able to provide an
131 | FFI of comparable simplicity by allowing the programmer to write C code
132 | fragments to be included verbatim into the output code. As an extreme example
133 | of this practice, here is a complete #F source code for the ubiquitous
134 | “Hello World” program:
135 |
136 |
137 | (%include <stdio.h>)
138 |
139 | (define main
140 | (lambda (argv)
141 | (%prim! "void(printf(\"Hello, World!\\n\"))")))
142 |
143 |
144 |
Note: This “Scheme” program does
145 | not use any Scheme data types, so none have to be defined. The resulting
146 | C file is 7KB long and it includes a complete run-time system
147 | needed to execute the code.
148 |
149 |
Portability
150 |
151 |
You are in a maze of twisty little #ifdefs, all different.
152 | — Anon.
153 |
154 |
166 |
167 |
37 |
38 |
index of entries
39 |
92 |
37 |
38 |
table of contents
39 |
103 |