955 lines
29 KiB
Scheme
955 lines
29 KiB
Scheme
; Hacked to change error to fatal-error.
|
|
; (One of the benchmarked systems has a problem with calls to error.)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; Parsing benchmark.
|
|
;
|
|
; Reads nboyer.sch into a string before timing begins.
|
|
;
|
|
; The timed portion of the benchmark parses the string
|
|
; representation of nboyer.sch 1000 times.
|
|
;
|
|
; The output of that parse is checked by comparing it
|
|
; the the value returned by the read procedure.
|
|
;
|
|
; Usage:
|
|
; (parsing-benchmark n input)
|
|
;
|
|
; n defaults to 1000, and input defaults to "nboyer.sch".
|
|
;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(library (r6rs-benchmarks parsing)
|
|
(export main)
|
|
(import (r6rs) (r6rs-benchmarks))
|
|
|
|
(define (parsing-benchmark . rest)
|
|
(let* ((n (if (null? rest) 1000 (car rest)))
|
|
(input (if (or (null? rest) (null? (cdr rest)))
|
|
"nboyer.sch"
|
|
(cadr rest)))
|
|
(input-string (read-file-as-string input))
|
|
(answer (call-with-input-file
|
|
input
|
|
(lambda (in)
|
|
(do ((x (read in) (read in))
|
|
(answer '() x))
|
|
((eof-object? x)
|
|
answer)))))
|
|
(benchmark-name
|
|
(string-append "parsing:" input ":" (number->string n))))
|
|
(run-benchmark benchmark-name
|
|
n
|
|
(lambda (x) (equal? x answer))
|
|
(lambda (input-string)
|
|
(lambda () (parse-string input-string)))
|
|
input-string)))
|
|
|
|
(define (read-from-string-port-benchmark . rest)
|
|
(let* ((n (if (null? rest) 1000 (car rest)))
|
|
(input (if (or (null? rest) (null? (cdr rest)))
|
|
"nboyer.sch"
|
|
(cadr rest)))
|
|
(input-string (read-file-as-string input))
|
|
(answer (call-with-input-file
|
|
input
|
|
(lambda (in)
|
|
(do ((x (read in) (read in))
|
|
(answer '() x))
|
|
((eof-object? x)
|
|
answer)))))
|
|
(benchmark-name
|
|
(string-append "reading:" input ":" (number->string n))))
|
|
(run-benchmark benchmark-name
|
|
n
|
|
(lambda ()
|
|
(let ((in (open-input-string input-string)))
|
|
(do ((x (read in) (read in))
|
|
(y #f x))
|
|
((eof-object? x) y))))
|
|
(lambda (x) (equal? x answer)))))
|
|
|
|
(define (read-file-as-string name)
|
|
(call-with-input-file
|
|
name
|
|
(lambda (in)
|
|
(do ((x (read-char in) (read-char in))
|
|
(chars '() (cons x chars)))
|
|
((eof-object? x)
|
|
(list->string (reverse chars)))))))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; The parser used for benchmarking.
|
|
;
|
|
; Given a string containing Scheme code, parses the entire
|
|
; string and returns the last <datum> read from the string.
|
|
;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(define (parse-string input-string)
|
|
|
|
; Constants and local variables.
|
|
|
|
(let* (; Constants.
|
|
|
|
; Any character that doesn't appear within nboyer.sch
|
|
; (or the input file, if different) can be used to
|
|
; represent end-of-file.
|
|
|
|
(eof #\~)
|
|
|
|
; length of longest token allowed
|
|
; (this allows static allocation in C)
|
|
|
|
(max_token_size 1024)
|
|
|
|
; Encodings of error messages.
|
|
|
|
(errLongToken 1) ; extremely long token
|
|
(errincompletetoken 2) ; any lexical error, really
|
|
(errLexGenBug 3) ; can't happen
|
|
|
|
; State for one-token buffering in lexical analyzer.
|
|
|
|
(kindOfNextToken 'z1) ; valid iff nextTokenIsReady
|
|
(nextTokenIsReady #f)
|
|
|
|
(tokenValue "") ; string associated with current token
|
|
|
|
(totalErrors 0) ; errors so far
|
|
(lineNumber 1) ; rudimentary source code location
|
|
(lineNumberOfLastError 0) ; ditto
|
|
|
|
; A string buffer for the characters of the current token.
|
|
|
|
(string_accumulator (make-string max_token_size))
|
|
|
|
; Number of characters in string_accumulator.
|
|
|
|
(string_accumulator_length 0)
|
|
|
|
; A single character of buffering.
|
|
; nextCharacter is valid iff nextCharacterIsReady
|
|
|
|
(nextCharacter #\space)
|
|
(nextCharacterIsReady #f)
|
|
|
|
; Index of next character to be read from input-string.
|
|
|
|
(input-index 0)
|
|
|
|
(input-length (string-length input-string))
|
|
)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; LexGen generated the code for the state machine.
|
|
;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(define (scanner0)
|
|
(let loop ((c (scanchar)))
|
|
(if (char-whitespace? c)
|
|
(begin
|
|
(consumechar)
|
|
(set! string_accumulator_length 0)
|
|
(loop (scanchar)))))
|
|
(let ((c (scanchar)))
|
|
(if (char=? c eof) (accept 'eof) (state0 c))))
|
|
|
|
(define (state0 c)
|
|
(case c
|
|
((#\`) (consumechar) (accept 'backquote))
|
|
((#\') (consumechar) (accept 'quote))
|
|
((#\)) (consumechar) (accept 'rparen))
|
|
((#\() (consumechar) (accept 'lparen))
|
|
((#\;) (consumechar) (state29 (scanchar)))
|
|
((#\+ #\-) (consumechar) (state28 (scanchar)))
|
|
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
|
|
(consumechar)
|
|
(state27 (scanchar)))
|
|
((#\.) (consumechar) (state16 (scanchar)))
|
|
((#\a
|
|
#\b
|
|
#\c
|
|
#\d
|
|
#\e
|
|
#\f
|
|
#\g
|
|
#\h
|
|
#\i
|
|
#\j
|
|
#\k
|
|
#\l
|
|
#\m
|
|
#\n
|
|
#\o
|
|
#\p
|
|
#\q
|
|
#\r
|
|
#\s
|
|
#\t
|
|
#\u
|
|
#\v
|
|
#\w
|
|
#\x
|
|
#\y
|
|
#\z
|
|
#\A
|
|
#\B
|
|
#\C
|
|
#\D
|
|
#\E
|
|
#\F
|
|
#\G
|
|
#\H
|
|
#\I
|
|
#\J
|
|
#\K
|
|
#\L
|
|
#\M
|
|
#\N
|
|
#\O
|
|
#\P
|
|
#\Q
|
|
#\R
|
|
#\S
|
|
#\T
|
|
#\U
|
|
#\V
|
|
#\W
|
|
#\X
|
|
#\Y
|
|
#\Z
|
|
#\!
|
|
#\$
|
|
#\%
|
|
#\&
|
|
#\*
|
|
#\/
|
|
#\:
|
|
#\<
|
|
#\=
|
|
#\>
|
|
#\?
|
|
#\^
|
|
#\_
|
|
#\~)
|
|
(consumechar)
|
|
(state14 (scanchar)))
|
|
((#\#) (consumechar) (state13 (scanchar)))
|
|
((#\") (consumechar) (state2 (scanchar)))
|
|
((#\,) (consumechar) (state1 (scanchar)))
|
|
(else
|
|
(if (char-whitespace? c)
|
|
(begin (consumechar) (state30 (scanchar)))
|
|
(scannererror errincompletetoken)))))
|
|
(define (state1 c)
|
|
(case c
|
|
((#\@) (consumechar) (accept 'splicing))
|
|
(else (accept 'comma))))
|
|
(define (state2 c)
|
|
(case c
|
|
((#\") (consumechar) (accept 'string))
|
|
(else
|
|
(if (isnotdoublequote? c)
|
|
(begin (consumechar) (state2 (scanchar)))
|
|
(scannererror errincompletetoken)))))
|
|
(define (state3 c)
|
|
(case c
|
|
((#\n) (consumechar) (state8 (scanchar)))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state4 c)
|
|
(case c
|
|
((#\i) (consumechar) (state3 (scanchar)))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state5 c)
|
|
(case c
|
|
((#\l) (consumechar) (state4 (scanchar)))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state6 c)
|
|
(case c
|
|
((#\w) (consumechar) (state5 (scanchar)))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state7 c)
|
|
(case c
|
|
((#\e) (consumechar) (state6 (scanchar)))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state8 c)
|
|
(case c
|
|
((#\e) (consumechar) (accept 'character))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state9 c)
|
|
(case c
|
|
((#\c) (consumechar) (state8 (scanchar)))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state10 c)
|
|
(case c
|
|
((#\a) (consumechar) (state9 (scanchar)))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state11 c)
|
|
(case c
|
|
((#\p) (consumechar) (state10 (scanchar)))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state12 c)
|
|
(case c
|
|
((#\s) (consumechar) (state11 (scanchar)))
|
|
((#\n) (consumechar) (state7 (scanchar)))
|
|
(else
|
|
(if (char? c)
|
|
(begin (consumechar) (accept 'character))
|
|
(scannererror errincompletetoken)))))
|
|
(define (state13 c)
|
|
(case c
|
|
((#\() (consumechar) (accept 'vecstart))
|
|
((#\t #\f) (consumechar) (accept 'boolean))
|
|
((#\\) (consumechar) (state12 (scanchar)))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state14 c)
|
|
(case c
|
|
((#\a
|
|
#\b
|
|
#\c
|
|
#\d
|
|
#\e
|
|
#\f
|
|
#\g
|
|
#\h
|
|
#\i
|
|
#\j
|
|
#\k
|
|
#\l
|
|
#\m
|
|
#\n
|
|
#\o
|
|
#\p
|
|
#\q
|
|
#\r
|
|
#\s
|
|
#\t
|
|
#\u
|
|
#\v
|
|
#\w
|
|
#\x
|
|
#\y
|
|
#\z
|
|
#\A
|
|
#\B
|
|
#\C
|
|
#\D
|
|
#\E
|
|
#\F
|
|
#\G
|
|
#\H
|
|
#\I
|
|
#\J
|
|
#\K
|
|
#\L
|
|
#\M
|
|
#\N
|
|
#\O
|
|
#\P
|
|
#\Q
|
|
#\R
|
|
#\S
|
|
#\T
|
|
#\U
|
|
#\V
|
|
#\W
|
|
#\X
|
|
#\Y
|
|
#\Z
|
|
#\!
|
|
#\$
|
|
#\%
|
|
#\&
|
|
#\*
|
|
#\/
|
|
#\:
|
|
#\<
|
|
#\=
|
|
#\>
|
|
#\?
|
|
#\^
|
|
#\_
|
|
#\~
|
|
#\0
|
|
#\1
|
|
#\2
|
|
#\3
|
|
#\4
|
|
#\5
|
|
#\6
|
|
#\7
|
|
#\8
|
|
#\9
|
|
#\+
|
|
#\-
|
|
#\.
|
|
#\@)
|
|
(consumechar)
|
|
(state14 (scanchar)))
|
|
(else (accept 'id))))
|
|
(define (state15 c)
|
|
(case c
|
|
((#\.) (consumechar) (accept 'id))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state16 c)
|
|
(case c
|
|
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
|
|
(consumechar)
|
|
(state18 (scanchar)))
|
|
((#\.) (consumechar) (state15 (scanchar)))
|
|
(else (accept 'period))))
|
|
(define (state17 c)
|
|
(case c
|
|
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
|
|
(consumechar)
|
|
(state18 (scanchar)))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state18 c)
|
|
(case c
|
|
((#\e #\s #\f #\d #\l)
|
|
(consumechar)
|
|
(state22 (scanchar)))
|
|
((#\#) (consumechar) (state19 (scanchar)))
|
|
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
|
|
(consumechar)
|
|
(state18 (scanchar)))
|
|
(else (accept 'number))))
|
|
(define (state19 c)
|
|
(case c
|
|
((#\e #\s #\f #\d #\l)
|
|
(consumechar)
|
|
(state22 (scanchar)))
|
|
((#\#) (consumechar) (state19 (scanchar)))
|
|
(else (accept 'number))))
|
|
(define (state20 c)
|
|
(case c
|
|
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
|
|
(consumechar)
|
|
(state20 (scanchar)))
|
|
(else (accept 'number))))
|
|
(define (state21 c)
|
|
(case c
|
|
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
|
|
(consumechar)
|
|
(state20 (scanchar)))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state22 c)
|
|
(case c
|
|
((#\+ #\-) (consumechar) (state21 (scanchar)))
|
|
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
|
|
(consumechar)
|
|
(state20 (scanchar)))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state23 c)
|
|
(case c
|
|
((#\#) (consumechar) (state23 (scanchar)))
|
|
(else (accept 'number))))
|
|
(define (state24 c)
|
|
(case c
|
|
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
|
|
(consumechar)
|
|
(state24 (scanchar)))
|
|
((#\#) (consumechar) (state23 (scanchar)))
|
|
(else (accept 'number))))
|
|
(define (state25 c)
|
|
(case c
|
|
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
|
|
(consumechar)
|
|
(state24 (scanchar)))
|
|
(else (scannererror errincompletetoken))))
|
|
(define (state26 c)
|
|
(case c
|
|
((#\#) (consumechar) (state26 (scanchar)))
|
|
((#\/) (consumechar) (state25 (scanchar)))
|
|
((#\e #\s #\f #\d #\l)
|
|
(consumechar)
|
|
(state22 (scanchar)))
|
|
((#\.) (consumechar) (state19 (scanchar)))
|
|
(else (accept 'number))))
|
|
(define (state27 c)
|
|
(case c
|
|
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
|
|
(consumechar)
|
|
(state27 (scanchar)))
|
|
((#\#) (consumechar) (state26 (scanchar)))
|
|
((#\/) (consumechar) (state25 (scanchar)))
|
|
((#\e #\s #\f #\d #\l)
|
|
(consumechar)
|
|
(state22 (scanchar)))
|
|
((#\.) (consumechar) (state18 (scanchar)))
|
|
(else (accept 'number))))
|
|
(define (state28 c)
|
|
(case c
|
|
((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
|
|
(consumechar)
|
|
(state27 (scanchar)))
|
|
((#\.) (consumechar) (state17 (scanchar)))
|
|
(else (accept 'id))))
|
|
(define (state29 c)
|
|
(case c
|
|
((#\newline)
|
|
(consumechar)
|
|
(begin
|
|
(set! string_accumulator_length 0)
|
|
(state0 (scanchar))))
|
|
(else
|
|
(if (isnotnewline? c)
|
|
(begin (consumechar) (state29 (scanchar)))
|
|
(scannererror errincompletetoken)))))
|
|
(define (state30 c)
|
|
(case c
|
|
(else
|
|
(if (char-whitespace? c)
|
|
(begin (consumechar) (state30 (scanchar)))
|
|
(begin
|
|
(set! string_accumulator_length 0)
|
|
(state0 (scanchar)))))))
|
|
(define (state31 c)
|
|
(case c
|
|
(else
|
|
(begin
|
|
(set! string_accumulator_length 0)
|
|
(state0 (scanchar))))))
|
|
(define (state32 c) (case c (else (accept 'id))))
|
|
(define (state33 c)
|
|
(case c (else (accept 'boolean))))
|
|
(define (state34 c)
|
|
(case c (else (accept 'character))))
|
|
(define (state35 c)
|
|
(case c (else (accept 'vecstart))))
|
|
(define (state36 c)
|
|
(case c (else (accept 'string))))
|
|
(define (state37 c)
|
|
(case c (else (accept 'lparen))))
|
|
(define (state38 c)
|
|
(case c (else (accept 'rparen))))
|
|
(define (state39 c)
|
|
(case c (else (accept 'quote))))
|
|
(define (state40 c)
|
|
(case c (else (accept 'backquote))))
|
|
(define (state41 c)
|
|
(case c (else (accept 'splicing))))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; End of state machine generated by LexGen.
|
|
;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; ParseGen generated the code for the strong LL(1) parser.
|
|
;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(define (parse-datum)
|
|
(case (next-token)
|
|
((splicing comma backquote quote lparen vecstart)
|
|
(let ((ast1 (parse-compound-datum)))
|
|
(identity ast1)))
|
|
((boolean number character string id)
|
|
(let ((ast1 (parse-simple-datum)))
|
|
(identity ast1)))
|
|
(else
|
|
(parse-error
|
|
'<datum>
|
|
'(backquote
|
|
boolean
|
|
character
|
|
comma
|
|
id
|
|
lparen
|
|
number
|
|
quote
|
|
splicing
|
|
string
|
|
vecstart)))))
|
|
|
|
(define (parse-simple-datum)
|
|
(case (next-token)
|
|
((id)
|
|
(let ((ast1 (parse-symbol))) (identity ast1)))
|
|
((string) (begin (consume-token!) (makeString)))
|
|
((character) (begin (consume-token!) (makeChar)))
|
|
((number) (begin (consume-token!) (makeNum)))
|
|
((boolean) (begin (consume-token!) (makeBool)))
|
|
(else
|
|
(parse-error
|
|
'<simple-datum>
|
|
'(boolean character id number string)))))
|
|
|
|
(define (parse-symbol)
|
|
(case (next-token)
|
|
((id) (begin (consume-token!) (makeSym)))
|
|
(else (parse-error '<symbol> '(id)))))
|
|
|
|
(define (parse-compound-datum)
|
|
(case (next-token)
|
|
((vecstart)
|
|
(let ((ast1 (parse-vector))) (identity ast1)))
|
|
((lparen quote backquote comma splicing)
|
|
(let ((ast1 (parse-list))) (identity ast1)))
|
|
(else
|
|
(parse-error
|
|
'<compound-datum>
|
|
'(backquote comma lparen quote splicing vecstart)))))
|
|
|
|
(define (parse-list)
|
|
(case (next-token)
|
|
((splicing comma backquote quote)
|
|
(let ((ast1 (parse-abbreviation)))
|
|
(identity ast1)))
|
|
((lparen)
|
|
(begin
|
|
(consume-token!)
|
|
(let ((ast1 (parse-list2))) (identity ast1))))
|
|
(else
|
|
(parse-error
|
|
'<list>
|
|
'(backquote comma lparen quote splicing)))))
|
|
|
|
(define (parse-list2)
|
|
(case (next-token)
|
|
((id string
|
|
character
|
|
number
|
|
boolean
|
|
vecstart
|
|
lparen
|
|
quote
|
|
backquote
|
|
comma
|
|
splicing)
|
|
(let ((ast1 (parse-datum)))
|
|
(let ((ast2 (parse-list3))) (cons ast1 ast2))))
|
|
((rparen) (begin (consume-token!) (emptyList)))
|
|
(else
|
|
(parse-error
|
|
'<list2>
|
|
'(backquote
|
|
boolean
|
|
character
|
|
comma
|
|
id
|
|
lparen
|
|
number
|
|
quote
|
|
rparen
|
|
splicing
|
|
string
|
|
vecstart)))))
|
|
|
|
(define (parse-list3)
|
|
(case (next-token)
|
|
((rparen
|
|
period
|
|
splicing
|
|
comma
|
|
backquote
|
|
quote
|
|
lparen
|
|
vecstart
|
|
boolean
|
|
number
|
|
character
|
|
string
|
|
id)
|
|
(let ((ast1 (parse-data)))
|
|
(let ((ast2 (parse-list4)))
|
|
(pseudoAppend ast1 ast2))))
|
|
(else
|
|
(parse-error
|
|
'<list3>
|
|
'(backquote
|
|
boolean
|
|
character
|
|
comma
|
|
id
|
|
lparen
|
|
number
|
|
period
|
|
quote
|
|
rparen
|
|
splicing
|
|
string
|
|
vecstart)))))
|
|
|
|
(define (parse-list4)
|
|
(case (next-token)
|
|
((period)
|
|
(begin
|
|
(consume-token!)
|
|
(let ((ast1 (parse-datum)))
|
|
(if (eq? (next-token) 'rparen)
|
|
(begin (consume-token!) (identity ast1))
|
|
(parse-error '<list4> '(rparen))))))
|
|
((rparen) (begin (consume-token!) (emptyList)))
|
|
(else (parse-error '<list4> '(period rparen)))))
|
|
|
|
(define (parse-abbreviation)
|
|
(case (next-token)
|
|
((quote backquote comma splicing)
|
|
(let ((ast1 (parse-abbrev-prefix)))
|
|
(let ((ast2 (parse-datum))) (list ast1 ast2))))
|
|
(else
|
|
(parse-error
|
|
'<abbreviation>
|
|
'(backquote comma quote splicing)))))
|
|
|
|
(define (parse-abbrev-prefix)
|
|
(case (next-token)
|
|
((splicing)
|
|
(begin (consume-token!) (symSplicing)))
|
|
((comma) (begin (consume-token!) (symUnquote)))
|
|
((backquote)
|
|
(begin (consume-token!) (symBackquote)))
|
|
((quote) (begin (consume-token!) (symQuote)))
|
|
(else
|
|
(parse-error
|
|
'<abbrev-prefix>
|
|
'(backquote comma quote splicing)))))
|
|
|
|
(define (parse-vector)
|
|
(case (next-token)
|
|
((vecstart)
|
|
(begin
|
|
(consume-token!)
|
|
(let ((ast1 (parse-data)))
|
|
(if (eq? (next-token) 'rparen)
|
|
(begin (consume-token!) (list2vector ast1))
|
|
(parse-error '<vector> '(rparen))))))
|
|
(else (parse-error '<vector> '(vecstart)))))
|
|
|
|
(define (parse-data)
|
|
(case (next-token)
|
|
((id string
|
|
character
|
|
number
|
|
boolean
|
|
vecstart
|
|
lparen
|
|
quote
|
|
backquote
|
|
comma
|
|
splicing)
|
|
(let ((ast1 (parse-datum)))
|
|
(let ((ast2 (parse-data))) (cons ast1 ast2))))
|
|
((rparen period) (emptyList))
|
|
(else
|
|
(parse-error
|
|
'<data>
|
|
'(backquote
|
|
boolean
|
|
character
|
|
comma
|
|
id
|
|
lparen
|
|
number
|
|
period
|
|
quote
|
|
rparen
|
|
splicing
|
|
string
|
|
vecstart)))))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; End of LL(1) parser generated by ParseGen.
|
|
;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; Help predicates used by the lexical analyzer's state machine.
|
|
;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(define (isnotdoublequote? c) (not (char=? c #\")))
|
|
(define (isnotnewline? c) (not (char=? c #\newline)))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; Lexical analyzer.
|
|
;
|
|
; This code is adapted from the quirk23 lexical analyzer written
|
|
; by Will Clinger for a compiler course.
|
|
;
|
|
; The scanner and parser were generated automatically and then
|
|
; printed using an R5RS Scheme pretty-printer, so they do not
|
|
; preserve case. In preparation for the case-sensitivity of
|
|
; R6RS Scheme, several identifiers and constants have been
|
|
; lower-cased in the hand-written code to match the generated
|
|
; code.
|
|
;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
; next-token and consume-token! are called by the parser.
|
|
|
|
; Returns the current token.
|
|
|
|
(define (next-token)
|
|
(if nextTokenIsReady
|
|
kindOfNextToken
|
|
(begin (set! string_accumulator_length 0)
|
|
(scanner0))))
|
|
|
|
; Consumes the current token.
|
|
|
|
(define (consume-token!)
|
|
(set! nextTokenIsReady #f))
|
|
|
|
; Called by the lexical analyzer's state machine,
|
|
; hence the unfortunate lower case.
|
|
|
|
(define (scannererror msg)
|
|
(define msgtxt
|
|
(cond ((= msg errLongToken)
|
|
"Amazingly long token")
|
|
((= msg errincompletetoken)
|
|
"in line ")
|
|
((= msg errLexGenBug)
|
|
"Bug in lexical analyzer (generated)")
|
|
(else "Bug in lexical analyzer")))
|
|
(fatal-error (string-append "Lexical Error: " msgtxt) lineNumber)
|
|
(set! nextTokenIsReady #f)
|
|
(set! nextCharacterIsReady #f)
|
|
(next-token))
|
|
|
|
; Accepts a token of the given kind, returning that kind.
|
|
;
|
|
; For some kinds of tokens, a value for the token must also be
|
|
; recorded in tokenValue.
|
|
|
|
(define (accept t)
|
|
(if (memq t '(boolean character id number string))
|
|
(set! tokenValue
|
|
(substring string_accumulator 0 string_accumulator_length)))
|
|
(set! kindOfNextToken t)
|
|
(set! nextTokenIsReady #t)
|
|
t)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; Character i/o, so to speak.
|
|
; Uses the input-string as input.
|
|
;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
; Returns the current character from the input.
|
|
|
|
(define (scanchar)
|
|
(if nextCharacterIsReady
|
|
nextCharacter
|
|
(begin (if (< input-index input-length)
|
|
(begin (set! nextCharacter
|
|
(string-ref input-string input-index))
|
|
(set! input-index (+ input-index 1)))
|
|
(set! nextCharacter eof))
|
|
(set! nextCharacterIsReady #t)
|
|
; For debugging, change #f to #t below.
|
|
(if #f
|
|
(write-char nextCharacter))
|
|
(scanchar))))
|
|
|
|
; Consumes the current character, and returns the next.
|
|
|
|
(define (consumechar)
|
|
(if (not nextCharacterIsReady)
|
|
(scanchar))
|
|
(if (< string_accumulator_length max_token_size)
|
|
(begin (set! nextCharacterIsReady #f)
|
|
(if (char=? nextCharacter #\newline)
|
|
(set! lineNumber (+ lineNumber 1)))
|
|
(string-set! string_accumulator
|
|
string_accumulator_length
|
|
nextCharacter)
|
|
(set! string_accumulator_length
|
|
(+ string_accumulator_length 1)))
|
|
(scannererror errLongToken)))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; Action procedures called by the parser.
|
|
;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(define (emptyList) '())
|
|
|
|
(define (identity x) x)
|
|
|
|
(define (list2vector vals) (list->vector vals))
|
|
|
|
(define (makeBool)
|
|
(string=? tokenValue "#t"))
|
|
|
|
(define (makeChar)
|
|
(string-ref tokenValue 0))
|
|
|
|
(define (makeNum)
|
|
(string->number tokenValue))
|
|
|
|
(define (makeString)
|
|
; Must strip off outer double quotes.
|
|
; Ought to process escape characters also, but we won't.
|
|
(substring tokenValue 1 (- (string-length tokenValue) 1)))
|
|
|
|
(define (makeSym)
|
|
(string->symbol tokenValue))
|
|
|
|
; Like append, but allows the last argument to be a non-list.
|
|
|
|
(define (pseudoAppend vals terminus)
|
|
(if (null? vals)
|
|
terminus
|
|
(cons (car vals)
|
|
(pseudoAppend (cdr vals) terminus))))
|
|
|
|
(define (symBackquote) 'quasiquote)
|
|
(define (symQuote) 'quote)
|
|
(define (symSplicing) 'unquote-splicing)
|
|
(define (symUnquote) 'unquote)
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; Error procedure called by the parser.
|
|
; As a hack, this error procedure recovers from end-of-file.
|
|
;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(define (parse-error nonterminal expected-terminals)
|
|
(if (eq? 'eof (next-token))
|
|
'eof
|
|
(begin
|
|
(display "Syntax error in line ")
|
|
(display lineNumber)
|
|
(display " while parsing a ")
|
|
(write nonterminal)
|
|
(newline)
|
|
(display " Encountered a ")
|
|
(display (next-token))
|
|
(display " while expecting something in")
|
|
(newline)
|
|
(display " ")
|
|
(write expected-terminals)
|
|
(newline)
|
|
(fatal-error "Syntax error"))))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; Parses repeatedly, returning the last <datum> parsed.
|
|
;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
(do ((x (parse-datum) (parse-datum))
|
|
(y 'eof x))
|
|
((eq? x 'eof)
|
|
y))))
|
|
|
|
(define (main . args)
|
|
(parsing-benchmark parsing-iters "r6rs-benchmarks/parsing-test.sch")))
|