rebase on fork of parser-tools
parent
3e71cfa350
commit
9b8e0f96c8
@ -0,0 +1,3 @@
|
||||
#lang info
|
||||
|
||||
(define scribblings '(("br-parser-tools.scrbl" (multi-page) (parsing-library))))
|
||||
@ -1,6 +1,6 @@
|
||||
(module lex-plt-v200 mzscheme
|
||||
(require parser-tools/lex
|
||||
(prefix : parser-tools/lex-sre))
|
||||
(require br-parser-tools/lex
|
||||
(prefix : br-parser-tools/lex-sre))
|
||||
|
||||
(provide epsilon
|
||||
~
|
||||
@ -1,5 +1,5 @@
|
||||
(module lex-sre mzscheme
|
||||
(require parser-tools/lex)
|
||||
(require br-parser-tools/lex)
|
||||
|
||||
(provide (rename sre-* *)
|
||||
(rename sre-+ +)
|
||||
@ -0,0 +1,369 @@
|
||||
#lang racket/base
|
||||
|
||||
;; Provides the syntax used to create lexers and the functions needed to
|
||||
;; create and use the buffer that the lexer reads from. See docs.
|
||||
|
||||
(require (for-syntax mzlib/list
|
||||
syntax/stx
|
||||
syntax/define
|
||||
syntax/boundmap
|
||||
"private-lex/util.rkt"
|
||||
"private-lex/actions.rkt"
|
||||
"private-lex/front.rkt"
|
||||
"private-lex/unicode-chars.rkt"
|
||||
racket/base
|
||||
racket/promise))
|
||||
|
||||
(require mzlib/stxparam
|
||||
syntax/readerr
|
||||
"private-lex/token.rkt")
|
||||
|
||||
(provide lexer lexer-src-pos lexer-srcloc define-lex-abbrev define-lex-abbrevs define-lex-trans
|
||||
|
||||
;; Dealing with tokens and related structures
|
||||
define-tokens define-empty-tokens token-name token-value token?
|
||||
(struct-out position)
|
||||
(struct-out position-token)
|
||||
(struct-out srcloc-token)
|
||||
|
||||
;; File path for highlighting errors while lexing
|
||||
file-path
|
||||
lexer-file-path ;; alternate name
|
||||
|
||||
;; Lex abbrevs for unicode char sets. See mzscheme manual section 3.4.
|
||||
any-char any-string nothing alphabetic lower-case upper-case title-case
|
||||
numeric symbolic punctuation graphic whitespace blank iso-control
|
||||
|
||||
;; A regular expression operator
|
||||
char-set)
|
||||
|
||||
;; wrap-action: syntax-object src-pos? -> syntax-object
|
||||
(define-for-syntax (wrap-action action src-loc-style)
|
||||
(with-syntax ([action-stx
|
||||
(cond
|
||||
[(eq? src-loc-style 'lexer-src-pos)
|
||||
#`(let/ec ret
|
||||
(syntax-parameterize
|
||||
([return-without-pos (make-rename-transformer #'ret)])
|
||||
(make-position-token #,action start-pos end-pos)))]
|
||||
[(eq? src-loc-style 'lexer-srcloc)
|
||||
#`(let/ec ret
|
||||
(syntax-parameterize
|
||||
([return-without-srcloc (make-rename-transformer #'ret)])
|
||||
(make-srcloc-token #,action lexeme-srcloc)))]
|
||||
[else action])])
|
||||
(syntax/loc action
|
||||
(λ (start-pos-p end-pos-p lexeme-p input-port-p)
|
||||
(define lexeme-srcloc-p (make-srcloc (object-name input-port-p)
|
||||
(position-line start-pos-p)
|
||||
(position-col start-pos-p)
|
||||
(position-offset start-pos-p)
|
||||
(and (number? (position-offset end-pos-p))
|
||||
(number? (position-offset start-pos-p))
|
||||
(- (position-offset end-pos-p)
|
||||
(position-offset start-pos-p)))))
|
||||
(syntax-parameterize
|
||||
([start-pos (make-rename-transformer #'start-pos-p)]
|
||||
[end-pos (make-rename-transformer #'end-pos-p)]
|
||||
[lexeme (make-rename-transformer #'lexeme-p)]
|
||||
[input-port (make-rename-transformer #'input-port-p)]
|
||||
[lexeme-srcloc (make-rename-transformer #'lexeme-srcloc-p)])
|
||||
action-stx)))))
|
||||
|
||||
(define-for-syntax (make-lexer-macro caller src-loc-style)
|
||||
(λ (stx)
|
||||
(syntax-case stx ()
|
||||
[(_ . RE+ACTS)
|
||||
(let ()
|
||||
(define spec/re-acts (syntax->list #'RE+ACTS))
|
||||
(for/and ([x (in-list spec/re-acts)])
|
||||
(syntax-case x ()
|
||||
[(RE ACT) #t]
|
||||
[else (raise-syntax-error caller "not a regular expression / action pair" stx x)]))
|
||||
(define eof-act (get-special-action spec/re-acts #'eof #'eof))
|
||||
(define spec-act (get-special-action spec/re-acts #'special #'(void)))
|
||||
(define spec-comment-act (get-special-action spec/re-acts #'special-comment #'#f))
|
||||
(define ids (list #'special #'special-comment #'eof))
|
||||
(define re-acts (filter (λ (spec/re-act)
|
||||
(syntax-case spec/re-act ()
|
||||
[((special) act)
|
||||
(not (ormap
|
||||
(λ (x)
|
||||
(and (identifier? #'special)
|
||||
(module-or-top-identifier=? #'special x)))
|
||||
ids))]
|
||||
[_ #t])) spec/re-acts))
|
||||
(define names (map (λ (x) (datum->syntax #f (gensym))) re-acts))
|
||||
(define acts (map (λ (x) (stx-car (stx-cdr x))) re-acts))
|
||||
(define re-actnames (map (λ (re-act name) (list (stx-car re-act) name)) re-acts names))
|
||||
(when (null? spec/re-acts)
|
||||
(raise-syntax-error caller "expected at least one action" stx))
|
||||
(define-values (trans start action-names no-look disappeared-uses) (build-lexer re-actnames))
|
||||
(when (vector-ref action-names start) ;; Start state is final
|
||||
(unless (and
|
||||
;; All the successor states are final
|
||||
(vector? (vector-ref trans start))
|
||||
(andmap (λ (x) (vector-ref action-names (vector-ref x 2)))
|
||||
(vector->list (vector-ref trans start)))
|
||||
;; Each character has a successor state
|
||||
(let loop ([check 0]
|
||||
[nexts (vector->list (vector-ref trans start))])
|
||||
(cond
|
||||
[(null? nexts) #f]
|
||||
[else
|
||||
(let ([next (car nexts)])
|
||||
(and (= (vector-ref next 0) check)
|
||||
(let ([next-check (vector-ref next 1)])
|
||||
(or (>= next-check max-char-num)
|
||||
(loop (add1 next-check) (cdr nexts))))))])))
|
||||
(eprintf "warning: lexer at ~a can accept the empty string\n" stx)))
|
||||
(with-syntax ([START-STATE-STX start]
|
||||
[TRANS-TABLE-STX trans]
|
||||
[NO-LOOKAHEAD-STX no-look]
|
||||
[(NAME ...) names]
|
||||
[(ACT ...) (map (λ (a) (wrap-action a src-loc-style)) acts)]
|
||||
[(ACT-NAME ...) (vector->list action-names)]
|
||||
[SPEC-ACT-STX (wrap-action spec-act src-loc-style)]
|
||||
[HAS-COMMENT-ACT?-STX (if (syntax-e spec-comment-act) #t #f)]
|
||||
[SPEC-COMMENT-ACT-STX (wrap-action spec-comment-act src-loc-style)]
|
||||
[EOF-ACT-STX (wrap-action eof-act src-loc-style)])
|
||||
(syntax-property
|
||||
(syntax/loc stx (let ([NAME ACT] ...)
|
||||
(let ([proc (lexer-body START-STATE-STX
|
||||
TRANS-TABLE-STX
|
||||
(vector ACT-NAME ...)
|
||||
NO-LOOKAHEAD-STX
|
||||
SPEC-ACT-STX
|
||||
HAS-COMMENT-ACT?-STX
|
||||
SPEC-COMMENT-ACT-STX
|
||||
EOF-ACT-STX)])
|
||||
;; reverse eta to get named procedures:
|
||||
(λ (port) (proc port)))))
|
||||
'disappeared-use disappeared-uses)))])))
|
||||
|
||||
(define-syntax lexer (make-lexer-macro 'lexer #f))
|
||||
(define-syntax lexer-src-pos (make-lexer-macro 'lexer-src-pos 'lexer-src-pos))
|
||||
(define-syntax lexer-srcloc (make-lexer-macro 'lexer-srcloc 'lexer-srcloc))
|
||||
|
||||
(define-syntax (define-lex-abbrev stx)
|
||||
(syntax-case stx ()
|
||||
[(_ NAME RE) (identifier? #'NAME)
|
||||
(syntax/loc stx
|
||||
(define-syntax NAME
|
||||
(make-lex-abbrev (λ () (quote-syntax RE)))))]
|
||||
[_ (raise-syntax-error 'define-lex-abbrev "form should be (define-lex-abbrev name re)" stx)]))
|
||||
|
||||
(define-syntax (define-lex-abbrevs stx)
|
||||
(syntax-case stx ()
|
||||
[(_ . XS)
|
||||
(with-syntax ([(ABBREV ...) (map
|
||||
(λ (a)
|
||||
(syntax-case a ()
|
||||
[(NAME RE) (identifier? #'NAME)
|
||||
(syntax/loc a (define-lex-abbrev NAME RE))]
|
||||
[_ (raise-syntax-error
|
||||
#f
|
||||
"form should be (define-lex-abbrevs (name re) ...)"
|
||||
stx
|
||||
a)]))
|
||||
(syntax->list #'XS))])
|
||||
(syntax/loc stx (begin ABBREV ...)))]
|
||||
[_ (raise-syntax-error #f "form should be (define-lex-abbrevs (name re) ...)" stx)]))
|
||||
|
||||
(define-syntax (define-lex-trans stx)
|
||||
(syntax-case stx ()
|
||||
[(_ name-form body-form)
|
||||
(let-values (((name body)
|
||||
(normalize-definition #'(define-syntax name-form body-form) #'λ)))
|
||||
|
||||
#`(define-syntax #,name
|
||||
(let ((func #,body))
|
||||
(unless (procedure? func)
|
||||
(raise-syntax-error 'define-lex-trans "expected a procedure as the transformer, got ~e" func))
|
||||
(unless (procedure-arity-includes? func 1)
|
||||
(raise-syntax-error 'define-lex-trans "expected a procedure that accepts 1 argument as the transformer, got ~e" func))
|
||||
(make-lex-trans func))))]
|
||||
[_
|
||||
(raise-syntax-error
|
||||
#f
|
||||
"form should be (define-lex-trans name transformer)"
|
||||
stx)]))
|
||||
|
||||
|
||||
(define (get-next-state-helper char min max table)
|
||||
(cond
|
||||
[(>= min max) #f]
|
||||
[else
|
||||
(define try (quotient (+ min max) 2))
|
||||
(define el (vector-ref table try))
|
||||
(define r1 (vector-ref el 0))
|
||||
(define r2 (vector-ref el 1))
|
||||
(cond
|
||||
[(and (>= char r1) (<= char r2)) (vector-ref el 2)]
|
||||
[(< char r1) (get-next-state-helper char min try table)]
|
||||
[else (get-next-state-helper char (add1 try) max table)])]))
|
||||
|
||||
|
||||
|
||||
|
||||
(define (get-next-state char table)
|
||||
(and table (get-next-state-helper char 0 (vector-length table) table)))
|
||||
|
||||
(define (lexer-body start-state trans-table actions no-lookahead special-action
|
||||
has-special-comment-action? special-comment-action eof-action)
|
||||
(letrec ([lexer
|
||||
(λ (ip)
|
||||
(let ((first-pos (get-position ip))
|
||||
(first-char (peek-char-or-special ip 0)))
|
||||
;(printf "(peek-char-or-special port 0) = ~e\n" first-char)
|
||||
(cond
|
||||
[(eof-object? first-char)
|
||||
(do-match ip first-pos eof-action (read-char-or-special ip))]
|
||||
[(special-comment? first-char)
|
||||
(read-char-or-special ip)
|
||||
(cond
|
||||
(has-special-comment-action?
|
||||
(do-match ip first-pos special-comment-action #f))
|
||||
(else (lexer ip)))]
|
||||
[(not (char? first-char))
|
||||
(do-match ip first-pos special-action (read-char-or-special ip))]
|
||||
[else
|
||||
(let lexer-loop (
|
||||
;; current-state
|
||||
(state start-state)
|
||||
;; the character to transition on
|
||||
(char first-char)
|
||||
;; action for the longest match seen thus far
|
||||
;; including a match at the current state
|
||||
(longest-match-action
|
||||
(vector-ref actions start-state))
|
||||
;; how many bytes precede char
|
||||
(length-bytes 0)
|
||||
;; how many characters have been read
|
||||
;; including the one just read
|
||||
(length-chars 1)
|
||||
;; how many characters are in the longest match
|
||||
(longest-match-length 0))
|
||||
(let ([next-state
|
||||
(cond
|
||||
[(not (char? char)) #f]
|
||||
[else (get-next-state (char->integer char)
|
||||
(vector-ref trans-table state))])])
|
||||
(cond
|
||||
[(not next-state)
|
||||
(check-match ip first-pos longest-match-length
|
||||
length-chars longest-match-action)]
|
||||
[(vector-ref no-lookahead next-state)
|
||||
(let ((act (vector-ref actions next-state)))
|
||||
(check-match ip
|
||||
first-pos
|
||||
(if act length-chars longest-match-length)
|
||||
length-chars
|
||||
(if act act longest-match-action)))]
|
||||
[else
|
||||
(let* ([act (vector-ref actions next-state)]
|
||||
[next-length-bytes (+ (char-utf-8-length char) length-bytes)]
|
||||
[next-char (peek-char-or-special ip next-length-bytes)])
|
||||
#;(printf "(peek-char-or-special port ~e) = ~e\n"
|
||||
next-length-bytes next-char)
|
||||
(lexer-loop next-state
|
||||
next-char
|
||||
(if act
|
||||
act
|
||||
longest-match-action)
|
||||
next-length-bytes
|
||||
(add1 length-chars)
|
||||
(if act
|
||||
length-chars
|
||||
longest-match-length)))])))])))])
|
||||
(λ (ip)
|
||||
(unless (input-port? ip)
|
||||
(raise-argument-error 'lexer "input-port?" 0 ip))
|
||||
(lexer ip))))
|
||||
|
||||
(define (check-match lb first-pos longest-match-length length longest-match-action)
|
||||
(unless longest-match-action
|
||||
(let* ([match (read-string length lb)]
|
||||
[end-pos (get-position lb)])
|
||||
(raise-read-error
|
||||
(format "lexer: No match found in input starting with: ~a" match)
|
||||
(file-path)
|
||||
(position-line first-pos)
|
||||
(position-col first-pos)
|
||||
(position-offset first-pos)
|
||||
(- (position-offset end-pos) (position-offset first-pos)))))
|
||||
(let ([match (read-string longest-match-length lb)])
|
||||
;(printf "(read-string ~e port) = ~e\n" longest-match-length match)
|
||||
(do-match lb first-pos longest-match-action match)))
|
||||
|
||||
(define file-path (make-parameter #f))
|
||||
(define lexer-file-path file-path)
|
||||
|
||||
(define (do-match ip first-pos action value)
|
||||
#;(printf "(action ~a ~a ~a ~a)\n"
|
||||
(position-offset first-pos) (position-offset (get-position ip)) value ip)
|
||||
(action first-pos (get-position ip) value ip))
|
||||
|
||||
(define (get-position ip)
|
||||
(define-values (line col off) (port-next-location ip))
|
||||
(make-position off line col))
|
||||
|
||||
(define-syntax (create-unicode-abbrevs stx)
|
||||
(syntax-case stx ()
|
||||
[(_ CTXT)
|
||||
(with-syntax ([(RANGES ...) (for/list ([range (in-list (list (force alphabetic-ranges)
|
||||
(force lower-case-ranges)
|
||||
(force upper-case-ranges)
|
||||
(force title-case-ranges)
|
||||
(force numeric-ranges)
|
||||
(force symbolic-ranges)
|
||||
(force punctuation-ranges)
|
||||
(force graphic-ranges)
|
||||
(force whitespace-ranges)
|
||||
(force blank-ranges)
|
||||
(force iso-control-ranges)))])
|
||||
`(union ,@(map (λ (x)
|
||||
`(char-range ,(integer->char (car x))
|
||||
,(integer->char (cdr x))))
|
||||
range)))]
|
||||
[(NAMES ...) (for/list ([sym (in-list '(alphabetic
|
||||
lower-case
|
||||
upper-case
|
||||
title-case
|
||||
numeric
|
||||
symbolic
|
||||
punctuation
|
||||
graphic
|
||||
whitespace
|
||||
blank
|
||||
iso-control))])
|
||||
(datum->syntax #'CTXT sym #f))])
|
||||
#'(define-lex-abbrevs (NAMES RANGES) ...))]))
|
||||
|
||||
(define-lex-abbrev any-char (char-complement (union)))
|
||||
(define-lex-abbrev any-string (intersection))
|
||||
(define-lex-abbrev nothing (union))
|
||||
(create-unicode-abbrevs #'here)
|
||||
|
||||
(define-lex-trans (char-set stx)
|
||||
(syntax-case stx ()
|
||||
[(_ STR)
|
||||
(string? (syntax-e #'STR))
|
||||
(with-syntax ([(CHAR ...) (string->list (syntax-e #'STR))])
|
||||
#'(union CHAR ...))]))
|
||||
|
||||
(define-syntax provide-lex-keyword
|
||||
(syntax-rules ()
|
||||
[(_ ID ...)
|
||||
(begin
|
||||
(define-syntax-parameter ID
|
||||
(make-set!-transformer
|
||||
(λ (stx)
|
||||
(raise-syntax-error
|
||||
'provide-lex-keyword
|
||||
(format "use of a lexer keyword (~a) is not in an appropriate lexer action" 'ID)
|
||||
stx))))
|
||||
...
|
||||
(provide ID ...))]))
|
||||
|
||||
(provide-lex-keyword start-pos end-pos lexeme lexeme-srcloc input-port return-without-pos return-without-srcloc)
|
||||
@ -1,7 +1,7 @@
|
||||
(module yacc-to-scheme mzscheme
|
||||
(require parser-tools/lex
|
||||
(prefix : parser-tools/lex-sre)
|
||||
parser-tools/yacc
|
||||
(require br-parser-tools/lex
|
||||
(prefix : br-parser-tools/lex-sre)
|
||||
br-parser-tools/yacc
|
||||
syntax/readerr
|
||||
mzlib/list)
|
||||
(provide trans)
|
||||
@ -0,0 +1,412 @@
|
||||
#lang scheme/base
|
||||
|
||||
(require (for-syntax scheme/base
|
||||
"private-yacc/parser-builder.rkt"
|
||||
"private-yacc/grammar.rkt"
|
||||
"private-yacc/yacc-helper.rkt"
|
||||
"private-yacc/parser-actions.rkt"))
|
||||
(require "private-lex/token.rkt"
|
||||
"private-yacc/parser-actions.rkt"
|
||||
mzlib/etc
|
||||
mzlib/pretty
|
||||
syntax/readerr)
|
||||
|
||||
(provide parser)
|
||||
|
||||
|
||||
;; convert-parse-table : (vectorof (listof (cons/c gram-sym? action?))) ->
|
||||
;; (vectorof (symbol runtime-action hashtable))
|
||||
(define-for-syntax (convert-parse-table table)
|
||||
(list->vector
|
||||
(map
|
||||
(lambda (state-entry)
|
||||
(let ((ht (make-hasheq)))
|
||||
(for-each
|
||||
(lambda (gs/action)
|
||||
(hash-set! ht
|
||||
(gram-sym-symbol (car gs/action))
|
||||
(action->runtime-action (cdr gs/action))))
|
||||
state-entry)
|
||||
ht))
|
||||
(vector->list table))))
|
||||
|
||||
(define-syntax (parser stx)
|
||||
(syntax-case stx ()
|
||||
((_ args ...)
|
||||
(let ((arg-list (syntax->list (syntax (args ...))))
|
||||
(src-pos #f)
|
||||
(debug #f)
|
||||
(error #f)
|
||||
(tokens #f)
|
||||
(start #f)
|
||||
(end #f)
|
||||
(precs #f)
|
||||
(suppress #f)
|
||||
(grammar #f)
|
||||
(yacc-output #f))
|
||||
(for-each
|
||||
(lambda (arg)
|
||||
(syntax-case* arg (debug error tokens start end precs grammar
|
||||
suppress src-pos yacc-output)
|
||||
(lambda (a b)
|
||||
(eq? (syntax-e a) (syntax-e b)))
|
||||
((debug filename)
|
||||
(cond
|
||||
((not (string? (syntax-e (syntax filename))))
|
||||
(raise-syntax-error
|
||||
#f
|
||||
"Debugging filename must be a string"
|
||||
stx
|
||||
(syntax filename)))
|
||||
(debug
|
||||
(raise-syntax-error #f "Multiple debug declarations" stx))
|
||||
(else
|
||||
(set! debug (syntax-e (syntax filename))))))
|
||||
((suppress)
|
||||
(set! suppress #t))
|
||||
((src-pos)
|
||||
(set! src-pos #t))
|
||||
((error expression)
|
||||
(if error
|
||||
(raise-syntax-error #f "Multiple error declarations" stx)
|
||||
(set! error (syntax expression))))
|
||||
((tokens def ...)
|
||||
(begin
|
||||
(when tokens
|
||||
(raise-syntax-error #f "Multiple tokens declarations" stx))
|
||||
(let ((defs (syntax->list (syntax (def ...)))))
|
||||
(for-each
|
||||
(lambda (d)
|
||||
(unless (identifier? d)
|
||||
(raise-syntax-error
|
||||
#f
|
||||
"Token-group name must be an identifier"
|
||||
stx
|
||||
d)))
|
||||
defs)
|
||||
(set! tokens defs))))
|
||||
((start symbol ...)
|
||||
(let ((symbols (syntax->list (syntax (symbol ...)))))
|
||||
(for-each
|
||||
(lambda (sym)
|
||||
(unless (identifier? sym)
|
||||
(raise-syntax-error #f
|
||||
"Start symbol must be a symbol"
|
||||
stx
|
||||
sym)))
|
||||
symbols)
|
||||
(when start
|
||||
(raise-syntax-error #f "Multiple start declarations" stx))
|
||||
(when (null? symbols)
|
||||
(raise-syntax-error #f
|
||||
"Missing start symbol"
|
||||
stx
|
||||
arg))
|
||||
(set! start symbols)))
|
||||
((end symbols ...)
|
||||
(let ((symbols (syntax->list (syntax (symbols ...)))))
|
||||
(for-each
|
||||
(lambda (sym)
|
||||
(unless (identifier? sym)
|
||||
(raise-syntax-error #f
|
||||
"End token must be a symbol"
|
||||
stx
|
||||
sym)))
|
||||
symbols)
|
||||
(let ((d (duplicate-list? (map syntax-e symbols))))
|
||||
(when d
|
||||
(raise-syntax-error
|
||||
#f
|
||||
(format "Duplicate end token definition for ~a" d)
|
||||
stx
|
||||
arg))
|
||||
(when (null? symbols)
|
||||
(raise-syntax-error
|
||||
#f
|
||||
"end declaration must contain at least 1 token"
|
||||
stx
|
||||
arg))
|
||||
(when end
|
||||
(raise-syntax-error #f "Multiple end declarations" stx))
|
||||
(set! end symbols))))
|
||||
((precs decls ...)
|
||||
(if precs
|
||||
(raise-syntax-error #f "Multiple precs declarations" stx)
|
||||
(set! precs (syntax/loc arg (decls ...)))))
|
||||
((grammar prods ...)
|
||||
(if grammar
|
||||
(raise-syntax-error #f "Multiple grammar declarations" stx)
|
||||
(set! grammar (syntax/loc arg (prods ...)))))
|
||||
((yacc-output filename)
|
||||
(cond
|
||||
((not (string? (syntax-e (syntax filename))))
|
||||
(raise-syntax-error #f
|
||||
"Yacc-output filename must be a string"
|
||||
stx
|
||||
(syntax filename)))
|
||||
(yacc-output
|
||||
(raise-syntax-error #f "Multiple yacc-output declarations" stx))
|
||||
(else
|
||||
(set! yacc-output (syntax-e (syntax filename))))))
|
||||
(_ (raise-syntax-error #f "argument must match (debug filename), (error expression), (tokens def ...), (start non-term), (end tokens ...), (precs decls ...), or (grammar prods ...)" stx arg))))
|
||||
(syntax->list (syntax (args ...))))
|
||||
(unless tokens
|
||||
(raise-syntax-error #f "missing tokens declaration" stx))
|
||||
(unless error
|
||||
(raise-syntax-error #f "missing error declaration" stx))
|
||||
(unless grammar
|
||||
(raise-syntax-error #f "missing grammar declaration" stx))
|
||||
(unless end
|
||||
(raise-syntax-error #f "missing end declaration" stx))
|
||||
(unless start
|
||||
(raise-syntax-error #f "missing start declaration" stx))
|
||||
(let-values (((table all-term-syms actions check-syntax-fix)
|
||||
(build-parser (if debug debug "")
|
||||
src-pos
|
||||
suppress
|
||||
tokens
|
||||
start
|
||||
end
|
||||
precs
|
||||
grammar)))
|
||||
(when (and yacc-output (not (string=? yacc-output "")))
|
||||
(with-handlers [(exn:fail:filesystem?
|
||||
(lambda (e)
|
||||
(eprintf
|
||||
"Cannot write yacc-output to file \"~a\"\n"
|
||||
yacc-output)))]
|
||||
(call-with-output-file yacc-output
|
||||
(lambda (port)
|
||||
(display-yacc (syntax->datum grammar)
|
||||
tokens
|
||||
(map syntax->datum start)
|
||||
(if precs
|
||||
(syntax->datum precs)
|
||||
#f)
|
||||
port))
|
||||
#:exists 'truncate)))
|
||||
(with-syntax ((check-syntax-fix check-syntax-fix)
|
||||
(err error)
|
||||
(ends end)
|
||||
(starts start)
|
||||
(debug debug)
|
||||
(table (convert-parse-table table))
|
||||
(all-term-syms all-term-syms)
|
||||
(actions actions)
|
||||
(src-pos src-pos))
|
||||
(syntax
|
||||
(begin
|
||||
check-syntax-fix
|
||||
(parser-body debug err (quote starts) (quote ends) table all-term-syms actions src-pos)))))))
|
||||
(_
|
||||
(raise-syntax-error #f
|
||||
"parser must have the form (parser args ...)"
|
||||
stx))))
|
||||
|
||||
(define (reduce-stack stack num ret-vals src-pos)
|
||||
(cond
|
||||
((> num 0)
|
||||
(let* ((top-frame (car stack))
|
||||
(ret-vals
|
||||
(if src-pos
|
||||
(cons (stack-frame-value top-frame)
|
||||
(cons (stack-frame-start-pos top-frame)
|
||||
(cons (stack-frame-end-pos top-frame)
|
||||
ret-vals)))
|
||||
(cons (stack-frame-value top-frame) ret-vals))))
|
||||
(reduce-stack (cdr stack) (sub1 num) ret-vals src-pos)))
|
||||
(else (values stack ret-vals))))
|
||||
|
||||
;; extract-helper : (symbol or make-token) any any -> symbol any any any
|
||||
(define (extract-helper tok v1 v2)
|
||||
(cond
|
||||
((symbol? tok)
|
||||
(values tok #f v1 v2))
|
||||
((token? tok)
|
||||
(values (real-token-name tok) (real-token-value tok) v1 v2))
|
||||
(else (raise-argument-error 'parser
|
||||
"(or/c symbol? token?)"
|
||||
0
|
||||
tok))))
|
||||
|
||||
;; well-formed-position-token?: any -> boolean
|
||||
;; Returns true if pt is a position token whose position-token-token
|
||||
;; is itself a token or a symbol.
|
||||
;; This is meant to help raise more precise error messages when
|
||||
;; a tokenizer produces an erroneous position-token wrapped twice.
|
||||
;; (as often happens when omitting return-without-pos).
|
||||
(define (well-formed-token-field? t)
|
||||
(or (symbol? t)
|
||||
(token? t)))
|
||||
|
||||
(define (well-formed-position-token? pt)
|
||||
(and (position-token? pt)
|
||||
(well-formed-token-field? (position-token-token pt))))
|
||||
|
||||
(define (well-formed-srcloc-token? st)
|
||||
(and (srcloc-token? st)
|
||||
(well-formed-token-field? (srcloc-token-token st))))
|
||||
|
||||
;; extract-src-pos : position-token -> symbol any any any
|
||||
(define (extract-src-pos ip)
|
||||
(unless (well-formed-position-token? ip)
|
||||
(raise-argument-error 'parser
|
||||
"well-formed-position-token?"
|
||||
0
|
||||
ip))
|
||||
(extract-helper (position-token-token ip)
|
||||
(position-token-start-pos ip)
|
||||
(position-token-end-pos ip)))
|
||||
|
||||
(define (extract-srcloc ip)
|
||||
(unless (well-formed-srcloc-token? ip)
|
||||
(raise-argument-error 'parser
|
||||
"well-formed-srcloc-token?"
|
||||
0
|
||||
ip))
|
||||
(let ([loc (srcloc-token-srcloc ip)])
|
||||
(extract-helper (srcloc-token-token ip)
|
||||
(position-token (srcloc-position loc) (srcloc-line loc) (srcloc-column loc))
|
||||
(position-token (+ (srcloc-position loc) (srcloc-span loc)) #f #f))))
|
||||
|
||||
|
||||
;; extract-no-src-pos : (symbol or make-token) -> symbol any any any
|
||||
(define (extract-no-src-pos ip)
|
||||
(extract-helper ip #f #f))
|
||||
|
||||
(define-struct stack-frame (state value start-pos end-pos) #:inspector (make-inspector))
|
||||
|
||||
(define (make-empty-stack i) (list (make-stack-frame i #f #f #f)))
|
||||
|
||||
|
||||
;; The table is a vector that maps each state to a hash-table that maps a
|
||||
;; terminal symbol to either an accept, shift, reduce, or goto structure.
|
||||
; We encode the structures according to the runtime-action data definition in
|
||||
;; parser-actions.rkt
|
||||
(define (parser-body debug? err starts ends table all-term-syms actions src-pos)
|
||||
(local ((define extract
|
||||
(if src-pos
|
||||
extract-src-pos
|
||||
extract-no-src-pos))
|
||||
|
||||
(define (fix-error stack tok val start-pos end-pos get-token)
|
||||
(when debug? (pretty-print stack))
|
||||
(local ((define (remove-input tok val start-pos end-pos)
|
||||
(if (memq tok ends)
|
||||
(raise-read-error "parser: Cannot continue after error"
|
||||
#f #f #f #f #f)
|
||||
(let ((a (find-action stack tok val start-pos end-pos)))
|
||||
(cond
|
||||
((runtime-shift? a)
|
||||
;; (printf "shift:~a\n" (runtime-shift-state a))
|
||||
(cons (make-stack-frame (runtime-shift-state a)
|
||||
val
|
||||
start-pos
|
||||
end-pos)
|
||||
stack))
|
||||
(else
|
||||
;; (printf "discard input:~a\n" tok)
|
||||
(let-values (((tok val start-pos end-pos)
|
||||
(extract (get-token))))
|
||||
(remove-input tok val start-pos end-pos))))))))
|
||||
(let remove-states ()
|
||||
(let ((a (find-action stack 'error #f start-pos end-pos)))
|
||||
(cond
|
||||
((runtime-shift? a)
|
||||
;; (printf "shift:~a\n" (runtime-shift-state a))
|
||||
(set! stack
|
||||
(cons
|
||||
(make-stack-frame (runtime-shift-state a)
|
||||
#f
|
||||
start-pos
|
||||
end-pos)
|
||||
stack))
|
||||
(remove-input tok val start-pos end-pos))
|
||||
(else
|
||||
;; (printf "discard state:~a\n" (car stack))
|
||||
(cond
|
||||
((< (length stack) 2)
|
||||
(raise-read-error "parser: Cannot continue after error"
|
||||
#f #f #f #f #f))
|
||||
(else
|
||||
(set! stack (cdr stack))
|
||||
(remove-states)))))))))
|
||||
|
||||
(define (find-action stack tok val start-pos end-pos)
|
||||
(unless (hash-ref all-term-syms
|
||||
tok
|
||||
#f)
|
||||
(if src-pos
|
||||
(err #f tok val start-pos end-pos)
|
||||
(err #f tok val))
|
||||
(raise-read-error (format "parser: got token of unknown type ~a" tok)
|
||||
#f #f #f #f #f))
|
||||
(hash-ref (vector-ref table (stack-frame-state (car stack)))
|
||||
tok
|
||||
#f))
|
||||
|
||||
(define (make-parser start-number)
|
||||
(lambda (get-token)
|
||||
(unless (and (procedure? get-token)
|
||||
(procedure-arity-includes? get-token 0))
|
||||
(error 'get-token "expected a nullary procedure, got ~e" get-token))
|
||||
(let parsing-loop ((stack (make-empty-stack start-number))
|
||||
(ip (get-token)))
|
||||
(let-values (((tok val start-pos end-pos)
|
||||
(extract ip)))
|
||||
(let ((action (find-action stack tok val start-pos end-pos)))
|
||||
(cond
|
||||
((runtime-shift? action)
|
||||
;; (printf "shift:~a\n" (runtime-shift-state action))
|
||||
(parsing-loop (cons (make-stack-frame (runtime-shift-state action)
|
||||
val
|
||||
start-pos
|
||||
end-pos)
|
||||
stack)
|
||||
(get-token)))
|
||||
((runtime-reduce? action)
|
||||
;; (printf "reduce:~a\n" (runtime-reduce-prod-num action))
|
||||
(let-values (((new-stack args)
|
||||
(reduce-stack stack
|
||||
(runtime-reduce-rhs-length action)
|
||||
null
|
||||
src-pos)))
|
||||
(let ((goto
|
||||
(runtime-goto-state
|
||||
(hash-ref
|
||||
(vector-ref table (stack-frame-state (car new-stack)))
|
||||
(runtime-reduce-lhs action)))))
|
||||
(parsing-loop
|
||||
(cons
|
||||
(if src-pos
|
||||
(make-stack-frame
|
||||
goto
|
||||
(apply (vector-ref actions (runtime-reduce-prod-num action)) args)
|
||||
(if (null? args) start-pos (cadr args))
|
||||
(if (null? args)
|
||||
end-pos
|
||||
(list-ref args (- (* (runtime-reduce-rhs-length action) 3) 1))))
|
||||
(make-stack-frame
|
||||
goto
|
||||
(apply (vector-ref actions (runtime-reduce-prod-num action)) args)
|
||||
#f
|
||||
#f))
|
||||
new-stack)
|
||||
ip))))
|
||||
((runtime-accept? action)
|
||||
;; (printf "accept\n")
|
||||
(stack-frame-value (car stack)))
|
||||
(else
|
||||
(if src-pos
|
||||
(err #t tok val start-pos end-pos)
|
||||
(err #t tok val))
|
||||
(parsing-loop (fix-error stack tok val start-pos end-pos get-token)
|
||||
(get-token))))))))))
|
||||
(cond
|
||||
((null? (cdr starts)) (make-parser 0))
|
||||
(else
|
||||
(let loop ((l starts)
|
||||
(i 0))
|
||||
(cond
|
||||
((null? l) null)
|
||||
(else (cons (make-parser i) (loop (cdr l) (add1 i))))))))))
|
||||
@ -0,0 +1,12 @@
|
||||
#lang info
|
||||
|
||||
(define collection 'multi)
|
||||
|
||||
(define deps '("br-parser-tools-lib"
|
||||
"br-parser-tools-doc"))
|
||||
(define implies '("br-parser-tools-lib"
|
||||
"br-parser-tools-doc"))
|
||||
|
||||
(define pkg-desc "Lex- and Yacc-style parsing tools")
|
||||
|
||||
(define pkg-authors '(mflatt))
|
||||
@ -1,3 +0,0 @@
|
||||
#lang info
|
||||
|
||||
(define scribblings '(("parser-tools.scrbl" (multi-page) (parsing-library))))
|
||||
@ -1,393 +0,0 @@
|
||||
(module lex mzscheme
|
||||
|
||||
;; Provides the syntax used to create lexers and the functions needed to
|
||||
;; create and use the buffer that the lexer reads from. See docs.
|
||||
|
||||
(require-for-syntax mzlib/list
|
||||
syntax/stx
|
||||
syntax/define
|
||||
syntax/boundmap
|
||||
"private-lex/util.rkt"
|
||||
"private-lex/actions.rkt"
|
||||
"private-lex/front.rkt"
|
||||
"private-lex/unicode-chars.rkt")
|
||||
|
||||
(require mzlib/stxparam
|
||||
syntax/readerr
|
||||
"private-lex/token.rkt")
|
||||
|
||||
(provide lexer lexer-src-pos define-lex-abbrev define-lex-abbrevs define-lex-trans
|
||||
|
||||
;; Dealing with tokens and related structures
|
||||
define-tokens define-empty-tokens token-name token-value token?
|
||||
(struct position (offset line col))
|
||||
(struct position-token (token start-pos end-pos))
|
||||
|
||||
;; File path for highlighting errors while lexing
|
||||
file-path
|
||||
|
||||
;; Lex abbrevs for unicode char sets. See mzscheme manual section 3.4.
|
||||
any-char any-string nothing alphabetic lower-case upper-case title-case
|
||||
numeric symbolic punctuation graphic whitespace blank iso-control
|
||||
|
||||
;; A regular expression operator
|
||||
char-set)
|
||||
|
||||
;; wrap-action: syntax-object src-pos? -> syntax-object
|
||||
(define-for-syntax (wrap-action action src-pos?)
|
||||
(with-syntax ((action-stx
|
||||
(if src-pos?
|
||||
#`(let/ec ret
|
||||
(syntax-parameterize
|
||||
((return-without-pos (make-rename-transformer #'ret)))
|
||||
(make-position-token #,action start-pos end-pos)))
|
||||
action)))
|
||||
(syntax/loc action
|
||||
(lambda (start-pos-p end-pos-p lexeme-p input-port-p)
|
||||
(syntax-parameterize
|
||||
((start-pos (make-rename-transformer #'start-pos-p))
|
||||
(end-pos (make-rename-transformer #'end-pos-p))
|
||||
(lexeme (make-rename-transformer #'lexeme-p))
|
||||
(input-port (make-rename-transformer #'input-port-p)))
|
||||
action-stx)))))
|
||||
|
||||
(define-for-syntax (make-lexer-trans src-pos?)
|
||||
(lambda (stx)
|
||||
(syntax-case stx ()
|
||||
((_ re-act ...)
|
||||
(begin
|
||||
(for-each
|
||||
(lambda (x)
|
||||
(syntax-case x ()
|
||||
((re act) (void))
|
||||
(_ (raise-syntax-error #f
|
||||
"not a regular expression / action pair"
|
||||
stx
|
||||
x))))
|
||||
(syntax->list (syntax (re-act ...))))
|
||||
(let* ((spec/re-act-lst
|
||||
(syntax->list (syntax (re-act ...))))
|
||||
(eof-act
|
||||
(get-special-action spec/re-act-lst #'eof #''eof))
|
||||
(spec-act
|
||||
(get-special-action spec/re-act-lst #'special #'(void)))
|
||||
(spec-comment-act
|
||||
(get-special-action spec/re-act-lst #'special-comment #'#f))
|
||||
(ids (list #'special #'special-comment #'eof))
|
||||
(re-act-lst
|
||||
(filter
|
||||
(lambda (spec/re-act)
|
||||
(syntax-case spec/re-act ()
|
||||
(((special) act)
|
||||
(not (ormap
|
||||
(lambda (x)
|
||||
(and (identifier? #'special)
|
||||
(module-or-top-identifier=? (syntax special) x)))
|
||||
ids)))
|
||||
(_ #t)))
|
||||
spec/re-act-lst))
|
||||
(name-lst (map (lambda (x) (datum->syntax-object #f (gensym))) re-act-lst))
|
||||
(act-lst (map (lambda (x) (stx-car (stx-cdr x))) re-act-lst))
|
||||
(re-actname-lst (map (lambda (re-act name)
|
||||
(list (stx-car re-act)
|
||||
name))
|
||||
re-act-lst
|
||||
name-lst)))
|
||||
(when (null? spec/re-act-lst)
|
||||
(raise-syntax-error (if src-pos? 'lexer/src-pos 'lexer) "expected at least one action" stx))
|
||||
(let-values (((trans start action-names no-look disappeared-uses)
|
||||
(build-lexer re-actname-lst)))
|
||||
(when (vector-ref action-names start) ;; Start state is final
|
||||
(unless (and
|
||||
;; All the successor states are final
|
||||
(andmap (lambda (x) (vector-ref action-names (vector-ref x 2)))
|
||||
(vector->list (vector-ref trans start)))
|
||||
;; Each character has a successor state
|
||||
(let loop ((check 0)
|
||||
(nexts (vector->list (vector-ref trans start))))
|
||||
(cond
|
||||
((null? nexts) #f)
|
||||
(else
|
||||
(let ((next (car nexts)))
|
||||
(and (= (vector-ref next 0) check)
|
||||
(let ((next-check (vector-ref next 1)))
|
||||
(or (>= next-check max-char-num)
|
||||
(loop (add1 next-check) (cdr nexts))))))))))
|
||||
(eprintf "Warning: lexer at ~a can accept the empty string.\n" stx)))
|
||||
(with-syntax ((start-state-stx start)
|
||||
(trans-table-stx trans)
|
||||
(no-lookahead-stx no-look)
|
||||
((name ...) name-lst)
|
||||
((act ...) (map (lambda (a)
|
||||
(wrap-action a src-pos?))
|
||||
act-lst))
|
||||
((act-name ...) (vector->list action-names))
|
||||
(spec-act-stx
|
||||
(wrap-action spec-act src-pos?))
|
||||
(has-comment-act?-stx
|
||||
(if (syntax-e spec-comment-act) #t #f))
|
||||
(spec-comment-act-stx
|
||||
(wrap-action spec-comment-act src-pos?))
|
||||
(eof-act-stx (wrap-action eof-act src-pos?)))
|
||||
(syntax-property
|
||||
(syntax/loc stx
|
||||
(let ([name act] ...)
|
||||
(let ([proc
|
||||
(lexer-body start-state-stx
|
||||
trans-table-stx
|
||||
(vector act-name ...)
|
||||
no-lookahead-stx
|
||||
spec-act-stx
|
||||
has-comment-act?-stx
|
||||
spec-comment-act-stx
|
||||
eof-act-stx)])
|
||||
;; reverse eta to get named procedures:
|
||||
(lambda (port) (proc port)))))
|
||||
'disappeared-use
|
||||
disappeared-uses)))))))))
|
||||
|
||||
(define-syntax lexer (make-lexer-trans #f))
|
||||
(define-syntax lexer-src-pos (make-lexer-trans #t))
|
||||
|
||||
(define-syntax (define-lex-abbrev stx)
|
||||
(syntax-case stx ()
|
||||
((_ name re)
|
||||
(identifier? (syntax name))
|
||||
(syntax/loc stx
|
||||
(define-syntax name
|
||||
(make-lex-abbrev (lambda () (quote-syntax re))))))
|
||||
(_
|
||||
(raise-syntax-error
|
||||
#f
|
||||
"form should be (define-lex-abbrev name re)"
|
||||
stx))))
|
||||
|
||||
(define-syntax (define-lex-abbrevs stx)
|
||||
(syntax-case stx ()
|
||||
((_ x ...)
|
||||
(with-syntax (((abbrev ...)
|
||||
(map
|
||||
(lambda (a)
|
||||
(syntax-case a ()
|
||||
((name re)
|
||||
(identifier? (syntax name))
|
||||
(syntax/loc a (define-lex-abbrev name re)))
|
||||
(_ (raise-syntax-error
|
||||
#f
|
||||
"form should be (define-lex-abbrevs (name re) ...)"
|
||||
stx
|
||||
a))))
|
||||
(syntax->list (syntax (x ...))))))
|
||||
(syntax/loc stx (begin abbrev ...))))
|
||||
(_
|
||||
(raise-syntax-error
|
||||
#f
|
||||
"form should be (define-lex-abbrevs (name re) ...)"
|
||||
stx))))
|
||||
|
||||
(define-syntax (define-lex-trans stx)
|
||||
(syntax-case stx ()
|
||||
((_ name-form body-form)
|
||||
(let-values (((name body)
|
||||
(normalize-definition (syntax (define-syntax name-form body-form)) #'lambda)))
|
||||
|
||||
#`(define-syntax #,name
|
||||
(let ((func #,body))
|
||||
(unless (procedure? func)
|
||||
(raise-syntax-error 'define-lex-trans "expected a procedure as the transformer, got ~e" func))
|
||||
(unless (procedure-arity-includes? func 1)
|
||||
(raise-syntax-error 'define-lex-trans "expected a procedure that accepts 1 argument as the transformer, got ~e" func))
|
||||
(make-lex-trans func)))))
|
||||
(_
|
||||
(raise-syntax-error
|
||||
#f
|
||||
"form should be (define-lex-trans name transformer)"
|
||||
stx))))
|
||||
|
||||
|
||||
(define (get-next-state-helper char min max table)
|
||||
(if (>= min max)
|
||||
#f
|
||||
(let* ((try (quotient (+ min max) 2))
|
||||
(el (vector-ref table try))
|
||||
(r1 (vector-ref el 0))
|
||||
(r2 (vector-ref el 1)))
|
||||
(cond
|
||||
((and (>= char r1) (<= char r2)) (vector-ref el 2))
|
||||
((< char r1) (get-next-state-helper char min try table))
|
||||
(else (get-next-state-helper char (add1 try) max table))))))
|
||||
|
||||
|
||||
|
||||
|
||||
(define (get-next-state char table)
|
||||
(if table
|
||||
(get-next-state-helper char 0 (vector-length table) table)
|
||||
#f))
|
||||
|
||||
(define (lexer-body start-state trans-table actions no-lookahead special-action
|
||||
has-special-comment-action? special-comment-action eof-action)
|
||||
(letrec ((lexer
|
||||
(lambda (ip)
|
||||
(let ((first-pos (get-position ip))
|
||||
(first-char (peek-char-or-special ip 0)))
|
||||
;(printf "(peek-char-or-special port 0) = ~e\n" first-char)
|
||||
(cond
|
||||
((eof-object? first-char)
|
||||
(do-match ip first-pos eof-action (read-char-or-special ip)))
|
||||
((special-comment? first-char)
|
||||
(read-char-or-special ip)
|
||||
(cond
|
||||
(has-special-comment-action?
|
||||
(do-match ip first-pos special-comment-action #f))
|
||||
(else (lexer ip))))
|
||||
((not (char? first-char))
|
||||
(do-match ip first-pos special-action (read-char-or-special ip)))
|
||||
(else
|
||||
(let lexer-loop (
|
||||
;; current-state
|
||||
(state start-state)
|
||||
;; the character to transition on
|
||||
(char first-char)
|
||||
;; action for the longest match seen thus far
|
||||
;; including a match at the current state
|
||||
(longest-match-action
|
||||
(vector-ref actions start-state))
|
||||
;; how many bytes precede char
|
||||
(length-bytes 0)
|
||||
;; how many characters have been read
|
||||
;; including the one just read
|
||||
(length-chars 1)
|
||||
;; how many characters are in the longest match
|
||||
(longest-match-length 0))
|
||||
(let ((next-state
|
||||
(cond
|
||||
((not (char? char)) #f)
|
||||
(else (get-next-state (char->integer char)
|
||||
(vector-ref trans-table state))))))
|
||||
(cond
|
||||
((not next-state)
|
||||
(check-match ip first-pos longest-match-length
|
||||
length-chars longest-match-action))
|
||||
((vector-ref no-lookahead next-state)
|
||||
(let ((act (vector-ref actions next-state)))
|
||||
(check-match ip
|
||||
first-pos
|
||||
(if act length-chars longest-match-length)
|
||||
length-chars
|
||||
(if act act longest-match-action))))
|
||||
(else
|
||||
(let* ((act (vector-ref actions next-state))
|
||||
(next-length-bytes (+ (char-utf-8-length char) length-bytes))
|
||||
(next-char (peek-char-or-special ip next-length-bytes)))
|
||||
#;(printf "(peek-char-or-special port ~e) = ~e\n"
|
||||
next-length-bytes next-char)
|
||||
(lexer-loop next-state
|
||||
next-char
|
||||
(if act
|
||||
act
|
||||
longest-match-action)
|
||||
next-length-bytes
|
||||
(add1 length-chars)
|
||||
(if act
|
||||
length-chars
|
||||
longest-match-length)))))))))))))
|
||||
(lambda (ip)
|
||||
(unless (input-port? ip)
|
||||
(raise-argument-error
|
||||
'lexer
|
||||
"input-port?"
|
||||
0
|
||||
ip))
|
||||
(lexer ip))))
|
||||
|
||||
(define (check-match lb first-pos longest-match-length length longest-match-action)
|
||||
(unless longest-match-action
|
||||
(let* ((match (read-string length lb))
|
||||
(end-pos (get-position lb)))
|
||||
(raise-read-error
|
||||
(format "lexer: No match found in input starting with: ~a" match)
|
||||
(file-path)
|
||||
(position-line first-pos)
|
||||
(position-col first-pos)
|
||||
(position-offset first-pos)
|
||||
(- (position-offset end-pos) (position-offset first-pos)))))
|
||||
(let ((match (read-string longest-match-length lb)))
|
||||
;(printf "(read-string ~e port) = ~e\n" longest-match-length match)
|
||||
(do-match lb first-pos longest-match-action match)))
|
||||
|
||||
(define file-path (make-parameter #f))
|
||||
|
||||
(define (do-match ip first-pos action value)
|
||||
#;(printf "(action ~a ~a ~a ~a)\n"
|
||||
(position-offset first-pos) (position-offset (get-position ip)) value ip)
|
||||
(action first-pos (get-position ip) value ip))
|
||||
|
||||
(define (get-position ip)
|
||||
(let-values (((line col off) (port-next-location ip)))
|
||||
(make-position off line col)))
|
||||
|
||||
(define-syntax (create-unicode-abbrevs stx)
|
||||
(syntax-case stx ()
|
||||
((_ ctxt)
|
||||
(with-syntax (((ranges ...) (map (lambda (range)
|
||||
`(union ,@(map (lambda (x)
|
||||
`(char-range ,(integer->char (car x))
|
||||
,(integer->char (cdr x))))
|
||||
range)))
|
||||
(list (force alphabetic-ranges)
|
||||
(force lower-case-ranges)
|
||||
(force upper-case-ranges)
|
||||
(force title-case-ranges)
|
||||
(force numeric-ranges)
|
||||
(force symbolic-ranges)
|
||||
(force punctuation-ranges)
|
||||
(force graphic-ranges)
|
||||
(force whitespace-ranges)
|
||||
(force blank-ranges)
|
||||
(force iso-control-ranges))))
|
||||
((names ...) (map (lambda (sym)
|
||||
(datum->syntax-object (syntax ctxt) sym #f))
|
||||
'(alphabetic
|
||||
lower-case
|
||||
upper-case
|
||||
title-case
|
||||
numeric
|
||||
symbolic
|
||||
punctuation
|
||||
graphic
|
||||
whitespace
|
||||
blank
|
||||
iso-control))))
|
||||
(syntax (define-lex-abbrevs (names ranges) ...))))))
|
||||
|
||||
(define-lex-abbrev any-char (char-complement (union)))
|
||||
(define-lex-abbrev any-string (intersection))
|
||||
(define-lex-abbrev nothing (union))
|
||||
(create-unicode-abbrevs #'here)
|
||||
|
||||
(define-lex-trans (char-set stx)
|
||||
(syntax-case stx ()
|
||||
((_ str)
|
||||
(string? (syntax-e (syntax str)))
|
||||
(with-syntax (((char ...) (string->list (syntax-e (syntax str)))))
|
||||
(syntax (union char ...))))))
|
||||
|
||||
(define-syntax provide-lex-keyword
|
||||
(syntax-rules ()
|
||||
[(_ id ...)
|
||||
(begin
|
||||
(define-syntax-parameter id
|
||||
(make-set!-transformer
|
||||
(lambda (stx)
|
||||
(raise-syntax-error
|
||||
#f
|
||||
(format "use of a lexer keyword (~a) is not in an appropriate lexer action"
|
||||
'id)
|
||||
stx))))
|
||||
...
|
||||
(provide id ...))]))
|
||||
|
||||
(provide-lex-keyword start-pos end-pos lexeme input-port return-without-pos)
|
||||
|
||||
)
|
||||
@ -1,396 +0,0 @@
|
||||
#lang scheme/base
|
||||
|
||||
(require (for-syntax scheme/base
|
||||
"private-yacc/parser-builder.rkt"
|
||||
"private-yacc/grammar.rkt"
|
||||
"private-yacc/yacc-helper.rkt"
|
||||
"private-yacc/parser-actions.rkt"))
|
||||
(require "private-lex/token.rkt"
|
||||
"private-yacc/parser-actions.rkt"
|
||||
mzlib/etc
|
||||
mzlib/pretty
|
||||
syntax/readerr)
|
||||
|
||||
(provide parser)
|
||||
|
||||
|
||||
;; convert-parse-table : (vectorof (listof (cons/c gram-sym? action?))) ->
|
||||
;; (vectorof (symbol runtime-action hashtable))
|
||||
(define-for-syntax (convert-parse-table table)
|
||||
(list->vector
|
||||
(map
|
||||
(lambda (state-entry)
|
||||
(let ((ht (make-hasheq)))
|
||||
(for-each
|
||||
(lambda (gs/action)
|
||||
(hash-set! ht
|
||||
(gram-sym-symbol (car gs/action))
|
||||
(action->runtime-action (cdr gs/action))))
|
||||
state-entry)
|
||||
ht))
|
||||
(vector->list table))))
|
||||
|
||||
(define-syntax (parser stx)
|
||||
(syntax-case stx ()
|
||||
((_ args ...)
|
||||
(let ((arg-list (syntax->list (syntax (args ...))))
|
||||
(src-pos #f)
|
||||
(debug #f)
|
||||
(error #f)
|
||||
(tokens #f)
|
||||
(start #f)
|
||||
(end #f)
|
||||
(precs #f)
|
||||
(suppress #f)
|
||||
(grammar #f)
|
||||
(yacc-output #f))
|
||||
(for-each
|
||||
(lambda (arg)
|
||||
(syntax-case* arg (debug error tokens start end precs grammar
|
||||
suppress src-pos yacc-output)
|
||||
(lambda (a b)
|
||||
(eq? (syntax-e a) (syntax-e b)))
|
||||
((debug filename)
|
||||
(cond
|
||||
((not (string? (syntax-e (syntax filename))))
|
||||
(raise-syntax-error
|
||||
#f
|
||||
"Debugging filename must be a string"
|
||||
stx
|
||||
(syntax filename)))
|
||||
(debug
|
||||
(raise-syntax-error #f "Multiple debug declarations" stx))
|
||||
(else
|
||||
(set! debug (syntax-e (syntax filename))))))
|
||||
((suppress)
|
||||
(set! suppress #t))
|
||||
((src-pos)
|
||||
(set! src-pos #t))
|
||||
((error expression)
|
||||
(if error
|
||||
(raise-syntax-error #f "Multiple error declarations" stx)
|
||||
(set! error (syntax expression))))
|
||||
((tokens def ...)
|
||||
(begin
|
||||
(when tokens
|
||||
(raise-syntax-error #f "Multiple tokens declarations" stx))
|
||||
(let ((defs (syntax->list (syntax (def ...)))))
|
||||
(for-each
|
||||
(lambda (d)
|
||||
(unless (identifier? d)
|
||||
(raise-syntax-error
|
||||
#f
|
||||
"Token-group name must be an identifier"
|
||||
stx
|
||||
d)))
|
||||
defs)
|
||||
(set! tokens defs))))
|
||||
((start symbol ...)
|
||||
(let ((symbols (syntax->list (syntax (symbol ...)))))
|
||||
(for-each
|
||||
(lambda (sym)
|
||||
(unless (identifier? sym)
|
||||
(raise-syntax-error #f
|
||||
"Start symbol must be a symbol"
|
||||
stx
|
||||
sym)))
|
||||
symbols)
|
||||
(when start
|
||||
(raise-syntax-error #f "Multiple start declarations" stx))
|
||||
(when (null? symbols)
|
||||
(raise-syntax-error #f
|
||||
"Missing start symbol"
|
||||
stx
|
||||
arg))
|
||||
(set! start symbols)))
|
||||
((end symbols ...)
|
||||
(let ((symbols (syntax->list (syntax (symbols ...)))))
|
||||
(for-each
|
||||
(lambda (sym)
|
||||
(unless (identifier? sym)
|
||||
(raise-syntax-error #f
|
||||
"End token must be a symbol"
|
||||
stx
|
||||
sym)))
|
||||
symbols)
|
||||
(let ((d (duplicate-list? (map syntax-e symbols))))
|
||||
(when d
|
||||
(raise-syntax-error
|
||||
#f
|
||||
(format "Duplicate end token definition for ~a" d)
|
||||
stx
|
||||
arg))
|
||||
(when (null? symbols)
|
||||
(raise-syntax-error
|
||||
#f
|
||||
"end declaration must contain at least 1 token"
|
||||
stx
|
||||
arg))
|
||||
(when end
|
||||
(raise-syntax-error #f "Multiple end declarations" stx))
|
||||
(set! end symbols))))
|
||||
((precs decls ...)
|
||||
(if precs
|
||||
(raise-syntax-error #f "Multiple precs declarations" stx)
|
||||
(set! precs (syntax/loc arg (decls ...)))))
|
||||
((grammar prods ...)
|
||||
(if grammar
|
||||
(raise-syntax-error #f "Multiple grammar declarations" stx)
|
||||
(set! grammar (syntax/loc arg (prods ...)))))
|
||||
((yacc-output filename)
|
||||
(cond
|
||||
((not (string? (syntax-e (syntax filename))))
|
||||
(raise-syntax-error #f
|
||||
"Yacc-output filename must be a string"
|
||||
stx
|
||||
(syntax filename)))
|
||||
(yacc-output
|
||||
(raise-syntax-error #f "Multiple yacc-output declarations" stx))
|
||||
(else
|
||||
(set! yacc-output (syntax-e (syntax filename))))))
|
||||
(_ (raise-syntax-error #f "argument must match (debug filename), (error expression), (tokens def ...), (start non-term), (end tokens ...), (precs decls ...), or (grammar prods ...)" stx arg))))
|
||||
(syntax->list (syntax (args ...))))
|
||||
(unless tokens
|
||||
(raise-syntax-error #f "missing tokens declaration" stx))
|
||||
(unless error
|
||||
(raise-syntax-error #f "missing error declaration" stx))
|
||||
(unless grammar
|
||||
(raise-syntax-error #f "missing grammar declaration" stx))
|
||||
(unless end
|
||||
(raise-syntax-error #f "missing end declaration" stx))
|
||||
(unless start
|
||||
(raise-syntax-error #f "missing start declaration" stx))
|
||||
(let-values (((table all-term-syms actions check-syntax-fix)
|
||||
(build-parser (if debug debug "")
|
||||
src-pos
|
||||
suppress
|
||||
tokens
|
||||
start
|
||||
end
|
||||
precs
|
||||
grammar)))
|
||||
(when (and yacc-output (not (string=? yacc-output "")))
|
||||
(with-handlers [(exn:fail:filesystem?
|
||||
(lambda (e)
|
||||
(eprintf
|
||||
"Cannot write yacc-output to file \"~a\"\n"
|
||||
yacc-output)))]
|
||||
(call-with-output-file yacc-output
|
||||
(lambda (port)
|
||||
(display-yacc (syntax->datum grammar)
|
||||
tokens
|
||||
(map syntax->datum start)
|
||||
(if precs
|
||||
(syntax->datum precs)
|
||||
#f)
|
||||
port))
|
||||
#:exists 'truncate)))
|
||||
(with-syntax ((check-syntax-fix check-syntax-fix)
|
||||
(err error)
|
||||
(ends end)
|
||||
(starts start)
|
||||
(debug debug)
|
||||
(table (convert-parse-table table))
|
||||
(all-term-syms all-term-syms)
|
||||
(actions actions)
|
||||
(src-pos src-pos))
|
||||
(syntax
|
||||
(begin
|
||||
check-syntax-fix
|
||||
(parser-body debug err (quote starts) (quote ends) table all-term-syms actions src-pos)))))))
|
||||
(_
|
||||
(raise-syntax-error #f
|
||||
"parser must have the form (parser args ...)"
|
||||
stx))))
|
||||
|
||||
(define (reduce-stack stack num ret-vals src-pos)
|
||||
(cond
|
||||
((> num 0)
|
||||
(let* ((top-frame (car stack))
|
||||
(ret-vals
|
||||
(if src-pos
|
||||
(cons (stack-frame-value top-frame)
|
||||
(cons (stack-frame-start-pos top-frame)
|
||||
(cons (stack-frame-end-pos top-frame)
|
||||
ret-vals)))
|
||||
(cons (stack-frame-value top-frame) ret-vals))))
|
||||
(reduce-stack (cdr stack) (sub1 num) ret-vals src-pos)))
|
||||
(else (values stack ret-vals))))
|
||||
|
||||
;; extract-helper : (symbol or make-token) any any -> symbol any any any
|
||||
(define (extract-helper tok v1 v2)
|
||||
(cond
|
||||
((symbol? tok)
|
||||
(values tok #f v1 v2))
|
||||
((token? tok)
|
||||
(values (real-token-name tok) (real-token-value tok) v1 v2))
|
||||
(else (raise-argument-error 'parser
|
||||
"(or/c symbol? token?)"
|
||||
0
|
||||
tok))))
|
||||
|
||||
;; well-formed-position-token?: any -> boolean
|
||||
;; Returns true if pt is a position token whose position-token-token
|
||||
;; is itself a token or a symbol.
|
||||
;; This is meant to help raise more precise error messages when
|
||||
;; a tokenizer produces an erroneous position-token wrapped twice.
|
||||
;; (as often happens when omitting return-without-pos).
|
||||
(define (well-formed-position-token? pt)
|
||||
(and (position-token? pt)
|
||||
(let ([t (position-token-token pt)])
|
||||
(or (symbol? t)
|
||||
(token? t)))))
|
||||
|
||||
;; extract-src-pos : position-token -> symbol any any any
|
||||
(define (extract-src-pos ip)
|
||||
(cond
|
||||
((well-formed-position-token? ip)
|
||||
(extract-helper (position-token-token ip)
|
||||
(position-token-start-pos ip)
|
||||
(position-token-end-pos ip)))
|
||||
(else
|
||||
(raise-argument-error 'parser
|
||||
"well-formed-position-token?"
|
||||
0
|
||||
ip))))
|
||||
|
||||
;; extract-no-src-pos : (symbol or make-token) -> symbol any any any
|
||||
(define (extract-no-src-pos ip)
|
||||
(extract-helper ip #f #f))
|
||||
|
||||
(define-struct stack-frame (state value start-pos end-pos) #:inspector (make-inspector))
|
||||
|
||||
(define (make-empty-stack i) (list (make-stack-frame i #f #f #f)))
|
||||
|
||||
|
||||
;; The table is a vector that maps each state to a hash-table that maps a
|
||||
;; terminal symbol to either an accept, shift, reduce, or goto structure.
|
||||
; We encode the structures according to the runtime-action data definition in
|
||||
;; parser-actions.rkt
|
||||
(define (parser-body debug? err starts ends table all-term-syms actions src-pos)
|
||||
(local ((define extract
|
||||
(if src-pos
|
||||
extract-src-pos
|
||||
extract-no-src-pos))
|
||||
|
||||
(define (fix-error stack tok val start-pos end-pos get-token)
|
||||
(when debug? (pretty-print stack))
|
||||
(local ((define (remove-input tok val start-pos end-pos)
|
||||
(if (memq tok ends)
|
||||
(raise-read-error "parser: Cannot continue after error"
|
||||
#f #f #f #f #f)
|
||||
(let ((a (find-action stack tok val start-pos end-pos)))
|
||||
(cond
|
||||
((runtime-shift? a)
|
||||
;; (printf "shift:~a\n" (runtime-shift-state a))
|
||||
(cons (make-stack-frame (runtime-shift-state a)
|
||||
val
|
||||
start-pos
|
||||
end-pos)
|
||||
stack))
|
||||
(else
|
||||
;; (printf "discard input:~a\n" tok)
|
||||
(let-values (((tok val start-pos end-pos)
|
||||
(extract (get-token))))
|
||||
(remove-input tok val start-pos end-pos))))))))
|
||||
(let remove-states ()
|
||||
(let ((a (find-action stack 'error #f start-pos end-pos)))
|
||||
(cond
|
||||
((runtime-shift? a)
|
||||
;; (printf "shift:~a\n" (runtime-shift-state a))
|
||||
(set! stack
|
||||
(cons
|
||||
(make-stack-frame (runtime-shift-state a)
|
||||
#f
|
||||
start-pos
|
||||
end-pos)
|
||||
stack))
|
||||
(remove-input tok val start-pos end-pos))
|
||||
(else
|
||||
;; (printf "discard state:~a\n" (car stack))
|
||||
(cond
|
||||
((< (length stack) 2)
|
||||
(raise-read-error "parser: Cannot continue after error"
|
||||
#f #f #f #f #f))
|
||||
(else
|
||||
(set! stack (cdr stack))
|
||||
(remove-states)))))))))
|
||||
|
||||
(define (find-action stack tok val start-pos end-pos)
|
||||
(unless (hash-ref all-term-syms
|
||||
tok
|
||||
#f)
|
||||
(if src-pos
|
||||
(err #f tok val start-pos end-pos)
|
||||
(err #f tok val))
|
||||
(raise-read-error (format "parser: got token of unknown type ~a" tok)
|
||||
#f #f #f #f #f))
|
||||
(hash-ref (vector-ref table (stack-frame-state (car stack)))
|
||||
tok
|
||||
#f))
|
||||
|
||||
(define (make-parser start-number)
|
||||
(lambda (get-token)
|
||||
(unless (and (procedure? get-token)
|
||||
(procedure-arity-includes? get-token 0))
|
||||
(error 'get-token "expected a nullary procedure, got ~e" get-token))
|
||||
(let parsing-loop ((stack (make-empty-stack start-number))
|
||||
(ip (get-token)))
|
||||
(let-values (((tok val start-pos end-pos)
|
||||
(extract ip)))
|
||||
(let ((action (find-action stack tok val start-pos end-pos)))
|
||||
(cond
|
||||
((runtime-shift? action)
|
||||
;; (printf "shift:~a\n" (runtime-shift-state action))
|
||||
(parsing-loop (cons (make-stack-frame (runtime-shift-state action)
|
||||
val
|
||||
start-pos
|
||||
end-pos)
|
||||
stack)
|
||||
(get-token)))
|
||||
((runtime-reduce? action)
|
||||
;; (printf "reduce:~a\n" (runtime-reduce-prod-num action))
|
||||
(let-values (((new-stack args)
|
||||
(reduce-stack stack
|
||||
(runtime-reduce-rhs-length action)
|
||||
null
|
||||
src-pos)))
|
||||
(let ((goto
|
||||
(runtime-goto-state
|
||||
(hash-ref
|
||||
(vector-ref table (stack-frame-state (car new-stack)))
|
||||
(runtime-reduce-lhs action)))))
|
||||
(parsing-loop
|
||||
(cons
|
||||
(if src-pos
|
||||
(make-stack-frame
|
||||
goto
|
||||
(apply (vector-ref actions (runtime-reduce-prod-num action)) args)
|
||||
(if (null? args) start-pos (cadr args))
|
||||
(if (null? args)
|
||||
end-pos
|
||||
(list-ref args (- (* (runtime-reduce-rhs-length action) 3) 1))))
|
||||
(make-stack-frame
|
||||
goto
|
||||
(apply (vector-ref actions (runtime-reduce-prod-num action)) args)
|
||||
#f
|
||||
#f))
|
||||
new-stack)
|
||||
ip))))
|
||||
((runtime-accept? action)
|
||||
;; (printf "accept\n")
|
||||
(stack-frame-value (car stack)))
|
||||
(else
|
||||
(if src-pos
|
||||
(err #t tok val start-pos end-pos)
|
||||
(err #t tok val))
|
||||
(parsing-loop (fix-error stack tok val start-pos end-pos get-token)
|
||||
(get-token))))))))))
|
||||
(cond
|
||||
((null? (cdr starts)) (make-parser 0))
|
||||
(else
|
||||
(let loop ((l starts)
|
||||
(i 0))
|
||||
(cond
|
||||
((null? l) null)
|
||||
(else (cons (make-parser i) (loop (cdr l) (add1 i))))))))))
|
||||
@ -1,12 +0,0 @@
|
||||
#lang info
|
||||
|
||||
(define collection 'multi)
|
||||
|
||||
(define deps '("parser-tools-lib"
|
||||
"parser-tools-doc"))
|
||||
(define implies '("parser-tools-lib"
|
||||
"parser-tools-doc"))
|
||||
|
||||
(define pkg-desc "Lex- and Yacc-style parsing tools")
|
||||
|
||||
(define pkg-authors '(mflatt))
|
||||
Loading…
Reference in New Issue