mbutterick
/
br-parser-tools
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix for v209

Browse Source 
original commit: bc0b0dd76a952684f0d2c369e1f864166efc7a31
tokens
Eli Barzilay 20 years ago
parent 195d429226
commit 12687e8f0e
1 changed files with 134 additions and 286 deletions
Show Stats Download Patch File Download Diff File

344
collects/parser-tools/lex.ss
Unescape Escape View File

@ -3,227 +3,140 @@
;; Provides the syntax used to create lexers and the functions needed to ;; Provides the syntax used to create lexers and the functions needed to
;; create and use the buffer that the lexer reads from. See doc.txt. ;; create and use the buffer that the lexer reads from. See doc.txt.
(require-for-syntax (lib "list.ss") (require-for-syntax "private-lex/util.ss"
(lib "stx.ss" "syntax")
(lib "define.ss" "syntax")
(lib "boundmap.ss" "syntax")
"private-lex/util.ss"
"private-lex/actions.ss" "private-lex/actions.ss"
"private-lex/front.ss" "private-lex/front.ss")
"private-lex/unicode-chars.ss")
(require (lib "stxparam.ss") (require (lib "readerr.ss" "syntax")
(lib "readerr.ss" "syntax") (lib "cffi.ss" "compiler")
"private-lex/token.ss") "private-lex/token.ss")
(provide lexer lexer-src-pos define-lex-abbrev define-lex-abbrevs define-lex-trans (provide lexer lexer-src-pos define-lex-abbrev define-lex-abbrevs
get-position position-offset position-line position-col position?
define-tokens define-empty-tokens token-name token-value token? file-path)
;; Dealing with tokens and related structures (define file-path (make-parameter #f))
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?) (define-syntaxes (lexer lexer-src-pos)
(let ((build-lexer
(lambda (wrap?)
(lambda (stx) (lambda (stx)
(syntax-case stx () (syntax-case stx ()
((_) ((_)
(raise-syntax-error #f "accepts the empty string" stx)) (raise-syntax-error #f "empty lexer is not allowed" stx))
((_ re-act ...) ((_ re-act ...)
(begin (begin
(for-each (for-each
(lambda (x) (lambda (x)
(syntax-case x () (syntax-case x ()
((re act) (void)) ((re act) (void))
(_ (raise-syntax-error #f (_ (raise-syntax-error 'lexer
"not a regular expression / action pair" "expects regular expression / action pairs"
stx
x)))) x))))
(syntax->list (syntax (re-act ...)))) (syntax->list (syntax (re-act ...))))
(let* ((spec/re-act-lst (let* ((spec/re-act-lst
(syntax->list (syntax (re-act ...)))) (syntax->list (syntax (re-act ...))))
(eof-act (eof-act
(get-special-action spec/re-act-lst #'eof #''eof)) (get-special-action spec/re-act-lst 'eof #''eof))
(spec-act (spec-act
(get-special-action spec/re-act-lst #'special #'(void))) (get-special-action spec/re-act-lst 'special #'(void)))
(spec-error-act (spec-error-act
(get-special-action spec/re-act-lst #'special-error #'(raise lexeme))) (get-special-action spec/re-act-lst 'special-error #'(raise exception)))
(spec-comment-act (spec-comment-act
(get-special-action spec/re-act-lst #'special-comment #'#f)) (get-special-action spec/re-act-lst 'special-comment #'#f))
(ids (list #'special #'special-comment #'special-error #'eof))
(re-act-lst (re-act-lst
(filter (filter-out-specials spec/re-act-lst
(lambda (spec/re-act) '(special special-comment special-error eof))))
(syntax-case spec/re-act () (let-values (((trans start actions no-look)
(((special) act) (build-lexer re-act-lst)))
(not (ormap
(lambda (x)
(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)))
(let-values (((trans start action-names no-look disappeared-uses)
(build-lexer re-actname-lst)))
#;(when (vector-ref action-names start)
(raise-syntax-error #f "accepts the empty string" stx))
(with-syntax ((start-state-stx start) (with-syntax ((start-state-stx start)
(trans-table-stx trans) (trans-table-stx trans)
(no-lookahead-stx no-look) (no-lookahead-stx no-look)
((name ...) name-lst) (actions-stx `(vector ,@(map (lambda (a)
((act ...) (map (lambda (a) (if a (wrap-action a 'lexeme #'here a) #f))
(wrap-action a src-pos?)) (vector->list actions))))
act-lst))
((act-name ...) (vector->list action-names))
(spec-act-stx (spec-act-stx
(wrap-action spec-act src-pos?)) (wrap-action spec-act 'special #'here spec-act))
(spec-error-act-stx (spec-error-act-stx
(wrap-action spec-error-act src-pos?)) (wrap-action spec-error-act 'exception #'here spec-error-act))
(has-comment-act?-stx (has-comment-act?-stx (if (syntax-e spec-comment-act) #t #f))
(if (syntax-e spec-comment-act) #t #f))
(spec-comment-act-stx (spec-comment-act-stx
(wrap-action spec-comment-act src-pos?)) (wrap-action spec-comment-act (gensym) #'here spec-comment-act))
(eof-act-stx (wrap-action eof-act src-pos?))) (eof-act-stx
(syntax-property (wrap-action eof-act 'lexeme #'here eof-act))
(syntax/loc stx (wrap? wrap?))
(let ([name act] ...) (syntax
(lexer-body start-state-stx (lexer-body start-state-stx
trans-table-stx trans-table-stx
(vector act-name ...) actions-stx
no-lookahead-stx no-lookahead-stx
spec-act-stx spec-act-stx
spec-error-act-stx spec-error-act-stx
has-comment-act?-stx has-comment-act?-stx
spec-comment-act-stx spec-comment-act-stx
eof-act-stx))) eof-act-stx
'disappeared-use wrap?))))))))))))
disappeared-uses))))))))) (values
(build-lexer #f)
(define-syntax lexer (make-lexer-trans #f)) (build-lexer #t))))
(define-syntax lexer-src-pos (make-lexer-trans #t))
(define-syntax (define-lex-abbrev stx) (define-syntax (define-lex-abbrev stx)
(syntax-case stx () (syntax-case stx ()
((_ name re) ((_ name re)
(identifier? (syntax name)) (syntax
(syntax/loc stx
(define-syntax name (define-syntax name
(make-lex-abbrev (quote-syntax re))))) (make-lex-abbrev (quote-syntax re)))))
(_ (_
(raise-syntax-error (raise-syntax-error
#f #f
"form should be (define-lex-abbrev name re)" "Form should be (define-lex-abbrev name re)"
stx)))) stx))))
(define-syntax (define-lex-abbrevs stx) (define-syntax (define-lex-abbrevs stx)
(syntax-case stx () (syntax-case stx ()
((_ x ...) ((_ x ...)
(with-syntax (((abbrev ...) (let* ((abbrev (syntax->list (syntax (x ...))))
(map (r (map (lambda (a)
(lambda (a)
(syntax-case a () (syntax-case a ()
((name re) ((name re)
(identifier? (syntax name)) (identifier? (syntax name))
(syntax/loc a (define-lex-abbrev name re))) (syntax (define-lex-abbrev name re)))
(_ (raise-syntax-error (_ (raise-syntax-error
#f 'Lexer-abbreviation
"form should be (define-lex-abbrevs (name re) ...)" "Form should be (identifier value)"
stx
a)))) a))))
(syntax->list (syntax (x ...)))))) abbrev)))
(syntax/loc stx (begin abbrev ...)))) (datum->syntax-object
(_ #'here
(raise-syntax-error (cons 'begin r)
#f stx)))
"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 ((certifier (syntax-local-certifier)))
(make-lex-trans (lambda (stx)
(certifier (#,body stx) 'a)))))))
(_ (_
(raise-syntax-error (raise-syntax-error
#f #f
"form should be (define-lex-trans name transformer)" "Form should be (define-lex-abbrevs (name re) ...)"
stx)))) 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 (define (lexer-body start-state trans-table actions no-lookahead
special-action special-error-action special-action special-error-action
has-special-comment-action? special-comment-action eof-action) has-special-comment-action? special-comment-action eof-action wrap?)
(letrec ((lexer (letrec ((lexer
(lambda (ip) (lambda (ip)
(unless (input-port? ip)
(raise-type-error
'lexer
"input-port"
0
ip))
(let ((first-pos (get-position ip)) (let ((first-pos (get-position ip))
(first-char (peek-char-or-special ip 0))) (first-char (peek-char-or-special ip 0)))
;(printf "(peek-char-or-special port 0) = ~e~n" first-char)
(cond (cond
((eof-object? first-char) ((eq? 'special first-char)
(do-match ip first-pos eof-action (read-char-or-special ip)))
((not (char? first-char))
(let* ((comment? #f) (let* ((comment? #f)
(error? #f) (error? #f)
(spec (with-handlers ((special-comment? (spec (with-handlers ((exn:special-comment?
(lambda (x) (set! comment? #t))) (lambda (x) (set! comment? #t)))
(exn:fail? (not-break-exn?
(lambda (ex) (set! error? #t) ex))) (lambda (ex) (set! error? #t) ex)))
(read-char-or-special ip)))) (read-char-or-special ip))))
(cond (cond
@ -234,7 +147,9 @@
(comment? special-comment-action) (comment? special-comment-action)
(error? special-error-action) (error? special-error-action)
(else special-action)) (else special-action))
spec))))) spec wrap?)))))
((eof-object? first-char)
(do-match ip first-pos eof-action (read-char-or-special ip) wrap?))
(else (else
(let lexer-loop ( (let lexer-loop (
;; current-state ;; current-state
@ -245,56 +160,47 @@
;; including a match at the current state ;; including a match at the current state
(longest-match-action (longest-match-action
(vector-ref actions start-state)) (vector-ref actions start-state))
;; how many bytes preceed char
(length-bytes 0)
;; how many characters have been read ;; how many characters have been read
;; including the one just read ;; including the one just read
(length-chars 1) (length 1)
;; how many characters are in the longest match ;; how many characters are in the longest match
(longest-match-length 0)) (longest-match-length 0))
(let ((next-state (let ((next-state
(cond (cond
((eof-object? char) #f) ((eof-object? char) #f)
((not (char? char)) #f) ((eq? char 'special) #f)
(else (get-next-state (char->integer char) (else
(vector-ref trans-table state)))))) (vector-ref
trans-table
(+ (char->integer char) (* 256 state)))))))
(cond (cond
((not next-state) ((not next-state)
(check-match ip first-pos longest-match-length (check-match ip first-pos longest-match-length
length-chars longest-match-action)) length longest-match-action wrap?))
((vector-ref no-lookahead next-state) ((vector-ref no-lookahead next-state)
(let ((act (vector-ref actions next-state))) (let ((act (vector-ref actions next-state)))
(check-match ip (check-match ip
first-pos first-pos
(if act length-chars longest-match-length) (if act length longest-match-length)
length-chars length
(if act act longest-match-action)))) (if act act longest-match-action)
wrap?)))
(else (else
(let* ((act (vector-ref actions next-state)) (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 (lexer-loop next-state
next-char (peek-char-or-special ip length)
(if act (if act
act act
longest-match-action) longest-match-action)
next-length-bytes (add1 length)
(add1 length-chars)
(if act (if act
length-chars length
longest-match-length))))))))))))) longest-match-length)))))))))))))
(lambda (ip) lexer))
(unless (input-port? ip)
(raise-type-error
'lexer
"input-port"
0
ip))
(lexer ip))))
(define (check-match lb first-pos longest-match-length length longest-match-action) (define id (lambda (x) x))
(define (check-match lb first-pos longest-match-length length longest-match-action wrap?)
(unless longest-match-action (unless longest-match-action
(let* ((match (read-string length lb)) (let* ((match (read-string length lb))
(end-pos (get-position lb))) (end-pos (get-position lb)))
@ -306,81 +212,23 @@
(position-offset first-pos) (position-offset first-pos)
(- (position-offset end-pos) (position-offset first-pos))))) (- (position-offset end-pos) (position-offset first-pos)))))
(let ((match (read-string longest-match-length lb))) (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 wrap?)))
(do-match lb first-pos longest-match-action match)))
(define file-path (make-parameter #f))
(define (do-match ip first-pos action value) (define (do-match ip first-pos action value wrap?)
#;(printf "(action ~a ~a ~a ~a)~n" (let ((end-pos (get-position ip)))
(position-offset first-pos) (position-offset (get-position ip)) value ip) (cond
(action first-pos (get-position ip) value ip)) (wrap?
(let/ec ret
(list (action first-pos end-pos value ret ip)
first-pos
end-pos)))
(else
(action first-pos end-pos value id ip)))))
(define-struct position (offset line col))
(define (get-position ip) (define (get-position ip)
(let-values (((line col off) (port-next-location ip))) (let-values (((line col off) (port-next-location ip)))
(make-position off line col))) (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)
) )

Write Preview
Loading…
Cancel
Save