From 86df35057c5d177f3f8e6bd80e6af076334f1a13 Mon Sep 17 00:00:00 2001 From: Matthew Butterick Date: Fri, 27 Jan 2017 17:20:45 -0800 Subject: [PATCH] fork parser tools --- .../br-parser-tools-doc/LICENSE.txt | 11 + br-parser-tools/br-parser-tools-doc/info.rkt | 14 + .../parser-tools/br-parser-tools.scrbl | 751 ++++++++++++++ .../br-parser-tools/Context-Free_Parsers.html | 10 + .../Converting_yacc_or_bison_Grammars.html | 8 + .../doc/br-parser-tools/LALR_1__Parsers.html | 91 ++ .../doc/br-parser-tools/Lexers.html | 138 +++ .../doc/br-parser-tools/blueboxes.rktd | 166 +++ .../doc/br-parser-tools/doc-index.html | 2 + .../parser-tools/doc/br-parser-tools/in.sxref | Bin 0 -> 9818 bytes .../doc/br-parser-tools/index.html | 3 + .../doc/br-parser-tools/out0.sxref | Bin 0 -> 709 bytes .../doc/br-parser-tools/out1.sxref | Bin 0 -> 14638 bytes .../doc/br-parser-tools/provides.sxref | Bin 0 -> 4423 bytes .../doc/br-parser-tools/stamp.sxref | 1 + .../doc/br-parser-tools/synced.rktd | 0 .../parser-tools/doc/doc-site.css | 0 .../parser-tools/doc/doc-site.js | 0 .../parser-tools/doc/manual-fonts.css | 343 ++++++ .../parser-tools/doc/manual-racket.css | 319 ++++++ .../parser-tools/doc/manual-racket.js | 98 ++ .../parser-tools/doc/manual-style.css | 742 +++++++++++++ .../parser-tools/doc/racket.css | 249 +++++ .../parser-tools/doc/scribble-common.js | 170 +++ .../parser-tools/doc/scribble-style.css | 0 .../parser-tools/doc/scribble.css | 485 +++++++++ .../br-parser-tools-doc/parser-tools/info.rkt | 3 + .../br-parser-tools-lib/LICENSE.txt | 11 + .../br-parser-tools/cfg-parser.rkt | 982 ++++++++++++++++++ .../br-parser-tools/examples/calc.rkt | 89 ++ .../br-parser-tools/examples/read.rkt | 242 +++++ .../br-parser-tools/info.rkt | 3 + .../br-parser-tools/lex-plt-v200.rkt | 24 + .../br-parser-tools/lex-sre.rkt | 119 +++ .../br-parser-tools/lex.rkt | 410 ++++++++ .../br-parser-tools/private-lex/actions.rkt | 16 + .../br-parser-tools/private-lex/deriv.rkt | 339 ++++++ .../private-lex/error-tests.rkt | 81 ++ .../br-parser-tools/private-lex/front.rkt | 179 ++++ .../br-parser-tools/private-lex/re.rkt | 385 +++++++ .../br-parser-tools/private-lex/stx.rkt | 220 ++++ .../private-lex/token-syntax.rkt | 9 + .../br-parser-tools/private-lex/token.rkt | 92 ++ .../private-lex/unicode-chars.rkt | 69 ++ .../br-parser-tools/private-lex/util.rkt | 127 +++ .../br-parser-tools/private-yacc/grammar.rkt | 280 +++++ .../br-parser-tools/private-yacc/graph.rkt | 61 ++ .../private-yacc/input-file-parser.rkt | 374 +++++++ .../br-parser-tools/private-yacc/lalr.rkt | 277 +++++ .../br-parser-tools/private-yacc/lr0.rkt | 372 +++++++ .../private-yacc/parser-actions.rkt | 54 + .../private-yacc/parser-builder.rkt | 113 ++ .../br-parser-tools/private-yacc/table.rkt | 290 ++++++ .../private-yacc/yacc-helper.rkt | 118 +++ .../br-parser-tools/yacc-to-scheme.rkt | 135 +++ .../br-parser-tools/yacc.rkt | 412 ++++++++ br-parser-tools/br-parser-tools-lib/info.rkt | 11 + br-parser-tools/br-parser-tools/LICENSE.txt | 11 + br-parser-tools/br-parser-tools/info.rkt | 12 + 59 files changed, 9521 insertions(+) create mode 100644 br-parser-tools/br-parser-tools-doc/LICENSE.txt create mode 100644 br-parser-tools/br-parser-tools-doc/info.rkt create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/br-parser-tools.scrbl create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/Context-Free_Parsers.html create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/Converting_yacc_or_bison_Grammars.html create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/LALR_1__Parsers.html create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/Lexers.html create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/blueboxes.rktd create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/doc-index.html create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/in.sxref create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/index.html create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/out0.sxref create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/out1.sxref create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/provides.sxref create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/stamp.sxref create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/synced.rktd create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/doc-site.css create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/doc-site.js create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-fonts.css create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-racket.css create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-racket.js create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-style.css create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/racket.css create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/scribble-common.js create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/scribble-style.css create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/doc/scribble.css create mode 100644 br-parser-tools/br-parser-tools-doc/parser-tools/info.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/LICENSE.txt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/cfg-parser.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/examples/calc.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/examples/read.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/info.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/lex-plt-v200.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/lex-sre.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/lex.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/actions.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/deriv.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/error-tests.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/front.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/re.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/stx.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/token-syntax.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/token.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/unicode-chars.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/util.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/grammar.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/graph.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/input-file-parser.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/lalr.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/lr0.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/parser-actions.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/parser-builder.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/table.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/yacc-helper.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/yacc-to-scheme.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/br-parser-tools/yacc.rkt create mode 100644 br-parser-tools/br-parser-tools-lib/info.rkt create mode 100644 br-parser-tools/br-parser-tools/LICENSE.txt create mode 100644 br-parser-tools/br-parser-tools/info.rkt diff --git a/br-parser-tools/br-parser-tools-doc/LICENSE.txt b/br-parser-tools/br-parser-tools-doc/LICENSE.txt new file mode 100644 index 0000000..c424668 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/LICENSE.txt @@ -0,0 +1,11 @@ +parser-tools-doc +Copyright (c) 2010-2014 PLT Design Inc. + +This package is distributed under the GNU Lesser General Public +License (LGPL). This means that you can link this package into proprietary +applications, provided you follow the rules stated in the LGPL. You +can also modify this package; if you distribute a modified version, +you must distribute it under the terms of the LGPL, which in +particular means that you must release the source code for the +modified software. See http://www.gnu.org/copyleft/lesser.html +for more information. diff --git a/br-parser-tools/br-parser-tools-doc/info.rkt b/br-parser-tools/br-parser-tools-doc/info.rkt new file mode 100644 index 0000000..8760588 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/info.rkt @@ -0,0 +1,14 @@ +#lang info + +(define collection 'multi) +(define deps '("base")) +(define build-deps '("scheme-lib" + "racket-doc" + "syntax-color-doc" + "br-parser-tools-lib" + "scribble-lib")) +(define update-implies '("br-parser-tools-lib")) + +(define pkg-desc "documentation part of \"br-parser-tools\"") + +(define pkg-authors '(mflatt)) diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/br-parser-tools.scrbl b/br-parser-tools/br-parser-tools-doc/parser-tools/br-parser-tools.scrbl new file mode 100644 index 0000000..733c8b6 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/br-parser-tools.scrbl @@ -0,0 +1,751 @@ +#lang scribble/doc +@(require scribble/manual scribble/struct scribble/xref scribble/bnf + (for-label scheme/base + scheme/contract + br-parser-tools/lex + (prefix-in : br-parser-tools/lex-sre) + br-parser-tools/yacc + br-parser-tools/cfg-parser)) + +@title{Parser Tools: @exec{lex} and @exec{yacc}-style Parsing} + +@author["Scott Owens"] + +This documentation assumes familiarity with @exec{lex} and @exec{yacc} +style lexer and parser generators. + +@table-of-contents[] + +@; ---------------------------------------------------------------------- + +@section{Lexers} + +@section-index["lex"] +@section-index["scanning"] +@section-index["scanner"] + +@defmodule[br-parser-tools/lex] + +@; ---------------------------------------- + +@subsection{Creating a Lexer} + +@defform/subs[#:literals (repetition union intersection complement concatenation + char-range char-complement + eof special special-comment) + (lexer [trigger action-expr] ...) + ([trigger re + (eof) + (special) + (special-comment)] + [re id + string + character + (repetition lo hi re) + (union re ...) + (intersection re ...) + (complement re) + (concatenation re ...) + (char-range char char) + (char-complement re) + (id datum ...)])]{ + + Produces a function that takes an input-port, matches the + @racket[re] patterns against the buffer, and returns the result of + executing the corresponding @racket[action-expr]. When multiple + patterns match, a lexer will choose the longest match, breaking + ties in favor of the rule appearing first. + + @margin-note{The implementation of @racketmodname[syntax-color/racket-lexer] + contains a lexer for the @racketmodname[racket] language. + In addition, files in the @filepath{examples} sub-directory + of the @filepath{br-parser-tools} collection contain + simpler example lexers.} + + An @racket[re] is matched as follows: + + @itemize[ + @item{@racket[id] --- expands to the named @deftech{lexer abbreviation}; + abbreviations are defined via @racket[define-lex-abbrev] or supplied by modules + like @racketmodname[br-parser-tools/lex-sre].} + @item{@racket[string] --- matches the sequence of characters in @racket[string].} + @item{@racket[character] --- matches a literal @racket[character].} + @item{@racket[(repetition lo hi re)] --- matches @racket[re] repeated between @racket[lo] + and @racket[hi] times, inclusive; @racket[hi] can be @racket[+inf.0] for unbounded repetitions.} + @item{@racket[(union re ...)] --- matches if any of the sub-expressions match} + @item{@racket[(intersection re ...)] --- matches if all of the @racket[re]s match.} + @item{@racket[(complement re)] --- matches anything that @racket[re] does not.} + @item{@racket[(concatenation re ...)] --- matches each @racket[re] in succession.} + @item{@racket[(char-range char char)] --- matches any character between the two (inclusive); + a single character string can be used as a @racket[char].} + @item{@racket[(char-complement re)] --- matches any character not matched by @racket[re]. + The sub-expression must be a set of characters @racket[re].} + @item{@racket[(id datum ...)] --- expands the @deftech{lexer macro} named @racket[id]; macros + are defined via @racket[define-lex-trans].} + ] + +Note that both @racket[(concatenation)] and @racket[""] match the +empty string, @racket[(union)] matches nothing, +@racket[(intersection)] matches any string, and +@racket[(char-complement (union))] matches any single character. + +The regular expression language is not designed to be used directly, +but rather as a basis for a user-friendly notation written with +regular expression macros. For example, +@racketmodname[br-parser-tools/lex-sre] supplies operators from Olin +Shivers's SREs, and @racketmodname[br-parser-tools/lex-plt-v200] supplies +(deprecated) operators from the previous version of this library. +Since those libraries provide operators whose names match other Racket +bindings, such as @racket[*] and @racket[+], they normally must be +imported using a prefix: + +@racketblock[ +(require (prefix-in : br-parser-tools/lex-sre)) +] + +The suggested prefix is @racket[:], so that @racket[:*] and +@racket[:+] are imported. Of course, a prefix other than @racket[:] +(such as @racket[re-]) will work too. + +Since negation is not a common operator on regular expressions, here +are a few examples, using @racket[:] prefixed SRE syntax: + +@itemize[ + +@item{@racketblock0[(complement "1")] + + Matches all strings except the string @racket["1"], including + @racket["11"], @racket["111"], @racket["0"], @racket["01"], + @racket[""], and so on.} + +@item{@racketblock0[(complement (:* "1"))] + + Matches all strings that are not sequences of @racket["1"], + including @racket["0"], @racket["00"], @racket["11110"], + @racket["0111"], @racket["11001010"] and so on.} + +@item{@racketblock0[(:& (:: any-string "111" any-string) + (complement (:or (:: any-string "01") (:+ "1"))))] + + Matches all strings that have 3 consecutive ones, but not those that + end in @racket["01"] and not those that are ones only. These + include @racket["1110"], @racket["0001000111"] and @racket["0111"] + but not @racket[""], @racket["11"], @racket["11101"], @racket["111"] + and @racket["11111"].} + +@item{@racketblock0[(:: "/*" (complement (:: any-string "*/" any-string)) "*/")] + + Matches Java/C block comments. @racket["/**/"], + @racket["/******/"], @racket["/*////*/"], @racket["/*asg4*/"] and so + on. It does not match @racket["/**/*/"], @racket["/* */ */"] and so + on. @racket[(:: any-string "*/" any-string)] matches any string + that has a @racket["*/"] in is, so @racket[(complement (:: any-string "*/" + any-string))] matches any string without a @racket["*/"] in it.} + +@item{@racketblock0[(:: "/*" (:* (complement "*/")) "*/")] + + Matches any string that starts with @racket["/*"] and ends with + @racket["*/"], including @racket["/* */ */ */"]. + @racket[(complement "*/")] matches any string except @racket["*/"]. + This includes @racket["*"] and @racket["/"] separately. Thus + @racket[(:* (complement "*/"))] matches @racket["*/"] by first + matching @racket["*"] and then matching @racket["/"]. Any other + string is matched directly by @racket[(complement "*/")]. In other + words, @racket[(:* (complement "xx"))] = @racket[any-string]. It is + usually not correct to place a @racket[:*] around a + @racket[complement].} +] + + + The following binding have special meaning inside of a lexer + action: + + @itemize[ + @item{@racket[start-pos] --- a @racket[position] struct for the first character matched.} + @item{@racket[end-pos] --- a @racket[position] struct for the character after the last character in the match.} + @item{@racket[lexeme] --- the matched string.} + @item{@racket[input-port] --- the input-port being + processed (this is useful for matching input with multiple + lexers).} + @item{@racket[(return-without-pos x)] is a function (continuation) that + immediately returns the value of @racket[x] from the lexer. This useful + in a src-pos lexer to prevent the lexer from adding source + information. For example: + + @racketblock[ + (define get-token + (lexer-src-pos + ... + ((comment) (get-token input-port)) + ...)) + ] + + would wrap the source location information for the comment around + the value of the recursive call. Using + @racket[((comment) (return-without-pos (get-token input-port)))] + will cause the value of the recursive call to be returned without + wrapping position around it.} + ] + + The lexer raises an exception @racket[(exn:read)] if none of the + regular expressions match the input. Hint: If @racket[(any-char + _custom-error-behavior)] is the last rule, then there will always + be a match, and @racket[_custom-error-behavior] is executed to + handle the error situation as desired, only consuming the first + character from the input buffer. + + In addition to returning characters, input + ports can return @racket[eof-object]s. Custom input ports can + also return a @racket[special-comment] value to indicate a + non-textual comment, or return another arbitrary value (a + special). The non-@racket[re] @racket[trigger] forms handle these + cases: + + @itemize[ + + @item{The @racket[(eof)] rule is matched when the input port + returns an @racket[eof-object] value. If no @racket[(eof)] + rule is present, the lexer returns the symbol @racket['eof] + when the port returns an @racket[eof-object] value.} + + @item{The @racket[(special-comment)] rule is matched when the + input port returns a @racket[special-comment] structure. If no + @racket[special-comment] rule is present, the lexer + automatically tries to return the next token from the input + port.} + + @item{The @racket[(special)] rule is matched when the input + port returns a value other than a character, + @racket[eof-object], or @racket[special-comment] structure. If + no @racket[(special)] rule is present, the lexer returns + @racket[(void)].}] + + End-of-files, specials, special-comments and special-errors cannot + be parsed via a rule using an ordinary regular expression + (but dropping down and manipulating the port to handle them + is possible in some situations). + + Since the lexer gets its source information from the port, use + @racket[port-count-lines!] to enable the tracking of line and + column information. Otherwise, the line and column information + will return @racket[#f]. + + When peeking from the input port raises an exception (such as by + an embedded XML editor with malformed syntax), the exception can + be raised before all tokens preceding the exception have been + returned. + + Each time the racket code for a lexer is compiled (e.g. when a + @filepath{.rkt} file containing a @racket[lexer] form is loaded), + the lexer generator is run. To avoid this overhead place the + lexer into a module and compile the module to a @filepath{.zo} + bytecode file.} + +@defform[(lexer-src-pos (trigger action-expr) ...)]{ + +Like @racket[lexer], but for each @racket[_action-result] produced by +an @racket[action-expr], returns @racket[(make-position-token +_action-result start-pos end-pos)] instead of simply +@racket[_action-result].} + +@deftogether[( +@defidform[start-pos] +@defidform[end-pos] +@defidform[lexeme] +@defidform[input-port] +@defidform[return-without-pos] +)]{ + +Use of these names outside of a @racket[lexer] action is a syntax +error.} + +@defstruct[position ([offset exact-positive-integer?] + [line exact-positive-integer?] + [col exact-nonnegative-integer?])]{ + + Instances of @racket[position] are bound to @racket[start-pos] and + @racket[end-pos]. The @racket[offset] field contains the offset of + the character in the input. The @racket[line] field contains the + line number of the character. The @racket[col] field contains the + offset in the current line.} + +@defstruct[position-token ([token any/c] + [start-pos position?] + [end-pos position?])]{ + + Lexers created with @racket[lexer-src-pos] return instances of @racket[position-token].} + + +@defparam[file-path source any/c]{ + + A parameter that the lexer uses as the source location if it + raises a @racket[exn:fail:read] error. Setting this parameter allows + DrRacket, for example, to open the file containing the error.} + + +@; ---------------------------------------- + +@subsection{Lexer Abbreviations and Macros} + +@defform[(char-set string)]{ + +A @tech{lexer macro} that matches any character in @racket[string].} + +@defidform[any-char]{A @tech{lexer abbreviation} that matches any character.} + +@defidform[any-string]{A @tech{lexer abbreviation} that matches any string.} + +@defidform[nothing]{A @tech{lexer abbreviation} that matches no string.} + +@deftogether[( +@defidform[alphabetic] +@defidform[lower-case] +@defidform[upper-case] +@defidform[title-case] +@defidform[numeric] +@defidform[symbolic] +@defidform[punctuation] +@defidform[graphic] +@defidform[whitespace] +@defidform[blank] +@defidform[iso-control] +)]{ + +@tech{Lexer abbreviations} that match @racket[char-alphabetic?] +characters, @racket[char-lower-case?] characters, etc.} + +@defform[(define-lex-abbrev id re)]{ + + Defines a @tech{lexer abbreviation} by associating a regular + expression to be used in place of the @racket[id] in other + regular expression. The definition of name has the same scoping + properties as a other syntactic binding (e.g., it can be exported + from a module).} + +@defform[(define-lex-abbrevs (id re) ...)]{ + + Like @racket[define-lex-abbrev], but defines several @tech{lexer + abbreviations}.} + + +@defform[(define-lex-trans id trans-expr)]{ + + Defines a @tech{lexer macro}, where @racket[trans-expr] produces a + transformer procedure that takes one argument. When @racket[(id + _datum ...)] appears as a regular expression, it is replaced with + the result of applying the transformer to the expression.} + + +@; ---------------------------------------- + +@subsection{Lexer SRE Operators} + +@defmodule[br-parser-tools/lex-sre] + +@; Put the docs in a macro, so that we can bound the scope of +@; the import of `*', etc.: +@(define-syntax-rule (lex-sre-doc) + (... + (begin + (require (for-label br-parser-tools/lex-sre)) + +@defform[(* re ...)]{ + +Repetition of @racket[re] sequence 0 or more times.} + +@defform[(+ re ...)]{ + +Repetition of @racket[re] sequence 1 or more times.} + +@defform[(? re ...)]{ + +Zero or one occurrence of @racket[re] sequence.} + +@defform[(= n re ...)]{ + +Exactly @racket[n] occurrences of @racket[re] sequence, where +@racket[n] must be a literal exact, non-negative number.} + +@defform[(>= n re ...)]{ + +At least @racket[n] occurrences of @racket[re] sequence, where +@racket[n] must be a literal exact, non-negative number.} + +@defform[(** n m re ...)]{ + +Between @racket[n] and @racket[m] (inclusive) occurrences of +@racket[re] sequence, where @racket[n] must be a literal exact, +non-negative number, and @racket[m] must be literally either +@racket[#f], @racket[+inf.0], or an exact, non-negative number; a +@racket[#f] value for @racket[m] is the same as @racket[+inf.0].} + +@defform[(or re ...)]{ + +Same as @racket[(union re ...)].} + +@deftogether[( +@defform[(: re ...)] +@defform[(seq re ...)] +)]{ + +Both forms concatenate the @racket[re]s.} + +@defform[(& re ...)]{ + +Intersects the @racket[re]s.} + +@defform[(- re ...)]{ + +The set difference of the @racket[re]s.} + +@defform[(~ re ...)]{ + +Character-set complement, which each @racket[re] must match exactly +one character.} + +@defform[(/ char-or-string ...)]{ + +Character ranges, matching characters between successive pairs of +characters.} + +))) + +@(lex-sre-doc) + +@; ---------------------------------------- + +@subsection{Lexer Legacy Operators} + +@defmodule[br-parser-tools/lex-plt-v200] + +@(define-syntax-rule (lex-v200-doc) + (... + (begin + (require (for-label br-parser-tools/lex-plt-v200)) + +@t{The @racketmodname[br-parser-tools/lex-plt-v200] module re-exports + @racket[*], @racket[+], @racket[?], and @racket[&] from + @racketmodname[br-parser-tools/lex-sre]. It also re-exports + @racket[:or] as @racket[:], @racket[::] as @racket[|@|], @racket[:~] + as @racket[^], and @racket[:/] as @racket[-].} + +@defform[(epsilon)]{ + +A @tech{lexer macro} that matches an empty sequence.} + +@defform[(~ re ...)]{ + +The same as @racket[(complement re ...)].}))) + +@(lex-v200-doc) + +@; ---------------------------------------- + +@subsection{Tokens} + +Each @racket[_action-expr] in a @racket[lexer] form can produce any +kind of value, but for many purposes, producing a @deftech{token} +value is useful. Tokens are usually necessary for inter-operating with +a parser generated by @racket[br-parser-tools/parser], but tokens may not +be the right choice when using @racket[lexer] in other situations. + +@defform[(define-tokens group-id (token-id ...))]{ + + Binds @racket[group-id] to the group of tokens being defined. For + each @racket[token-id], a function + @racketidfont{token-}@racket[token-id] is created that takes any + value and puts it in a token record specific to @racket[token-id]. + The token value is inspected using @racket[token-id] and + @racket[token-value]. + + A token cannot be named @racketidfont{error}, since + @racketidfont{error} it has special use in the parser.} + +@defform[(define-empty-tokens group-id (token-id ...) )]{ + + + Like @racket[define-tokens], except a each token constructor + @racketidfont{token-}@racket[token-id] takes no arguments and returns + @racket[(@#,racket[quote] token-id)].} + + +@defproc[(token-name [t (or/c token? symbol?)]) symbol?]{ + + Returns the name of a token that is represented either by a symbol + or a token structure.} + + +@defproc[(token-value [t (or/c token? symbol?)]) any/c]{ + + Returns the value of a token that is represented either by a symbol + or a token structure, returning @racket[#f] for a symbol token.} + + +@defproc[(token? [v any/c]) boolean?]{ + + Returns @racket[#t] if @racket[val] is a + token structure, @racket[#f] otherwise.} + +@; ---------------------------------------------------------------------- + +@section{LALR(1) Parsers} + +@section-index["yacc"] + +@defmodule[br-parser-tools/yacc] + +@defform/subs[#:literals (grammar tokens start end precs src-pos + suppress debug yacc-output prec) + (parser clause ...) + ([clause (grammar (non-terminal-id + ((grammar-id ...) maybe-prec expr) + ...) + ...) + (tokens group-id ...) + (start non-terminal-id ...) + (end token-id ...) + (@#,racketidfont{error} expr) + (precs (assoc token-id ...) ...) + (src-pos) + (suppress) + (debug filename) + (yacc-output filename)] + [maybe-prec code:blank + (prec token-id)] + [assoc left right nonassoc])]{ + + Creates a parser. The clauses may be in any order, as long as there + are no duplicates and all non-@italic{OPTIONAL} declarations are + present: + + @itemize[ + + @item{@racketblock0[(grammar (non-terminal-id + ((grammar-id ...) maybe-prec expr) + ...) + ...)] + + Declares the grammar to be parsed. Each @racket[grammar-id] can + be a @racket[token-id] from a @racket[group-id] named in a + @racket[tokens] declaration, or it can be a + @racket[non-terminal-id] declared in the @racket[grammar] + declaration. The optional @racket[prec] declaration works with + the @racket[precs] declaration. The @racket[expr] is a + ``semantic action,'' which is evaluated when the input is found + to match its corresponding production. + + Each action is Racket code that has the same scope as its + parser's definition, except that the variables @racket[$1], ..., + @racketidfont{$}@math{i} are bound, where @math{i} is the number + of @racket[grammar-id]s in the corresponding production. Each + @racketidfont{$}@math{k} is bound to the result of the action + for the @math{k}@superscript{th} grammar symbol on the right of + the production, if that grammar symbol is a non-terminal, or the + value stored in the token if the grammar symbol is a terminal. + If the @racket[src-pos] option is present in the parser, then + variables @racket[$1-start-pos], ..., + @racketidfont{$}@math{i}@racketidfont{-start-pos} and + @racket[$1-end-pos], ..., + @racketidfont{$}@math{i}@racketidfont{-end-pos} and are also + available, and they refer to the position structures + corresponding to the start and end of the corresponding + @racket[grammar-symbol]. Grammar symbols defined as empty-tokens + have no @racketidfont{$}@math{k} associated, but do have + @racketidfont{$}@math{k}@racketidfont{-start-pos} and + @racketidfont{$}@math{k}@racketidfont{-end-pos}. + Also @racketidfont{$n-start-pos} and @racketidfont{$n-end-pos} + are bound to the largest start and end positions, (i.e., + @racketidfont{$}@math{i}@racketidfont{-start-pos} and + @racketidfont{$}@math{i}@racketidfont{-end-pos}). + + An @deftech{error production} can be defined by providing + a production of the form @racket[(error α)], where α is a + string of grammar symbols, possibly empty. + + All of the productions for a given non-terminal must be grouped + with it. That is, no @racket[non-terminal-id] may appear twice + on the left hand side in a parser.} + + + @item{@racket[(tokens group-id ...)] + + Declares that all of the tokens defined in each + @racket[group-id]---as bound by @racket[define-tokens] or + @racket[define-empty-tokens]---can be used by the parser in the + @racket[grammar] declaration.} + + + @item{@racket[(start non-terminal-id ...)] + + Declares a list of starting non-terminals for the grammar.} + + + @item{@racket[(end token-id ...)] + + Specifies a set of tokens from which some member must follow any + valid parse. For example, an EOF token would be specified for a + parser that parses entire files and a newline token for a parser + that parses entire lines individually.} + + + @item{@racket[(@#,racketidfont{error} expr)] + + The @racket[expr] should evaluate to a function which will be + executed for its side-effect whenever the parser encounters an + error. + + If the @racket[src-pos] declaration is present, the function + should accept 5 arguments,: + + @racketblock[(lambda (tok-ok? tok-name tok-value _start-pos _end-pos) + ....)] + + Otherwise it should accept 3: + + @racketblock[(lambda (tok-ok? tok-name tok-value) + ....)] + + The first argument will be @racket[#f] if and only if the error + is that an invalid token was received. The second and third + arguments will be the name and the value of the token at which + the error was detected. The fourth and fifth arguments, if + present, provide the source positions of that token.} + + + @item{@racket[(precs (assoc token-id ...) ...)] + @italic{OPTIONAL} + + Precedence declarations to resolve shift/reduce and + reduce/reduce conflicts as in @exec{yacc}/@exec{bison}. An + @racket[assoc] must be one of @racket[left], @racket[right] or + @racket[nonassoc]. States with multiple shift/reduce or + reduce/reduce conflicts (or some combination thereof) are not + resolved with precedence.} + + @item{@racket[(src-pos)] @italic{OPTIONAL} + + Causes the generated parser to expect input in the form + @racket[(make-position-token _token _start-pos _end-pos)] instead + of simply @racket[_token]. Include this option when using the + parser with a lexer generated with @racket[lexer-src-pos].} + + + @item{@racket[(debug filename)] @italic{OPTIONAL} + + Causes the parser generator to write the LALR table to the file + named @racket[filename] (unless the file exists), where + @racket[filename] is a literal string. Additionally, if a debug + file is specified, when a running generated parser encounters a + parse error on some input file, after the user specified error + expression returns, the complete parse stack is printed to + assist in debugging the grammar of that particular parser. The + numbers in the stack printout correspond to the state numbers in + the LALR table file.} + + + @item{@racket[(yacc-output filename)] @italic{OPTIONAL} + + Causes the parser generator to write a grammar file in + approximately the syntax of @exec{yacc}/@exec{bison}. The file + might not be a valid @exec{yacc} file, because the Racket + grammar can use symbols that are invalid in C.} + + + @item{@racket[(suppress)] @italic{OPTIONAL} + + Causes the parser generator not to report shift/reduce or + reduce/reduce conflicts.} + + ] + + The result of a @racket[parser] expression with one @racket[start] + non-terminal is a function, @racket[_parse], that takes one + argument. This argument must be a zero argument function, + @racket[_gen], that produces successive tokens of the input each + time it is called. If desired, the @racket[_gen] may return + symbols instead of tokens, and the parser will treat symbols as + tokens of the corresponding name (with @racket[#f] as a value, so + it is usual to return symbols only in the case of empty tokens). + The @racket[_parse] function returns the value associated with the + parse tree by the semantic actions. If the parser encounters an + error, after invoking the supplied error function, it will try to + use @tech{error production}s to continue parsing. If it cannot, it + raises @racket[exn:fail:read]. + + If multiple non-terminals are provided in @racket[start], the + @racket[parser] expression produces a list of parsing functions, + one for each non-terminal in the same order. Each parsing function + is like the result of a parser expression with only one + @racket[start] non-terminal, + + Each time the Racket code for a @racket[parser] is compiled + (e.g. when a @filepath{.rkt} file containing a @racket[parser] form + is loaded), the parser generator is run. To avoid this overhead + place the parser into a module and compile the module to a + @filepath{.zo} bytecode file.} + + + + +@section{Context-Free Parsers} + +@section-index["cfg-parser"] + +@defmodule[br-parser-tools/cfg-parser]{The @racketmodname[br-parser-tools/cfg-parser] +library provides a parser generator that is an alternative to that of +@racketmodname[br-parser-tools/yacc].} + +@defform/subs[#:literals (grammar tokens start end precs src-pos + suppress debug yacc-output prec) + (cfg-parser clause ...) + ([clause (grammar (non-terminal-id + ((grammar-id ...) maybe-prec expr) + ...) + ...) + (tokens group-id ...) + (start non-terminal-id ...) + (end token-id ...) + (@#,racketidfont{error} expr) + (src-pos)])]{ + + Creates a parser similar to that of @racket[parser]. Unlike @racket[parser], + @racket[cfg-parser], can consume arbitrary and potentially ambiguous context-free + grammars. Its interface is a subset of @racketmodname[br-parser-tools/yacc], with + the following differences: + + @itemize[ + + @item{@racket[(start non-terminal-id)] + + Unlike @racket[parser], @racket[cfg-parser] only allows for + a single non-terminal-id.} + + @item{The @racket[cfg-parser] form does not support the @racket[precs], + @racket[suppress], @racket[debug], or @racket[yacc-output] + options of @racket[parser].} + ] +} + +@; ---------------------------------------------------------------------- + +@section{Converting @exec{yacc} or @exec{bison} Grammars} + +@defmodule[br-parser-tools/yacc-to-scheme] + +@defproc[(trans [file path-string?]) any/c]{ + +Reads a C @exec{yacc}/@exec{bison} grammar from @racket[file] and +produces an s-expression that represents a Racket parser for use with +@racket[parser]. + +This function is intended to assist in the manual conversion of +grammars for use with @racket[parser], and not as a fully automatic +conversion tool. It is not entirely robust. For example, if the C +actions in the original grammar have nested blocks, the tool will fail. + +Annotated examples are in the @filepath{examples} subdirectory of the +@filepath{br-parser-tools} collection.} + +@; ---------------------------------------------------------------------- + +@index-section[] diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/Context-Free_Parsers.html b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/Context-Free_Parsers.html new file mode 100644 index 0000000..e0a8be8 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/Context-Free_Parsers.html @@ -0,0 +1,10 @@ + +3 Context-Free Parsers
▼Parser Tools:   lex and yacc-style Parsing
On this page:
cfg-parser
  top  ← prev  up  next → 

3 Context-Free Parsers

 (require br-parser-tools/cfg-parser)
  package: br-parser-tools-lib
The br-parser-tools/cfg-parser +library provides a parser generator that is an alternative to that of +br-parser-tools/yacc.

syntax

(cfg-parser clause ...)

 
clause = 
(grammar (non-terminal-id
          ((grammar-id ...) maybe-prec expr)
          ...)
         ...)
  | (tokens group-id ...)
  | (start non-terminal-id ...)
  | (end token-id ...)
  | (error expr)
  | (src-pos)
Creates a parser similar to that of parser. Unlike parser, +cfg-parser, can consume arbitrary and potentially ambiguous context-free +grammars. Its interface is a subset of br-parser-tools/yacc, with +the following differences:

  • (start non-terminal-id)

    Unlike parser, cfg-parser only allows for +a single non-terminal-id.

  • The cfg-parser form does not support the precs, + suppress, debug, or yacc-output + options of parser.

  top  ← prev  up  next → 
 
\ No newline at end of file diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/Converting_yacc_or_bison_Grammars.html b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/Converting_yacc_or_bison_Grammars.html new file mode 100644 index 0000000..5225dd5 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/Converting_yacc_or_bison_Grammars.html @@ -0,0 +1,8 @@ + +4 Converting yacc or bison Grammars
▼Parser Tools:   lex and yacc-style Parsing
On this page:
trans
  top  ← prev  up  next → 

4 Converting yacc or bison Grammars

 (require br-parser-tools/yacc-to-scheme)
  package: br-parser-tools-lib

procedure

(trans file) → any/c

  file : path-string?
Reads a C yacc/bison grammar from file and +produces an s-expression that represents a Racket parser for use with +parser.

This function is intended to assist in the manual conversion of +grammars for use with parser, and not as a fully automatic +conversion tool. It is not entirely robust. For example, if the C +actions in the original grammar have nested blocks, the tool will fail.

Annotated examples are in the "examples" subdirectory of the +"br-parser-tools" collection.

  top  ← prev  up  next → 
 
\ No newline at end of file diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/LALR_1__Parsers.html b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/LALR_1__Parsers.html new file mode 100644 index 0000000..ae20ddc --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/LALR_1__Parsers.html @@ -0,0 +1,91 @@ + +2 LALR(1) Parsers
▼Parser Tools:   lex and yacc-style Parsing
On this page:
parser
  top  ← prev  up  next → 

2 LALR(1) Parsers

 (require br-parser-tools/yacc)
  package: br-parser-tools-lib

syntax

(parser clause ...)

 
clause = 
(grammar (non-terminal-id
          ((grammar-id ...) maybe-prec expr)
          ...)
         ...)
  | (tokens group-id ...)
  | (start non-terminal-id ...)
  | (end token-id ...)
  | (error expr)
  | (precs (assoc token-id ...) ...)
  | (src-pos)
  | (suppress)
  | (debug filename)
  | (yacc-output filename)
     
maybe-prec = 
  | (prec token-id)
     
assoc = left
  | right
  | nonassoc
Creates a parser. The clauses may be in any order, as long as there +are no duplicates and all non-OPTIONAL declarations are +present:

  • (grammar (non-terminal-id
              ((grammar-id ...) maybe-prec expr)
              ...)
             ...)

    Declares the grammar to be parsed. Each grammar-id can +be a token-id from a group-id named in a +tokens declaration, or it can be a +non-terminal-id declared in the grammar +declaration. The optional prec declaration works with +the precs declaration. The expr is a +“semantic action,” which is evaluated when the input is found +to match its corresponding production.

    Each action is Racket code that has the same scope as its +parser’s definition, except that the variables $1, ..., +$i are bound, where i is the number +of grammar-ids in the corresponding production. Each +$k is bound to the result of the action +for the kth grammar symbol on the right of +the production, if that grammar symbol is a non-terminal, or the +value stored in the token if the grammar symbol is a terminal. +If the src-pos option is present in the parser, then +variables $1-start-pos, ..., +$i-start-pos and +$1-end-pos, ..., +$i-end-pos and are also +available, and they refer to the position structures +corresponding to the start and end of the corresponding +grammar-symbol. Grammar symbols defined as empty-tokens +have no $k associated, but do have +$k-start-pos and +$k-end-pos. +Also $n-start-pos and $n-end-pos +are bound to the largest start and end positions, (i.e., +$i-start-pos and +$i-end-pos).

    An error production can be defined by providing +a production of the form (error α), where α is a +string of grammar symbols, possibly empty.

    All of the productions for a given non-terminal must be grouped +with it. That is, no non-terminal-id may appear twice +on the left hand side in a parser.

  • (tokens group-id ...)

    Declares that all of the tokens defined in each +group-id—as bound by define-tokens or +define-empty-tokens—can be used by the parser in the +grammar declaration.

  • (start non-terminal-id ...)

    Declares a list of starting non-terminals for the grammar.

  • (end token-id ...)

    Specifies a set of tokens from which some member must follow any +valid parse. For example, an EOF token would be specified for a +parser that parses entire files and a newline token for a parser +that parses entire lines individually.

  • (error expr)

    The expr should evaluate to a function which will be +executed for its side-effect whenever the parser encounters an +error.

    If the src-pos declaration is present, the function +should accept 5 arguments,:

    (lambda (tok-ok? tok-name tok-value start-pos end-pos)
      ....)

    Otherwise it should accept 3:

    (lambda (tok-ok? tok-name tok-value)
      ....)

    The first argument will be #f if and only if the error +is that an invalid token was received. The second and third +arguments will be the name and the value of the token at which +the error was detected. The fourth and fifth arguments, if +present, provide the source positions of that token.

  • (precs (assoc token-id ...) ...) +OPTIONAL

    Precedence declarations to resolve shift/reduce and +reduce/reduce conflicts as in yacc/bison. An +assoc must be one of left, right or +nonassoc. States with multiple shift/reduce or +reduce/reduce conflicts (or some combination thereof) are not +resolved with precedence.

  • (src-pos) OPTIONAL

    Causes the generated parser to expect input in the form +(make-position-token token start-pos end-pos) instead +of simply token. Include this option when using the +parser with a lexer generated with lexer-src-pos.

  • (debug filename) OPTIONAL

    Causes the parser generator to write the LALR table to the file +named filename (unless the file exists), where +filename is a literal string. Additionally, if a debug +file is specified, when a running generated parser encounters a +parse error on some input file, after the user specified error +expression returns, the complete parse stack is printed to +assist in debugging the grammar of that particular parser. The +numbers in the stack printout correspond to the state numbers in +the LALR table file.

  • (yacc-output filename) OPTIONAL

    Causes the parser generator to write a grammar file in +approximately the syntax of yacc/bison. The file +might not be a valid yacc file, because the Racket +grammar can use symbols that are invalid in C.

  • (suppress) OPTIONAL

    Causes the parser generator not to report shift/reduce or +reduce/reduce conflicts.

The result of a parser expression with one start +non-terminal is a function, parse, that takes one +argument. This argument must be a zero argument function, +gen, that produces successive tokens of the input each +time it is called. If desired, the gen may return +symbols instead of tokens, and the parser will treat symbols as +tokens of the corresponding name (with #f as a value, so +it is usual to return symbols only in the case of empty tokens). +The parse function returns the value associated with the +parse tree by the semantic actions. If the parser encounters an +error, after invoking the supplied error function, it will try to +use error productions to continue parsing. If it cannot, it +raises exn:fail:read.

If multiple non-terminals are provided in start, the +parser expression produces a list of parsing functions, +one for each non-terminal in the same order. Each parsing function +is like the result of a parser expression with only one +start non-terminal,

Each time the Racket code for a parser is compiled +(e.g. when a ".rkt" file containing a parser form +is loaded), the parser generator is run. To avoid this overhead +place the parser into a module and compile the module to a +".zo" bytecode file.

  top  ← prev  up  next → 
 
\ No newline at end of file diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/Lexers.html b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/Lexers.html new file mode 100644 index 0000000..1748700 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/Lexers.html @@ -0,0 +1,138 @@ + +1 Lexers
▼Parser Tools:   lex and yacc-style Parsing
►1 Lexers
On this page:
1.1 Creating a Lexer
lexer
lexer-src-pos
start-pos
end-pos
lexeme
input-port
return-without-pos
position
position-token
file-path
1.2 Lexer Abbreviations and Macros
char-set
any-char
any-string
nothing
alphabetic
lower-case
upper-case
title-case
numeric
symbolic
punctuation
graphic
whitespace
blank
iso-control
define-lex-abbrev
define-lex-abbrevs
define-lex-trans
1.3 Lexer SRE Operators
*
+
?
=
>=
**
or
:
seq
&
-
~
/
1.4 Lexer Legacy Operators
epsilon
~
1.5 Tokens
define-tokens
define-empty-tokens
token-name
token-value
token?
  top  ← prev  up  next → 

1 Lexers

 (require br-parser-tools/lex)
  package: br-parser-tools-lib

1.1 Creating a Lexer

syntax

(lexer [trigger action-expr] ...)

 
trigger = re
  | (eof)
  | (special)
  | (special-comment)
     
re = id
  | string
  | character
  | (repetition lo hi re)
  | (union re ...)
  | (intersection re ...)
  | (complement re)
  | (concatenation re ...)
  | (char-range char char)
  | (char-complement re)
  | (id datum ...)
Produces a function that takes an input-port, matches the + re patterns against the buffer, and returns the result of + executing the corresponding action-expr. When multiple + patterns match, a lexer will choose the longest match, breaking + ties in favor of the rule appearing first.

The implementation of syntax-color/racket-lexer +contains a lexer for the racket language. +In addition, files in the "examples" sub-directory +of the "br-parser-tools" collection contain +simpler example lexers.

An re is matched as follows:

  • id — expands to the named lexer abbreviation; +abbreviations are defined via define-lex-abbrev or supplied by modules +like br-parser-tools/lex-sre.

  • string — matches the sequence of characters in string.

  • character — matches a literal character.

  • (repetition lo hi re) — matches re repeated between lo +and hi times, inclusive; hi can be +inf.0 for unbounded repetitions.

  • (union re ...) — matches if any of the sub-expressions match

  • (intersection re ...) — matches if all of the res match.

  • (complement re) — matches anything that re does not.

  • (concatenation re ...) — matches each re in succession.

  • (char-range char char) — matches any character between the two (inclusive); +a single character string can be used as a char.

  • (char-complement re) — matches any character not matched by re. +The sub-expression must be a set of characters re.

  • (id datum ...) — expands the lexer macro named id; macros +are defined via define-lex-trans.

Note that both (concatenation) and "" match the +empty string, (union) matches nothing, +(intersection) matches any string, and +(char-complement (union)) matches any single character.

The regular expression language is not designed to be used directly, +but rather as a basis for a user-friendly notation written with +regular expression macros. For example, +br-parser-tools/lex-sre supplies operators from Olin +Shivers’s SREs, and br-parser-tools/lex-plt-v200 supplies +(deprecated) operators from the previous version of this library. +Since those libraries provide operators whose names match other Racket +bindings, such as * and +, they normally must be +imported using a prefix:

(require (prefix-in : br-parser-tools/lex-sre))

The suggested prefix is :, so that :* and +:+ are imported. Of course, a prefix other than : +(such as re-) will work too.

Since negation is not a common operator on regular expressions, here +are a few examples, using : prefixed SRE syntax:

  • (complement "1")

    Matches all strings except the string "1", including +"11", "111", "0", "01", +"", and so on.

  • (complement (:* "1"))

    Matches all strings that are not sequences of "1", +including "0", "00", "11110", +"0111", "11001010" and so on.

  • (:& (:: any-string "111" any-string)
        (complement (:or (:: any-string "01") (:+ "1"))))

    Matches all strings that have 3 consecutive ones, but not those that +end in "01" and not those that are ones only. These +include "1110", "0001000111" and "0111" +but not "", "11", "11101", "111" +and "11111".

  • (:: "/*" (complement (:: any-string "*/" any-string)) "*/")

    Matches Java/C block comments. "/**/", +"/******/", "/*////*/", "/*asg4*/" and so +on. It does not match "/**/*/", "/* */ */" and so +on. (:: any-string "*/" any-string) matches any string +that has a "*/" in is, so (complement (:: any-string "*/" any-string)) matches any string without a "*/" in it.

  • (:: "/*" (:* (complement "*/")) "*/")

    Matches any string that starts with "/*" and ends with +"*/", including "/* */ */ */". +(complement "*/") matches any string except "*/". +This includes "*" and "/" separately. Thus +(:* (complement "*/")) matches "*/" by first +matching "*" and then matching "/". Any other +string is matched directly by (complement "*/"). In other +words, (:* (complement "xx")) = any-string. It is +usually not correct to place a :* around a +complement.

The following binding have special meaning inside of a lexer + action:

  • start-pos — a position struct for the first character matched.

  • end-pos — a position struct for the character after the last character in the match.

  • lexeme — the matched string.

  • input-port — the input-port being +processed (this is useful for matching input with multiple +lexers).

  • (return-without-pos x) is a function (continuation) that +immediately returns the value of x from the lexer. This useful +in a src-pos lexer to prevent the lexer from adding source +information. For example:

    (define get-token
      (lexer-src-pos
      ...
      ((comment) (get-token input-port))
      ...))

    would wrap the source location information for the comment around +the value of the recursive call. Using +((comment) (return-without-pos (get-token input-port))) +will cause the value of the recursive call to be returned without +wrapping position around it.

The lexer raises an exception (exn:read) if none of the + regular expressions match the input. Hint: If (any-char custom-error-behavior) is the last rule, then there will always + be a match, and custom-error-behavior is executed to + handle the error situation as desired, only consuming the first + character from the input buffer.

In addition to returning characters, input + ports can return eof-objects. Custom input ports can + also return a special-comment value to indicate a + non-textual comment, or return another arbitrary value (a + special). The non-re trigger forms handle these + cases:

  • The (eof) rule is matched when the input port +returns an eof-object value. If no (eof) +rule is present, the lexer returns the symbol 'eof +when the port returns an eof-object value.

  • The (special-comment) rule is matched when the +input port returns a special-comment structure. If no +special-comment rule is present, the lexer +automatically tries to return the next token from the input +port.

  • The (special) rule is matched when the input +port returns a value other than a character, +eof-object, or special-comment structure. If +no (special) rule is present, the lexer returns +(void).

End-of-files, specials, special-comments and special-errors cannot + be parsed via a rule using an ordinary regular expression + (but dropping down and manipulating the port to handle them + is possible in some situations).

Since the lexer gets its source information from the port, use + port-count-lines! to enable the tracking of line and + column information. Otherwise, the line and column information + will return #f.

When peeking from the input port raises an exception (such as by + an embedded XML editor with malformed syntax), the exception can + be raised before all tokens preceding the exception have been + returned.

Each time the racket code for a lexer is compiled (e.g. when a + ".rkt" file containing a lexer form is loaded), + the lexer generator is run. To avoid this overhead place the + lexer into a module and compile the module to a ".zo" + bytecode file.

syntax

(lexer-src-pos (trigger action-expr) ...)

Like lexer, but for each action-result produced by +an action-expr, returns (make-position-token action-result start-pos end-pos) instead of simply +action-result.

syntax

start-pos

syntax

end-pos

syntax

lexeme

syntax

input-port

syntax

return-without-pos

Use of these names outside of a lexer action is a syntax +error.

struct

(struct position (offset line col)
    #:extra-constructor-name make-position)
  offset : exact-positive-integer?
  line : exact-positive-integer?
  col : exact-nonnegative-integer?
Instances of position are bound to start-pos and +end-pos. The offset field contains the offset of +the character in the input. The line field contains the +line number of the character. The col field contains the +offset in the current line.

struct

(struct position-token (token start-pos end-pos)
    #:extra-constructor-name make-position-token)
  token : any/c
  start-pos : position?
  end-pos : position?
Lexers created with lexer-src-pos return instances of position-token.

parameter

(file-path) → any/c

(file-path source) → void?
  source : any/c
A parameter that the lexer uses as the source location if it +raises a exn:fail:read error. Setting this parameter allows +DrRacket, for example, to open the file containing the error.

1.2 Lexer Abbreviations and Macros

syntax

(char-set string)

A lexer macro that matches any character in string.

syntax

any-char

A lexer abbreviation that matches any character.

syntax

any-string

A lexer abbreviation that matches any string.

syntax

nothing

A lexer abbreviation that matches no string.

syntax

alphabetic

syntax

lower-case

syntax

upper-case

syntax

title-case

syntax

numeric

syntax

symbolic

syntax

punctuation

syntax

graphic

syntax

whitespace

syntax

blank

syntax

iso-control

Lexer abbreviations that match char-alphabetic? +characters, char-lower-case? characters, etc.

syntax

(define-lex-abbrev id re)

Defines a lexer abbreviation by associating a regular +expression to be used in place of the id in other +regular expression. The definition of name has the same scoping +properties as a other syntactic binding (e.g., it can be exported +from a module).

syntax

(define-lex-abbrevs (id re) ...)

Like define-lex-abbrev, but defines several lexer +abbreviations.

syntax

(define-lex-trans id trans-expr)

Defines a lexer macro, where trans-expr produces a +transformer procedure that takes one argument. When (id datum ...) appears as a regular expression, it is replaced with +the result of applying the transformer to the expression.

1.3 Lexer SRE Operators

 (require br-parser-tools/lex-sre)
  package: br-parser-tools-lib

syntax

(* re ...)

Repetition of re sequence 0 or more times.

syntax

(+ re ...)

Repetition of re sequence 1 or more times.

syntax

(? re ...)

Zero or one occurrence of re sequence.

syntax

(= n re ...)

Exactly n occurrences of re sequence, where +n must be a literal exact, non-negative number.

syntax

(>= n re ...)

At least n occurrences of re sequence, where +n must be a literal exact, non-negative number.

syntax

(** n m re ...)

Between n and m (inclusive) occurrences of +re sequence, where n must be a literal exact, +non-negative number, and m must be literally either +#f, +inf.0, or an exact, non-negative number; a +#f value for m is the same as +inf.0.

syntax

(or re ...)

Same as (union re ...).

syntax

(: re ...)

syntax

(seq re ...)

Both forms concatenate the res.

syntax

(& re ...)

Intersects the res.

syntax

(- re ...)

The set difference of the res.

syntax

(~ re ...)

Character-set complement, which each re must match exactly +one character.

syntax

(/ char-or-string ...)

Character ranges, matching characters between successive pairs of +characters.

1.4 Lexer Legacy Operators

 (require br-parser-tools/lex-plt-v200)
  package: br-parser-tools-lib

The br-parser-tools/lex-plt-v200 module re-exports +*, +, ?, and & from +br-parser-tools/lex-sre. It also re-exports +:or as :, :: as @, :~ +as ^, and :/ as -.

syntax

(epsilon)

A lexer macro that matches an empty sequence.

syntax

(~ re ...)

The same as (complement re ...).

1.5 Tokens

Each action-expr in a lexer form can produce any +kind of value, but for many purposes, producing a token +value is useful. Tokens are usually necessary for inter-operating with +a parser generated by br-parser-tools/parser, but tokens may not +be the right choice when using lexer in other situations.

syntax

(define-tokens group-id (token-id ...))

Binds group-id to the group of tokens being defined. For +each token-id, a function +token-token-id is created that takes any +value and puts it in a token record specific to token-id. +The token value is inspected using token-id and +token-value.

A token cannot be named error, since +error it has special use in the parser.

syntax

(define-empty-tokens group-id (token-id ...))

Like define-tokens, except a each token constructor +token-token-id takes no arguments and returns +(quote token-id).

procedure

(token-name t) → symbol?

  t : (or/c token? symbol?)
Returns the name of a token that is represented either by a symbol +or a token structure.

procedure

(token-value t) → any/c

  t : (or/c token? symbol?)
Returns the value of a token that is represented either by a symbol +or a token structure, returning #f for a symbol token.

procedure

(token? v) → boolean?

  v : any/c
Returns #t if val is a +token structure, #f otherwise.

  top  ← prev  up  next → 
 
\ No newline at end of file diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/blueboxes.rktd b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/blueboxes.rktd new file mode 100644 index 0000000..194e240 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/blueboxes.rktd @@ -0,0 +1,166 @@ +3346 +((3) 0 () 5 ((q lib "br-parser-tools/lex.rkt") (q 628 . 6) (q lib "br-parser-tools/lex-sre.rkt") (q 836 . 6) (q lib "br-parser-tools/lex-plt-v200.rkt")) () (h ! (equal) ((c form c (c (? . 0) q return-without-pos)) q (602 . 2)) ((c def c (c (? . 0) q token?)) q (2067 . 3)) ((c form c (c (? . 0) q nothing)) q (1168 . 2)) ((c def c (c (? . 0) q position-line)) c (? . 1)) ((c form c (c (? . 0) q define-lex-abbrevs)) q (1405 . 2)) ((c form c (c (? . 0) q char-set)) q (1108 . 2)) ((c form c (c (? . 0) q define-empty-tokens)) q (1866 . 2)) ((c form c (c (? . 2) q seq)) q (1665 . 2)) ((c form c (c (? . 0) q start-pos)) q (538 . 2)) ((c def c (c (? . 0) q make-position)) c (? . 1)) ((c def c (c (? . 0) q position-token-token)) c (? . 3)) ((c form c (c (? . 0) q numeric)) q (1255 . 2)) ((c form c (c (? . 0) q lexer)) q (0 . 19)) ((c form c (c (? . 0) q any-string)) q (1150 . 2)) ((c form c (c (? . 0) q lexeme)) q (570 . 2)) ((c form c (c (? . 0) q upper-case)) q (1219 . 2)) ((c form c (c (? . 2) q =)) q (1550 . 2)) ((c def c (c (? . 0) q token-name)) q (1922 . 3)) ((q def ((lib "br-parser-tools/yacc-to-scheme.rkt") trans)) q (3193 . 3)) ((c form c (c (? . 2) q /)) q (1747 . 2)) ((c form c (c (? . 0) q alphabetic)) q (1183 . 2)) ((c form c (c (? . 4) q ~)) q (1796 . 2)) ((c def c (c (? . 0) q struct:position)) c (? . 1)) ((c form c (c (? . 0) q end-pos)) q (555 . 2)) ((c form c (c (? . 0) q symbolic)) q (1270 . 2)) ((c form c (c (? . 0) q whitespace)) q (1320 . 2)) ((c form c (c (? . 0) q define-lex-trans)) q (1448 . 2)) ((c def c (c (? . 0) q position-offset)) c (? . 1)) ((c form c (c (? . 2) q *)) q (1490 . 2)) ((c def c (c (? . 0) q struct:position-token)) c (? . 3)) ((c def c (c (? . 0) q token-value)) q (1995 . 3)) ((c form c (c (? . 0) q iso-control)) q (1351 . 2)) ((c form c (c (? . 0) q input-port)) q (584 . 2)) ((c form c (c (? . 2) q :)) q (1645 . 2)) ((c form c (c (? . 0) q lower-case)) q (1201 . 2)) ((c def c (c (? . 0) q position-token?)) c (? . 3)) ((q form ((lib "br-parser-tools/yacc.rkt") parser)) q (2119 . 23)) ((c form c (c (? . 2) q -)) q (1707 . 2)) ((c form c (c (? . 0) q punctuation)) q (1286 . 2)) ((c form c (c (? . 0) q blank)) q (1338 . 2)) ((c form c (c (? . 0) q lexer-src-pos)) q (486 . 2)) ((c form c (c (? . 2) q ~)) q (1727 . 2)) ((c def c (c (? . 0) q make-position-token)) c (? . 3)) ((c def c (c (? . 0) q position-token-start-pos)) c (? . 3)) ((c def c (c (? . 0) q position)) c (? . 1)) ((c def c (c (? . 0) q position-token)) c (? . 3)) ((q form ((lib "br-parser-tools/cfg-parser.rkt") cfg-parser)) q (2827 . 12)) ((c form c (c (? . 2) q or)) q (1624 . 2)) ((c form c (c (? . 2) q &)) q (1687 . 2)) ((c def c (c (? . 0) q file-path)) q (1023 . 4)) ((c form c (c (? . 2) q +)) q (1510 . 2)) ((c form c (c (? . 0) q define-tokens)) q (1816 . 2)) ((c form c (c (? . 2) q ?)) q (1530 . 2)) ((c form c (c (? . 0) q title-case)) q (1237 . 2)) ((c form c (c (? . 2) q **)) q (1597 . 2)) ((c form c (c (? . 4) q epsilon)) q (1779 . 2)) ((c def c (c (? . 0) q position-token-end-pos)) c (? . 3)) ((c form c (c (? . 0) q define-lex-abbrev)) q (1370 . 2)) ((c form c (c (? . 0) q any-char)) q (1134 . 2)) ((c def c (c (? . 0) q position?)) c (? . 1)) ((c form c (c (? . 0) q graphic)) q (1305 . 2)) ((c form c (c (? . 2) q >=)) q (1573 . 2)) ((c def c (c (? . 0) q position-col)) c (? . 1)))) +syntax +(lexer [trigger action-expr] ...) +  +trigger = re +   | (eof) +   | (special) +   | (special-comment) +       + re = id +   | string +   | character +   | (repetition lo hi re) +   | (union re ...) +   | (intersection re ...) +   | (complement re) +   | (concatenation re ...) +   | (char-range char char) +   | (char-complement re) +   | (id datum ...) +syntax +(lexer-src-pos (trigger action-expr) ...) +syntax +start-pos +syntax +end-pos +syntax +lexeme +syntax +input-port +syntax +return-without-pos +struct +(struct position (offset line col) +    #:extra-constructor-name make-position) +  offset : exact-positive-integer? +  line : exact-positive-integer? +  col : exact-nonnegative-integer? +struct +(struct position-token (token start-pos end-pos) +    #:extra-constructor-name make-position-token) +  token : any/c +  start-pos : position? +  end-pos : position? +parameter +(file-path) -> any/c +(file-path source) -> void? +  source : any/c +syntax +(char-set string) +syntax +any-char +syntax +any-string +syntax +nothing +syntax +alphabetic +syntax +lower-case +syntax +upper-case +syntax +title-case +syntax +numeric +syntax +symbolic +syntax +punctuation +syntax +graphic +syntax +whitespace +syntax +blank +syntax +iso-control +syntax +(define-lex-abbrev id re) +syntax +(define-lex-abbrevs (id re) ...) +syntax +(define-lex-trans id trans-expr) +syntax +(* re ...) +syntax +(+ re ...) +syntax +(? re ...) +syntax +(= n re ...) +syntax +(>= n re ...) +syntax +(** n m re ...) +syntax +(or re ...) +syntax +(: re ...) +syntax +(seq re ...) +syntax +(& re ...) +syntax +(- re ...) +syntax +(~ re ...) +syntax +(/ char-or-string ...) +syntax +(epsilon) +syntax +(~ re ...) +syntax +(define-tokens group-id (token-id ...)) +syntax +(define-empty-tokens group-id (token-id ...)) +procedure +(token-name t) -> symbol? +  t : (or/c token? symbol?) +procedure +(token-value t) -> any/c +  t : (or/c token? symbol?) +procedure +(token? v) -> boolean? +  v : any/c +syntax +(parser clause ...) +  + clause = (grammar (non-terminal-id +           ((grammar-id ...) maybe-prec expr) +           ...) +          ...) +   | (tokens group-id ...) +   | (start non-terminal-id ...) +   | (end token-id ...) +   | (error expr) +   | (precs (assoc token-id ...) ...) +   | (src-pos) +   | (suppress) +   | (debug filename) +   | (yacc-output filename) +       +maybe-prec =  +   | (prec token-id) +       + assoc = left +   | right +   | nonassoc +syntax +(cfg-parser clause ...) +  +clause = (grammar (non-terminal-id +           ((grammar-id ...) maybe-prec expr) +           ...) +          ...) +   | (tokens group-id ...) +   | (start non-terminal-id ...) +   | (end token-id ...) +   | (error expr) +   | (src-pos) +procedure +(trans file) -> any/c +  file : path-string? diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/doc-index.html b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/doc-index.html new file mode 100644 index 0000000..3f2283e --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/doc-index.html @@ -0,0 +1,2 @@ + +Index
▼Parser Tools:   lex and yacc-style Parsing
  top  ← prev  up  next → 

Index

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

 

&
*
**
+
-
/
:
=
>=
?
alphabetic
any-char
any-string
blank
br-parser-tools/cfg-parser
br-parser-tools/lex
br-parser-tools/lex-plt-v200
br-parser-tools/lex-sre
br-parser-tools/yacc
br-parser-tools/yacc-to-scheme
cfg-parser
cfg-parser
char-set
Context-Free Parsers
Converting yacc or bison Grammars
Creating a Lexer
define-empty-tokens
define-lex-abbrev
define-lex-abbrevs
define-lex-trans
define-tokens
end-pos
epsilon
error production
file-path
graphic
input-port
iso-control
LALR(1) Parsers
lex
lexeme
lexer
lexer abbreviation
Lexer Abbreviations and Macros
Lexer Legacy Operators
lexer macro
Lexer SRE Operators
lexer-src-pos
Lexers
lower-case
make-position
make-position-token
nothing
numeric
or
parser
Parser Tools: lex and yacc-style Parsing
position
position-col
position-line
position-offset
position-token
position-token-end-pos
position-token-start-pos
position-token-token
position-token?
position?
punctuation
return-without-pos
scanner
scanning
seq
start-pos
struct:position
struct:position-token
symbolic
title-case
token
token-name
token-value
token?
Tokens
trans
upper-case
whitespace
yacc
~
~

  top  ← prev  up  next → 
 
\ No newline at end of file diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/in.sxref b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/in.sxref new file mode 100644 index 0000000000000000000000000000000000000000..667d96ebbb352e271cb7820f24f9f0f83a22b776 GIT binary patch literal 9818 zcma)BXLl1<8Xk>f$9CA5;1Fy~F_>ZuvIWMbBt(Dn$6igCp>fC=XvYgxij)MY<;}Fd2w^3 zdH(BK!2fh%3u#(~fWM3Xx=lNguuL~|w6Wsp5093FO5>?aIx>5#HdY(o+dFqdPcoZu zEtu3-77Fj4@;iC4| z_K4BG&}_H*BC(ihMcT|(YjmRs_=NC^$6|?iY9Lcu;aL5aW2H>1v?_m@k88G@{gM7f zi_JdMoWG>4ZIKykZ|k>~#1^#2S{GS{*=j^g!)R^z;~6ZZ8R%M>Hb#3=bUIy|rG>SX z+8S-G_J+1z8`P3oM$2kDv|ZXEZB)CU-Pb=(Z+aohbZ%v)t?0ATovuA(rJ|wgq%mZL({?8A#_d!%XYG#JcEU1J(dD+&nJ|*E zJ|h}lYYrMt*hr)YjhN-e&FIQuJKooUf1=T*HP%RKX}=LqEOjiSFFLC$vn3g`6Vd3_ z7t)417|ytk7<%+YHPH&o?x(m3d$Z+)O(SDPqjNhf$FZHzL~Fz_-EhiIrK|zNjSpMl zc*?Z~EGN36xw$#Iw8KbkX)!xR?5ydAs{5>d(O%d}rrj;nNT!o)(Uvtzn`>B_>o&7G z2jO8Ok+pj0I%OoSmA2Dju1bro5g!qWyJhLCFFj;EXXDHMcT24Jw?$(WPpwO zW21U$qqw_e;!=NHe~c`1iY)VrEa4){T%SdRZC66h7Gya^FQ0&G+5rkS$mu^X2U17a=05VSQDJD-;_@t5uVO0wTDlI6iSG>a&j#$D-4Y6B6h)z5XNz045mS0P_ z+u|@z;lbk2p>dAoW}Q@cbKD)YvjvG)r?V;3&5C!VogyDhU>tVS=qEeNJsP>!^q zfcKRMZD76W7oGn263ES6hM+=mLQn8&me;7TMv0HsRSRlXEvQghP~o5w0Ud!A48qqI zk*Wp3R0~Rw7KF#XQ%49^Fk(kU<+BB$OXl1yvr^)#DEI#0Iwo=y2sal+lq^L+1*!#2 zsTR}?3x}^O3aMHkmll-piK0hB$x=)tghgnv@k?0_*B!cNmj?;#yV#DYPx9&a!0rtY zl}MTbA(v{wJy$KL5EhXL@zwX`d|13qS@a!eB@*#;#>(V2rcYS(b;Dm$q*JO!jWQ{k zJ)|~;f_;H&YYPq~5jbJzzN>Ok5J5cHJviIx_XD+tQBUE#(469tHVOMwrJiP=1Gew5Q{8bRyq?;$Rici*DK-CuCyThCEXiuKy&z&k{cR)C_}WD1H%0p_kpJM zX-X!X46s0kk;GH!+&jRLPm?HRMaJ6XlX$Z zW7{?=LhMV`f{onhZLXC0^35R5ocj@(TsqV2+X+_ffTAJgQ}3 zkp){tYLIcS%m`=sflEbT2y&LV`%R)Ne4*6T6n^t=G0a>qo%Dm3dq6}!(R1JUICDix z+)#P+qkb-$Q_+lvV_DHm+T2O_wAl+HHpb$8RRSV_{ z3&bM(>UhQ$f07YDx$T6PbzV_c)qg6`a(b21hmAZR*V zlwP$Uw6q|~9koR?EosVwl;MgBv8dWvN}0dW32&AVE+d#o(4T`vv^Yo7XKD3-9X_Nb zYb;vrXL2{=Y0k2R=&Nkr$L39Be#py@azDEDX8&(*Q4pq~*lNgaKEVg1XpvrMb~;fz zINu{q@En=z31~LujkFT&A(0YhOhEFd3T(L(fkJc=G!b+VBncJ}Y%TD{y{aT?9lOPF4iBz=@luft@ZyEw}p-|{PoIm$YG~&C>qEd z;x6)BhiLgFr#i;Cg3Rw01js#%M2Q@Tt=!c*qCO>CU~3RB$Ee&;yg*3sRZ{~+8U6tmLwwtySca}wEUPr>^wZo zmzmtg8HHIiAeh`|BWZ53ri+$`c^RYS=e#_@c!e=e^h$zJF84mO2YJ0+tc&jZynvp@ zQk*owU3PycuxQ|6(j4Vf2Uz=n*ZX)aHYX-9jo=l6HwgL&E^zq#RB-F-iCa%_m80@r zJx|M}IZ{l#sJJq6+beVmm-_@I?m8DJ#z0R`Ss6VrL?;M7QYC6HpDZaXrsQfZpGr_qFpXe3g=&y`U#JG6W&}_(D9cPq zA=(9Bj0nMef&~Pvq+jUQw-MD&K)0@( z?p^tk%08r8>eoL@LUHFnEhBiInvY7MZ!S^Fxm;54T0veb2|5Tm3A!j$x77PWbrZEJ zfLcXVPXN_J)an3gHBm1FP%jX*CV*N))QbVsi$uK?K)pnBSSu;aVI8&nGQleZuM)gQ zo8Wc7{*9nbP)&i~^b6NhjJF8hCU}S7U8?atsrL=|J)$-QP#cKq4WN1}`_at%lEPvm zs00rUHWi( zUxB6MvXiB|{y_Q^Nq6g1$ez3umG9-8`xy5#9$-AER}MgTNbx$%>?q?A#-ohK7>_fa z&}p70^HF>QJ;^7{d>bVCmLq(h zCz0kmHO==N;fK7)m*xj1e+(jjWb&sV@+T&L4kCYM@|Pg;7bbrVB7bG_w;=L2CVvki zf9GLrE0L!HhVfa6GV^UE^nh$vL_35C;+>4U7v^CUv-W7qwR z2N(}B9^#OP^IpD?hfC-YIg%$4a#XnbL`OKn(Y(k<9%b@a5P6Kr<3Z$c&V3?JBKJuz zx5xquzOp9LSWe}oz6wrpoYO(%X`aFvp558J2%*n0d!F$E<3+|xT>s^~moM*S4tXU{ xBIH$ey~cQ*@do2f4tXo@$=gBXZO(TmPa@x4j(d;sKH~$%hb5I2{{`D! +Parser Tools: lex and yacc-style Parsing
▼Parser Tools:   lex and yacc-style Parsing
On this page:
Parser Tools:   lex and yacc-style Parsing
6.8.0.1
  top  ← prev  up  next → 

Parser Tools: lex and yacc-style Parsing

Scott Owens

This documentation assumes familiarity with lex and yacc +style lexer and parser generators.

    1 Lexers

      1.1 Creating a Lexer

      1.2 Lexer Abbreviations and Macros

      1.3 Lexer SRE Operators

      1.4 Lexer Legacy Operators

      1.5 Tokens

    2 LALR(1) Parsers

    3 Context-Free Parsers

    4 Converting yacc or bison Grammars

    Index

  top  ← prev  up  next → 
 
\ No newline at end of file diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/out0.sxref b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/out0.sxref new file mode 100644 index 0000000000000000000000000000000000000000..6cd0df7f70facdfa474c536d68b026e8ce74424e GIT binary patch literal 709 zcmZuuu}H%4-2kE zno2y?m}jW{!ssbCf&Ob6M;R8VMIyxu`Xawm!?8+*L|-dq{HH-RVR!dq0#_O<;`c8^ zlsLxxgY-!@L#{IXEPL{WT{@!$GJN)_$4S~xoo3UhNz`dOp65{xE`exU-zX)E(^Qku z_L;JNqnZZZM#XHEvl9^OE?FMShV3xqFa(heovzH zn7A4f$Hb0_7?=1O8oxtt0p?(PVA-3Mh2X)AWh<+z;X`;l`h$H|b%bKzO_Dn3#`=`I=Av%|uK@$9zo8{LRnAM9e++y_fm2vZU?^mtMWR z@7#OOUEX_H^pe95JyEx=uA#2+=}?*fVbTbNBB5EKHKDbkrcg_$Gqfx8Oz7EAcj#c~ zc<6NKa_G&_?a-ajz0iZuKZgD(^v|K+LjM-}Yv?~h{}cK@T0PU4Z7ek!jW(mpc+Pmi zIA)wMP8)9+w~RZ+55|4tAB^9Oe>MKy_)p`%jIcS$oM+aUtIf4$i`iwS%wBWQJYXI+ zkC918tuT`1I?&GbYceYBV^ zWO{nCc6~Zuuvcm(Z9^1*Jn|tlP_Mv=ld^qI{ zbi6o_aqQx7Ds6YUYx8}5McYYi*w&ZH+AOv;Yag_S?AD%aDmU1i={=aJ-AOQ+oGla; z+w9?DCY#T-La>lnwsR;oNK2(PTl?*tlj?7B9Ak!XYlC_u)+Y{c&lL0VbUx=4^4aaf zBe}FQl7b_~RH=u6nOy%47li2X%xBjV#$)bN!G)b8m-EF$ylKnk z-2u?{RBn{H?8xMXN5EOZ>2NX*5s*$5?ZoD`+{ln!$fS+wCAf^fb(o@H7n+Oq{&w{| zQDaQ=(I9-?=05LKBk^FT`!!3%ZgXSTlrMCQ3=i7{wxlDQe^CyNsRi2^DdgfWW}JaM z8(nOwso5$B=zvGWHWAg}i&`8zJz) zdSA`z%%yJAh|Zg*ilTnN8Op|o3wh$p$=F5Ij}hy&$$^-dV58! z9B5#W`SV?nY|0_~{w4~9N>EJGm>tkobVezUq#CW#3&bA9(yMf1VPNf0z6VuU$mbo2 zKq}@2#Oy59XHJRe?WEUE=X-5k$&$co@J_@aDD*6?6orkNfGBm25!n^WtT2rQ`ifpV zn;NxyH9;_KhK(v+iX%c~r|sU60s<7YV`)HMkXA;xgdJsqB#8B!Wioz8HDljC3#WF(c*#Gjhp{nh)`x2^ED@deC<2DB(z;YHR_@rRc0N`*+f` zD9vZi>?z2irFzU~i}h4?$na!!G#Y(s(AhgWbcIZqXjUwzsfr4k`h6C-veVn0 zJoz=k=ecvsm`II=w@pvl`Z(NOQ>lIL5E?d^)`ZGVY)ZvCv<6M$voMh+dL?Eb5zc%P zjxJbGs&X`yP7~wtVtRneENYrHHDIq?IA9v!CJVSTn$uG><@2@i3Qc`KjU`8qMkh~J zv5Jd5SzEL|Y8VOa`-w<29H#9@oBB@bUPpva)#j^cEOku7wDi2jo1X3sXFx&*IFog|7D@uRS@?%c);fLLT(~*Y2TMITBlk1PA zVw}W8rr1V#O9hTJZq+C`NnR$~*^7N3n!C`xvA8H($$PsQR!n6kbq z`q&spD-H1n87P$Bveta=0CwYCe-g|j^Mzy&r9>{dt&kcTqBDr9OqrDPG@xgr4?QH$ zmZBfTVkIF)4~!3IY3p0r(12!$)iPmUpbAH1sb(uHMTmz|=|Y}}@J>{k{Cfyb?NtJp zZ$_%AwLO7{G85B%W`tloZ(?R7S!*sJtF2ag6p6$r5yTuN9J^>*(TNjd%FlhMbm`ju+k`fMKTHpL^J%f8(gVrP zQVP2~v})3yb1zUCF9}06FQYg=jT=wVgIF$xXccI9iszF|o5WZYomOrKRQp+1zE|JR z_Qkb|Os0}tk+M#9XewS~6*8``o6+ghDQ9SZcjD~@+m6Yw$c2|AW3aPY1G!?#G+d4} zBsz-eR4!*1gjaA{>({k(0v@j{h#oe!NdA^N)q9v)g2u`2QcP}a6&2nUNvwqJb(-z( znAA^@g;kB!CGNgwk_l`}Z0}QTvE6h`PdWKQk#b5J#vQ7NR^{HlsF$i6g{I{sTAs`o zy^=oGa-%L6EPb#O}9-l$Gb3TPrkz$LTo@KVOG^g9a9Dh zwK-eQ1SP`lkB;o6w)ixXqo6q^e8zC4=l&|mw^sF}x0-6py+vw9zZH%yTI98{F`6;~ z)OyNRQwGXwH;`ogd~c#Xi;K0U;AgH=*_!T}GShEyS;*O|VR{XsT{*?hEA%0`*T_Z3 z-F!(>z9ijzq4R7F6~^zp72K+&UFX8INr^1$wEI)(Q7zHvD1iH}w{R^imkVDGQ|Hd& zxQIz<>ow)Ug>d;JIL>_0M;`Gf8XY6qf@CwlwGfAjVltKMO?F`q(kxh~S@5Zey#w!A zD0&JpA$vg;_X0Xupcl}7>N&9<@eyw*sFc_PbsHB#$QX2VSuh*D;U*fY?s!vcs+;Lp z6nw#;3BMnvS}ya3LqJ2}7Eg-Ro#tb`131Cw2}U+r~e>Umt18oE?K@xEnhk2a=<_g%VRXQ=3W9xy9G&$DztBF z^e?L`G*;FsJx`3O=Ly1w81zhHGwEZ!xu+6;@Uf{G!K1zSn1_$w(Z?q7Y=Pj*THsM= zEtGQ$wYiv_iv@{&*5~+XH~+20n%!>U@GSUzl#GZYWY!Xiy+rEMig2k*!s8lP2?>t_ z1d?E(0$=88JX*_LjAdhEEWs+N{kYs}Qjx!NEzD|`te8LyM_bs9#! zoU0Eq(CAt(YQ1b4G{9g;!uloj#cfI8Qr#6@BvI{Hv(mIGb*@&sGNLt<)rQ_>K@!>) z>Dut%pbN2vM*_l&KV}hsFfQW1R^;bp6U*1)<7*y%V+z*SNp{u+8BX{ZUN187N$P&0 zpf-pl0S zrq=5#wGi5=Bw;`&eG%!}CDPT#(=L4c%-Q+}k*tj}(2Y>Osge_Fx18H8=U~4)Wl&y8 z|M!e-2)A!Y!VswR#pooJiH7)%M=5bc;3DiErI-a!2Y}eVr?m~@X?P?z2o1HFq44bY zWkE3u(B&@ZGt%j2;I#Dz!NhZN^0^=rO|FJNY8t$d;4EYP5g(95a?Qq<3lVlA(^I7n-kRCxh zygr0kw2XDG%Lk?H2Q_~V$+<&8e`*;Pw)~x@z^mk1euNK5Le(^-szIPOXo_BvieAzb z1#02X<{r9Q(%X>j_(52f3pD(hrg6rgG2W>?;=VuT7iqo}Iqak9h_`M1rK}g+_x=JM zEQ+u+D>tm8rnLH~Da_X6aZEP8fEUMU6#!3%H4l!PSIo!?n&rUyE?XyLzMWFqPDyR5 zwE-s36t}qH5hK+Uw{TNr{R;1N2_7EKbC;hH6a}wP{6nUCBL*p~^Da?kt=j0qijlHv zquZ(jbkWIz>AJu#3+XY`oCjTa_a*4!lD(+>xv2bsUnv7B5Byg>s8@YM%NO0(=*|RF(Dj0_Vsnzn?sxBV>STm#-3iv<3;OC=+u{3PI8(M5TC95>!(Hy{f)R=^Do`MWCQ@0JO9fZuyU z1Ju5!l%YjfH>GKPdeA@h+%21xXS^)9EYaS_|>EPZL z$J5w&8eGKB72@ZNs9o;>`Gsfi9UZcSx;tzy3&Y;6c-=Y9Pc^DdLj&o@!4tzT$Ig-gAa*X@;0vFv6&Fg#@8)8p(D)Y6-Aew#~!AoNi$*hj>$Y>Ph<1`-Pce7g%y$s&^r0>@a)%PP#B zkP^rF*$MtUi%+_wYgtEoxT=qn;}~+1*RwDTsevJS)}0Ewr@XRpp(B`5BZqSPJ55Sq zu4t%%JfKF*ejX2N0X?HTqg(MlSpl%~v0Kw|B=dj%r2Lc%YzDu z1f}p*F%-4n?JGQupONskbc~Min)LXAo++<|>C}pUM5LWssr?B1?o0dh40>H=5bbqB z=vpu^R-J3_b=}^Q$XsXAA&bz=faSWTn_k6$A4*w8!W%lMM*>eHyYSPIdvriX%k%FI z58_SV(0~4Y%deQWe5LqpU2%ywZ?iWn40rG=n`;B?uXj=283*MZMu99qcDNvc%T$u+ zhimiz=t+?^I)Cr__qq2(;ON~tMAynJ!`fRal())+@&Ymp_rY`l)j8Q|X{i(`Wu@6B)|T z+q$78(Z0?8vM~JJ1eT{)aGfVHhye%n}XJu?um6!Bv1Kr=x$%42|959k~IidPc!TaGZ~*D_^yBqB~C)G~z7 zhh+j!g{u@D6=x78we;e6l$EkD0)`))#3p|%BEgSEgwy)Lj$Uubd(ZK4u#Yn~WC1-F z-ud1)pNRNgmYno|Jw;xYrI3zP^7tVi1Nb!S(oZ2zO8cJ-#_X(wrYZ$QV1sCJ-4i4A wUaQ4@+jd^sAl_h~XXWMYF8dVHN*ErO5hjPbq*bS}B57sUc3s(SV_7z3IcXEumAzX1t|Iv-j`Le*SuXXoOPEWt zBxOql8ni%x0tFHvhvt-`$Do%M2vD>r(B6swx%JWl1#-xx$e{%S^je@9&fDQ5H}b)H z@6F#g-^_6K{9D#@^VjAV=C9t@4*9o(Z@Q*Ep*^K7YCSE`V(k~&FSS2vf71S<{Z;!| z`$YRx`?vPFHl{c9Gy0-_Q(w|=>yDo4Kh@vSf2aRJ|49E#|F3=oYXle{%@SDovmH2U9YXx9@L`RXSp1Vi0Es zSYhNRHP4+JbwE|jB0Kf^Vn7M6P)=I|_o2u^P~OcOOE+(6!_k{8y?s>driA} zWhqM5dWjqNeXkuvkB7x==PC#vyJD4MH<#w-^vQ}-399V|ao_EV%=gTrM~StWK~BS3 zxHk}q?`@S-F?)t*NFmP4hm{d#BVGF4fjNd2-aND$zOvT??bEk4!b^&=mzp&9i4$ zqVSPOGJK~|bE3rQ`e_t88;Ls@;KZ57j%~NL?>Sc;8bE~m(?UEx=eQs{Xd!d)@(Fkqq`j|srW_{vI zl}MY{H<3NtLw=Gd&`(qyVXqFGto^v}XCjSVPw0)20hA5aytJAF9*8v&r+yHHhsG+wwcu8nJrj?)3X1JD5jYSq7{VPsK!?6*b->YWalV8IbmmbWqZ zN(YWQ@WdRT2KxAF?&HZ092+W+ci<^?qzDsAI;oCRd~CpUDL?~`D-S110t>#TAf04m z3r;EZ)1*!@zpfO{sN*-3E+UZ`&A?fua84aDn#}1ue3SgOB z=@Rk=Tws9(h=z?34YM{|Qn%n@>DGWbR%^f|_A|=aW!AC4E*V=euLM`vn3&|q3#`z9 zt4aa!aP_4>#{5jhJC=dfFc2S~WtY@CGEf5$BK69*D;}_V1#1?3M_E2cf}Hc&5ze1i zN*J_ceN9pOU8RFP#K6!eHwT(=O4nJT0pH`J1=yabvj{i%iP&F+o0X8wikreIw+y#G zhblow>PWgo{^;0JpsO@54}mPgN+o)!msTr+H3b^Sl`F7547oA<+pgF!Ih$-?0Xk({ zWQLE0M+-0?A_-wp1}~_%7z{;{`7PKk-Dp&*0_F$H#Uw`d%!4sL`BZNJlGbTQ&Esr;sP6l&2WzSxJ=T#oiF6= z%y{s_z$gpuX#P1>w4)qeBt;sad&594souM2`QU~0b4N2(J?dZ6sE zL)hD!nkVU6ma!8JQ@5Ryb{}>R}(qVz1Edz+6}#cQYeB&PNN7|3&Z!D=Xr1 zM6*)ku>c!_*}zXY)91qq2VCMk9>hr{K>mBT3~ zDRw^xLbm0RY&kRBGkLVpO)cAxy~*N#xrD?9E8%Y9<24Rt0RmwPT!pmg`37L)vI3eF zRM2)Q-KN=l17zE9(m2d)UsT=#Y(55qVfl!yz6kgsU;~6v3V{n9Z&X~VPyvT~52YNn z_#I$Du{~%kI26{KqhM6|O1~M3fEJWCKaM1;mtN(Eij8rTl#Fp!OL#Ef(oL>6#`@;i E7t432?f?J) literal 0 HcmV?d00001 diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/stamp.sxref b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/stamp.sxref new file mode 100644 index 0000000..e769a50 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/stamp.sxref @@ -0,0 +1 @@ +("3b7b1bba00241dab306a03c51c1a0d3cd638493374bd6fe4f9796aa4f48ec21e154a911452939887" "2db07a7be06a931a970c9ee101e90228f9c1c6fcd9676e52634e35fc448a283a7429a4d38e6a8c1e" "d8d3930e051fde87175bb0f52680184b782e2377") \ No newline at end of file diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/synced.rktd b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/br-parser-tools/synced.rktd new file mode 100644 index 0000000..e69de29 diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/doc-site.css b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/doc-site.css new file mode 100644 index 0000000..e69de29 diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/doc-site.js b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/doc-site.js new file mode 100644 index 0000000..e69de29 diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-fonts.css b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-fonts.css new file mode 100644 index 0000000..dfd3739 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-fonts.css @@ -0,0 +1,343 @@ +@font-face { +font-family: Miso; +font-style: normal; +font-weight: bold; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff'); +} + +/* Miso license */ +/* + M M I SSS OOO + MM MM I S S O O + M M M M I S O O + M M M I S O O + M M I S O O + M M I S S O O + M M I SSS OOO + +--------------------------------------- +MISO is an architectural lettering font +completed in 2006 by Mårten Nettelbladt. +--------------------------------------- +MISO is available in three weights +(Light, Regular, Bold) +in TrueType and OpenType format. +--------------------------------------- + + L I C E N S E I N F O R M A T I O N +--------------------------------------- +MISO is a free typeface. However, +there is one important limitation: + +MISO MUST ALWAYS REMAIN COMPLETELY FREE + +You can use MISO for personal and commercial work. +You can share MISO with your friends +as long as you include this text file. + +You must not sell MISO. +You must not charge someone else for using MISO. +You must not bundle MISO with a sold product. + +Use it, share it, but keep it free. +--------------------------------------- + +Mårten Nettelbladt +Omkrets arkitektur +www.omkrets.se + +Stockholm, Sweden +July 9th 2009 + +--------------------------------------- +If you have any comments about MISO +please let me know: +miso (a) omkrets.se +--------------------------------------- + +November 27th 2008 +Converted to OpenType by Torin Hill. + +June 24th 2007 +Some small adjustments + +October 23rd 2006 +Released +*/ + +@font-face { +font-family: Charter; +font-style: normal; +font-weight: normal; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,d09GRgABAAAAAG0AABEAAAAAygQAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRlRNAAABgAAAABwAAAAcaEQHBkdERUYAAAGcAAAAHgAAACABFQAET1MvMgAAAbwAAABRAAAAYIwffPhjbWFwAAACEAAAAaoAAAH63UMlG2N2dCAAAAO8AAAAOgAAADoGwAWGZnBnbQAAA/gAAAGxAAACZVO0L6dnYXNwAAAFrAAAAAgAAAAIAAAAEGdseWYAAAW0AABeIAAAs9xP2KaRaGVhZAAAY9QAAAA0AAAANv9DC6JoaGVhAABkCAAAACAAAAAkB98EJGhtdHgAAGQoAAACRAAAA6DwhiesbG9jYQAAZmwAAAHSAAAB0q+xgpZtYXhwAABoQAAAACAAAAAgAgcBU25hbWUAAGhgAAACZQAABlmMUhFncG9zdAAAasgAAAFtAAAB+tWbg65wcmVwAABsOAAAAMAAAAF2cYil1XdlYmYAAGz4AAAABgAAAAazdVHdAAAAAQAAAADMPaLPAAAAAM4DAEQAAAAAzgNj8njaY2BkYGDgA2IJBhBgYmAEwudAzALmMQAADjcBGgAAeNpjYGLcxjiBgZWBhWkPUxcDA0MPhGa8y2DL8IGBgYmBlZkNRLEA5RgZkEBBZVExgwODwm8mpl//hRhuMV9heAdTw/iQaT6QUmBgBADr+RASAAAAeNpjYGBgZoBgGQZGBhD4AuQxgvksDDeAtBGDApAlxFDHsIbhP6MhoxNjMGMiYwVjHeMkpuNMdxVEFKQU5BSUFNQUDBSsFFwUlZSEHjD8Zvr/H6hXgWEhwzqgHkfGIMYEoJ5aoJ5jTDcUhBUkFGQUFMB6LOF6GP/////4/8H/B/73/2/4X/g/9b//f+//Fv9Y/359cODB3gd7Hux+sOPB+gfLH8y7f/DeJYWnrE+hbiYRMLIxwDUyMgEJJnQFwCBhYWVj5+Dk4ubh5eMXEBQSFhEVE5eQlJKWkZWTV1BUUlZRVVPX0NTS1tHV0zcwNDI2MTUzt7C0sraxtbN3cHRydnF1c/fw9PL28fXzDwgMCg4JDQuPiIyKjomNi09IZGhpbe+cOG3OwgWLlixeunzlilWr165Zt37j5k1btm3dtXP3ntsFySkZd8vm52U9LslkaJvBUMjAkFYKdl12FcOyHfVJuQynGBhyqu8xNDRPPXzk8pUbN69e286w//gjhgcPnz2/U3791v2mrsbujt6+/p7JUxgmzZo988Dpi/lnz52vuHThDABeipnsAAAAAAHhAp8ALgCaACQAKQA1ADkAPgBCAFYAcwAfAFoAdAA2ADsASgBOAFMAWgBeAGIAZQBqAC8ASABRAAB42l1Ru05bQRDdDQ8DgcTYIDnaFLOZkMZ7oQUJxNWNYmQ7heUIaTdykYtxAR9AgUQN2q8ZoKGkSJsGIRdIfEI+IRIza4iiNDs7s3POmTNLypGqd+lrz1PnJJDC3QbNNv1OSLWzAPek6+uNjLSDB1psZvTKdfv+Cwab0ZQ7agDlPW8pDxlNO4FatKf+0fwKhvv8H/M7GLQ00/TUOgnpIQTmm3FLg+8ZzbrLD/qC1eFiMDCkmKbiLj+mUv63NOdqy7C1kdG8gzMR+ck0QFNrbQSa/tQh1fNxFEuQy6axNpiYsv4kE8GFyXRVU7XM+NrBXbKz6GCDKs2BB9jDVnkMHg4PJhTStyTKLA0R9mKrxAgRkxwKOeXcyf6kQPlIEsa8SUo744a1BsaR18CgNk+z/zybTW1vHcL4WRzBd78ZSzr4yIbaGBFiO2IpgAlEQkZV+YYaz70sBuRS+89AlIDl8Y9/nQi07thEPJe1dQ4xVgh6ftvc8suKu1a5zotCd2+qaqjSKc37Xs6+xwOeHgvDQWPBm8/7/kqB+jwsrjRoDgRDejd6/6K16oirvBc+sifTv7FaAAAAAAEAAf//AA942tS9CXwcV5UvfG/1vldV763eW90tdUtqqVutdmu1JMv7bse7YzteYxJngSTOBtkI2QMEmBBCQkgCzGNmqGopyZDhGU/YZkIGeDOM5wFvGJY3kIYwAwNDCGDpO+fe6tZi2U6A3+/7PrDUpWpFfc+5Zz/n/osI5OqZ18kPhE8TK/GQEqlZCMmrOnu95hBIniregkLPKLaianTVFSd7UX00T1SHTpIVqdrd09fbVyr6vB5jKqnrLXo9Jl1Kl7k66Q8kEgF//IQu3B3WBbrxh6RwxcqVYm76DvrOBIH/CaSDfoLGhJfhs72kiyjmgiKXpgQ9MenziqNIFV9BIWdUvaeu6EXVRvOqy1NX/fDx3T3u3hJ8mIumspnK7GVHe06IizHhY7l2mnDFBeHDPT168d/+zWko9tjN8Mo/d+lMXfiU8GXSQmL4uaSguv2lkkp1dVUKF4uKvqC6onDDADcsjiKsJF5QE+xzK+VSJQVffhP78qbYV7YCXyMU3lr6ZPcTf7WlsOGxjYX193+k5+nJrYWNH95S2Dz2wdKf/ajw/sLP5e/+p/RduDgr/gz+Fd5PiI70zzxG/0v4MUmRdlIgnye1JOyCEiupRl1dyRVrSaM1P7k0mbDka8YkXhoFuHTBDqkB+I1ssRZw4e2AB28H8NLlsMD2dRcUyxm1FRhI42ckVQjVlVYRKakZ7ZlisTgVD5Fn9fmaM5CDn5S4qHYCl8Oe+qQn3GnOq+5QXe2BO60W2G19Ve2Mw6u3SlRjEi5IVQlIk5ZwptDqryouWbXL1SpjUYz6SlKm3NsH195S0e9NFWgm5Y1SkBOTN1XOuD3+spO6h2m5N9vfJVtK617Yvz1nHt3f6XJ1dR/be/me3M3Bywqlh3oHrw5+6kpHkBpyD0zsd61e4Xt8r1f67/C21SuPiUeO6OnrW2M/sg5N28zLurcniIHEZn6lK4M8W4gEUhUjafIRUpOBn7UoinbSUK+5gXE1HXJPNNSnzPaozpFXzXAZTLPLoKFOlQyTPatcV6yi6gQeGODSIKL0qwm4TIhqK1y2yHU1C69OqyQ/pzOZBdkLzFBbE/CjOxCMRD3wI1HNsiSrvpZqVRWDkjxpIFYn3Ecx7mPKk8xUPKViuTeVdNMSTTfvymKpKKZim+/ZvOm+TcvXb9y4fiP99ND0VhqYvUW/fdlVV1128KqrDv7VX/3l2RuFJ88e+LJ2h0rTz9A9BGWsPPMr4dPAlwTIWC/5EKnFkB1pS70WwougsV4zIUuKuvqULMVMjrziKamyEVhRZqxIOutKUlRyKEh6dx2VJOfGW2oB6LeAZvbBayEnyc8bTUIs3WZHqbBIShboD4ZAXsJVRZKmiCOSzOJbsqy0VZWiNCVY7PpOxo5KbwWlhhFv8vdVChTkx2Q0xSgITRZMDLDJVypWska3x+fvK/dmUklj+a7Nxx6/dGLdX3RZ5cpXV4Yr63crnYf27z25Z8vStSPfWJ/p7L6s3NlW/uwNgxtXLd+/benAptYXx3rd5rY26/7VuwztgeK2ay6f2Dn4wzKl6Yl8597iQAV4RtE+kXcx+5RA66SZJqrYGnaJfdkXGiRuheJUeLTIrI8J/9bxmWvpHcLXiINUSU2PnNYZ6/CXVCuy2Mn+oskDm0BQfU02S17RFVUX2lq9lSkbk5aK1wlK5PN7u+jx9999ZO++Q3d9gEZe+q6Uk08/r56Scq7vErb2GHxepfF5Rvw8E3yeo6AS7fN0IN3weTorfp4OzIVi1D7PSODzrPB5ftTPTLbM9TZ2aN/eI3e//wN3HZJOqc+flnPSd1869V0X6Fwf3Uw/D5+lB61zEjcJkA5SM1GwYWKJKsGCYj2j2t11NQQCYgdiXtCZBLNL9ARQN4AssKRZ/wj1m/Aq5a/EaIFW/C7aN3Gl/vaY/pC14Mxm40677aB+PHHF8q7bhAF5ud2srtxkupFmhoZu7TZtWhl6fEJeYma03wJG/kvCVmIja0nNiraUFBQTGHgzqHCxRhmLqQ4tpB0XpwhF1SKBSBdrFsYOiwkMqdWCl1ZiyasOvsXlhFSSEt6ElJJuoeZ+app+o586q9Qx/cvq9H9RJ352dmY7+QY5TlxkiCguYLejrugKUxYb8aLoiAVFAGZI9Zpgxz8vuCz5SSIY4UMk5L0OeW9H3vcN0RQqA/eupuyJpWIilMntW32P9yqb1BKM9naPHeb0FsjXqUhl0PIk82bUWscvijpKaH5K5yIWPViwhgfzFr7/9fFxLidrwP+/TK6HnWsnNXPD+zcuqGLFCEA1gN/HLxv7E32aiqaSazK96XSopaUvnW4JpeHvzfzfmafpK8KTsBaJ1CgLImAV/KNNYNvCzH7tFX5/Vs98cTvYJR3YJRP8/mqQGvxgm66u2WcdrEBmKzD76opZs8S+uupGm2sGU6oDY8NMrGiDn6jeQJgl6RNhiaIxqUN70Sdmksb22759223fTq5aPrFq1X2r/4KufOGF6b/+a7r7kUcfpW2Pfhh5cSl8+yqsxU4OarywGJnECLgYKojx05r+OAqKDSyAs17T23Ab9SgwNj1e2qgFv5thR3GxeliWIsD6CPhQ+KlaVajEdthdrpQksGyJ8giVLv1W2H7FtPp2u7A0N3r2EZchlzdKQojvUQ6+vQHripF7SI3gulps9VoLE+OWCHyyF9dnNdVrVi/cI1YXinYcwqkzqiMAWi+qJlhKwA/mhUUHJhBqJSAqUTTmEYgKIgU1Cr4eIgPVAa5KaakqJgk8vRJBs03UFhRLWlWskmoKoJMvlYf1zPyavGiWZ+U0USl5c+t2HuiJrxgu5LyBUPSmXfuvfuKvaafcOTK89tKJ9dkVGwNvc0VDlW1Ht+147v2XPMNobJ/5b/oa0NhN7iW1LqTRDFJg7kJ6zKCqtVakMQQ0hlrxXihmyU95nF2t4LA9JtiSnoKSOKNGQEwiPFjMg8PyI4EZZ10two0IOGWI6WAH/NILRrNTTLW2dTHZQUlS8lXFI6lt7fB+SFYyzB0BVRjLFLmrMZWLs9deY7Lhq0zMQAIb2uMB0Rlr61y2c+3KcFDn1K/ZONFfzknd0Run3vbBLXseuOaSaw76IoZLArvHB0f1A3TZ0MCKyKWOaKB30561N+SN2ya2XTfB9KJl5jtCi/As+B4HuYwwCUQrZiypNiuzVIQJHrHgVjsxzlPsRdUMHllXrJmZ6TKDValZzMygoRUD466aLZo42rQdFSTFwYI2WpIglEU/W5Ja6CX911yz7vXXXxqlH5++dPTHPx6lZS6LxZnXaR30O0reRWrh5j6Fm/sk4j65bfUpnyMswub4IMRw+HARDiaWsYLiOqN6wAJ6WNDqkUEWPXzLgrBTcXj1uGCndAbYCZs0aXT4wmyXHLhLwarikxTPwt2BDUHL7G0mI5liImhxtSWSy3d8o5KgR6b/d7V46Ib337jmwCX+qG6bfdfyDxnp6vV/Jx7fdvBdVZ4XFMEWOcDfS0DdpaQmInVeCLBbwEtbWMSjM9cZBeCsZZA0WVQDqDLasgOgOpNWl2jG8MYBYRLIGuiOV5JrxGGuQvSn0zP2a64cgheTtmAtstFky1j8X3+tO/kh/4bdu66//2t37F23YnjTxqVbhwTqPV2399//7qGb9x2+7/H3XH/r0Q1rd3d6YV9WgLy4YV8sZILb3SmzlbRAbG+mTBYI8t7KVm4J1SHPY2IBG8YYb0FpMMJiKfJYx6xTwgtRF02YVtBXpqe20OXTr4j0N59sO3uTTzi5m8WUHTM/p78V/hIyxzjJk/08zlYDJi2UbEfr3cE+0osBI+piAnIRr6hm4DOtcK8F72FWh3lHBoNmkyAHog623+0B+Jnora5o69zoUDM02jY32ZaFfGI2KOy49/Jr9+48Plh5+PYjx29dd8nKpet3XFMqZDZs2ThW6Z1QT5Y7Tmw8fOnq4vZI8abN17xtz9imVYOVkVzLBI32rIj2bhtcvozJRH7mFYEIf05EEiGbCXdLLSATzgI3O1FGnwTCIHFhMIIwxOBVApaqFmsVk6Sazmmvoix4nMy9Ky0SRFlVLgeMHsGU7avMBrgaFfl7rrj85CvP+3+8dOvY7msvXbeif5l97cTwBvo/j911z8kPTU9PdF3xyez1V2zZmSp3HztxANa7H/z5v9HvEzPEYYU5Ht0O4Zgqo0f3MGNBINhzoXNjft07z69DJt8Uy/3p3gx38ml40Rw9/XRLa2tLKJPhejMKMU8dPtNFQuRyUnPjRwXt9UXCn5aCIp7BQNMHn+0TFTtLSyH0EgoLgiI1DDwURFAovcUdRIUCtQ9ULxAhuWcXPXpilAVLl66OaQufFzQJaxrLp+R2khZOCwViJMRdTnsd1Hu7MDIdoK9Sqfja8Fe+PAL03UIU4Uv0GZB4E1DIIiwzMwcGNAfmgmrRIquENw1ftwirzr4grFKq1b+BPZ//GZVyJy0bvLfTV6cDwkh65MtfGX6tiDysgF19DPyfD3KNA6QWx30L2bU4SAYTK+vQxMpe1OMkCz+sYn1SsgWc4NlczTQVxS8FrzZQHkVGj13TheJM+GRIwlSjda7YsWwchS1PTSB98mwxp7J5dN81u/aW37dq3NhmtA/uTPgDyWTAL6zP9h3cvPxY23Xv77t1fPVBenaGV3eAhrUzR3VHhSkySFaQ50kthBlApKROQBBVLai9Osw/FLmkZsx1dQQMaidwEKOplUyHeiCr7hFRFNUhsBJDoppDhwVhySqaV/pCLw4f/8W3iDdvdSqjojJ2Wk20vKHET5PJeGJ0rAv+R5tXytIQVXNDkrzUYnDIoWhnb6XKXUgvsKCvApZ4YgQSVTPxpnI9IkpXSIJAh9mYYcp4YHLSVHKI8uiG3fRXSkYXNXrnaKhJ+8kPv5bNpCGHH6FZ1Ny17xv4+LYnPrskfaxn9aaxvuVLWo/2FUpyn1XKmv3uzvzyj77z6Stu+eJT993qfOL9n77+aprY0ltub3eal+//9Vfe3Tf4mfdetW3J6DrL1h0r963tqbT4A1v+IuVxB3q33Hn9Y4ferjzz5VXJHde87eNXjf3jEuFdRJj5DQjRfcInwXd5yCiPElnKA3m90SIWi0UmSVMOyBLAKTvQNHsLWi2PAlMEA7onjP3Qt6bKFXfJ7QfhAHpSmH+7Szpz/0/Gfj74w2HTytdWWEcdLx9ttwvXnn3I3t5ucH7+805DO22nXvQLCVhLF/gimYRJljyi+QX0pBRiExToLMYMeGHU1adiIdkMa4qhKLSxxNQNoVsEVuxmuSmEMWCuFDe3ry4/GBZRsaLlSMJ1Epyzv662w1tJN3hauzfEpD3kxRjCBVRlgaqa3pqE24pRUgwsfIWYu0DLiWIzess2A4ly48qYSlQlqUpm/v19Ow/c/a5DrbEjlz6bHXAEL935jClrA7KFrNPY9vFrs/SS1fsOF3Xja+42Fun4ypt0LFbKQzyxFnQ6AvlgLYg8kMA3SkGkSgJF5sptg3s2HUsdTKjc3KM4IW53Mm1QTGAuRWaq0a94nUhXEEmUgrBdfgySsBankxlpTLW1iluSi+eIUMIoPdtF859/fNcVS1yOauWad99/U0de9C05dOTgio176cbHP598bLcceuzdD33MIV71RKqt6xm0S7iX98JeipDVL9diImnOTmIBEmjGLB82TnIyP+hhBogl/LBKkcU84AZVg606h/lNNcuW4hKaIMbt19XTt3Zfu3nLBiq+594NDR6rT0zuaw110eT7H+ZxKK6rFdYVIS9pOVGAryrAIptAC7CXRSEOtsCaw8RCUCtkDU4/MYG8OUEG/U6868e6qdOPl05J2wIgJgDEOEAKWcqkI6xCAlkTUqdIRSyOokxaMXwCS9xisZrBa4nc+7s93NFbJcVWVSwYtxI1QDgn/BKEWBA1Yjqin8uRBG5bylsaoSV2JSXwirGF/tsSp/PHzzithYLV+Qy1O6XeBm/ef4nrrHPV/1npmn5VPPw08CbI8sUnSQv5DKn5kDd+MMGeIosLVRMwhBRrJhYXmvTAELPkow4eyEssXZCcwBCzxAJHGzIkXFCCEPICQ0zFmswEGD1RLSjjZZBgyhv0AYdk5oWwY+AIscRTD8zQAVMiLE5mUaaiRyUEwfCzeF41QcyphlqqWtTJCJ9lAav9AXuyQfq9isvx/QYLpBW/B74IN7Q9vs81/YZz1b+ucs0QMEKcK039+wjoX5I8Tnj5F/VvEaWb8vlZ5dcHbAqCMKfmqiCWGsJOVgcIM4MUDgKhYcipQSlNhZopzBgJ1LOKsBuIrOlsUbQ2kENbkNAor35CBNNSVW1Atkqc8LZOOp/GVsqs9OmiDb196dndh5e44D96+933X9+1RFrx24p0cvvhFZv20I1Pfi7yJGjuh+9+8CnHNzgH/pOrr6YnfwuykCJPaV4hyL1CoCWJXgF1RJFKqhFuWUQ3NgXsMaYfdvQRrUwT4kC+rViLM4bFU0C+GfQiPlcv4iJuMeiL6nPWa74IvudDRsnFWoSlf5EQ/CQW1TQahRj6HJ0PrLPRjnUR7zzDgIQnGixoSkCCVUtQGX45LNEd0vAvtevpT0nDDWVoMzpfe42/nv0WZwbW5+CK240UfIsDP1wQo3C7AcxQnJwRyAXFUmRlOiDbDpTYGc12l0azfQ7NrGI3f9VsrUslaelZ/DZnTWwt+Pn2mV/Rv4bP96FP8BLuAmtGb7Otg4031Q7rcME6/Kz2JYCgCSJGmaiCNZll97ILs3umfxY7yB76RovQ6M94eX/GLrEmndaSAa/WXCjGePYlARDW5YPS+Nlh6di1w/ZPvtOhv/wqepSvefqj997ZlKG3w5rj5GZNhgJMhlR/bHEJCtuZBIXRoycYKyNcgiKMm5G4xs3IXG4mUS4omshQVQlLF5QOqeTWrliQokt554hG5rvGJd8Y+8cfrnr286vnCcb0L6gLryy/nX7R0B6ljv/ETaFgJwnksU9C7HSZJhN27kvspLH588VDXigeFnTmc2VDsYus3iKKrFZJVDvRMv/5ZKCZaxmRpJFfVaUfzLHpKDJfFU8+z/gPpks3xvj/QVJrwfU5PaUSsrfmEIOoxWjYsTZEYIHmImN69IzqF8HDRZmHQ90TirUoc3LRFh5R+UVVRk8NdNiYIGHVEl2ebGtIGO6KKqPFMhgx5CBhjKXcviqrY7IaDVptIGKBsupSulnTHf3m506dGbHbR/5zzPqz/P+Vh/5pUHaA6W6ZttL/is1RVaH37HuFI2e/6za3t5vdQozb8RDI32eA/iC5m9Q8KH+OkuoFUmWNcjOjXDVZsVcbKij+M8j4msioFd2wOX6RsQE3R+ROyQG/4NA3goKa3tGo46otWLYVMSZ2MpKxfqO3uzjJWnGk5J3dxNQs1dnQ5+gl8uA/Dspj03fKg/80JMtAZnCa0DOyBQRPPvuMsGTaPpc8VmP4uaAKCsRYLWQZqTlwhz3goFibKIhVhjCvMgRZdOXHtCjIXapfgnU69LjOIIQcqlmrKlTQpTSymKxWJRFZTeHI7jtu3320lHt4+507jx47efCykycvO3iSbnz24I4dh565avvKzdsOfeK+p56ino89ydcH8QSrLXlIjJwkNReuTzSy4IhVxiMsopgy+10CDyMaxWeQLMVbbAgXBhWzkqXYRNYQwmo+1p1DWCg3Y68UWW+TQfkjIHc1twdkjPNcS02z3ia73bM1s+D/feTO+0/6e3lc8LZu+ZJde/cnkf17rj5wveFLzdBg+rRh25aNawVOW3Zmo/CcoII9jpNbNemylVihmbE/ZgIxK7Ao0iEqLsw6RM2swY74YUf8WrzrqyNJEW1zUG88GODEMD5X9ZCUKBG55pBZYGCWVJeImxYLLbJpRhOGAOj6y1200uxgZC/fc8ede4596HbDvR3FdUtP3f5nx286eOjGG//uRrrpEwe3bz/4iQf+xnuDrV181vM3D9771Me0DYQYfuY3wnth/9pJibyhWXA/s+BKW5EnJt5GQlZi4fJUqiOIOVkK97KXWbuMk80iZJjBy7SjwcvMNXgZ3gjGsL/M8/UvkNee4fl6XFQip1XR9oYin37xb9/4+RDctk1KouzOw3uT0XjEnZ+M4fca3IzfF78vZQTPVK3BO/ACPCTPy3FRikRjXfx/dMHPLOMvZIDfDuBqRxCjCwcwuiTVDNh0mZfzoV5AxEfh34AWYekgyMKiPkiWTpMpLR8hMzfd8PHVETFoFCsDls7EsoQUsIkGz8QyZ6tUXR0L7N62c193w27v2HNHq6cQepsrH85YIq5865A4VBD+A5PjXXR01doxtGeDEAP8EuLSLnIXqXWyGADEzdjZjAE8uBNhuBf2sIAzgDF4oaBIZ9SYrzHMIdWVGA8Kcs76ZCBngfQDLL7aDXdiEhvYUCzSc0aHJ9jayaofxk4eFYBzlXLAHI+s+OZFB72ZbAYYUV4YkPqjej/XvcEBu6Nj2YqNQ5tF855177x8y/ZelyvTO7JqeL2py5uKODoeuOG4R3m75B/rKxdTRn3b6mXbjoc/sk/yjlUKpYROtsheR8fYrquAD5BMChMgl25yJQFfi8kaiKRVy1Mknrixa6LHvgarXYLWuUWWebF+Bvgus6uRqNRcLH1x2TG+mM09sLqpEgdqmmteltHovqVcVBTKFafzMXl8+nfj8mNOp2B47LG9rrNf1cxG2bWXx49ByCk+yXzxTYSPTlgsde6FROaFajqXXCw2fbARFmhkPtiI3ZEoG+WJMp0RcXRA9YIf8rLQwSvDL9i9jZCDmRC7EVYdDFUbDURPrOFwMYZbGNKZjHHcPsiV/ntY3rrv0q3uQfC0UsvI9PdGWliyhFHQh47u33+UHuQOafoDI5via9cmNo7QtzsJnanP/E64leX7HdzSc9qsGm0WO6NNKmDkAGtysYyuu0fHltBC+cQGOH9/vd/2ueesw18Z/tHET7UPNtPfYGhjBx9/NfISmwhPslj46zwWrkkyBDYl9pE1k9kB1/xj7S72sf4ChrloW17a8x8vo21RvF1OxXdaNXreUAynXxzq/Fkv3jYopi6IWMyK8bRTdZvfMCie0y++9PWfDbP/Ru5SPW6z4ob3LGF4zwz/4Rs/17H3JPh74mnVbDGrFvMbTsV6mjxvMFqsotvXMD1LHQajyQy3JNnt8TZuz9ohyAkkjR2lWY7YaEr3vRHz7U8tf+ZG2/jXx59c9uefGP8UcsbsnC4K9rN1+s9Oe1ub8+yfCamz/ypczuRt5nXQkQPAoxgZ1Cy3j+dv3kAUIz8c7VBcJSyk1sxOqThnWk01YJJlY4k1FvR0WbYqvzZWo2vU97C8Zxn7++fGfjFovvMhS/8rS194adnZcdODTxjH2x00SFscsH32r73sAImxTv9u+h/s7e0m5w+/Jxvb2Rp/CWvcB2sMkB2k5mbRC+ixVFxUdIIFxXdGdYFauFha6EKp9zEV9kGkxmICl09rRxHP4vLl1TS3rHO8WrV++FOWoVeGviEumz67TPwKEzbb9M+ozWlra3NMT36f6/A36V6QOTC3QgvL/96uxfpWcH1WFuhbHY1AX4cTCKZG9ZHlg8YzqkFkI2AOnD3A6JEVjxyEz26oDgOGjNjwcUogO6iyVt5kVU04LWlhPogmXDSFvTVW2umkN0//t1us0H+avot22eS+dmG549KP5M5+znHDc8ze3D9zCz0pfJGYSIF1HmCfsfNAjazzgNbQ4K7XDGz9Bh3PpHg7wo/9XPi6/2dPPHGXbmX+rCMHf88x8zT9dWM+g8yfz3CXaMoxRP9iSHjyrB5+t2vmZhpqfLaJjT4ouoKq1z4bMlMjfDZlJo2a+MSS9tklKVWGr64nnnjttV3CL/O/fwH+3t/T53UR4WVixHkqAlFFaYrqiRkbQ/DXzc38jxVFaMmdypr+nsxsn+48O02fp57p1/75nxlPyIyH/mpmPdDgJ7ggYq7j1xxKvAlvgv5q2l7rx98/JiRph/A9+P02/H38UJueEQ78mxJc+BP7D1Wqa4xalfypYwcPFIXvneJxYm7mDfoq/SnkYllyh9b5ToKHDrDymqFekyivrdVMUmOCa0qXDksQRekMvLINmxWDKMqJ7tsaYO67lTKueT28gt1qleRJKRROYkvCK7GqYRqjYC/BqjYXJCdvfle0OYTZ8QuWhswZkys7ae7WT2bL6eyE5DyxZ8NyufygY9/EwMSOfLpr/dt33rhqoi0+VBK3OuTC2LK1098VDa39oytG052dSrzC6TYDA38DvHNCFnCF5qUlrFgguX4IjrEb5qg3hqoE1BbIwBxnsK2LswgOV0NLFBePlC3OOsuxXA5eDvVITNcxlQElwRK9vjEeo7Wj8lSaE+mbb86sWrrzykcevm1LLHDZns1rUmXho7HW6VdT7zxy+93CR8++j+4/uvewyGQlDfv257BvLWSXVoP3mEG3cfVOsEpO1lVzWrQiJ2mWsLErboQ98hVZSG+TsKrnCfIurlZ3Bz0nvmpjFEFLTsqzRTw2GpO+6/IVG2JBn98fHN28Z/3Ska0bjtz8i6vv6+sIRFybnSf27jmW6+25F3ndOvM65FnfY3nWHY1uOkQXThYaGbRlY7aF6gJMNzMTZbZq4z7YaHey/jpLrMBnqjYP5PahZvoVYulXCLNclnOxHonM5ixYpTICW1KzEbHapMpfTmlzSqnyrGRJSGTre69t61l3U0bq/sDa9VtO7Ni8rLykL7l23/dPPmL7XKz17E4Qp96hO27cfjhFt4vXcHlKz7xOT8N+eEiYHNZodDR2JKSrT3ktMpZivWhkInwIF2cGitjg9PEGp+IqqlG49FlxUxyy1tjB5NGCBBDMrZj+GOdsjikxZ1cqJd5hT99xePNldPpzu9ct377rsoO37P5xX7Fn9c+uefDyPR6bbd+V/ZXBe2ri0NINKEsR+Har8CrI0rFG7dBQV0JFLNPpS6pHV1eNsCtGVnYwNgrnujPYwQkAEe5iLaBrdCfguw+TqGZ3Ab4bYF8iaIc8EPYppkbSAjvQaHObssYIVsZxQyJleenSa3YlO9p3j97/gDTcahDpFXGX7aaHE4GsbTD6zlWF6Q/AHrBZjbaZjECA7xnIAQfJGVJzIMMHjPVJl2PAzFrMSmtBzcFLoKBWkPtDbHCzFxZO0GJl3fVJQy82OUJyXQkXlV5RrWKW66lPdnqqcD8u19VhHp/9Onb6ixhP6ZUwBFSQ/PW0vKF0nyaT4Uh3D4uiavyCJW69VjZ1oobAhdZMfQO4e1XpuYCjNVfpR1PokVWXjKoXyOH+GrChrVQkYJEiy5NWT2+VTYj4wSpit7aRwgCjuPkAhYxR7POZ5s2MFCgbGin29UJ63VYtWbur48d3VJc8fCJ8+TbJJuzfvWFw03Xb9m1cOzi6taP/QHtnuG9HH/zb2T1u8fsyVcem6qo94UK+uGyHzy/4XM5K30jP2MSmjsGRfCZikx299Iol4+NXj7O8D0IjIQn6HScf5h4E61gR0Gu7K8RiOdwSr3VRmwrZROwMkyKwqYFYs8cVY/IT4wN9LA7BqV6r1IxnJGujo8MSikCMG12JG10v5NeqNVZdxOw2i1rM6DZ/ct+UubI8OiGXv12QuiqFUbnwnT6J2d+vD65bM/0jEDgUREulOzGt8h+EQ1z3sfauh3jCTrxYR2pqkK3IpoUhC2YTlgZHHRI9VcRhFR+rPViAJIuuUeqGULJZeDAUFZ04KekcThBhFzsdolrASU6ZXKLbw8bMJcVa5bGwFoJxjWI2TYcTLzgxkipLy9+ekfueSXYn4R9ScBxI2gIECPcFE8nuBD+zMlObyZBXgAYZrMA2UrOwKeeCZpDB86k+O6/XGc4w42tgFtdgYgUvbVzD7QJbAKmMi9fwbCD1UxavLxji89Cm3oof0jq2RszpQGLdjXWuTx8or3hHxpMe3BpPf4Iv9plWcUC6j07Cek/sPdo+GtUtb6yYy5wIMhcht3H/h2lqyFBXXX6QOFw+Hn2ALZjSe4IWMLx6x6LyFy0o4TMYp6D8eVnLyxuAvQizfDWMQTDrToe1+UIPFracYYhZzHpWldFEq1TR0lU+05/yzpEr94dNnaeW3qssffw9/bNiFfu0U59Om9/3G0Mm8dL/mJUoXrc3Am12sr0xr2vAmsFi69cmdj2LTeySxWZ1Z7WhscKWmzJy9ScDbFXMufGF8Pp8FWxrN/lHTap9KTxPZABvFkimC63+Ys3GwkMX3M5Z66o+UiwqORHdBZtcBRnv9GDpvtbJxLyzG8W8c66Yd4rsoEkcKIhnG324WpY14bKtFiykMbfvhl9wM4/vRv8SYi3LkB9IxBnYTh1zLEqW9aXjuDE4+uIConOgIVPuUCzbgWpjhBzGUZ2rLzhb6V9gGeYahsYP0T4JJPRI/5rUtf2DExLYCXlX5zK58M/d0o7uMalb063K4Pj4hlWz9uJo01w0r7Xeh5AF3jKbyfJfmXG2JnliaDPNlBds9VbmifUaT7WuE+fpbNdpbssJeBrhIQVEqudJRtFiRjSW+ZBlRNUDm+C3w1rQYVnIosUMJ2fJlb1jE1Lfd7rBbHYvncOHxaxmM1b6NdCOs3yrtNl4u1GLldjRHF4Ps/jqioXXw7CajhNULpDgSUFnMrLCn2zHFoaBNMI6bkuabhDDoFfuvOvlOy9dNzS8bt0ta39x1f0P/J8HHjix7+qr9sMXrsUP8YMe1uInSfJn2hxICDNnyjtPcUsdy7xsyBMNuB/SMgPGbaybLpxBuVRNAdgxt9AUToEJpwDCqejZgE9Em6ZljXSBTwtEIFlitXIRJyoFd5VJrFxV9HLNEWFTPQYM/sD9z9uG2VbBnNzBz3Ziw7ItV77nqkxFWvrTx7rTq/dsHOsaeB6UeRluxx3Hrn/I8knYA+oRT+y55GBS24uM4KSvsfm8G3mfgDUJ2F7EjGwg1AUE24tsPA97A07WGwCXDMHSBbwyTuvhKISq87DkAmefrVKTyhgr2WqjAjwkdwpNGVsYk6c/dPvQZipQufyTEWnt8I4rd21akRgsRNbv/tHJhyQx6daf/QdJ39qql15qfdcNew676HW2KzU9oydhf4PkxBzPHNAUzMEVzF3UOiC2elPTQkzTfFzTfLpG37+m883RNJbv+bgiwUaiCuks3uoC+1LhZeem1pRl2KvuAbMUjcY9scKwtFzTmUuLBcGxLbBq+gdcVfCMBOjKUVh/lryH1DK4fqyIGViLwsCOS+JG+SDelVw+szYKCzm5/YwadM85HxnkZyVSEOy6Uyb8xRBPzYPYidZZ2VTHc3qLyxfNMN0yZHhRXZZq9mgKpdGHUy2srO5noeWcinq2WVDXaQX1XLc9t63UWZ0Y3HPJeLHHnE215bNd5lZvxJ45uGOV/Y5LAp0rM6FYf/fYat81K7yZZDTr00tW2RJdsnxjoyZ9lo4LwxBVXU5qErMSkJhjdYidYa0ZWFXcoEc/CAGVhwVU7LSTp3HaCScgPCys8qA3ZGGUR/OGdkzMXdi0Upyga1jRQs+I9SvMRGaTqrIUHMunH300UYynJ4YHO+izscje44Xp3wz2mNO+rgrVzhyFZn4tRGCvQuR92nySCbJclgpKYNkFTeL4gRvFXmJTxNYiGx8Ocice1DcGj1AQLaBj7iK345amHbcwO26xacPE+iCPfC2S4sPjqqxTZMJKo1hVCI6hVxsen+vT/MS3LIXekSkU+4ZBJuXCB/YsH52gn4ylp5/r643SLXCxHmRxydj6NTSANdHfwbff0e/PraNTrRhqeCt1dMO3yvbrbjP3qQOfWfIU/Vw6rRenP0tXiBgSTa+lz+NnTUP8oYPP8pFPajMlkoxVdBbcOUraR55bQ9/3H6cWqaG/9O2fhXkNXYb77tOqpUWrkYuvnTmnRq47T43cZjBqJfJ5FXKtPq5bvD4uALG77x66/gjQu+Th4RvfM/xujeS/oe+cvoNONMi+efrdlM9G2OHbr4D2+fVxw2x9nGr1ccMF6+NohbTA1D8vQtXq4/bqe+8e+pcuw9bd5u6pJXc9MvjPOcPeI4Zq2vy3X7Cl00brnbc5jOm09TNnzOm0yfzB99lNaVYbn2F59/dB1nNkEREACUCxRgEFKZAWlwLs4WNa6++r6Ciw6OSt5r5a/9+1ru2OZUL7O1s/pTHp72mFMyi0bXMsGA1keg7TGq9508+w+fx3nKfmTc9f8w6B/WAVXoMFTfnFy98ErCQ/W2RqhEc0pRW9S7zobfus01agl0//9F9ctlKR3i6uuz8z/Xbxkke4fRiduYl+XPg8SZOtBFIpNQTuNVVgB2btBdWqHc+OsYMEfjeWg2p+lhH7cbDFVsRAmagpzEB8MT5n564qdlk1iVzFMR4Yor19A9TrpBEKSVYUX3x+LKbCG2ilRy3SeHn3UcfqcnX18qHOzcHja/smdCK1d9CB5UcuWZsWSuObNm50ievXbNlQptn1l1+yZpCy9X9nxkODwu9ZfVqrMqs6qc6+DI3avPSd4dd0r/4+AL+/FOh9qkFvmtfZIwU2tMmjCkav7gzYQDXhZnUkXYJtVJpZbk5vBMMjfYIdb8N41QlhhLvKj/EisZUufMlkcY4CiUWrnURKkQF5unRz59Dy1dXyasfR3eVxyaIXdRN9644H9tHyhi1r1ouujRs3jZeE9NpLjiwfoB10cM0ll6/n+7WdfF/4Kb0WZPw3hA1LmOvY5gmU+HkpLt5ocX42/NI3+ESAX1Q8p1WD+Q0wHi/+4oN/+yy3OIEu1e8xw1tO1SK+odhOv/jT33yhgtMCIHmTZoPVDX7JZp60sCuD1Qxx76TVYnPnX/zpR76wjf2iX5z0+j3u/KQPv7O/FxAn/QH4oQZ/gU8X4HABvI/DBd4qWWoxeMBa2bw+f9NS0aXW5s3AAgPGD0nSqqoLMveBzh4dfNSoucJsly6V3H50W+8uQ8QRFH1e64YrL9udKzknEr2+dd8fXREXrAazXi+sXbpcMgSsNhZjzsXiGOIxJp9WNdvZuD5ksHhuRw6yYXB4YdmLbMPGNjtqZvZo7QF+vsPDSwc4yg/BRvJqPKaByBwCQ+U4IVzrTya6E4mz/x5MoHnNiSsb+BhP0G8IO0mEtOLEGbY4lJYSnsZVEsVagI1SBUJ41i/QGLBSXAUlyQErdMWaixkMF3bkjcwJG1nskWaaEIXYI8pzVV2iWFSDoTqrVWPo5eazw54QztnhKTEIFgNsplFxsSF3Iy/iVOZAS2QzeSoV0bCAFIPFZiMzfslJl159oMs5PNEpJjpMhbTYWVlv79p/zbax6sDSXx+5Rzx8mf+RY57pw+4rH/UePOy489C64yL9kPQ2LtN4mPn3sBe5Rt451cbP0/HY2Fzn+BuYAoVc7ECq15KfMpqIy9GE7kiAr8kXFP0ZCI3VlIedaUixwCWFWB76FCtEsNKvHg85pPgJBxyzbi+qHVitS8Heulj7vw2dVTpTrULaoZ3PL5VRs1PlUuOEyvwWBJY/vR5IeUoJb3q8Y+UKIduyq7h8eyLkklqCYKw+97lDQsFLe6ruvYdThZz7poG2noG8P6a/1HLFzQm54Hh8WGdYq/W/yKeFsvAc6HgrOUIwioiamFW24HxamiUBLWJdaWH4IqoIm4qH/Fog5lepHoxSQpo02bzsJJcoq05WzY1i2uMNwrspaZI69TKDjAA7zc4JjNBMbyVbwZqDv+LHA38mvwnbW1mTm6WumLnmDufzh1OH+8cn+g+lDuVy8K2ycnnl8OqdS0d27bxt59cPVe+pHmo93NFxuPVQZfnEEriG/4Ial+7a/c5du5iP/i0QWBCeJBnECmEzHS1Glvuc27+eisVD1MGKEDE2Uz/VmmI3xJLaygaJqZItKJEzsPmYFDUmoT2oIkUtNdLmoWO45UU+GA3bC9kJFmONjDOpOAsFVNKKo5em6sKgwEU17JlmJxzEIItfxm/2Wh74sKXy2cqJ93564Ec/kFZOT0+4v/W/y0/fc1Brjf8HtbLW+OncsVyNN8drcPkF3OfvzFwCvutv2Fm3CNF6zJAroPNCf4s+rNlflnTMjw0Pf5peO/0QxGHwHf7GyMw76HPC10iVjGFEyhTFDCycM53TWlDzoDp5PMu9NN+G1mGcWYd+GYfSFAPmYzJc94tqFqwB8BSuRsA82ItqGO53sdOkcDEiqjYQtmWoOBCCKO1VtSuLJ7/MLiEUa10yNIpClZBYuJ8HdioZNCaThgR/x8x1yT3bNWimaVGDf85R0wKFfI4VErpMbKISz5pmjSPX9/Yc3Ds60Wnty3VUjaIz7uly3DNaPXZ48/J1Qo+ju7urqrdbAs6k3GF7+6rxtVsf2E5jl5dCw/mJNf7bN0Z7Wu0et122+ozjB3u3+wvbxi6J3b4rVGi1uSWnaJXMXkPfHd2jycr4jt4s08Xjwnp6rzBJLMRNygw3SSpN6eykW4/s0a4axSFDgA0t4DEVV6Bx0nMO7kzz6ng0F4nkoi/yF+E2XyTi80YiXu0VJGJ85h91E8IZIpEE6cfzBCx3c8HORgWecE8t6XEZHHl1CextzxLc255eMIvpDnY3DXc70ni3ox13fIAfpA6xg9RYaiuA5SuIai9sMxjAMu57USlzX2GFTR6E196CJD9n8EXTriUs/+5ZAlvaV1U6pCmrHCKsc56WlSzfU2YV+S7ySolfO7yXZaf3/HM3nB2VouyoVGb86r6H1619b9+JoepVTz32g/zho/c9dNmRw4ceePjg4avuuWrZqrwr3b7i0j3LohVHfuWa4++hWz96bWVwqHL1x9c8tOTKH3zsocOHD19+38OHDx0+9uDld/pPrvG97ZkrPVtvDd7F7WmcrqInhE+weYJ3QdbOTuY45k4PYBMBQqikoT7ld5BrYG/ThSmdg2zCvWXTBFMxicTgPh8okOcNFEjnHyjQhdHqhvj5FC1aOGeYIELPHSaIX3prpC0U63VYtywbKDvajltW9Hb0jsXDyYFt4/TpYk/Yl2+1DVgcia7u8ldt+mB7V7EzFIvd4udymyXj9L30o8RIHHgStuI1+b3aS/aZ665LPn3ddX+38d1jb7ti9N38hWG5/JXwJfo0MZDuxslbSGkY9AGLKYzoX3HKr6bXNdwpVnCINuZXvkVYtYQer/7355Dv+nkyvIJsIt9cTIqXTTB5LY5B7rzMUFdKIIy6+tTwanZ7GHYklcRLZUNJTWF4vnmuJC8Hvo/Cbqws1kaX45pGx8HoLx/Fy+VJ2NhRUV2L591B2jOzwr0FXpdjXLmsqq4dBSF3+aKG/nbcuIykdCEqhVoso3MYXibJta7+5VhsWi1NETnUbsVfS8pqZkX1TQk+RE9FZtr8UcEfpdr5QEGbgsXBsIqE/wUXiwXa0HEItQFE+/6HDh16+J8+PjzQFbI6rDpHW0fO05VwyrLBlW+XbSOfL6+xiLeNDkuWherx8KHDh4/d/95Dh48c7Upemet3mOL2aMoU97eaI/bWPnsiQD9kSrea6P6n6Jb2Tp5XHRH200eEx2dxbix1/JqLc2Nq4tzg7h+hncL+wUGGp0FrtCB8meHMrCccpQITSlNBtRkbKDNT5hA5rM9rQDNThhC5Gf7eebFmiIF1nWWtoJ5tBiUtm67dtOkdbf3tuSXVzf2C8I6NcOO+XLV/M2wfnif3CF8SlgIdLrJvznly7GMYzBj61vQGJsw4s2HQNzqILCd3srTXIbF6q5aD49yXtVhzsjMMTlYUa5xOwkPptJyAkAHhMZg6nH2hAV7kqVbpmuqnPgX/kL9haqfrwCaFyMMah5hFwnifmNBrw0p9YMN9rHLgY1PJLbiiKSs3RFY+c+uWQBvdDW1U3KISBAs1FQiRAfilQGEqyK5YVc6KZwJ97EygWFUCOFdDVB9pFBBUvZun7AyKSoObaR5eL1VK3vA7DxfaY2GnK71pYGT15Td+xR6h9szeY335gnOpZax3pFS+YkfpMtYvpAY6AfR1Yt0xjvT5gD4fttCID5vpbIbLAffSWKjJa0M2+Qa2CVW6MLRTgxKrE+OIUBtcetD8phDQhAX0HhEsEI7CByMNvBmP9JzR7Iin87M4Jm2sBZ9h1eJUI2Obg2ZSZqI0izNTmgc00+IVrVZPMNY5cJnP4SyWuzKtLba4Z+PgwIqDlaG9q5esoSscsq7k7GtbI6TaV+akqkl2xnoqXStC+t720gqEFCLfFJL0UTYXF0cpPP9cHGJ0lUzfPHDw/ULy1CkWM39rpldwU4WUyJOk1o4ZYqqk2i04MFWzt7MZZpxmcYnF4iSxR5B5vawpbgTLaNQOR8n1SbfoMoMphMwhU2CD3aKIzYKpGBcR7SjB8K3/leeFA5eoOE/DLynSaaI6JcjT2Xc2RpLBYWl7O6LsYRPFl6rydvowBbeuHdWHK502njWsQxvIzCM755916uEy689L5ZUlY3v6QKRv1RJr0JPymexGs9HhaV2baOvcs89pdZnsbkn2PiVt+9iG3/08GmzrvPON6bPd7kAkaYt6nHKkY2NPh+345aWrBvt8fq3mrdKXIcdwYCePJfVWji1lZW7Lascs0GrW0HyA/TYG2oVHSszAKlMIFNHcOLHLcNqYzAxQr0lK4f+ToWtv+uJwz1r5h/Tbx/a2Ws8uFb40/TTH+KIieZk+DPFiEqNFxANpgnuRheBes6EhA/fqzdANLQz0g9UzydRMgl4FVz5EyLGx2r0drKiIx6lxakMw4FlFPjHkQ9foR7iRKXuIbMToVER5UiWITjDTtVvAkQkmj9bDc2JB3qMBi/rnqMKcht5UNBJPFU3OtMWWahupxNOq2e9JC28boplkrsfK1jgCdqwAem5HTBqGnAREWx3IbibmLJpqjgRIbwXEy3oeEC/W7x15WDav+Ne1ZuFIMDt9v0UXDOlsdIzHe2G6kt4Ia0L/s1KTANHB/Y+jiXJmkVknV8Ob5J7Hcq7nIQb9PM+T0TxPKhm+7NGDBx8N93cVqvBF//zxA5c9dtl/3b1+/d3r+Tq6IAb7szkxWLbs9/r5S9d11z2dvO66Z8ZHr3jbGERg/AVipoGZn+p2Cs8CP/GEWpT8Oz+jVnMia4USe52Swg4nRETeEvZwFH+xJrEhEQnrRGEW1IbdeNbcwn7NUJoys1BWpU7s8kwRLbCN8U0RL7gp2POBsEmJsOoRnmwPsomHoB8nHtjx9JAEexdv7B2bcph0ukREklKCsuIGXoYlBpGiWtAeR1kPiG+tfO7WMlhObFI2MLLKA/fI5mX/tNIcQ0C7S2j4X1pXrux+/HHhuL91+lmLEAjorLTz7HsQjvPK1p/8pPWOO1r/EiztACG6cY2XHeT3vF+H3a42cKxtjE9tOcsC3pot0jymTSUDeENNgnsKICIsCYCFXcjKzjfLShzcaZFY7QZnB9KgEV6WpnmBiUpaVPLovnPcfecKU3lum7vwoJGe989aJNXZhjOXsupKwmtagkScqOY2TDXSYJEDDfg7PuK9KIMT87x8eZ6bX8Du9MkDHW2RFqcztbY6tPzgO/6nPbwY51PbDxTbOp0Dlni0u9pdPLSlew/Ic0iT5wJ4r2EySn5Hat0ozynkeU9JDSBbUw22TvWOdKeA+0tKai9Idn+x1juCzOkdgvc6zfjeVCczKTVzZyNUUPqKU7IT31NlVO+xghI/02AyBg45uPSikVzA7ZyoDoFkLy2qgyDZlWJtcAjfG+yHvRsaxMshyKjVcZy1apFkxLFLprKd3SztlZRSVR3CEcme4ggbVR7pBWaXqyx+VXOjVexTq1ncKQi10gvjjowWeMxH9psXeZyrCCGPy2L1hFryS7o7RdlZKObT8bDVJcprrl12aW//jhXllU/P1xF6qUPUFZylTCKtS2SSiTaxbBKdkc5Sftyv7850j2WmPztfbwQyOPM6fVL4NJs/OaB1OREn0sYQD214RLsFbWoc/RrHbzA7GWSkDoeGESpJh7N3URefLjHqcKq+hQ2SRtGWEzWOhXSir87WlzFQGKCVWVC5OXX1wV17e9+7ctyUNdojcQRLerRRXv+LOehI4WC276AQ4IV2UH2O06N7lqETBy6I1OObReoJFjiUyhykHuxbBxZF6tGV/CndQrQe58EDxRvORezRPXtqeox6563Lc5F1yRdc1wURhLIQRZ6DIiRDWLkYktCfQ6Q5d10B8D0XWldwdl3hAh+jnrOuIEO1XJRfFWBY1nQOy6wnlp7o27E9fi7XhB+fOvXgg4xxZHZP74U15sG/vvcCa+xorBFhiwKm+mQ6kITw14s19EJBcZ+ZamOI3Eobc3AYBcNP7EhnG0Sckw5J7OBoVUstOr3F7jUnOzmE5RxSO4DUrqqSlFS5rbo4yeXeEkJZDtGSR5NsPpfiPYcL3kui+xzt7bS7NXnQJnqoZREhEqwneocNOqvQ3d8bCQpmYToLrNFrfDkJfMGooY28+wKcCTc5EyoomdKUl5czsYXSzs6S+wNsnAp9VWugzrDB/DJnCXPqMamm07PD1a3ypMVujixkC2FeflF2NENekNHZ+Hc+I+y8Lhp8+egwvzqHDRNapfTsG9RLTY2yaZMPX9D4kCMPvkk+qEl4aSvg4WzWSHKfUWMhVuVLI/WhOusRxdwcXSYtPaf3eHVRnCJW/IvzIMx4oLYl8WC97K8uLh5yE99XV7LRWVxK43yO0PFDy5YVe5a8fHQsH421t8ei+XN4Ej40vqynuGx6E7DEFc3lorFcjs1R/x0ozgTrubSTVzV+hDk//NE0w7Tg07sYPzL8asTkgHzJbmwgbkwls8SIUZCujtbSyPlW8zka45sN3FERs6ocemClraj6PTilV4uzUxpxcPAoVth4FIuNCh6W5FrAZZhbQmaG7qRYCqoZAikNTRUz2zw2HJD1NjZSZGWdBAQoTFKWLKi+LDOFqh0PHiMUKGM1XQzmiV3xLg63lNKSKt1r6ReMFafza/e5rF1dVtd9/+USe6dbqlL9pGHpuq+3W4Sec8CfmvYzR1c1sCUSGgZZL3mOT4BPtTlIj35R9DGlWFDjBjbJybCBMeBJF9QOXRMGXgNFyoJxyvGcDiIWHGEsSKx2Px+wDCHhs4hzFe0FxcxJU7p4MF1EAU3JNZvUgWfavAUEynRjtJKOwmWqADdtGDgSf/VigGZ08Szx/DhnZGH+uCjy2fSB+Vklx0FrBT8UgatX/vSIY8k/CnEM+e8JgE7H4gm0gG6JYY81ZPOPwB6j4BvPhz82fRyCisVByCCuWMCzr/1/lmfR2DyeqTaICf9YrkGcc16uncF4Z1GuYVxB5vGtlXzjT8+39JvlW6K4OOsyGusmY/EkQvP+KeWNB2PnZd4JHpSdn38PPshiMo2HJ4GHWdJD/vNPzUUcyCqUphI8SslBlFI8P1d1mjVNge2cz+FOxuG2ALr5xXldwnp6G+JauhB0SbUiyk++MCui/gB6d3Avb4HJi3R/z8vxK+a1hc+j7hMLm8XM94iItQZyrCNusoHU9NpUNsI22RoVUAdH9TCdUUVnvSaamgNF4KJZ54EVPHHyDUsTookdFCT8gLZuAfKaCPboXU30NbBBZ4PnQrBp59DgbeKCdW26AAqc502hwOG67DjmIrpZvXkhHhzkF6ZZTLhn5mh/Y1ENvffAurphXUbiI1u08x5mI4NQcgoaOorIUeGsDCS15rY2zlLgEKSV9VysJgbixQqsbjwhK1BEUOJFfJbpLFigh+tUW3ONXI8WY56OyLDGHtArCwkCH+/mz9fAFhrOy7AuNiJDuYs4lZBoTiWEiwxK0HGGowM65qIDakGalaEDThp8DpB8EmCH0AyB+mSI3YhByI9BrwOHHHUmkPYYZMBqOMkJmw3gFzJ/9lE6XIClJpVb+Y2m7P7+Gwvpbb4Fe+PScFA9HAXP1UC0lTSZCbPodIoSl4kPgFEdznuxk0hu9oQRPJodLta8bJO8MTAnbnZ2zo1y5OWjX9ZAnePgeV28NonFMrhbRdAe7URaqTwHOzVPWfFMA1DFooxrTxND9fWqtIvDqH7iE3RF92tNHFUERbRN/xjRVH/bzXWVYaxBDhskJURjuQjKGkTTahzS1854DjYnYuIoURrs2nysNWzmdPOktptNeUxl+U/Zi+GwlVkUztoBSrc0qZPdgtbljuRAAPRZnJZaCNGm5tBAhroRPgxnqLIXhGurnDcRPhfI7doFmfAFgd3etzAlRt1hOG+g3yJ78tiKRZHe4oshvSU0pLdJhz4cZTndmwR7Qyt5HsC3VWAsFwd9oy+f4j70/4X1gq08z3qfA8N5nvXaWU9y/nqT51lvarH1ts5Zb+wtrhct6nmWvI4b1vOvmgUrjXXfy9Zdxme8nLNupaOAaCOThWSHmWHSUaVvLiERUKsiV6simwGaauc/tc8SWcHKSVGSn3N4gjF9x3wy1Q7MUsNFNKxJNkV3EcLPqzjn4cXYAu05D1Oy5+qNXuPPScafNCkgWti5HAL30lmainF/01ZkD7+bZRCOGiQC7LFtGL3m4TI/y5oe7ekTk8Aa/Vva/0UiqfMwYM28OOo85B9fJI6i5BESEiaFAWIjZIRmKzgM6zdlTY+8+mq2/mrbq/CvPvZqva0O//BHTaYmBVV4jXghAk4j1izzWPEGx1pMzWfc+RDlRNQeGsCfZofzF6rsZnO5L5j0LsljCaIeKzYO0Rh3cavcIj1nsXlIII3v6fnZFY1d2sAum9bNVnD+iKXv2lHMbP7ozjvXru9vH7rz2M47tm0czo7ccKifRnqXHbp5T/+qwzeNA4MObW/dHzh0+QvPHt7WcXnL8SO1O7bSb2U/Nn1T18fuu2cX4lIiFhvoexzypFsvgsaW/mPR2DIaGttkMJRIMRl5K4BsaIgXB2W7AVGGLgbMRntP/f+LXhy4WJzeH+IUycXovf7UfHqzF6W37Y+lt30Ova1/CL3oCBYn+WbuB94M1eARdBrdJ4HuHOklygUpx+p4sTTVyu1eZ5HV6S7GCfTPmQCbPsQyZjdcdl+MP32ajeRQpnk82qXauxHkIfhW0Qkri1jNxTl34/yZ5Isx8JsLzafAselAhgIkTPZcHJ0uchF0uqiGTlczBsOswXpxhDpUhXNR6r7eUIPFkepuOnWqiZkieBn2cStOrTVz1cC8XHXKHWb1CreuPmVvnYVv56UeyLlUW6g493g2S2N9c4sUPt5bgSycqT6mV2xKwt1Eam/FuWExpqFys2xkHmL7vEP32dmOcqpfFPt/OSxWEKDX1ysOr28Lbdu5Z3/SPSfhGtt1Yt87DBuAAS/qt25av0ZA7JKZN4QJ4d/JGLB59kz6aJFj+eM0eZpJeBqHavsLiL7GjhEAySOeem2EUTsyhofRR5qkjogMCENy1ycTUhGiqWSIRQgV7ZFUVpGdxcAHu+KZAqmIkESpfkwtKhAZTUXTnV1l9HdWSRP9NJa64lWlX5oSdNaWpWw0h3GmMbY37zgBHtBpniQQsl06fE5u83EymJu4+233XLlxhywbc916pzXkSlv3712dXl+0tiSzBWvMH2lNZlxjS6z9XWvzQfNYyuSi97z7yW0bevuFXKvdLdlEi8dQ3jS603PXdm93qycScokeHyhZYY2jM1iZ2NT9nun7ZUMKbA3DtRO+R6IQMeexd8mQ7TIXRbZrbyDbKbFC4ylfqbngdinGxwa4HT7fK+VkcMhqm1WSn5dC4XgimZkzlt7+B+DcsSrQhbHuxsC/3nJBvDvhY6em981i3s3lSRZ4ct9bR/sDo9zgyQUA/zq1+XzkRbKtPc95oQZz1T8W9Q/TqAsi/20D63Nh9D96JVqgubxIky48Dch40X5RXnQ0eREvsN424RDSTV5w39PgRTebh+fykcdHxDL5aE23c6bUgskUM7cdf4iQaGWvC8vJcu6k0xcUFfoD1vlvSkuDP18E/iwho+RfNf4MXpQ/I03+FApqGlK7YrpgZkLGhoWAW1XgVlVUyjh7xZ/TDaycKvOrsjjpKVuded6PKzCOVkWGvsY5OtnhHTbP1loKUx18lAAHh4bLmtClC4P4tOoskfgDakbO5a5aQIT5WLn6Jvh8/qmCC7N+YEFu6LzwHpw9Z9xgWWM/9Np+TLJ5gx4ygE9TZzvScdEdKTR3JFtQqqWpJA+peiEqGGQb0j5PlfGiFS4gw+5qcl3xikoF3ynCO8WCWoGEakibclcTWXSiMcyzO6r45GtVMiGMXQPgufCHyPZs5bOp/M1bi3N7GQ+mPJzJn+A/nc80LtUiqWmfZha+OjvXwHmtczA72UOGyBf/AEvZXcCjNcoAOw9IleGm0QRbiSF5EbxzUXvc1xxZL861pMoSfLczVMcDgmqxnc9DLJGek5K5vImNxnU2mLyIXVUHQB9q7W2d1epbsLGzQxLZORMS81i+QppvdXV8YMKfi8by+Vg0dxELrPLZietmxyZYXv+68D/oT8Ev9QLH/5LU0iyvh9wAh/DVArDeQzm+vxX5WqxZGciL1Ql8L0fSHuB72djkdAdwT0Lu4XOCO0SshGBPIwqBULmIx7Qx7A/ho9+LjLkOiRWHlB5J9WATKiqrPhBrpU+a9MfTAyxvKqchTAqRZLbIw6SaUfJprB3WLeStv0/D5mygyMzncrrUyx/Flven169Zlim1JpZLjuM7Lo33Pb6NTteXblsxsHbbsVX7Ni8Z35pr7Vx91TbqPkV3FcrXJbqTcZ+k8bd7dHDw6D6//f7R3srgqhUT45zH79CLunet4/hOCQ0ntkg+oc1JZLQ5iXPBYlFsowY8x66Embob2FnoHIpwaS6MbJrmcaRrIx/pmgWVVRJMZKU6HnZU05JWfFPapMloMMVENiFP6jzOHGNpCkPvBAio6sw0ByMuhDrrXnwuYlEw2vsWjkSci047/Q/z5yF0HMeVYdUGeEdkPpJrFBKRIEdyDWIHq9B4YgaCuQYZmGtoFswVz34yrGwvjrY9p3PIPn+AodDJC1Fd1ajMT0Z7dQyE9zz4rhgYms6D8boaIsLbF8F5FQ6c+gWHep1HXxjou+HCSLVKdB5954DVJjWwWqQsEo1r+HrmWHUBbSGNtijSFrkYdi0mlovj126H8G4RDNtJrU4+S1sL5JfvXEhbAmgLc9rCQJuvwHp3Gm1hRltklrb0nL2LSM+zvQu28M1TzYGFJCY0EhkYmPe828dCNhc9zw6u57FabpFNpE9jhNbYR71G6yTQGiUZ0o059HxqW/EJlJzaGMNdUbpKUwHu+9uLDJ1RIz1WnPRaCeLfBliaGG8yYbLDGIf72QDGDmpHgD9vHNGV8YRXVpp06GReU5qLTxy7AD7xHL+u8WD2zkJurOUu3MW48Un+wwLJpg03/mVkDJVm6yO/ZZiseAZMRFRj3qM3MEwdBllptTFMVgtDBUXAKmzVO4AbQnNeQsQxCkezVW8psqdKOUxYN7Cx/TewIxgqsWnPwNI1mvcNiC0jqOTlCMGalfqE7506+925AKzNnn2OYX2K89CXF8GOdfJ16s5gF/xC0LFsnYgWy4CBmhixqtOkIZbOx4rFPr62xidAweZhxCa1eg1icdEQrNNI3LhO3sM3sCaqk50uZGc0VDuskxbYiIH1jCrCIkVr82FVVrHZx7drcw94jJsKBicTIruZHbpQqVNDq9fNaew3litwHZEbXE2ynv4Cxupmfg/rbWFYAvgEpIcb/XwG3chjN1FiK3Y5GKRctNnTDxYbNk+DGHA00EcdTYBHh7vZ2wct8buxlR/mPW7VwM+BqH4HayaoYTc+6oTZRJeNFZ+AsPmN/Xmwvey2not7VqNy/QLwgrMfnLdLt8328xMzv6Y/E/6VBCGvvYXU/Eh1BHy8XdCOgOIsg2YhjM1eSYuPHeCIc9hr1itpATJqFrsDNTqOY9lmg80pyn4rx60GyojaiidBPaTxyEfFLk+azC65tem+/BnskhRouaI1TtAG9GlxJZ7YTtx7pb+tteM233Wtm65ZccJ39FN3HTx8294NwyPr23uia3/1tveYqn3rMivaTZHkqrHs8EvP3PzYw1976Zp3HL12zIH6w3BUIU+Nk35E/36zSKpg/tQsZKe92R7YulbMTgfeDLTqZDKig/SzwtPPi+Gs4qPA2zHP7eJJKuI8YLENYazapSmbN9TawyT/HPBVtQcPtiQq1TcDw3r+sfdFAVpvX5CWXhCwVRg6t3PZ8LW/BntgBsvlJ3s1iyA2UFzxiaMWsAMBJl4OH3tmqlsDcg1qAy/4VAS39DzCuVrtNsYIn9hEdGUWTLHNRXZtlsXmobtuByN7/3yEV2HvqemvN1Fe56/XPWe9c1FnWTAXWAx4NqgBz7KVerx+1AADoi3OQ6DlkZvnPEi0PKiZh0Z7GIztAkTa/4VnQ+asFZ88f0hbq7uxVgw8rQxeD9cq+tjZYp+2VmwIixpvfdILuGKbw+piS5bZcaCge3bJ1sYDXGZZPKeoNI/Lu7nd7Z3PaPokKxwtxusvwvqTpJN8SFt/prH+DnwaLRheUL+wK2hmqJ7sCDqWWn31SWsKghHtiAiWW9s5aZM+Qzvcl/h9qTDl40qFR9KlGCLjILH2YCbPZwA6MrN0BtFpW7DEb3dJ2tPBmhRfuLwzjwkbF6hOZAE3XjynhDPV5Ixe48sk8EVm85t3apzxNTiDYSl4+HRpys59UbzYeMCKGxhgcWOUhtUCt8iEErmSMiALowEM1nESk7HLyQ8gh7VTYD42l64ztrBaY9i3GGrygooLJ3tucMYYsJM7IoNG93P8xwb5Zxvh2N0a1bQw2/DXgT8aE74kyHDlIF7SRRRbgZ2y1oAivAVV0rDx9WcQ/s/iwvgCpxk03AsDXyzskKgt+xZh1fQzia5EPOBP4Es3dVarHwjE4TpB93fhvYZMKsD7btB+zA2u0CYtok2d0h4KDJz2QOjr4b1Eq5NP53lwbkCUGdrX8wadw2X2s7M5VhniMwb45eBQskEE6yE+7CsrOlk1mGefN9L0f425AffcuYH0nYernb3J3gN3HR7q7Y/3b98T/Ww8P7KumuwZ2dAG/PXtdu9ddfeJB8IHPUdWvmvNMB0Onpj+Veqq/TuH+ZwbYs+CzQiBR/zgW0GfBTPCTif/YQC0cQ2AVhVa2OjupC8cYRMVGg4tQn9eHIEW7fo5KLQ5HOQ6DxItrZ76o2gO/ylo5qC7k76WsEax6ohU3zTN6BDOoflDOAx2HppvPjWf5gR59C3TnPxDaU4t2Ocp2OdYokF29C2Rjf7lHMq7tJmy8xOPQ2U6jf5JhtfXRT79ljiQKigdpakoN63ZImvfnMOOyRY9GtR4oH5exkzmXPhQynSAHSLKBXibJ96C7PGxQ+I1k91WffNMWWxw4BwOdcwftDoPo751zqSVwLF6NT0pnwetV1MJFO4mYC8EE9rp0gsA96IcLwrey2T5AgC+VzB59sDaLLA2PP/8Pu05XKHGc7gQfN9dUD0GnGvQnn6hCAU27ehjT+JSdQi9f27wzcAnWQju4lUdi4a+zx7BJzD0faMdd8iOE3F4BgFx6Z3s2RGLP6xr7gN65yDve25G2P0T77kqW5FHflKWtnRnEHi/MKA9O6YJuw9htW747Eeb2Ps6bV8asnzl+XZmMbFtOcMkNM6PTM4VwZrej2PxIISTOqPAcClzcs1stTTl8WJQzItJ46I7vEAiL7DXLy86/8eem0N/BBnEjgtWPhikyUUel8OwRSwNJP7Fn4rTqHLMrxVQYtWekx4kV2tPQEDQFzyd4Gmci6kZMH/WI7BW41HcCoUPdTJUK+38DOJQaKdqsGDkKeKJQsSQlkX+ZDjJKfEY3OnRolB3pTlmAgHCnAOTJusB9vD0S0Mn8fnp04kRaRUNjlILHyt5ZTizafob4snn2w3OHxeBBgPQkGe1z+2NJ1kb8BQKe7AhQsQUGNKuzJZt87BzQec+v1oHph4zCZvMHldIVB0+tNrEwhi3ZrdwnY2nNJgMB9fdlNkWupo9QGYNbRujJWDsF6vZNdNf4zL/25J2XvM3ui8JnwRJ7yR1widdAqDnCbxow8ZadP7ZpQ4dO87awWpxHWyEXuD9zimnP6G/8FEwnkykg2CgId0HgqLtxSIr7/mLmInOP0SHWxMWIb4Ot4BZt4qYXuFxJZZaGNOSPKlPtOEYg+r2sA1UrOwxMxbeXfbj6c5YO39AJknDawfEhbk5M7bnPRlr1OZu+YOw8/s3nfzwID25xOn8xgMuPKzkeuBXLrE8fWjlgyc37zt29fPXXPP81XTjxw5uveOm+SeVbr5z64Fn7/3o49T50ce0ePfXOjPr+7SSDvIx7ieVUEmVLHXuM2M6Hvvice1WHT4Eeyrt8GG9OI2FoU4G3BOB7DLCQSydHnZCNsPjYvSKCJSSxBJQSMeJN+CBjow8aZJ8ad4jY9KO2RmeGE6D7X2OWN2BCIscWqVJGk5yrLm+3uZTeOYVjLFrJjTw5wyNsvk7D9ww1H9s8x46fWbHusFVWzeeGF996EB8VbV/5cp3UP8rhY788B3fvf+yy47u81h1l11ZrgwdOkR3n77qqtMnHnIOja3mM2jsedW6Z8H2lskjb+GJ1X1v8onVFe2J1aqen2tbauUPre4u9uKklRpAK1X60zzAGkJorOO+qedYC5X/p7Kri43iusL3zuzu7I93d2bX+++d9e6s1+v98do7GDDgYrdQl5QgQ3FxCmqApNA0pKRFJbRCqdoKKUqMiNSIp7ZRozRRqUJ3bYtUSM1TqRS1jURESZu+IKFK7EuekPJQYfecc2e86x/AefDM7Hh35p5z78z5ued+36GZzd8f3xCdtdy8ePED4gn9nJ+E90s/aOvXG2Uiwdi1bJLB2ggfSaNSJzOGlCTzsrdIRTKKNu4RtCQlgoSgwr1GGXMvyKonuEmaRQRGK1VHN8xPIgt9PYamZEBo6jFsJVILdSRbNZnnWBx8mQpq6dFVmZhlLpkLPcKw99XpmXtUlea8TopNxCl/AiH/vEEnimD+8VmMJpAcydmDE3FNQxc+HGpm3uuxMPoeX9a5nvVfW+b5nbUFrOsXfP5rrT8quIppnWKUnf0CbMWxx7AVxy26hnnJqxJH3sYJi7kYDmt4ixfPixHQyV8s/w67W8jB/wjPBMoxu2EGCgS7DJvL0myEhwIFc7oEIpVfW5C8EEdQd65gpED88VBkdB1mimXpVhBULL4nZOskqpDukGycuZYO8f9Jf4DnfUJgZuIkSY8JLhZm0SkrpRBxQ5omvufSJF+6B2WmhLniFsXniKgNfqWF6E41oRbjJ1JUWEyWtAKl4MqfqGTOnEnlx/YVhqrTNf2tt3g4pT87oudfLERHk0cP/Wf462MH8mNGKh//mvaN6alhY+LYy0Obd2bInzwl5fgrNEdV7uBh9gkeZsQelIPIyryakVlkPE9Zxew5e6115/WqrOGycSQbct2+nqPzegjSyKRRQbKM6j4l1GupFK73grQFrneDaaDTRrDWdIEptngEEBeZ1wkuD9sp4FplMiqIMWjDtZKDG6SlofDYdgu+D1MkLV/or23dMlic2PvkhHTd5y5mMkW3b3LHdiHLDWkfH5L+xHyIlejpwErsIlfJlWjRn9/GSlyGhrqRicYymVg0I/2c9rpOtvMC6OZFGUYni7BdhL6Ii80hWJNlkcID58GbpPlkFUdvUnBYqrRwV3ZTMBLGSWNwXSkRuX7d0YV2aVGplNFL0ok1xUOcXVsqcjTpflZjcxL6OV21poJJ5YCYx9NahCzZVLqIYaAhgZ/mIQqRTVtMsAuWs3FtV2XzqJKMp479Yt/I4I5RR12h6x+Txvgvpb9AfDDJ4OlFH2E+7FLhzSsrgimM37ay0VhuDsNhwS9y0+hZunFBr0wTsbJrmTLyYTnnY6tXY647/yL0/2+a31Ys1nFHe7RDb3hWj3FEm1MufHvm4s5Xj/8ZR/kH9Jwz9jG/z4OCc3wV9rCASB3j8Bq5//HYGLO+L9977Pfle/b3DX6dXZU+hHckPEN+6BZfi+B+RbcIgnfm9AqyHeghv01ULnomZtrqOVqeksb92ZRRlqIzh5+aCLrDajJbx3tk4B5X7HtAO7zWPaTbiCc8J+G8LZMU+x7eZeJOzLwabRTazJQ0gXeoHOXXZ74MNwjFs/XSoSN0j6Uj7Ap7/gvfI7b2HuP+XNIoH3378JfwFgm4xcxhUQvAr/OXSI4Mm0ZtNdImKgyCFntB6kqdobnApyuCWHsEZxxJWhTYqtOCTxA6bTJ1dB2tbnm4lj/EQ6GOFQovdSpfQt3zM+02O2qNbhOVQ0aidx39YPiF9QlpOBtCS8FCMavNIb+1EEPoj9Kpa3vJfGiv/YbanlzTfyv7UsK+5GeoL+02p0Wbw49oMzH9wdkUemYspVptTmGb44l2m4k4fXWvL9fCGOIf7VHwJur6aVL1igHxT7GjUzh3pC39lN+VPoIjL7S7G7lKhK65DydJKLj33l7wJFkB3kIedV7zIHewDyI1X63hNIl+EkN7r49wVyWaEvRgpjKA6SI/aF5DKThIMQ8GOUhxWXhLLKKANYvJhgyBvxEbwfB/8vXXfzgQKJUChUq1L5C8uGcPv1stqsald95ZfEqW9+6d1dVidZAhKuzSeavdHmp3gunMYM9R63XR+p46GCSEWXb5BLdMvtZQbzcidYSCgLFPKa6wqoXGu2TF7esKBKVkKtNLDhC1NgAurpCm6fXjDHpo3tcVT5AAOzkIINtSKIaCWxIljKLItjyT8PddMzA0FCgUAn3Vii3YRfj7HsrG37UkfPf92dm9sguEXHwOpeS/ErJydpnd5e9LKOkg2tgF2YG47daOUInBTrgIzN3aWdjEIdve5i5P79g+PX2Obz138OCO7d8Uc1cnlz6XfwaeMvJipNluixM41GOaZMa7oljlgKfIoOtke51B8pKxMjMIh0EBgZoItnA1FKOA2zK3+XWOTiJEcjLFi9Z+QOxTmwkxOb9ih21U4Jm67/g9+IseQoDM0HrmEfYPUZVG6Z5GlUgfGkSVajNAqc7WgrtLx6yDGw4TfXjYGDGbCWeLVjuL5eBIAuFdxg9GwXAoI01KlgqmcVkTFrBgcmIYDoeJbKNZDokgPEA1iopbCkUwNMpn4WM4nkjrGCU0Nw3DGBqoDhZpRLkRfC+aKlC+R8WICt63AfEwtEOjbqQQgKgbUUPbUByqWVeN2KrPmQOvHNj/6v6v7pua2jeFgKEHebx96k77kH96/PTp48+cPv3M1avvPfgxIoX+1TrDtcW3+ZGrKz4Jv66ffYX9jXCPDWa7pc4g85OfShDbTqKXdRCgSAcrhcVIgdcYhGvcpGtk7WvAj3GI+oV323QJ1CNxBRtT2cJTpnYsPQ2bSelNGK1REQlRwNvhFhigqt8SXioKRvbuLL8k/V26DCOmwh7gbPCcbhRN01zoEmjAnnRvfykfq4OvvOAKJXN9+ZiJKNcIrxyOQwDN1Sbztsghr5LkmsDy1UQU5YbYyk1FW27MH/oJ5M6PrrabMDrQzy4IP7sMnwr047kC4uKPF4rwizIlN8ohxEUSM8I9cMke4qjrAUuLxFdZgoPOZjwCOLgsC66eLFYfxOLdIusOfuc1tz/ak6Vh1QhqzVSFEJmbkZi9tJQyhMRQMQLBG8K0xnBjsVaMKEa/dXT2v0mXsqnwk/5Nbte9E7t2P9vb+7x+JDqT+VZG2r97d9F12xGNOD5xFQdjXQvz/pjzpjMScd767LNbjmjUcVOMm/PcL93gk20/zt3Cv44Owwn389Ie7t+2jfw+xu9w9DfZsJbV8HixF/oQA/pe6R6torpl1V+lRP1VMp23shwOs9ktt7Duas6VteMd2CK+z2BtYcAi9qlRcaNSb+a6iQwwR7n+XB/m+nN2rh+2TvhZjpZ1Ngr1Zry7NZchXKoMRJ+YiSsnWnNlIk4spzwCZRTBH+Z8AaTmbcS1uegALopolEUCN8sJdJam+RvKaHNgEL4c0NQVPL7LtrzfBWFrB8KzoXVAS+bSI6Hx8R8c0PvKT277aFtWrX26OfSJZr6hV3S9ghMPpzKq+qNL6Xg+tDX70p7U4hNWxdWpxTew3Op0Ja1Hojr1Eep2iHR7xdJsWGgWXmNtzeprNGvTKlqaTHdqEra9D9EnxWdYsRlbrti0IG+6QYtYExjLoYeDWOKqQLVHzTXVGJavu0h3q/QV69ST0FyE9GWpaYdyIqqN3h3RqsYTE6/NamZbQ8NDDw5YXPTHk1v1l/fUSEHs/8tKlrF42mNgZGBgYGJgWGKy43k8v81XBnnmF0ARhnPMyZ9h9P/4/yIsK5kPA7kcILUMDAB2yQ1geNpjYGRgYL7yX4iBgeXk//j/CSwrGYAiKOAFAJpXBwp42m2TP2hTURTGv3OulVIrRls0f2zTEkO0jRHF1r+YhBbEpnYQRQepthWVoOgkDkUR1MVFiDjrIIKDg2iGIuIiNHsdJIuREiyCDkYqVrx+9/KspTTw455373n3nPd9J7IR/idHCWM5hqtSQFrnkNM09pvjiOtb9OEZ0vIYRRKXBvpNHpPMT0kWO7gWpGZnmb+NjJKeII6RXQGHSZr08p2zJM87brl73Cp17DHPMaw37U89jW69jl59xTVHIohomc+f0C2DSMhrtOoE95sRM+Po1AqiWuV5hnlVpPQuz9I4qCcQ4nsRLdo58wjQU3Zeh+x3HcJ2eYJ7UsNarhnzGRV+E8hFWWDvMTTLGyS1D1vkC5KSR4euwVbdjTYJs36LfaFNjKOsX2D9vSTG/BQ2aRvzb6BT7qNHRlh7H6Ly1S4YY//IPFrlm7Uyw/p15FmvyjXH7z/pdGfPTvOkjjr97C9/3kCWFM1tDMgkumQKKa+Ze27gvBxhD86LK9hMYtyb0YT9ILOs63xp4CX3s/KA51P81gkc8JzjeZ0aOb1XwIzbae9BLvAggPqHvAeDaCcb6NG6Rf2Xwb5KPi57//7jPMggoWPUkHqvhL7nnNADr/9SwtTFeRCmnmH7W0Ps65/+y3C6+JgeLMV5QK/avRe8i3PUQi+bTI0972Q+Z8f5tzgr9It7q6nlpYDL5B25Q8pkLIjBWQIqSJC4Q0rsteRX979Z79ARPGTehVUu5wdSJIOn9ozpxzXv5UfO6iHO3AA6/gJawdB8AAAAAAAAAAAAAAA+AHoAwgFoAfQCjgK0AuwDIgNqA6gD4gQABCgEQASGBNIFRAXMBhgGhgbkBx4HkAfoCCIIgAiSCLIIxAkmCeQKKgquCxALXAvqDG4M8A14DbgOEg6CDtIPUg/CEBIQgBDyEboSPhKYEwgTPhPQFCIUeBTQFPgVDhU2FVoVchWUFhAWcBbGFzgXlhf0GLYZNhmYGfAaXhqiG1AbzhwUHJQdBB1kHeIeOh6sHuIfYB+wH/IgSiCqIMIhIiHGIgoijCMUI4IkCCQqJNolFiW8JjYmUCZ4J1YndCe6KAYodij+KRwptCnyKhgqaiq0KvgrEiu4LHotVC24LgQuUC6iLy4vsjA8MPAxlDIuMsozbDQuNHo0xjUYNZQ2BDa2Nw43ZjfCOFI40jjsOV451jpOOso7cDvQPE49AD2KPhA+oD9oQB5A2EGEQhxCjEL6Q3BEAERURKhFAEV8RfRGsEcIR15HvkhKSMpJCEl4SfJKbErsS4ZL1ExSTNJNFk14TchOgE8ST6hQOlDOUTJRoFH6UiJSSlKIUrBS9lMmU3BTlFOsU8RT9lQoVFpUtFUOVWhVxFY6VmZWuFd0V5ZXuFfSWJBYqFi0WWJZ7gAAAAEAAADoAFIABwAAAAAAAgABAAIAFgAAAQAA/QAAAAB42sVUy27TUBCdpE6BDUJC4rGzuqFIASUBpLasIKpEkbIJSBFLx7Fjq4kT2Q5V2UQsWPAFiB9C8FecOXecB6RIsKHRvfd4Zu7MmUeviNySb1IT/dvc6zwd3iNy2JO7K7yP8x60Ne8GFIncN1wTz/touA7NJ8N7G9iDTYUbctP7bHhf6t4Xw9fkg/fV8HU5adw2/F3uNHqGf0irES67SZCXUe73o/FiEuT+IBrGs6xcyqGE8lB86cpM5nIpuaQylkRKyNpyLEdYj4iOpSNNSF/CopQCK5dIAplCdiYZ/DymvkvZkJ5G8BVR2pMX0PvyDnEWOAPe9hEpIhoitg/rHJoMviPc9cFItVN4KvBLcTeDdIF9RI36meC3m9UceMY9haxkhHV+Bb5K6NVfYSxDq4LiKfAI1rF9F7AbIlYKqwgMqjt6Kocm2WTknZN/anxS3FswJ42Y8Hx6Becu9Fqb0vI7xK79eQsWc95sY83oT7lklMWsjMup4rAZqcsbrg75X3lTnJvXS9ZU/cwhLWhbRbtgLon5chWosg9xut49X3XlPadDq9Q0rgHvKUoZOYNVadX2TTYBjmmXkmFA377NRTULrospGagutu6F8H11rVz833vywCZFJ1MZT9mf8xUn5XBOthfk52Z+RE3ByAl1ynDIWdGvXznrTK8nLjUPuzLZ7uv2tGz3dZ3pCb4OkNsZLN5g9eUU/489engF1IfsFPs6J9fBsc1wZBO9uw6O15/ehQOsJVcHe4svip7L/8jp39+xAd+rqrq+5TIwNq/RywmlLe7PUP023lHdO5B0IG/Lk59ypQTdAAAAeNptz1VoFQAAQNGzZ8zubmf3s9sZm+3s7nbGzNkxY7aiCPqlWAgqdmJ3J3Z3d/7qw28v3P97BfzjT4wa/sfbkGECkkgqmeTCpZBSKqmlkVY66WWQUSaZZZFVNtnlkFMuueWRVz75FVBQhEIKK6KoYooroaRSSiujrHKCyqugokoqq6KqaqqHWmqqpbY6ItVVT30NRInWUCONNdFUM821EKOlVlpro6122uugo04666KrbrrroadeeltnlkSHLQ/9zLbYAitttN589820zHc/LLLCXCc99s0qm/zy029rbXHeWVv10dcS/VzU3zkXXHXJZVe8M8AN11y3zUBfLXXbTbcM8sEn8wwWa4hhhoqz2nAjjTDKaPHGGGuc98abaIJJpphsvzWmmSrBdB99dsAdz72w3Q4vvXLQa29scNczDzz0yFP3PLHTLnvtc8pue5w2wwlzbHbGEUcdstCXsIBjjofHx8VGB4PBv9TtcTQAAAB42kXOzQ7BUBQEYFepVov+3P4RQSQ29zW0m27Eqk08h4WVjSXPcmrl7ZjIcezmm2SSean3jdS9V5NzaDqlHm1X2abZUNDWpI8I13ZJtjk1PbLWJVlmT4N1+bQmffPFEBj8YAPDC2ME2DuGA4y2DBdwNowx4K4YHjDOGT7gRYwJ4DMUTfnKDO103jedVZ3BAJyFwhAM9sIIDBfCGIz+Ww3GhTABdSZMwSQVZmCaCHMw08ICzGPhHCyELWnzASCeZioAAVHds3QAAA==') format('woff'); +} +@font-face { +font-family: Charter; +font-style: italic; +font-weight: normal; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff'); +} +@font-face { +font-family: Charter; +font-style: normal; +font-weight: bold; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff'); +} + +/* Charter license */ +/* (c) Copyright 1989-1992, Bitstream Inc., Cambridge, MA. You are hereby granted permission under all Bitstream propriety rights to use, copy, modify, sublicense, sell, and redistribute the 4 Bitstream Charter (r) Type 1 outline fonts and the 4 Courier Type 1 outline fonts for any purpose and without restriction; provided, that this notice is left intact on all copies of such fonts and that Bitstream's trademark is acknowledged as shown below on all unmodified copies of the 4 Charter Type 1 fonts. BITSTREAM CHARTER is a registered trademark of Bitstream Inc. */ + + + +@font-face { +font-family: Fira; +font-style: normal; +font-weight: 300; /* "Light" */ +font-stretch: normal; + src: url(data:application/x-font-woff;charset=utf-8;base64,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) format('woff'); +} + +@font-face { +font-family: Fira; +font-style: italic; +font-weight: 300; /* "Light" */ +font-stretch: normal; + src: url(data:application/x-font-woff;charset=utf-8;base64,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) format('woff'); +} + +@font-face { +font-family: Fira; +font-style: normal; +font-weight: 400; /* "Regular" */ +font-stretch: normal; + src: url(data:application/x-font-woff;charset=utf-8;base64,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) format('woff'); +} + +@font-face { +font-family: Fira; +font-style: normal; +font-weight: 600; /* "Medium" */ +font-stretch: normal; + src: url(data:application/x-font-woff;charset=utf-8;base64,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) format('woff'); +} + + +/* Fira license */ +/* This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. */ + + + +@font-face { +font-family: Source Code Pro; +font-style: normal; +font-weight: 300; +font-stretch: normal; +src: url(data:application/font-woff;charset=utf-8;base64,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) format('woff'); +}@font-face { +font-family: Source Code Pro; +font-style: normal; +font-weight: 400; +font-stretch: normal; +src: url(data:application/font-woff;charset=utf-8;base64,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) format('woff'); +}@font-face { +font-family: Source Code Pro; +font-style: normal; +font-weight: 500; +font-stretch: normal; +src: url(data:application/font-woff;charset=utf-8;base64,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) format('woff'); +}@font-face { +font-family: Source Code Pro; +font-style: normal; +font-weight: 600; +font-stretch: normal; +src: url(data:application/font-woff;charset=utf-8;base64,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) format('woff'); +} + +/* Source Code Pro license */ +/* Copyright 2010, 2012 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries. + +This Font Software is licensed under the SIL Open Font License, Version 1.1. + +This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. */ \ No newline at end of file diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-racket.css b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-racket.css new file mode 100644 index 0000000..18c9360 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-racket.css @@ -0,0 +1,319 @@ +/* See the beginning of "manual.css". */ + +/* Monospace: */ + +.RktIn, .RktRdr, .RktPn, .RktMeta, +.RktMod, .RktKw, .RktVar, .RktSym, +.RktRes, .RktOut, .RktCmt, .RktVal, +.RktBlk, .RktErr { + font-family: 'Source Code Pro', monospace; + white-space: inherit; + font-size: 1rem; +} + +/* this selctor grabs the first linked Racket symbol +in a definition box (i.e., the symbol being defined) */ +a.RktValDef, a.RktStxDef, a.RktSymDef, +span.RktValDef, span.RktStxDef, span.RktSymDef +{ + font-size: 1.15rem; + color: black; + font-weight: 600; +} + + +.inheritedlbl { + font-family: 'Fira', sans; +} + +.RBackgroundLabelInner { + font-family: inherit; +} + +/* ---------------------------------------- */ +/* Inherited methods, left margin */ + +.inherited { + width: 95%; + margin-top: 0.5em; + text-align: left; + background-color: inherit; +} + +.inherited td { + font-size: 82%; + padding-left: 0.5rem; + line-height: 1.3; + text-indent: 0; + padding-right: 0; +} + +.inheritedlbl { + font-style: normal; +} + +/* ---------------------------------------- */ +/* Racket text styles */ + +.RktIn { + color: #cc6633; + background-color: #eee; +} + +.RktInBG { + background-color: #eee; +} + + +.refcolumn .RktInBG { + background-color: white; +} + +.RktRdr { +} + +.RktPn { + color: #843c24; +} + +.RktMeta { + color: black; +} + +.RktMod { + color: inherit; +} + +.RktOpt { + color: black; +} + +.RktKw { + color: black; +} + +.RktErr { + color: red; + font-style: italic; + font-weight: 400; +} + +.RktVar { + position: relative; + left: -1px; font-style: italic; + color: #444; +} + +.SVInsetFlow .RktVar { + font-weight: 400; + color: #444; +} + + +.RktSym { + color: inherit; +} + + + +.RktValLink, .RktStxLink, .RktModLink { + text-decoration: none; + color: #07A; + font-weight: 500; + font-size: 1rem; +} + +/* for syntax links within headings */ +h2 a.RktStxLink, h3 a.RktStxLink, h4 a.RktStxLink, h5 a.RktStxLink, +h2 a.RktValLink, h3 a.RktValLink, h4 a.RktValLink, h5 a.RktValLink, +h2 .RktSym, h3 .RktSym, h4 .RktSym, h5 .RktSym, +h2 .RktMod, h3 .RktMod, h4 .RktMod, h5 .RktMod, +h2 .RktVal, h3 .RktVal, h4 .RktVal, h5 .RktVal, +h2 .RktPn, h3 .RktPn, h4 .RktPn, h5 .RktPn { + color: #333; + font-size: 1.65rem; + font-weight: 400; +} + +.toptoclink .RktStxLink, .toclink .RktStxLink, +.toptoclink .RktValLink, .toclink .RktValLink, +.toptoclink .RktModLink, .toclink .RktModLink { + color: inherit; +} + +.tocset .RktValLink, .tocset .RktStxLink, .tocset .RktModLink { + color: black; + font-weight: 400; + font-size: 0.9rem; +} + +.tocset td a.tocviewselflink .RktValLink, +.tocset td a.tocviewselflink .RktStxLink, +.tocset td a.tocviewselflink .RktMod, +.tocset td a.tocviewselflink .RktSym { + font-weight: lighter; + color: white; +} + + +.RktRes { + color: #0000af; +} + +.RktOut { + color: #960096; +} + +.RktCmt { + color: #c2741f; +} + +.RktVal { + color: #228b22; +} + +/* ---------------------------------------- */ +/* Some inline styles */ + +.together { /* for definitions grouped together in one box */ + width: 100%; + border-top: 2px solid white; +} + +tbody > tr:first-child > td > .together { + border-top: 0px; /* erase border on first instance of together */ +} + +.RktBlk { + white-space: pre; + text-align: left; +} + +.highlighted { + font-size: 1rem; + background-color: #fee; +} + +.defmodule { + font-family: 'Source Code Pro'; + padding: 0.25rem 0.75rem 0.25rem 0.5rem; + margin-bottom: 1rem; + width: 100%; + background-color: hsl(60, 29%, 94%); +} + +.defmodule a { + color: #444; +} + + +.defmodule td span.hspace:first-child { + position: absolute; + width: 0; + display: inline-block; +} + +.defmodule .RpackageSpec .Smaller, +.defmodule .RpackageSpec .stt { + font-size: 1rem; +} + + +.specgrammar { + float: none; + padding-left: 1em; +} + + +.RBibliography td { + vertical-align: text-top; + padding-top: 1em; +} + +.leftindent { + margin-left: 2rem; + margin-right: 0em; +} + +.insetpara { + margin-left: 1em; + margin-right: 1em; +} + +.SCodeFlow .Rfilebox { + margin-left: -1em; /* see 17.2 of guide, module languages */ +} + +.Rfiletitle { + text-align: right; + background-color: #eee; +} + +.SCodeFlow .Rfiletitle { + border-top: 1px dotted gray; + border-right: 1px dotted gray; +} + + +.Rfilename { + border-top: 0; + border-right: 0; + padding-left: 0.5em; + padding-right: 0.5em; + background-color: inherit; +} + +.Rfilecontent { + margin: 0.5em; +} + +.RpackageSpec { + padding-right: 0; +} + +/* ---------------------------------------- */ +/* For background labels */ + +.RBackgroundLabel { + float: right; + width: 0px; + height: 0px; +} + +.RBackgroundLabelInner { + position: relative; + width: 25em; + left: -25.5em; + top: 0.20rem; /* sensitive to monospaced font choice */ + text-align: right; + z-index: 0; + font-weight: 300; + font-family: 'Source Code Pro'; + font-size: 0.9rem; + color: gray; +} + + +.RpackageSpec .Smaller { + font-weight: 300; + font-family: 'Source Code Pro'; + font-size: 0.9rem; +} + +.RForeground { + position: relative; + left: 0px; + top: 0px; + z-index: 1; +} + +/* ---------------------------------------- */ +/* For section source modules & tags */ + +.RPartExplain { + background: #eee; + font-size: 0.9rem; + margin-top: 0.2rem; + padding: 0.2rem; + text-align: left; +} diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-racket.js b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-racket.js new file mode 100644 index 0000000..203d6d3 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-racket.js @@ -0,0 +1,98 @@ +/* For the Racket manual style */ + +AddOnLoad(function() { + /* Look for header elements that have x-source-module and x-part tag. + For those elements, add a hidden element that explains how to + link to the section, and set the element's onclick() to display + the explanation. */ + var tag_names = ["h1", "h2", "h3", "h4", "h5"]; + for (var j = 0; j < tag_names.length; j++) { + elems = document.getElementsByTagName(tag_names[j]); + for (var i = 0; i < elems.length; i++) { + var elem = elems.item(i); + AddPartTitleOnClick(elem); + } + } +}) + +function AddPartTitleOnClick(elem) { + var mod_path = elem.getAttribute("x-source-module"); + var tag = elem.getAttribute("x-part-tag"); + if (mod_path && tag) { + // Might not be present: + var prefixes = elem.getAttribute("x-part-prefixes"); + + var info = document.createElement("div"); + info.className = "RPartExplain"; + + /* The "top" tag refers to a whole document: */ + var is_top = (tag == "\"top\""); + info.appendChild(document.createTextNode("Link to this " + + (is_top ? "document" : "section") + + " with ")); + + /* Break `secref` into two lines if the module path and tag + are long enough: */ + var is_long = (is_top ? false : ((mod_path.length + + tag.length + + (prefixes ? (16 + prefixes.length) : 0)) + > 60)); + + var line1 = document.createElement("div"); + var line1x = ((is_long && prefixes) ? document.createElement("div") : line1); + var line2 = (is_long ? document.createElement("div") : line1); + + function add(dest, str, cn) { + var s = document.createElement("span"); + s.className = cn; + s.style.whiteSpace = "nowrap"; + s.appendChild(document.createTextNode(str)); + dest.appendChild(s); + } + /* Construct a `secref` call with suitable syntax coloring: */ + add(line1, "\xA0@", "RktRdr"); + add(line1, (is_top ? "other-doc" : "secref"), "RktSym"); + add(line1, "[", "RktPn"); + if (!is_top) + add(line1, tag, "RktVal"); + if (is_long) { + /* indent additional lines: */ + if (prefixes) + add(line1x, "\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0", "RktPn"); + add(line2, "\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0", "RktPn"); + } + if (prefixes) { + add(line1x, " #:tag-prefixes ", "RktPn"); + add(line1x, "'", "RktVal"); + add(line1x, prefixes, "RktVal"); + } + if (!is_top) + add(line2, " #:doc ", "RktPn"); + add(line2, "'", "RktVal"); + add(line2, mod_path, "RktVal"); + add(line2, "]", "RktPn"); + + info.appendChild(line1); + if (is_long) + info.appendChild(line1x); + if (is_long) + info.appendChild(line2); + + info.style.display = "none"; + + /* Add the new element afterthe header: */ + var n = elem.nextSibling; + if (n) + elem.parentNode.insertBefore(info, n); + else + elem.parentNode.appendChild(info); + + /* Clicking the header shows the explanation element: */ + elem.onclick = function () { + if (info.style.display == "none") + info.style.display = "block"; + else + info.style.display = "none"; + } + } +} diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-style.css b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-style.css new file mode 100644 index 0000000..1327c9a --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/manual-style.css @@ -0,0 +1,742 @@ + +/* See the beginning of "scribble.css". + This file is used by the `scribble/manual` language, along with + "manual-racket.css". */ + +@import url("manual-fonts.css"); + +* { + margin: 0; + padding: 0; +} + +@media all {html {font-size: 15px;}} +@media all and (max-width:940px){html {font-size: 14px;}} +@media all and (max-width:850px){html {font-size: 13px;}} +@media all and (max-width:830px){html {font-size: 12px;}} +@media all and (max-width:740px){html {font-size: 11px;}} + +/* CSS seems backward: List all the classes for which we want a + particular font, so that the font can be changed in one place. (It + would be nicer to reference a font definition from all the places + that we want it.) + + As you read the rest of the file, remember to double-check here to + see if any font is set. */ + +/* Monospace: */ +.maincolumn, .refpara, .refelem, .tocset, .stt, .hspace, .refparaleft, .refelemleft { + font-family: 'Source Code Pro', monospace; + white-space: inherit; + font-size: 1rem; +} + +.stt { + font-weight: 500; +} + +h2 .stt { + font-size: 2.7rem; +} + +.toptoclink .stt { + font-size: inherit; +} +.toclink .stt { + font-size: 90%; +} + +.RpackageSpec .stt { + font-weight: 300; + font-family: 'Source Code Pro'; + font-size: 0.9rem; +} + +h3 .stt, h4 .stt, h5 .stt { + color: #333; + font-size: 1.65rem; + font-weight: 400; +} + + +/* Serif: */ +.main, .refcontent, .tocview, .tocsub, .sroman, i { + font-family: 'Charter', serif; + font-size: 1.18rem; +} + + +/* Sans-serif: */ +.version, .versionNoNav, .ssansserif { + font-family: 'Fira', sans-serif; +} +.ssansserif { + font-family: 'Fira'; + font-weight: 500; + font-size: 0.9em; +} + +.tocset .ssansserif { + font-size: 100%; +} + +/* ---------------------------------------- */ + +p, .SIntrapara { + display: block; + margin: 0 0 1em 0; + line-height: 1.4; +} + +.compact { + padding: 0 0 1em 0; +} + +li { + list-style-position: outside; + margin-left: 1.2em; +} + +h1, h2, h3, h4, h5, h6, h7, h8 { + font-family: 'Fira'; + font-weight: 300; + font-size: 1.6rem; + color: #333; + margin-top: inherit; + margin-bottom: 1rem; + line-height: 1.25; + -moz-font-feature-settings: 'tnum=1'; + -moz-font-feature-settings: 'tnum' 1; + -webkit-font-feature-settings: 'tnum' 1; + -o-font-feature-settings: 'tnum' 1; + -ms-font-feature-settings: 'tnum' 1; + font-feature-settings: 'tnum' 1; + +} + +h3, h4, h5, h6, h7, h8 { + border-top: 1px solid black; +} + + + +h2 { /* per-page main title */ + font-family: 'Miso'; + font-weight: bold; + margin-top: 4rem; + font-size: 3rem; + line-height: 1.1; + width: 90%; +} + +h3, h4, h5, h6, h7, h8 { + margin-top: 2em; + padding-top: 0.1em; + margin-bottom: 0.75em; +} + +/* ---------------------------------------- */ +/* Main */ + +body { + color: black; + background-color: white; +} + +.maincolumn { + width: auto; + margin-top: 4rem; + margin-left: 17rem; + margin-right: 2rem; + margin-bottom: 10rem; /* to avoid fixed bottom nav bar */ + max-width: 700px; + min-width: 370px; /* below this size, code samples don't fit */ +} + +a { + text-decoration: inherit; +} + +a, .toclink, .toptoclink, .tocviewlink, .tocviewselflink, .tocviewtoggle, .plainlink, +.techinside, .techoutside:hover, .techinside:hover { + color: #07A; +} + +a:hover { + text-decoration: underline; +} + + +/* ---------------------------------------- */ +/* Navigation */ + +.navsettop, .navsetbottom { + left: 0; + width: 15rem; + height: 6rem; + font-family: 'Fira'; + font-size: 0.9rem; + border-bottom: 0px solid hsl(216, 15%, 70%); + background-color: inherit; + padding: 0; +} + +.navsettop { + position: absolute; + top: 0; + left: 0; + margin-bottom: 0; + border-bottom: 0; +} + +.navsettop a, .navsetbottom a { + color: black; +} + +.navsettop a:hover, .navsetbottom a:hover { + background: hsl(216, 78%, 95%); + text-decoration: none; +} + +.navleft, .navright { + position: static; + float: none; + margin: 0; + white-space: normal; +} + + +.navleft a { + display: inline-block; +} + +.navright a { + display: inline-block; + text-align: center; +} + +.navleft a, .navright a, .navright span { + display: inline-block; + padding: 0.5rem; + min-width: 1rem; +} + + +.navright { + height: 2rem; + white-space: nowrap; +} + + +.navsetbottom { + display: none; +} + +.nonavigation { + color: #889; +} + +.searchform { + display: block; + margin: 0; + padding: 0; + border-bottom: 1px solid #eee; + height: 4rem; +} + +.nosearchform { + margin: 0; + padding: 0; + height: 4rem; +} + +.searchbox { + font-size: 1rem; + width: 12rem; + margin: 1rem; + padding: 0.25rem; + vertical-align: middle; + background-color: white; +} + +#search_box { + font-size: 0.8rem; +} + +/* ---------------------------------------- */ +/* Version */ + +.versionbox { + position: absolute; + float: none; + top: 0.25rem; + left: 17rem; + z-index: 11000; + height: 2em; + font-size: 70%; + font-weight: lighter; + width: inherit; + margin: 0; +} +.version, .versionNoNav { + font-size: inherit; +} +.version:before, .versionNoNav:before { + content: "v."; +} + + +/* ---------------------------------------- */ +/* Margin notes */ + +/* cancel scribble.css styles: */ +.refpara, .refelem { + position: static; + float: none; + height: auto; + width: auto; + margin: 0; +} + +.refcolumn { + position: static; + display: block; + width: auto; + font-size: inherit; + margin: 2rem; + margin-left: 2rem; + padding: 0.5em; + padding-left: 0.75em; + padding-right: 1em; + background: hsl(60, 29%, 94%); + border: 1px solid #ccb; + border-left: 0.4rem solid #ccb; +} + + +/* slightly different handling for margin-note* on narrow screens */ +@media all and (max-width:1340px) { + span.refcolumn { + float: right; + width: 50%; + margin-left: 1rem; + margin-bottom: 0.8rem; + margin-top: 1.2rem; + } + +} + +.refcontent, .refcontent p { + line-height: 1.5; + margin: 0; +} + +.refcontent p + p { + margin-top: 1em; +} + +.refcontent a { + font-weight: 400; +} + +.refpara, .refparaleft { + top: -1em; +} + + +@media all and (max-width:600px) { + .refcolumn { + margin-left: 0; + margin-right: 0; + } +} + + +@media all and (min-width:1340px) { + .refcolumn { + margin: 0 -22.5rem 1rem 0; + float: right; + clear: right; + width: 18rem; + } +} + +.refcontent { + font-family: 'Fira'; + font-size: 1rem; + line-height: 1.6; + margin: 0 0 0 0; +} + + +.refparaleft, .refelemleft { + position: relative; + float: left; + right: 2em; + height: 0em; + width: 13em; + margin: 0em 0em 0em -13em; +} + +.refcolumnleft { + background-color: hsl(60, 29%, 94%); + display: block; + position: relative; + width: 13em; + font-size: 85%; + border: 0.5em solid hsl(60, 29%, 94%); + margin: 0 0 0 0; +} + + +/* ---------------------------------------- */ +/* Table of contents, left margin */ + +.tocset { + position: absolute; + float: none; + left: 0; + top: 0rem; + width: 14rem; + padding: 7rem 0.5rem 0.5rem 0.5rem; + background-color: hsl(216, 15%, 70%); + margin: 0; + +} + +.tocset td { + vertical-align: text-top; + padding-bottom: 0.4rem; + padding-left: 0.2rem; + line-height: 1.1; + font-family: 'Fira'; + -moz-font-feature-settings: 'tnum=1'; + -moz-font-feature-settings: 'tnum' 1; + -webkit-font-feature-settings: 'tnum' 1; + -o-font-feature-settings: 'tnum' 1; + -ms-font-feature-settings: 'tnum' 1; + font-feature-settings: 'tnum' 1; + +} + +.tocset td a { + color: black; + font-weight: 400; +} + + +.tocview { + text-align: left; + background-color: inherit; +} + + +.tocview td, .tocsub td { + line-height: 1.3; +} + + +.tocview table, .tocsub table { + width: 90%; +} + +.tocset td a.tocviewselflink { + font-weight: lighter; + font-size: 110%; /* monospaced styles below don't need to enlarge */ + color: white; +} + +.tocviewselflink { + text-decoration: none; +} + +.tocsub { + text-align: left; + margin-top: 0.5em; + background-color: inherit; +} + +.tocviewlist, .tocsublist { + margin-left: 0.2em; + margin-right: 0.2em; + padding-top: 0.2em; + padding-bottom: 0.2em; +} +.tocviewlist table { + font-size: 82%; +} + +.tocviewlisttopspace { + margin-bottom: 1em; +} + +.tocviewsublist, .tocviewsublistonly, .tocviewsublisttop, .tocviewsublistbottom { + margin-left: 0.4em; + border-left: 1px solid #99a; + padding-left: 0.8em; +} +.tocviewsublist { + margin-bottom: 1em; +} +.tocviewsublist table, +.tocviewsublistonly table, +.tocviewsublisttop table, +.tocviewsublistbottom table, +table.tocsublist { + font-size: 1rem; +} + +.tocviewsublist td, .tocviewsublistbottom td, .tocviewsublisttop td, .tocsub td, +.tocviewsublistonly td { + font-size: 90%; +} + + +.tocviewtoggle { + font-size: 75%; /* looks better, and avoids bounce when toggling sub-sections due to font alignments */ +} + +.tocsublist td { + padding-left: 0.5rem; + padding-top: 0.25rem; + text-indent: 0; +} + +.tocsublinknumber { + font-size: 100%; +} + +.tocsublink { + font-size: 82%; + text-decoration: none; +} + +.tocsubseclink { + font-size: 100%; + text-decoration: none; +} + +.tocsubnonseclink { + font-size: 82%; + text-decoration: none; + margin-left: 1rem; + padding-left: 0; + display: inline-block; +} + +/* the label "on this page" */ +.tocsubtitle { + display: block; + font-size: 62%; + font-family: 'Fira'; + font-weight: bolder; + font-style: normal; + letter-spacing: 2px; + text-transform: uppercase; + margin: 0.5em; +} + +.toptoclink { + font-weight: bold; + font-size: 110%; + margin-bottom: 0.5rem; + margin-top: 1.5rem; + display: inline-block; +} + +.toclink { + font-size: inherit; +} + +/* ---------------------------------------- */ +/* Some inline styles */ + +.indexlink { + text-decoration: none; +} + +pre { + margin-left: 2em; +} + +blockquote { + margin-left: 2em; + margin-right: 2em; + margin-bottom: 1em; +} + +.SCodeFlow { + border-left: 1px dotted black; + padding-left: 1em; + padding-right: 1em; + margin-top: 1em; + margin-bottom: 1em; + margin-left: 0em; + margin-right: 2em; + white-space: nowrap; + line-height: 1.5; +} + +.SCodeFlow img { + margin-top: 0.5em; + margin-bottom: 0.5em; +} + +.boxed { + margin: 0; + margin-top: 2em; + padding: 0.25em; + padding-bottom: 0.5em; + background: #f3f3f3; + box-sizing:border-box; + border-top: 1px solid #99b; + background: hsl(216, 78%, 95%); + background: -moz-linear-gradient(to bottom left, hsl(0, 0%, 99%) 0%, hsl(216, 78%, 95%) 100%); + background: -webkit-linear-gradient(to bottom left, hsl(0, 0%, 99%) 0%, hsl(216, 78%, 95%) 100%); + background: -o-linear-gradient(to bottom left, hsl(0, 0%, 99%) 0%, hsl(216, 78%, 95%) 100%); + background: -ms-linear-gradient(to bottom left, hsl(0, 0%, 99%) 0%, hsl(216, 78%, 95%) 100%); + background: linear-gradient(to bottom left, hsl(0, 0%, 99%) 0%, hsl(216, 78%, 95%) 100%); +} + +blockquote > blockquote.SVInsetFlow { +/* resolves issue in e.g. /reference/notation.html */ + margin-top: 0em; +} + +.leftindent .SVInsetFlow { /* see e.g. section 4.5 of Racket Guide */ + margin-top: 1em; + margin-bottom: 1em; +} + +.SVInsetFlow a, .SCodeFlow a { + color: #07A; + font-weight: 500; +} + +.SubFlow { + display: block; + margin: 0em; +} + +.boxed { + width: 100%; + background-color: inherit; +} + +.techoutside { text-decoration: none; } + +.SAuthorListBox { + position: static; + float: none; + font-family: 'Fira'; + font-weight: 300; + font-size: 110%; + margin-top: 1rem; + margin-bottom: 3rem; + width: 30rem; + height: auto; +} + +.author > a { /* email links within author block */ + font-weight: inherit; + color: inherit; +} + +.SAuthorList { + font-size: 82%; +} +.SAuthorList:before { + content: "by "; +} +.author { + display: inline; + white-space: nowrap; +} + +/* phone + tablet styles */ + +@media all and (max-width:720px){ + + + @media all and (max-width:720px){ + + @media all {html {font-size: 15px;}} + @media all and (max-width:700px){html {font-size: 14px;}} + @media all and (max-width:630px){html {font-size: 13px;}} + @media all and (max-width:610px){html {font-size: 12px;}} + @media all and (max-width:550px){html {font-size: 11px;}} + @media all and (max-width:520px){html {font-size: 10px;}} + + .navsettop, .navsetbottom { + display: block; + position: absolute; + width: 100%; + height: 4rem; + border: 0; + background-color: hsl(216, 15%, 70%); + } + + .searchform { + display: inline; + border: 0; + } + + .navright { + position: absolute; + right: 1.5rem; + margin-top: 1rem; + border: 0px solid red; + } + + .navsetbottom { + display: block; + margin-top: 8rem; + } + + .tocset { + display: none; + } + + .tocset table, .tocset tbody, .tocset tr, .tocset td { + display: inline; + } + + .tocview { + display: none; + } + + .tocsub .tocsubtitle { + display: none; + } + + .versionbox { + top: 4.5rem; + left: 1rem; /* same distance as main-column */ + z-index: 11000; + height: 2em; + font-size: 70%; + font-weight: lighter; + } + + + .maincolumn { + margin-left: 1em; + margin-top: 7rem; + margin-bottom: 0rem; + } + + } + +} + +/* print styles : hide the navigation elements */ +@media print { + .tocset, + .navsettop, + .navsetbottom { display: none; } + .maincolumn { + width: auto; + margin-right: 13em; + margin-left: 0; + } +} \ No newline at end of file diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/racket.css b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/racket.css new file mode 100644 index 0000000..b44fef5 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/racket.css @@ -0,0 +1,249 @@ + +/* See the beginning of "scribble.css". */ + +/* Monospace: */ +.RktIn, .RktRdr, .RktPn, .RktMeta, +.RktMod, .RktKw, .RktVar, .RktSym, +.RktRes, .RktOut, .RktCmt, .RktVal, +.RktBlk { + font-family: monospace; + white-space: inherit; +} + +/* Serif: */ +.inheritedlbl { + font-family: serif; +} + +/* Sans-serif: */ +.RBackgroundLabelInner { + font-family: sans-serif; +} + +/* ---------------------------------------- */ +/* Inherited methods, left margin */ + +.inherited { + width: 100%; + margin-top: 0.5em; + text-align: left; + background-color: #ECF5F5; +} + +.inherited td { + font-size: 82%; + padding-left: 1em; + text-indent: -0.8em; + padding-right: 0.2em; +} + +.inheritedlbl { + font-style: italic; +} + +/* ---------------------------------------- */ +/* Racket text styles */ + +.RktIn { + color: #cc6633; + background-color: #eeeeee; +} + +.RktInBG { + background-color: #eeeeee; +} + +.RktRdr { +} + +.RktPn { + color: #843c24; +} + +.RktMeta { + color: black; +} + +.RktMod { + color: black; +} + +.RktOpt { + color: black; +} + +.RktKw { + color: black; +} + +.RktErr { + color: red; + font-style: italic; +} + +.RktVar { + color: #262680; + font-style: italic; +} + +.RktSym { + color: #262680; +} + +.RktSymDef { /* used with RktSym at def site */ +} + +.RktValLink { + text-decoration: none; + color: blue; +} + +.RktValDef { /* used with RktValLink at def site */ +} + +.RktModLink { + text-decoration: none; + color: blue; +} + +.RktStxLink { + text-decoration: none; + color: black; +} + +.RktStxDef { /* used with RktStxLink at def site */ +} + +.RktRes { + color: #0000af; +} + +.RktOut { + color: #960096; +} + +.RktCmt { + color: #c2741f; +} + +.RktVal { + color: #228b22; +} + +/* ---------------------------------------- */ +/* Some inline styles */ + +.together { + width: 100%; +} + +.prototype, .argcontract, .RBoxed { + white-space: nowrap; +} + +.prototype td { + vertical-align: text-top; +} + +.RktBlk { + white-space: inherit; + text-align: left; +} + +.RktBlk tr { + white-space: inherit; +} + +.RktBlk td { + vertical-align: baseline; + white-space: inherit; +} + +.argcontract td { + vertical-align: text-top; +} + +.highlighted { + background-color: #ddddff; +} + +.defmodule { + width: 100%; + background-color: #F5F5DC; +} + +.specgrammar { + float: right; +} + +.RBibliography td { + vertical-align: text-top; +} + +.leftindent { + margin-left: 1em; + margin-right: 0em; +} + +.insetpara { + margin-left: 1em; + margin-right: 1em; +} + +.Rfilebox { +} + +.Rfiletitle { + text-align: right; + margin: 0em 0em 0em 0em; +} + +.Rfilename { + border-top: 1px solid #6C8585; + border-right: 1px solid #6C8585; + padding-left: 0.5em; + padding-right: 0.5em; + background-color: #ECF5F5; +} + +.Rfilecontent { + margin: 0em 0em 0em 0em; +} + +.RpackageSpec { + padding-right: 0.5em; +} + +/* ---------------------------------------- */ +/* For background labels */ + +.RBackgroundLabel { + float: right; + width: 0px; + height: 0px; +} + +.RBackgroundLabelInner { + position: relative; + width: 25em; + left: -25.5em; + top: 0px; + text-align: right; + color: white; + z-index: 0; + font-weight: bold; +} + +.RForeground { + position: relative; + left: 0px; + top: 0px; + z-index: 1; +} + +/* ---------------------------------------- */ +/* History */ + +.SHistory { + font-size: 82%; +} diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/doc/scribble-common.js b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/scribble-common.js new file mode 100644 index 0000000..1ec7da5 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/doc/scribble-common.js @@ -0,0 +1,170 @@ +// Common functionality for PLT documentation pages + +// Page Parameters ------------------------------------------------------------ + +var page_query_string = location.search.substring(1); + +var page_args = + ((function(){ + if (!page_query_string) return []; + var args = page_query_string.split(/[&;]/); + for (var i=0; i= 0) args[i] = [a.substring(0,p), a.substring(p+1)]; + else args[i] = [a, false]; + } + return args; + })()); + +function GetPageArg(key, def) { + for (var i=0; i= 0 && cur.substring(0,eql) == key) + return unescape(cur.substring(eql+1)); + } + return def; + } +} + +function SetCookie(key, val) { + try { + localStorage[key] = val; + } catch(e) { + var d = new Date(); + d.setTime(d.getTime()+(365*24*60*60*1000)); + try { + document.cookie = + key + "=" + escape(val) + "; expires="+ d.toGMTString() + "; path=/"; + } catch (e) {} + } +} + +// note that this always stores a directory name, ending with a "/" +function SetPLTRoot(ver, relative) { + var root = location.protocol + "//" + location.host + + NormalizePath(location.pathname.replace(/[^\/]*$/, relative)); + SetCookie("PLT_Root."+ver, root); +} + +// adding index.html works because of the above +function GotoPLTRoot(ver, relative) { + var u = GetCookie("PLT_Root."+ver, null); + if (u == null) return true; // no cookie: use plain up link + // the relative path is optional, default goes to the toplevel start page + if (!relative) relative = "index.html"; + location = u + relative; + return false; +} + +// Utilities ------------------------------------------------------------------ + +var normalize_rxs = [/\/\/+/g, /\/\.(\/|$)/, /\/[^\/]*\/\.\.(\/|$)/]; +function NormalizePath(path) { + var tmp, i; + for (i = 0; i < normalize_rxs.length; i++) + while ((tmp = path.replace(normalize_rxs[i], "/")) != path) path = tmp; + return path; +} + +// `noscript' is problematic in some browsers (always renders as a +// block), use this hack instead (does not always work!) +// document.write(""); + +// Interactions --------------------------------------------------------------- + +function DoSearchKey(event, field, ver, top_path) { + var val = field.value; + if (event && event.keyCode == 13) { + var u = GetCookie("PLT_Root."+ver, null); + if (u == null) u = top_path; // default: go to the top path + u += "search/index.html?q=" + encodeURIComponent(val); + u = MergePageArgsIntoUrl(u); + location = u; + return false; + } + return true; +} + +function TocviewToggle(glyph, id) { + var s = document.getElementById(id).style; + var expand = s.display == "none"; + s.display = expand ? "block" : "none"; + glyph.innerHTML = expand ? "▼" : "►"; +} + +// Page Init ------------------------------------------------------------------ + +// Note: could make a function that inspects and uses window.onload to chain to +// a previous one, but this file needs to be required first anyway, since it +// contains utilities for all other files. +var on_load_funcs = []; +function AddOnLoad(fun) { on_load_funcs.push(fun); } +window.onload = function() { + for (var i=0; i + .techinside doesn't work with IE, so use both (and IE doesn't + work with inherit in the second one, so use blue directly) */ +.techinside { color: black; } +.techinside:hover { color: blue; } +.techoutside:hover>.techinside { color: inherit; } + +.SCentered { + text-align: center; +} + +.imageleft { + float: left; + margin-right: 0.3em; +} + +.Smaller { + font-size: 82%; +} + +.Larger { + font-size: 122%; +} + +/* A hack, inserted to break some Scheme ids: */ +.mywbr { + display: inline-block; + height: 0; + width: 0; + font-size: 1px; +} + +.compact li p { + margin: 0em; + padding: 0em; +} + +.noborder img { + border: 0; +} + +.SAuthorListBox { + position: relative; + float: right; + left: 2em; + top: -2.5em; + height: 0em; + width: 13em; + margin: 0em -13em 0em 0em; +} +.SAuthorList { + font-size: 82%; +} +.SAuthorList:before { + content: "by "; +} +.author { + display: inline; + white-space: nowrap; +} + +/* print styles : hide the navigation elements */ +@media print { + .tocset, + .navsettop, + .navsetbottom { display: none; } + .maincolumn { + width: auto; + margin-right: 13em; + margin-left: 0; + } +} diff --git a/br-parser-tools/br-parser-tools-doc/parser-tools/info.rkt b/br-parser-tools/br-parser-tools-doc/parser-tools/info.rkt new file mode 100644 index 0000000..f219d03 --- /dev/null +++ b/br-parser-tools/br-parser-tools-doc/parser-tools/info.rkt @@ -0,0 +1,3 @@ +#lang info + +(define scribblings '(("br-parser-tools.scrbl" (multi-page) (parsing-library)))) diff --git a/br-parser-tools/br-parser-tools-lib/LICENSE.txt b/br-parser-tools/br-parser-tools-lib/LICENSE.txt new file mode 100644 index 0000000..f6889f1 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/LICENSE.txt @@ -0,0 +1,11 @@ +parser-tools-lib +Copyright (c) 2010-2014 PLT Design Inc. + +This package is distributed under the GNU Lesser General Public +License (LGPL). This means that you can link this package into proprietary +applications, provided you follow the rules stated in the LGPL. You +can also modify this package; if you distribute a modified version, +you must distribute it under the terms of the LGPL, which in +particular means that you must release the source code for the +modified software. See http://www.gnu.org/copyleft/lesser.html +for more information. diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/cfg-parser.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/cfg-parser.rkt new file mode 100644 index 0000000..7b8b839 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/cfg-parser.rkt @@ -0,0 +1,982 @@ +#lang racket/base +;; This module implements a parser form like the br-parser-tools's +;; `parser', except that it works on an arbitrary CFG (returning +;; the first sucecssful parse). + +;; I'm pretty sure that this is an implementation of Earley's +;; algorithm. + +;; To a first approximation, it's a backtracking parser. Alternative +;; for a non-terminal are computed in parallel, and multiple attempts +;; to compute the same result block until the first one completes. If +;; you get into deadlock, such as when trying to match +;; := +;; then it means that there's no successful parse, so everything +;; that's blocked fails. + +;; A cache holds the series of results for a particular non-terminal +;; at a particular starting location. (A series is used, instead of a +;; sinlge result, for backtracking.) Otherwise, the parser uses +;; backtracking search. Backtracking is implemented through explicit +;; success and failure continuations. Multiple results for a +;; particular nonterminal and location are kept only when they have +;; different lengths. (Otherwise, in the spirit of finding one +;; successful parse, only the first result is kept.) + +;; The br-parser-tools's `parse' is used to transform tokens in the +;; grammar to tokens specific to this parser. In other words, this +;; parser uses `parser' so that it doesn't have to know anything about +;; tokens. +;; + + + +(require br-parser-tools/yacc + br-parser-tools/lex) + +(require (for-syntax racket/base + syntax/boundmap + br-parser-tools/private-lex/token-syntax)) + +(provide cfg-parser) + +;; A raw token, wrapped so that we can recognize it: +(define-struct tok (name orig-name val start end)) + +;; Represents the thread scheduler: +(define-struct tasks (active active-back waits multi-waits cache progress?)) + +(define-for-syntax make-token-identifier-mapping make-hasheq) +(define-for-syntax token-identifier-mapping-get + (case-lambda + [(t tok) + (hash-ref t (syntax-e tok))] + [(t tok fail) + (hash-ref t (syntax-e tok) fail)])) +(define-for-syntax token-identifier-mapping-put! + (lambda (t tok v) + (hash-set! t (syntax-e tok) v))) +(define-for-syntax token-identifier-mapping-map + (lambda (t f) + (hash-map t f))) + +;; Used to calculate information on the grammar, such as whether +;; a particular non-terminal is "simple" instead of recursively defined. +(define-for-syntax (nt-fixpoint nts proc nt-ids patss) + (define (ormap-all val f as bs) + (cond + [(null? as) val] + [else (ormap-all (or (f (car as) (car bs)) val) + f + (cdr as) (cdr bs))])) + (let loop () + (when (ormap-all #f + (lambda (nt pats) + (let ([old (bound-identifier-mapping-get nts nt)]) + (let ([new (proc nt pats old)]) + (if (equal? old new) + #f + (begin + (bound-identifier-mapping-put! nts nt new) + #t))))) + nt-ids patss) + (loop)))) + +;; Tries parse-a followed by parse-b. If parse-a is not simple, +;; then after parse-a succeeds once, we parallelize parse-b +;; and trying a second result for parse-a. +(define (parse-and simple-a? parse-a parse-b + stream last-consumed-token depth end success-k fail-k + max-depth tasks) + (letrec ([mk-got-k + (lambda (success-k fail-k) + (lambda (val stream last-consumed-token depth max-depth tasks next1-k) + (if simple-a? + (parse-b val stream last-consumed-token depth end + (mk-got2-k success-k fail-k next1-k) + (mk-fail2-k success-k fail-k next1-k) + max-depth tasks) + (parallel-or + (lambda (success-k fail-k max-depth tasks) + (parse-b val stream last-consumed-token depth end + success-k fail-k + max-depth tasks)) + (lambda (success-k fail-k max-depth tasks) + (next1-k (mk-got-k success-k fail-k) + fail-k max-depth tasks)) + success-k fail-k max-depth tasks))))] + [mk-got2-k + (lambda (success-k fail-k next1-k) + (lambda (val stream last-consumed-token depth max-depth tasks next-k) + (success-k val stream last-consumed-token depth max-depth tasks + (lambda (success-k fail-k max-depth tasks) + (next-k (mk-got2-k success-k fail-k next1-k) + (mk-fail2-k success-k fail-k next1-k) + max-depth tasks)))))] + [mk-fail2-k + (lambda (success-k fail-k next1-k) + (lambda (max-depth tasks) + (next1-k (mk-got-k success-k fail-k) + fail-k + max-depth + tasks)))]) + (parse-a stream last-consumed-token depth end + (mk-got-k success-k fail-k) + fail-k + max-depth tasks))) + +;; Parallel or for non-terminal alternatives +(define (parse-parallel-or parse-a parse-b stream last-consumed-token depth end success-k fail-k max-depth tasks) + (parallel-or (lambda (success-k fail-k max-depth tasks) + (parse-a stream last-consumed-token depth end success-k fail-k max-depth tasks)) + (lambda (success-k fail-k max-depth tasks) + (parse-b stream last-consumed-token depth end success-k fail-k max-depth tasks)) + success-k fail-k max-depth tasks)) + +;; Generic parallel-or +(define (parallel-or parse-a parse-b success-k fail-k max-depth tasks) + (define answer-key (gensym)) + (letrec ([gota-k + (lambda (val stream last-consumed-token depth max-depth tasks next-k) + (report-answer answer-key + max-depth + tasks + (list val stream last-consumed-token depth next-k)))] + [faila-k + (lambda (max-depth tasks) + (report-answer answer-key + max-depth + tasks + null))]) + (let* ([tasks (queue-task + tasks + (lambda (max-depth tasks) + (parse-a gota-k + faila-k + max-depth tasks)))] + [tasks (queue-task + tasks + (lambda (max-depth tasks) + (parse-b gota-k + faila-k + max-depth tasks)))] + [queue-next (lambda (next-k tasks) + (queue-task tasks + (lambda (max-depth tasks) + (next-k gota-k + faila-k + max-depth tasks))))]) + (letrec ([mk-got-one + (lambda (immediate-next? get-nth success-k) + (lambda (val stream last-consumed-token depth max-depth tasks next-k) + (let ([tasks (if immediate-next? + (queue-next next-k tasks) + tasks)]) + (success-k val stream last-consumed-token depth max-depth + tasks + (lambda (success-k fail-k max-depth tasks) + (let ([tasks (if immediate-next? + tasks + (queue-next next-k tasks))]) + (get-nth max-depth tasks success-k fail-k)))))))] + [get-first + (lambda (max-depth tasks success-k fail-k) + (wait-for-answer #f max-depth tasks answer-key + (mk-got-one #t get-first success-k) + (lambda (max-depth tasks) + (get-second max-depth tasks success-k fail-k)) + #f))] + [get-second + (lambda (max-depth tasks success-k fail-k) + (wait-for-answer #f max-depth tasks answer-key + (mk-got-one #f get-second success-k) + fail-k #f))]) + (get-first max-depth tasks success-k fail-k))))) + +;; Non-terminal alternatives where the first is "simple" can be done +;; sequentially, which is simpler +(define (parse-or parse-a parse-b + stream last-consumed-token depth end success-k fail-k max-depth tasks) + (letrec ([mk-got-k + (lambda (success-k fail-k) + (lambda (val stream last-consumed-token depth max-depth tasks next-k) + (success-k val stream last-consumed-token depth + max-depth tasks + (lambda (success-k fail-k max-depth tasks) + (next-k (mk-got-k success-k fail-k) + (mk-fail-k success-k fail-k) + max-depth tasks)))))] + [mk-fail-k + (lambda (success-k fail-k) + (lambda (max-depth tasks) + (parse-b stream last-consumed-token depth end success-k fail-k max-depth tasks)))]) + (parse-a stream last-consumed-token depth end + (mk-got-k success-k fail-k) + (mk-fail-k success-k fail-k) + max-depth tasks))) + +;; Starts a thread +(define queue-task + (lambda (tasks t [progress? #t]) + (make-tasks (tasks-active tasks) + (cons t (tasks-active-back tasks)) + (tasks-waits tasks) + (tasks-multi-waits tasks) + (tasks-cache tasks) + (or progress? (tasks-progress? tasks))))) + +;; Reports an answer to a waiting thread: +(define (report-answer answer-key max-depth tasks val) + (let ([v (hash-ref (tasks-waits tasks) answer-key (lambda () #f))]) + (if v + (let ([tasks (make-tasks (cons (v val) + (tasks-active tasks)) + (tasks-active-back tasks) + (tasks-waits tasks) + (tasks-multi-waits tasks) + (tasks-cache tasks) + #t)]) + (hash-remove! (tasks-waits tasks) answer-key) + (swap-task max-depth tasks)) + ;; We have an answer ready too fast; wait + (swap-task max-depth + (queue-task tasks + (lambda (max-depth tasks) + (report-answer answer-key max-depth tasks val)) + #f))))) + +;; Reports an answer to multiple waiting threads: +(define (report-answer-all answer-key max-depth tasks val k) + (let ([v (hash-ref (tasks-multi-waits tasks) answer-key (lambda () null))]) + (hash-remove! (tasks-multi-waits tasks) answer-key) + (let ([tasks (make-tasks (append (map (lambda (a) (a val)) v) + (tasks-active tasks)) + (tasks-active-back tasks) + (tasks-waits tasks) + (tasks-multi-waits tasks) + (tasks-cache tasks) + #t)]) + (k max-depth tasks)))) + +;; Waits for an answer; if `multi?' is #f, this is sole waiter, otherwise +;; there might be many. Use wither #t or #f (and `report-answer' or +;; `report-answer-all', resptively) consistently for a particular answer key. +(define (wait-for-answer multi? max-depth tasks answer-key success-k fail-k deadlock-k) + (let ([wait (lambda (val) + (lambda (max-depth tasks) + (if val + (if (null? val) + (fail-k max-depth tasks) + (let-values ([(val stream last-consumed-token depth next-k) (apply values val)]) + (success-k val stream last-consumed-token depth max-depth tasks next-k))) + (deadlock-k max-depth tasks))))]) + (if multi? + (hash-set! (tasks-multi-waits tasks) answer-key + (cons wait (hash-ref (tasks-multi-waits tasks) answer-key + (lambda () null)))) + (hash-set! (tasks-waits tasks) answer-key wait)) + (let ([tasks (make-tasks (tasks-active tasks) + (tasks-active-back tasks) + (tasks-waits tasks) + (tasks-multi-waits tasks) + (tasks-cache tasks) + #t)]) + (swap-task max-depth tasks)))) + +;; Swap thread +(define (swap-task max-depth tasks) + ;; Swap in first active: + (if (null? (tasks-active tasks)) + (if (tasks-progress? tasks) + (swap-task max-depth + (make-tasks (reverse (tasks-active-back tasks)) + null + (tasks-waits tasks) + (tasks-multi-waits tasks) + (tasks-cache tasks) + #f)) + ;; No progress, so issue failure for all multi-waits + (if (zero? (hash-count (tasks-multi-waits tasks))) + (error 'swap-task "Deadlock") + (swap-task max-depth + (make-tasks (apply + append + (hash-map (tasks-multi-waits tasks) + (lambda (k l) + (map (lambda (v) (v #f)) l)))) + (tasks-active-back tasks) + (tasks-waits tasks) + (make-hasheq) + (tasks-cache tasks) + #t)))) + (let ([t (car (tasks-active tasks))] + [tasks (make-tasks (cdr (tasks-active tasks)) + (tasks-active-back tasks) + (tasks-waits tasks) + (tasks-multi-waits tasks) + (tasks-cache tasks) + (tasks-progress? tasks))]) + (t max-depth tasks)))) + +;; Finds the symbolic representative of a token class +(define-for-syntax (map-token toks tok) + (car (token-identifier-mapping-get toks tok))) + +(define no-pos-val (make-position #f #f #f)) +(define-for-syntax no-pos + (let ([npv ((syntax-local-certifier) #'no-pos-val)]) + (lambda (stx) npv))) +(define-for-syntax at-tok-pos + (lambda (sel expr) + (lambda (stx) + #`(let ([v #,expr]) (if v (#,sel v) no-pos-val))))) + +;; Builds a matcher for a particular alternative +(define-for-syntax (build-match nts toks pat handle $ctx) + (let loop ([pat pat] + [pos 1]) + (if (null? pat) + #`(success-k #,handle stream last-consumed-token depth max-depth tasks + (lambda (success-k fail-k max-depth tasks) + (fail-k max-depth tasks))) + (let ([id (datum->syntax (car pat) + (string->symbol (format "$~a" pos)))] + [id-start-pos (datum->syntax (car pat) + (string->symbol (format "$~a-start-pos" pos)))] + [id-end-pos (datum->syntax (car pat) + (string->symbol (format "$~a-end-pos" pos)))] + [n-end-pos (and (null? (cdr pat)) + (datum->syntax (car pat) '$n-end-pos))]) + (cond + [(bound-identifier-mapping-get nts (car pat) (lambda () #f)) + ;; Match non-termimal + #`(parse-and + ;; First part is simple? (If so, we don't have to parallelize the `and'.) + #,(let ([l (bound-identifier-mapping-get nts (car pat) (lambda () #f))]) + (or (not l) + (andmap values (caddr l)))) + #,(car pat) + (let ([original-stream stream]) + (lambda (#,id stream last-consumed-token depth end success-k fail-k max-depth tasks) + (let-syntax ([#,id-start-pos (at-tok-pos #'(if (eq? original-stream stream) + tok-end + tok-start) + #'(if (eq? original-stream stream) + last-consumed-token + (and (pair? original-stream) + (car original-stream))))] + [#,id-end-pos (at-tok-pos #'tok-end #'last-consumed-token)] + #,@(if n-end-pos + #`([#,n-end-pos (at-tok-pos #'tok-end #'last-consumed-token)]) + null)) + #,(loop (cdr pat) (add1 pos))))) + stream last-consumed-token depth + #,(let ([cnt (apply + + (map (lambda (item) + (cond + [(bound-identifier-mapping-get nts item (lambda () #f)) + => (lambda (l) (car l))] + [else 1])) + (cdr pat)))]) + #`(- end #,cnt)) + success-k fail-k max-depth tasks)] + [else + ;; Match token + (let ([tok-id (map-token toks (car pat))]) + #`(if (and (pair? stream) + (eq? '#,tok-id (tok-name (car stream)))) + (let* ([stream-a (car stream)] + [#,id (tok-val stream-a)] + [last-consumed-token (car stream)] + [stream (cdr stream)] + [depth (add1 depth)]) + (let ([max-depth (max max-depth depth)]) + (let-syntax ([#,id-start-pos (at-tok-pos #'tok-start #'stream-a)] + [#,id-end-pos (at-tok-pos #'tok-end #'stream-a)] + #,@(if n-end-pos + #`([#,n-end-pos (at-tok-pos #'tok-end #'stream-a)]) + null)) + #,(loop (cdr pat) (add1 pos))))) + (fail-k max-depth tasks)))]))))) + +;; Starts parsing to match a non-terminal. There's a minor +;; optimization that checks for known starting tokens. Otherwise, +;; use the cache, block if someone else is already trying the match, +;; and cache the result if it's computed. +;; The cache maps nontermial+startingpos+iteration to a result, where +;; the iteration is 0 for the first match attempt, 1 for the second, +;; etc. +(define (parse-nt/share key min-cnt init-tokens stream last-consumed-token depth end max-depth tasks success-k fail-k k) + (if (and (positive? min-cnt) + (pair? stream) + (not (memq (tok-name (car stream)) init-tokens))) + ;; No such leading token; give up + (fail-k max-depth tasks) + ;; Run pattern + (let loop ([n 0] + [success-k success-k] + [fail-k fail-k] + [max-depth max-depth] + [tasks tasks] + [k k]) + (let ([answer-key (gensym)] + [table-key (vector key depth n)] + [old-depth depth] + [old-stream stream]) + #;(printf "Loop ~a\n" table-key) + (cond + [(hash-ref (tasks-cache tasks) table-key (lambda () #f)) + => (lambda (result) + #;(printf "Reuse ~a\n" table-key) + (result success-k fail-k max-depth tasks))] + [else + #;(printf "Try ~a ~a\n" table-key (map tok-name stream)) + (hash-set! (tasks-cache tasks) table-key + (lambda (success-k fail-k max-depth tasks) + #;(printf "Wait ~a ~a\n" table-key answer-key) + (wait-for-answer #t max-depth tasks answer-key success-k fail-k + (lambda (max-depth tasks) + #;(printf "Deadlock ~a ~a\n" table-key answer-key) + (fail-k max-depth tasks))))) + (let result-loop ([max-depth max-depth][tasks tasks][k k]) + (letrec ([orig-stream stream] + [new-got-k + (lambda (val stream last-consumed-token depth max-depth tasks next-k) + ;; Check whether we already have a result that consumed the same amount: + (let ([result-key (vector #f key old-depth depth)]) + (cond + [(hash-ref (tasks-cache tasks) result-key (lambda () #f)) + ;; Go for the next-result + (result-loop max-depth + tasks + (lambda (end max-depth tasks success-k fail-k) + (next-k success-k fail-k max-depth tasks)))] + [else + #;(printf "Success ~a ~a\n" table-key + (map tok-name (let loop ([d old-depth][s old-stream]) + (if (= d depth) + null + (cons (car s) (loop (add1 d) (cdr s))))))) + (let ([next-k (lambda (success-k fail-k max-depth tasks) + (loop (add1 n) + success-k + fail-k + max-depth + tasks + (lambda (end max-depth tasks success-k fail-k) + (next-k success-k fail-k max-depth tasks))))]) + (hash-set! (tasks-cache tasks) result-key #t) + (hash-set! (tasks-cache tasks) table-key + (lambda (success-k fail-k max-depth tasks) + (success-k val stream last-consumed-token depth max-depth tasks next-k))) + (report-answer-all answer-key + max-depth + tasks + (list val stream last-consumed-token depth next-k) + (lambda (max-depth tasks) + (success-k val stream last-consumed-token depth max-depth tasks next-k))))])))] + [new-fail-k + (lambda (max-depth tasks) + #;(printf "Failure ~a\n" table-key) + (hash-set! (tasks-cache tasks) table-key + (lambda (success-k fail-k max-depth tasks) + (fail-k max-depth tasks))) + (report-answer-all answer-key + max-depth + tasks + null + (lambda (max-depth tasks) + (fail-k max-depth tasks))))]) + (k end max-depth tasks new-got-k new-fail-k)))]))))) + +(define-syntax (cfg-parser stx) + (syntax-case stx () + [(_ clause ...) + (let ([clauses (syntax->list #'(clause ...))]) + (let-values ([(start grammar cfg-error parser-clauses src-pos?) + (let ([all-toks (apply + append + (map (lambda (clause) + (syntax-case clause (tokens) + [(tokens t ...) + (apply + append + (map (lambda (t) + (let ([v (syntax-local-value t (lambda () #f))]) + (cond + [(terminals-def? v) + (map (lambda (v) + (cons v #f)) + (syntax->list (terminals-def-t v)))] + [(e-terminals-def? v) + (map (lambda (v) + (cons v #t)) + (syntax->list (e-terminals-def-t v)))] + [else null]))) + (syntax->list #'(t ...))))] + [_else null])) + clauses))] + [all-end-toks (apply + append + (map (lambda (clause) + (syntax-case clause (end) + [(end t ...) + (syntax->list #'(t ...))] + [_else null])) + clauses))]) + (let loop ([clauses clauses] + [cfg-start #f] + [cfg-grammar #f] + [cfg-error #f] + [src-pos? #f] + [parser-clauses null]) + (if (null? clauses) + (values cfg-start + cfg-grammar + cfg-error + (reverse parser-clauses) + src-pos?) + (syntax-case (car clauses) (start error grammar src-pos) + [(start tok) + (loop (cdr clauses) #'tok cfg-grammar cfg-error src-pos? parser-clauses)] + [(error expr) + (loop (cdr clauses) cfg-start cfg-grammar #'expr src-pos? parser-clauses)] + [(grammar [nt [pat handle0 handle ...] ...] ...) + (let ([nts (make-bound-identifier-mapping)] + [toks (make-token-identifier-mapping)] + [end-toks (make-token-identifier-mapping)] + [nt-ids (syntax->list #'(nt ...))] + [patss (map (lambda (stx) + (map syntax->list (syntax->list stx))) + (syntax->list #'((pat ...) ...)))]) + (for-each (lambda (nt) + (bound-identifier-mapping-put! nts nt (list 0))) + nt-ids) + (for-each (lambda (t) + (token-identifier-mapping-put! end-toks t #t)) + all-end-toks) + (for-each (lambda (t) + (unless (token-identifier-mapping-get end-toks (car t) (lambda () #f)) + (let ([id (gensym (syntax-e (car t)))]) + (token-identifier-mapping-put! toks (car t) + (cons id (cdr t)))))) + all-toks) + ;; Compute min max size for each non-term: + (nt-fixpoint + nts + (lambda (nt pats old-list) + (let ([new-cnt + (apply + min + (map (lambda (pat) + (apply + + + (map (lambda (elem) + (car + (bound-identifier-mapping-get nts + elem + (lambda () (list 1))))) + pat))) + pats))]) + (if (new-cnt . > . (car old-list)) + (cons new-cnt (cdr old-list)) + old-list))) + nt-ids patss) + ;; Compute set of toks that must appear at the beginning + ;; for a non-terminal + (nt-fixpoint + nts + (lambda (nt pats old-list) + (let ([new-list + (apply + append + (map (lambda (pat) + (let loop ([pat pat]) + (if (pair? pat) + (let ([l (bound-identifier-mapping-get + nts + (car pat) + (lambda () + (list 1 (map-token toks (car pat)))))]) + ;; If the non-terminal can match 0 things, + ;; then it might match something from the + ;; next pattern element. Otherwise, it must + ;; match the first element: + (if (zero? (car l)) + (append (cdr l) (loop (cdr pat))) + (cdr l))) + null))) + pats))]) + (let ([new (filter (lambda (id) + (andmap (lambda (id2) + (not (eq? id id2))) + (cdr old-list))) + new-list)]) + (if (pair? new) + ;; Drop dups in new list: + (let ([new (let loop ([new new]) + (if (null? (cdr new)) + new + (if (ormap (lambda (id) + (eq? (car new) id)) + (cdr new)) + (loop (cdr new)) + (cons (car new) (loop (cdr new))))))]) + (cons (car old-list) (append new (cdr old-list)))) + old-list)))) + nt-ids patss) + ;; Determine left-recursive clauses: + (for-each (lambda (nt pats) + (let ([l (bound-identifier-mapping-get nts nt)]) + (bound-identifier-mapping-put! nts nt (list (car l) + (cdr l) + (map (lambda (x) #f) pats))))) + nt-ids patss) + (nt-fixpoint + nts + (lambda (nt pats old-list) + (list (car old-list) + (cadr old-list) + (map (lambda (pat simple?) + (or simple? + (let ([l (map (lambda (elem) + (bound-identifier-mapping-get + nts + elem + (lambda () #f))) + pat)]) + (andmap (lambda (i) + (or (not i) + (andmap values (caddr i)))) + l)))) + pats (caddr old-list)))) + nt-ids patss) + ;; Build a definition for each non-term: + (loop (cdr clauses) + cfg-start + (map (lambda (nt pats handles $ctxs) + (define info (bound-identifier-mapping-get nts nt)) + (list nt + #`(let ([key (gensym '#,nt)]) + (lambda (stream last-consumed-token depth end success-k fail-k max-depth tasks) + (parse-nt/share + key #,(car info) '#,(cadr info) stream last-consumed-token depth end + max-depth tasks + success-k fail-k + (lambda (end max-depth tasks success-k fail-k) + #,(let loop ([pats pats] + [handles (syntax->list handles)] + [$ctxs (syntax->list $ctxs)] + [simple?s (caddr info)]) + (if (null? pats) + #'(fail-k max-depth tasks) + #`(#,(if (or (null? (cdr pats)) + (car simple?s)) + #'parse-or + #'parse-parallel-or) + (lambda (stream last-consumed-token depth end success-k fail-k max-depth tasks) + #,(build-match nts + toks + (car pats) + (car handles) + (car $ctxs))) + (lambda (stream last-consumed-token depth end success-k fail-k max-depth tasks) + #,(loop (cdr pats) + (cdr handles) + (cdr $ctxs) + (cdr simple?s))) + stream last-consumed-token depth end success-k fail-k max-depth tasks))))))))) + nt-ids + patss + (syntax->list #'(((begin handle0 handle ...) ...) ...)) + (syntax->list #'((handle0 ...) ...))) + cfg-error + src-pos? + (list* + (with-syntax ([((tok tok-id . $e) ...) + (token-identifier-mapping-map toks + (lambda (k v) + (list* k + (car v) + (if (cdr v) + #f + '$1))))] + [(pos ...) + (if src-pos? + #'($1-start-pos $1-end-pos) + #'(#f #f))]) + #`(grammar (start [() null] + [(atok start) (cons $1 $2)]) + (atok [(tok) (make-tok 'tok-id 'tok $e pos ...)] ...))) + #`(start start) + parser-clauses)))] + [(grammar . _) + (raise-syntax-error + #f + "bad grammar clause" + stx + (car clauses))] + [(src-pos) + (loop (cdr clauses) + cfg-start + cfg-grammar + cfg-error + #t + (cons (car clauses) parser-clauses))] + [_else + (loop (cdr clauses) + cfg-start + cfg-grammar + cfg-error + src-pos? + (cons (car clauses) parser-clauses))]))))]) + #`(let ([orig-parse (parser + [error (lambda (a b c) + (error 'cfg-parser "unexpected ~a token: ~a" b c))] + . #,parser-clauses)] + [error-proc #,cfg-error]) + (letrec #,grammar + (lambda (get-tok) + (let ([tok-list (orig-parse get-tok)]) + (letrec ([success-k + (lambda (val stream last-consumed-token depth max-depth tasks next) + (if (null? stream) + val + (next success-k fail-k max-depth tasks)))] + [fail-k (lambda (max-depth tasks) + (define (call-error-proc tok-ok? tok-name tok-value start-pos end-pos) + (cond + [(procedure-arity-includes? error-proc 5) + (error-proc tok-ok? tok-name tok-value start-pos end-pos)] + [else + (error-proc tok-ok? tok-name tok-value)])) + (cond + [(null? tok-list) + (if error-proc + (call-error-proc #t + 'no-tokens + #f + (make-position #f #f #f) + (make-position #f #f #f)) + (error + 'cfg-parse + "no tokens"))] + [else + (let ([bad-tok (list-ref tok-list + (min (sub1 (length tok-list)) + max-depth))]) + (if error-proc + (call-error-proc #t + (tok-orig-name bad-tok) + (tok-val bad-tok) + (tok-start bad-tok) + (tok-end bad-tok)) + (error + 'cfg-parse + "failed at ~a" + (tok-val bad-tok))))]))]) + (#,start tok-list + ;; we simulate a token at the very beginning with zero width + ;; for use with the position-generating code (*-start-pos, *-end-pos). + (if (null? tok-list) + (tok #f #f #f + (position 1 + #,(if src-pos? #'1 #'#f) + #,(if src-pos? #'0 #'#f)) + (position 1 + #,(if src-pos? #'1 #'#f) + #,(if src-pos? #'0 #'#f))) + (tok (tok-name (car tok-list)) + (tok-orig-name (car tok-list)) + (tok-val (car tok-list)) + (tok-start (car tok-list)) + (tok-start (car tok-list)))) + 0 + (length tok-list) + success-k + fail-k + 0 + (make-tasks null null + (make-hasheq) (make-hasheq) + (make-hash) #t)))))))))])) + + +(module* test racket/base + (require (submod "..") + br-parser-tools/lex + racket/block + racket/generator + rackunit) + + ;; Test: parsing regular expressions. + ;; Here is a test case on locations: + (block + (define-tokens regexp-tokens (ANCHOR STAR OR LIT LPAREN RPAREN EOF)) + (define lex (lexer-src-pos ["|" (token-OR lexeme)] + ["^" (token-ANCHOR lexeme)] + ["*" (token-STAR lexeme)] + [(repetition 1 +inf.0 alphabetic) (token-LIT lexeme)] + ["(" (token-LPAREN lexeme)] + [")" (token-RPAREN lexeme)] + [whitespace (return-without-pos (lex input-port))] + [(eof) (token-EOF 'eof)])) + (define -parse (cfg-parser + (tokens regexp-tokens) + (start top) + (end EOF) + (src-pos) + (grammar [top [(maybe-anchor regexp) + (cond [$1 + `(anchored ,$2 ,(pos->sexp $1-start-pos) ,(pos->sexp $2-end-pos))] + [else + `(unanchored ,$2 ,(pos->sexp $1-start-pos) ,(pos->sexp $2-end-pos))])]] + [maybe-anchor [(ANCHOR) #t] + [() #f]] + [regexp [(regexp STAR) `(star ,$1 ,(pos->sexp $1-start-pos) ,(pos->sexp $2-end-pos))] + [(regexp OR regexp) `(or ,$1 ,$3 ,(pos->sexp $1-start-pos) ,(pos->sexp $3-end-pos))] + [(LPAREN regexp RPAREN) `(group ,$2 ,(pos->sexp $1-start-pos) ,(pos->sexp $3-end-pos))] + [(LIT) `(lit ,$1 ,(pos->sexp $1-start-pos) ,(pos->sexp $1-end-pos))]]))) + (define (pos->sexp pos) + (position-offset pos)) + + (define (parse s) + (define ip (open-input-string s)) + (port-count-lines! ip) + (-parse (lambda () (lex ip)))) + + (check-equal? (parse "abc") + '(unanchored (lit "abc" 1 4) 1 4)) + (check-equal? (parse "a | (b*) | c") + '(unanchored (or (or (lit "a" 1 2) + (group (star (lit "b" 6 7) 6 8) 5 9) + 1 9) + (lit "c" 12 13) + 1 13) + 1 13))) + + + ;; Check that cfg-parser can accept error functions of 3 arguments: + (block + (define-tokens non-terminals (ONE ZERO EOF)) + (define parse + (cfg-parser (tokens non-terminals) + (start ones) + (end EOF) + (error (lambda (tok-ok tok-name tok-val) + (error (format "~a ~a ~a" tok-ok tok-name tok-val)))) + (grammar [ones [() null] + [(ONE ones) (cons $1 $2)]]))) + (define (sequence->tokenizer s) + (define-values (more? next) (sequence-generate s)) + (lambda () + (cond [(more?) (next)] + [else (token-EOF 'eof)]))) + (check-exn #rx"#t ZERO zero" + (lambda () (parse (sequence->tokenizer (list (token-ZERO "zero"))))))) + + + + + ;; Check that cfg-parser can accept error functions of 5 arguments: + (block + (define-tokens non-terminals (ONE ZERO EOF)) + (define parse + (cfg-parser (tokens non-terminals) + (start ones) + (src-pos) + (end EOF) + (error (lambda (tok-ok tok-name tok-val start-pos end-pos) + (error (format "~a ~a ~a ~a ~a" + tok-ok tok-name tok-val + (position-offset start-pos) + (position-offset end-pos))))) + (grammar [ones [() null] + [(ONE ones) (cons $1 $2)]]))) + (define (sequence->tokenizer s) + (define-values (more? next) (sequence-generate s)) + (lambda () + (cond [(more?) (next)] + [else (position-token (token-EOF 'eof) + (position #f #f #f) + (position #f #f #f))]))) + (check-exn #rx"#t ZERO zero 2 3" + (lambda () + (parse + (sequence->tokenizer + (list (position-token + (token-ZERO "zero") + (position 2 2 5) + (position 3 2 6)))))))) + + + + + + ;; Tests used during development + (define-tokens non-terminals (PLUS MINUS STAR BAR COLON EOF)) + + (define lex + (lexer + ["+" (token-PLUS '+)] + ["-" (token-MINUS '-)] + ["*" (token-STAR '*)] + ["|" (token-BAR '||)] + [":" (token-COLON '|:|)] + [whitespace (lex input-port)] + [(eof) (token-EOF 'eof)])) + + (define parse + (cfg-parser + (tokens non-terminals) + (start ) + (end EOF) + (error (lambda (a b stx) + (error 'parse "failed at ~s" stx))) + (grammar [ [(PLUS) "plus"] + [( BAR ) (list $1 $2 $3)] + [( COLON) (list $1)]] + [ [(MINUS) "minus"] + [( STAR) (cons $1 $2)]] + [ [( MINUS) "yes"]] + [ [(PLUS) 'plus] + [(MINUS) 'minus]] + [ [() '0] + [( PLUS) (add1 $1)] + [( PLUS) (add1 $1)]]))) + + (let ([p (open-input-string #;"+*|-|-*|+**" #;"-|+*|+**" + #;"+*|+**|-" #;"-|-*|-|-*" + #;"-|-*|-|-**|-|-*|-|-**" + "-|-*|-|-**|-|-*|-|-***|-|-*|-|-**|-|-*|-|-****|-|-*|-|-**|-|-*|-|-*** + |-|-*|-|-**|-|-*|-|-*****|-|-*|-|-**|-|-*|-|-***|-|-*|-|-**|-|-*|-|-****| + -|-*|-|-**|-|-*|-|-***|-|-*|-|-**|-|-*|-|-*****" + ;; This one fails: + #;"+*")]) + (check-equal? (parse (lambda () (lex p))) + '((((((((((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *) || (((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *)) . *) + || + (((((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *) || (((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *)) . *)) + . + *) + || + (((((((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *) || (((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *)) . *) + || + (((((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *) || (((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *)) . *)) + . + *)) + . + *) + || + (((((((((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *) || (((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *)) . *) + || + (((((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *) || (((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *)) . *)) + . + *) + || + (((((((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *) || (((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *)) . *) + || + (((((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *) || (((("minus" || "minus") . *) || (("minus" || "minus") . *)) . *)) . *)) + . + *)) + . + *))))) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/examples/calc.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/examples/calc.rkt new file mode 100644 index 0000000..9ad1218 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/examples/calc.rkt @@ -0,0 +1,89 @@ +#lang scheme + +;; An interactive calculator inspired by the calculator example in the bison manual. + + +;; Import the parser and lexer generators. +(require br-parser-tools/yacc + br-parser-tools/lex + (prefix-in : br-parser-tools/lex-sre)) + +(define-tokens value-tokens (NUM VAR FNCT)) +(define-empty-tokens op-tokens (newline = OP CP + - * / ^ EOF NEG)) + +;; A hash table to store variable values in for the calculator +(define vars (make-hash)) + +(define-lex-abbrevs + (lower-letter (:/ "a" "z")) + + (upper-letter (:/ #\A #\Z)) + + ;; (:/ 0 9) would not work because the lexer does not understand numbers. (:/ #\0 #\9) is ok too. + (digit (:/ "0" "9"))) + +(define calcl + (lexer + [(eof) 'EOF] + ;; recursively call the lexer on the remaining input after a tab or space. Returning the + ;; result of that operation. This effectively skips all whitespace. + [(:or #\tab #\space) (calcl input-port)] + ;; (token-newline) returns 'newline + [#\newline (token-newline)] + ;; Since (token-=) returns '=, just return the symbol directly + [(:or "=" "+" "-" "*" "/" "^") (string->symbol lexeme)] + ["(" 'OP] + [")" 'CP] + ["sin" (token-FNCT sin)] + [(:+ (:or lower-letter upper-letter)) (token-VAR (string->symbol lexeme))] + [(:+ digit) (token-NUM (string->number lexeme))] + [(:: (:+ digit) #\. (:* digit)) (token-NUM (string->number lexeme))])) + + +(define calcp + (parser + + (start start) + (end newline EOF) + (tokens value-tokens op-tokens) + (error (lambda (a b c) (void))) + + (precs (right =) + (left - +) + (left * /) + (left NEG) + (right ^)) + + (grammar + + (start [() #f] + ;; If there is an error, ignore everything before the error + ;; and try to start over right after the error + [(error start) $2] + [(exp) $1]) + + (exp [(NUM) $1] + [(VAR) (hash-ref vars $1 (lambda () 0))] + [(VAR = exp) (begin (hash-set! vars $1 $3) + $3)] + [(FNCT OP exp CP) ($1 $3)] + [(exp + exp) (+ $1 $3)] + [(exp - exp) (- $1 $3)] + [(exp * exp) (* $1 $3)] + [(exp / exp) (/ $1 $3)] + [(- exp) (prec NEG) (- $2)] + [(exp ^ exp) (expt $1 $3)] + [(OP exp CP) $2])))) + +;; run the calculator on the given input-port +(define (calc ip) + (port-count-lines! ip) + (letrec ((one-line + (lambda () + (let ((result (calcp (lambda () (calcl ip))))) + (when result + (printf "~a\n" result) + (one-line)))))) + (one-line))) + +(calc (open-input-string "x=1\n(x + 2 * 3) - (1+2)*3")) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/examples/read.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/examples/read.rkt new file mode 100644 index 0000000..a10b2c1 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/examples/read.rkt @@ -0,0 +1,242 @@ +;; This implements the equivalent of racket's read-syntax for R5RS scheme. +;; It has not been thoroughly tested. Also it will read an entire file into a +;; list of syntax objects, instead of returning one syntax object at a time + +(module read mzscheme + + (require br-parser-tools/lex + (prefix : br-parser-tools/lex-sre) + br-parser-tools/yacc + syntax/readerr) + + (define-tokens data (DATUM)) + (define-empty-tokens delim (OP CP HASHOP QUOTE QUASIQUOTE UNQUOTE UNQUOTE-SPLICING DOT EOF)) + + (define scheme-lexer + (lexer-src-pos + + ;; Skip comments, without accumulating extra position information + [(:or scheme-whitespace comment) (return-without-pos (scheme-lexer input-port))] + + ["#t" (token-DATUM #t)] + ["#f" (token-DATUM #f)] + [(:: "#\\" any-char) (token-DATUM (caddr (string->list lexeme)))] + ["#\\space" (token-DATUM #\space)] + ["#\\newline" (token-DATUM #\newline)] + [(:or (:: initial (:* subsequent)) "+" "-" "...") (token-DATUM (string->symbol lexeme))] + [#\" (token-DATUM (list->string (get-string-token input-port)))] + [#\( 'OP] + [#\) 'CP] + [#\[ 'OP] + [#\] 'CP] + ["#(" 'HASHOP] + [num2 (token-DATUM (string->number lexeme 2))] + [num8 (token-DATUM (string->number lexeme 8))] + [num10 (token-DATUM (string->number lexeme 10))] + [num16 (token-DATUM (string->number lexeme 16))] + ["'" 'QUOTE] + ["`" 'QUASIQUOTE] + ["," 'UNQUOTE] + [",@" 'UNQUOTE-SPLICING] + ["." 'DOT] + [(eof) 'EOF])) + + (define get-string-token + (lexer + [(:~ #\" #\\) (cons (car (string->list lexeme)) + (get-string-token input-port))] + [(:: #\\ #\\) (cons #\\ (get-string-token input-port))] + [(:: #\\ #\") (cons #\" (get-string-token input-port))] + [#\" null])) + + + (define-lex-abbrevs + [letter (:or (:/ "a" "z") (:/ #\A #\Z))] + [digit (:/ #\0 #\9)] + [scheme-whitespace (:or #\newline #\return #\tab #\space #\vtab)] + [initial (:or letter (char-set "!$%&*/:<=>?^_~@"))] + [subsequent (:or initial digit (char-set "+-.@"))] + [comment (:: #\; (:* (:~ #\newline)) #\newline)] + + + ;; See ${PLTHOME}/collects/syntax-color/racket-lexer.rkt for an example of + ;; using regexp macros to avoid the cut and paste. + ; [numR (:: prefixR complexR)] + ; [complexR (:or realR + ; (:: realR "@" realR) + ; (:: realR "+" urealR "i") + ; (:: realR "-" urealR "i") + ; (:: realR "+i") + ; (:: realR "-i") + ; (:: "+" urealR "i") + ; (:: "-" urealR "i") + ; (:: "+i") + ; (:: "-i"))] + ; [realR (:: sign urealR)] + ; [urealR (:or uintegerR (:: uintegerR "/" uintegerR) decimalR)] + ; [uintegerR (:: (:+ digitR) (:* #\#))] + ; [prefixR (:or (:: radixR exactness) + ; (:: exactness radixR))] + + [num2 (:: prefix2 complex2)] + [complex2 (:or real2 + (:: real2 "@" real2) + (:: real2 "+" ureal2 "i") + (:: real2 "-" ureal2 "i") + (:: real2 "+i") + (:: real2 "-i") + (:: "+" ureal2 "i") + (:: "-" ureal2 "i") + (:: "+i") + (:: "-i"))] + [real2 (:: sign ureal2)] + [ureal2 (:or uinteger2 (:: uinteger2 "/" uinteger2))] + [uinteger2 (:: (:+ digit2) (:* #\#))] + [prefix2 (:or (:: radix2 exactness) + (:: exactness radix2))] + [radix2 "#b"] + [digit2 (:or "0" "1")] + [num8 (:: prefix8 complex8)] + [complex8 (:or real8 + (:: real8 "@" real8) + (:: real8 "+" ureal8 "i") + (:: real8 "-" ureal8 "i") + (:: real8 "+i") + (:: real8 "-i") + (:: "+" ureal8 "i") + (:: "-" ureal8 "i") + (:: "+i") + (:: "-i"))] + [real8 (:: sign ureal8)] + [ureal8 (:or uinteger8 (:: uinteger8 "/" uinteger8))] + [uinteger8 (:: (:+ digit8) (:* #\#))] + [prefix8 (:or (:: radix8 exactness) + (:: exactness radix8))] + [radix8 "#o"] + [digit8 (:/ "0" "7")] + + [num10 (:: prefix10 complex10)] + [complex10 (:or real10 + (:: real10 "@" real10) + (:: real10 "+" ureal10 "i") + (:: real10 "-" ureal10 "i") + (:: real10 "+i") + (:: real10 "-i") + (:: "+" ureal10 "i") + (:: "-" ureal10 "i") + (:: "+i") + (:: "-i"))] + [real10 (:: sign ureal10)] + [ureal10 (:or uinteger10 (:: uinteger10 "/" uinteger10) decimal10)] + [uinteger10 (:: (:+ digit10) (:* #\#))] + [prefix10 (:or (:: radix10 exactness) + (:: exactness radix10))] + [radix10 (:? "#d")] + [digit10 digit] + [decimal10 (:or (:: uinteger10 suffix) + (:: #\. (:+ digit10) (:* #\#) suffix) + (:: (:+ digit10) #\. (:* digit10) (:* #\#) suffix) + (:: (:+ digit10) (:+ #\#) #\. (:* #\#) suffix))] + + [num16 (:: prefix16 complex16)] + [complex16 (:or real16 + (:: real16 "@" real16) + (:: real16 "+" ureal16 "i") + (:: real16 "-" ureal16 "i") + (:: real16 "+i") + (:: real16 "-i") + (:: "+" ureal16 "i") + (:: "-" ureal16 "i") + "+i" + "-i")] + [real16 (:: sign ureal16)] + [ureal16 (:or uinteger16 (:: uinteger16 "/" uinteger16))] + [uinteger16 (:: (:+ digit16) (:* #\#))] + [prefix16 (:or (:: radix16 exactness) + (:: exactness radix16))] + [radix16 "#x"] + [digit16 (:or digit (:/ #\a #\f) (:/ #\A #\F))] + + + [suffix (:or "" (:: exponent-marker sign (:+ digit10)))] + [exponent-marker (:or "e" "s" "f" "d" "l")] + [sign (:or "" "+" "-")] + [exactness (:or "" "#i" "#e")]) + + + (define stx-for-original-property (read-syntax #f (open-input-string "original"))) + + ;; A macro to build the syntax object + (define-syntax (build-so stx) + (syntax-case stx () + ((_ value start end) + (with-syntax ((start-pos (datum->syntax-object + (syntax end) + (string->symbol + (format "$~a-start-pos" + (syntax-object->datum (syntax start)))))) + (end-pos (datum->syntax-object + (syntax end) + (string->symbol + (format "$~a-end-pos" + (syntax-object->datum (syntax end)))))) + (source (datum->syntax-object + (syntax end) + 'source-name))) + (syntax + (datum->syntax-object + #f + value + (list source + (position-line start-pos) + (position-col start-pos) + (position-offset start-pos) + (- (position-offset end-pos) + (position-offset start-pos))) + stx-for-original-property)))))) + + (define (scheme-parser source-name) + (parser + (src-pos) + + (start s) + (end EOF) + (error (lambda (a name val start end) + (raise-read-error + "read-error" + source-name + (position-line start) + (position-col start) + (position-offset start) + (- (position-offset end) + (position-offset start))))) + (tokens data delim) + + + (grammar + + (s [(sexp-list) (reverse $1)]) + + (sexp [(DATUM) (build-so $1 1 1)] + [(OP sexp-list CP) (build-so (reverse $2) 1 3)] + [(HASHOP sexp-list CP) (build-so (list->vector (reverse $2)) 1 3)] + [(QUOTE sexp) (build-so (list 'quote $2) 1 2)] + [(QUASIQUOTE sexp) (build-so (list 'quasiquote $2) 1 2)] + [(UNQUOTE sexp) (build-so (list 'unquote $2) 1 2)] + [(UNQUOTE-SPLICING sexp) (build-so (list 'unquote-splicing $2) 1 2)] + [(OP sexp-list DOT sexp CP) (build-so (append (reverse $2) $4) 1 5)]) + + (sexp-list [() null] + [(sexp-list sexp) (cons $2 $1)])))) + + (define (rs sn ip) + (port-count-lines! ip) + ((scheme-parser sn) (lambda () (scheme-lexer ip)))) + + (define readsyntax + (case-lambda ((sn) (rs sn (current-input-port))) + ((sn ip) (rs sn ip)))) + + (provide (rename readsyntax read-syntax)) + + ) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/info.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/info.rkt new file mode 100644 index 0000000..ae66609 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/info.rkt @@ -0,0 +1,3 @@ +#lang info + +(define compile-omit-paths '("private-lex/error-tests.rkt")) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/lex-plt-v200.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/lex-plt-v200.rkt new file mode 100644 index 0000000..0cbb175 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/lex-plt-v200.rkt @@ -0,0 +1,24 @@ +(module lex-plt-v200 mzscheme + (require br-parser-tools/lex + (prefix : br-parser-tools/lex-sre)) + + (provide epsilon + ~ + (rename :* *) + (rename :+ +) + (rename :? ?) + (rename :or :) + (rename :& &) + (rename :: @) + (rename :~ ^) + (rename :/ -)) + + (define-lex-trans epsilon + (syntax-rules () + ((_) ""))) + + (define-lex-trans ~ + (syntax-rules () + ((_ re) (complement re))))) + + diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/lex-sre.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/lex-sre.rkt new file mode 100644 index 0000000..820d090 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/lex-sre.rkt @@ -0,0 +1,119 @@ +(module lex-sre mzscheme + (require br-parser-tools/lex) + + (provide (rename sre-* *) + (rename sre-+ +) + ? + (rename sre-= =) + (rename sre->= >=) + ** + (rename sre-or or) + : + seq + & + ~ + (rename sre-- -) + (rename sre-/ /) + /-only-chars) + + (define-lex-trans sre-* + (syntax-rules () + ((_ re ...) + (repetition 0 +inf.0 (union re ...))))) + + (define-lex-trans sre-+ + (syntax-rules () + ((_ re ...) + (repetition 1 +inf.0 (union re ...))))) + + (define-lex-trans ? + (syntax-rules () + ((_ re ...) + (repetition 0 1 (union re ...))))) + + (define-lex-trans sre-= + (syntax-rules () + ((_ n re ...) + (repetition n n (union re ...))))) + + (define-lex-trans sre->= + (syntax-rules () + ((_ n re ...) + (repetition n +inf.0 (union re ...))))) + + (define-lex-trans ** + (syntax-rules () + ((_ low #f re ...) + (** low +inf.0 re ...)) + ((_ low high re ...) + (repetition low high (union re ...))))) + + (define-lex-trans sre-or + (syntax-rules () + ((_ re ...) + (union re ...)))) + + (define-lex-trans : + (syntax-rules () + ((_ re ...) + (concatenation re ...)))) + + (define-lex-trans seq + (syntax-rules () + ((_ re ...) + (concatenation re ...)))) + + (define-lex-trans & + (syntax-rules () + ((_ re ...) + (intersection re ...)))) + + (define-lex-trans ~ + (syntax-rules () + ((_ re ...) + (char-complement (union re ...))))) + + ;; set difference + (define-lex-trans (sre-- stx) + (syntax-case stx () + ((_) + (raise-syntax-error #f + "must have at least one argument" + stx)) + ((_ big-re re ...) + (syntax (& big-re (complement (union re ...))))))) + + (define-lex-trans (sre-/ stx) + (syntax-case stx () + ((_ range ...) + (let ((chars + (apply append (map (lambda (r) + (let ((x (syntax-e r))) + (cond + ((char? x) (list x)) + ((string? x) (string->list x)) + (else + (raise-syntax-error + #f + "not a char or string" + stx + r))))) + (syntax->list (syntax (range ...))))))) + (unless (even? (length chars)) + (raise-syntax-error + #f + "not given an even number of characters" + stx)) + #`(/-only-chars #,@chars))))) + + (define-lex-trans /-only-chars + (syntax-rules () + ((_ c1 c2) + (char-range c1 c2)) + ((_ c1 c2 c ...) + (union (char-range c1 c2) + (/-only-chars c ...))))) + + ) + + diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/lex.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/lex.rkt new file mode 100644 index 0000000..fc8e359 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/lex.rkt @@ -0,0 +1,410 @@ +(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 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 position (offset line col)) + (struct position-token (token start-pos end-pos)) + (struct srcloc-token (token srcloc)) + + ;; 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-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-pos (make-rename-transformer #'ret)]) + (make-srcloc-token #,action lexeme-srcloc)))] + [else action]))) + (syntax/loc action + (lambda (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-trans src-loc-style) + (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 (or src-loc-style '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-loc-style)) + act-lst)) + ((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: + (lambda (port) (proc port))))) + 'disappeared-use + disappeared-uses))))))))) + + (define-syntax lexer (make-lexer-trans #f)) + (define-syntax lexer-src-pos (make-lexer-trans 'lexer-src-pos)) + (define-syntax lexer-srcloc (make-lexer-trans 'lexer-srcloc)) + + (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 lexeme-srcloc input-port return-without-pos) + + ) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/actions.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/actions.rkt new file mode 100644 index 0000000..6ec0c7f --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/actions.rkt @@ -0,0 +1,16 @@ +#lang scheme/base + +(provide (all-defined-out)) +(require syntax/stx) + +;; get-special-action: (syntax-object list) syntax-object syntax-object -> syntax-object +;; Returns the first action from a rule of the form ((which-special) action) +(define (get-special-action rules which-special none) + (cond + ((null? rules) none) + (else + (syntax-case (car rules) () + (((special) act) + (and (identifier? #'special) (module-or-top-identifier=? (syntax special) which-special)) + (syntax act)) + (_ (get-special-action (cdr rules) which-special none)))))) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/deriv.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/deriv.rkt new file mode 100644 index 0000000..28919a3 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/deriv.rkt @@ -0,0 +1,339 @@ +(module deriv mzscheme + + (require mzlib/list + (prefix is: mzlib/integer-set) + "re.rkt" + "util.rkt") + + (provide build-dfa print-dfa (struct dfa (num-states start-state final-states/actions transitions))) + + (define e (build-epsilon)) + (define z (build-zero)) + + + ;; Don't do anything with this one but extract the chars + (define all-chars (->re `(char-complement (union)) (make-cache))) + + ;; get-char-groups : re bool -> (list-of char-setR?) + ;; Collects the char-setRs in r that could be used in + ;; taking the derivative of r. + (define (get-char-groups r found-negation) + (cond + ((or (eq? r e) (eq? r z)) null) + ((char-setR? r) (list r)) + ((concatR? r) + (if (re-nullable? (concatR-re1 r)) + (append (get-char-groups (concatR-re1 r) found-negation) + (get-char-groups (concatR-re2 r) found-negation)) + (get-char-groups (concatR-re1 r) found-negation))) + ((repeatR? r) + (get-char-groups (repeatR-re r) found-negation)) + ((orR? r) + (apply append (map (lambda (x) (get-char-groups x found-negation)) (orR-res r)))) + ((andR? r) + (apply append (map (lambda (x) (get-char-groups x found-negation)) (andR-res r)))) + ((negR? r) + (if found-negation + (get-char-groups (negR-re r) #t) + (cons all-chars (get-char-groups (negR-re r) #t)))))) + + (test-block ((c (make-cache)) + (r1 (->re #\1 c)) + (r2 (->re #\2 c))) + ((get-char-groups e #f) null) + ((get-char-groups z #f) null) + ((get-char-groups r1 #f) (list r1)) + ((get-char-groups (->re `(concatenation ,r1 ,r2) c) #f) + (list r1)) + ((get-char-groups (->re `(concatenation ,e ,r2) c) #f) + (list r2)) + ((get-char-groups (->re `(concatenation (repetition 0 +inf.0 ,r1) ,r2) c) #f) + (list r1 r2)) + ((get-char-groups (->re `(repetition 0 +inf.0 ,r1) c) #f) + (list r1)) + ((get-char-groups + (->re `(union (repetition 0 +inf.0 ,r1) + (concatenation (repetition 0 +inf.0 ,r2) "3") "4") c) #f) + (list r1 r2 (->re "3" c) (->re "4" c))) + ((get-char-groups (->re `(complement ,r1) c) #f) + (list all-chars r1)) + ((get-char-groups + (->re `(intersection (repetition 0 +inf.0 ,r1) + (concatenation (repetition 0 +inf.0 ,r2) "3") "4") c) #f) + (list r1 r2 (->re "3" c) (->re "4" c))) + ) + (define loc:member? is:member?) + + ;; deriveR : re char cache -> re + (define (deriveR r c cache) + (cond + ((or (eq? r e) (eq? r z)) z) + ((char-setR? r) + (if (loc:member? c (char-setR-chars r)) e z)) + ((concatR? r) + (let* ((r1 (concatR-re1 r)) + (r2 (concatR-re2 r)) + (d (build-concat (deriveR r1 c cache) r2 cache))) + (if (re-nullable? r1) + (build-or (list d (deriveR r2 c cache)) cache) + d))) + ((repeatR? r) + (build-concat (deriveR (repeatR-re r) c cache) + (build-repeat (sub1 (repeatR-low r)) + (sub1 (repeatR-high r)) + (repeatR-re r) cache) + cache)) + ((orR? r) + (build-or (map (lambda (x) (deriveR x c cache)) + (orR-res r)) + cache)) + ((andR? r) + (build-and (map (lambda (x) (deriveR x c cache)) + (andR-res r)) + cache)) + ((negR? r) + (build-neg (deriveR (negR-re r) c cache) cache)))) + + (test-block ((c (make-cache)) + (a (char->integer #\a)) + (b (char->integer #\b)) + (r1 (->re #\a c)) + (r2 (->re `(repetition 0 +inf.0 #\a) c)) + (r3 (->re `(repetition 0 +inf.0 ,r2) c)) + (r4 (->re `(concatenation #\a ,r2) c)) + (r5 (->re `(repetition 0 +inf.0 ,r4) c)) + (r6 (->re `(union ,r5 #\a) c)) + (r7 (->re `(concatenation ,r2 ,r2) c)) + (r8 (->re `(complement ,r4) c)) + (r9 (->re `(intersection ,r2 ,r4) c))) + ((deriveR e a c) z) + ((deriveR z a c) z) + ((deriveR r1 b c) z) + ((deriveR r1 a c) e) + ((deriveR r2 a c) r2) + ((deriveR r2 b c) z) + ((deriveR r3 a c) r2) + ((deriveR r3 b c) z) + ((deriveR r4 a c) r2) + ((deriveR r4 b c) z) + ((deriveR r5 a c) (->re `(concatenation ,r2 ,r5) c)) + ((deriveR r5 b c) z) + ((deriveR r6 a c) (->re `(union (concatenation ,r2 ,r5) "") c)) + ((deriveR r6 b c) z) + ((deriveR r7 a c) (->re `(union (concatenation ,r2 ,r2) ,r2) c)) + ((deriveR r7 b c) z) + ((deriveR r8 a c) (->re `(complement, r2) c)) + ((deriveR r8 b c) (->re `(complement ,z) c)) + ((deriveR r9 a c) r2) + ((deriveR r9 b c) z) + ((deriveR (->re `(repetition 1 2 "ab") c) a c) + (->re `(concatenation "b" (repetition 0 1 "ab")) c))) + + ;; An re-action is (cons re action) + + ;; derive : (list-of re-action) char cache -> (union (list-of re-action) #f) + ;; applies deriveR to all the re-actions's re parts. + ;; Returns #f if the derived state is equivalent to z. + (define (derive r c cache) + (let ((new-r (map (lambda (ra) + (cons (deriveR (car ra) c cache) (cdr ra))) + r))) + (if (andmap (lambda (x) (eq? z (car x))) + new-r) + #f + new-r))) + + (test-block ((c (make-cache)) + (r1 (->re #\1 c)) + (r2 (->re #\2 c))) + ((derive null (char->integer #\1) c) #f) + ((derive (list (cons r1 1) (cons r2 2)) (char->integer #\1) c) + (list (cons e 1) (cons z 2))) + ((derive (list (cons r1 1) (cons r2 2)) (char->integer #\3) c) #f)) + + + ;; get-final : (list-of re-action) -> (union #f syntax-object) + ;; An re that accepts e represents a final state. Return the + ;; action from the first final state or #f if there is none. + (define (get-final res) + (cond + ((null? res) #f) + ((re-nullable? (caar res)) (cdar res)) + (else (get-final (cdr res))))) + + (test-block ((c->i char->integer) + (c (make-cache)) + (r1 (->re #\a c)) + (r2 (->re #\b c)) + (b (list (cons z 1) (cons z 2) (cons z 3) (cons e 4) (cons z 5))) + (a (list (cons r1 1) (cons r2 2)))) + ((derive null (c->i #\a) c) #f) + ((derive a (c->i #\a) c) (list (cons e 1) (cons z 2))) + ((derive a (c->i #\b) c) (list (cons z 1) (cons e 2))) + ((derive a (c->i #\c) c) #f) + ((derive (list (cons (->re `(union " " "\n" ",") c) 1) + (cons (->re `(concatenation (repetition 0 1 "-") + (repetition 1 +inf.0 (char-range "0" "9"))) c) 2) + (cons (->re `(concatenation "-" (repetition 1 +inf.0 "-")) c) 3) + (cons (->re "[" c) 4) + (cons (->re "]" c) 5)) (c->i #\[) c) + b) + ((get-final a) #f) + ((get-final (list (cons e 1) (cons e 2))) 1) + ((get-final b) 4)) + + + ;; A state is (make-state (list-of re-action) nat) + (define-struct state (spec index)) + + ;; get->key : re-action -> (list-of nat) + ;; states are indexed by the list of indexes of their res + (define (get-key s) + (map (lambda (x) (re-index (car x))) s)) + + (define loc:partition is:partition) + + ;; compute-chars : (list-of state) -> (list-of char-set) + ;; Computed the sets of equivalent characters for taking the + ;; derivative of the car of st. Only one derivative per set need to be taken. + (define (compute-chars st) + (cond + ((null? st) null) + (else + (loc:partition (map char-setR-chars + (apply append (map (lambda (x) (get-char-groups (car x) #f)) + (state-spec (car st))))))))) + + (test-block ((c (make-cache)) + (c->i char->integer) + (r1 (->re `(char-range #\1 #\4) c)) + (r2 (->re `(char-range #\2 #\3) c))) + ((compute-chars null) null) + ((compute-chars (list (make-state null 1))) null) + ((map is:integer-set-contents + (compute-chars (list (make-state (list (cons r1 1) (cons r2 2)) 2)))) + (list (is:integer-set-contents (is:make-range (c->i #\2) (c->i #\3))) + (is:integer-set-contents (is:union (is:make-range (c->i #\1)) + (is:make-range (c->i #\4))))))) + + + ;; A dfa is (make-dfa int int + ;; (list-of (cons int syntax-object)) + ;; (list-of (cons int (list-of (cons char-set int))))) + ;; Each transitions is a state and a list of chars with the state to transition to. + ;; The finals and transitions are sorted by state number, and duplicate free. + (define-struct dfa (num-states start-state final-states/actions transitions) (make-inspector)) + + (define loc:get-integer is:get-integer) + + ;; build-dfa : (list-of re-action) cache -> dfa + (define (build-dfa rs cache) + (let* ((transitions (make-hash-table)) + (get-state-number (make-counter)) + (start (make-state rs (get-state-number)))) + (cache (cons 'state (get-key rs)) (lambda () start)) + (let loop ((old-states (list start)) + (new-states null) + (all-states (list start)) + (cs (compute-chars (list start)))) + (cond + ((and (null? old-states) (null? new-states)) + (make-dfa (get-state-number) (state-index start) + (sort (filter (lambda (x) (cdr x)) + (map (lambda (state) + (cons (state-index state) (get-final (state-spec state)))) + all-states)) + (lambda (a b) (< (car a) (car b)))) + (sort (hash-table-map transitions + (lambda (state trans) + (cons (state-index state) + (map (lambda (t) + (cons (car t) + (state-index (cdr t)))) + trans)))) + (lambda (a b) (< (car a) (car b)))))) + ((null? old-states) + (loop new-states null all-states (compute-chars new-states))) + ((null? cs) + (loop (cdr old-states) new-states all-states (compute-chars (cdr old-states)))) + (else + (let* ((state (car old-states)) + (c (car cs)) + (new-re (derive (state-spec state) (loc:get-integer c) cache))) + (cond + (new-re + (let* ((new-state? #f) + (new-state (cache (cons 'state (get-key new-re)) + (lambda () + (set! new-state? #t) + (make-state new-re (get-state-number))))) + (new-all-states (if new-state? (cons new-state all-states) all-states))) + (hash-table-put! transitions + state + (cons (cons c new-state) + (hash-table-get transitions state + (lambda () null)))) + (cond + (new-state? + (loop old-states (cons new-state new-states) new-all-states (cdr cs))) + (else + (loop old-states new-states new-all-states (cdr cs)))))) + (else (loop old-states new-states all-states (cdr cs)))))))))) + + (define (print-dfa x) + (printf "number of states: ~a\n" (dfa-num-states x)) + (printf "start state: ~a\n" (dfa-start-state x)) + (printf "final states: ~a\n" (map car (dfa-final-states/actions x))) + (for-each (lambda (trans) + (printf "state: ~a\n" (car trans)) + (for-each (lambda (rule) + (printf " -~a-> ~a\n" + (is:integer-set-contents (car rule)) + (cdr rule))) + (cdr trans))) + (dfa-transitions x))) + + (define (build-test-dfa rs) + (let ((c (make-cache))) + (build-dfa (map (lambda (x) (cons (->re x c) 'action)) + rs) + c))) + + +#| + (define t1 (build-test-dfa null)) + (define t2 (build-test-dfa `(#\a))) + (define t3 (build-test-dfa `(#\a #\b))) + (define t4 (build-test-dfa `((repetition 0 +inf.0 #\a) + (repetition 0 +inf.0 (concatenation #\a #\b))))) + (define t5 (build-test-dfa `((concatenation (repetition 0 +inf.0 (union #\0 #\1)) #\1)))) + (define t6 (build-test-dfa `((repetition 0 +inf.0 (repetition 0 +inf.0 #\a)) + (repetition 0 +inf.0 (concatenation #\b (repetition 1 +inf.0 #\b)))))) + (define t7 (build-test-dfa `((concatenation (repetition 0 +inf.0 #\a) (repetition 0 +inf.0 #\b) + (repetition 0 +inf.0 #\c) (repetition 0 +inf.0 #\d) + (repetition 0 +inf.0 #\e))))) + (define t8 + (build-test-dfa `((concatenation (repetition 0 +inf.0 (union #\a #\b)) #\a (union #\a #\b) + (union #\a #\b) (union #\a #\b) (union #\a #\b))))) + (define t9 (build-test-dfa `((concatenation "/*" + (complement (concatenation (intersection) "*/" (intersection))) + "*/")))) + (define t11 (build-test-dfa `((complement "1")))) + (define t12 (build-test-dfa `((concatenation (intersection (concatenation (repetition 0 +inf.0 "a") "b") + (concatenation "a" (repetition 0 +inf.0 "b"))) + "ab")))) + (define x (build-test-dfa `((union " " "\n" ",") + (concatenation (repetition 0 1 "-") (repetition 1 +inf.0 (char-range "0" "9"))) + (concatenation "-" (repetition 1 +inf.0 "-")) + "[" + "]"))) + (define y (build-test-dfa + `((repetition 1 +inf.0 + (union (concatenation "|" (repetition 0 +inf.0 (char-complement "|")) "|") + (concatenation "|" (repetition 0 +inf.0 (char-complement "|")))))))) + (define t13 (build-test-dfa `((intersection (concatenation (intersection) "111" (intersection)) + (complement (union (concatenation (intersection) "01") + (repetition 1 +inf.0 "1"))))))) + (define t14 (build-test-dfa `((complement "1")))) +|# + ) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/error-tests.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/error-tests.rkt new file mode 100644 index 0000000..bbccbe0 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/error-tests.rkt @@ -0,0 +1,81 @@ +#lang scheme/base +(require (for-syntax scheme/base) + "../lex.rkt" + rackunit) + +(define-syntax (catch-syn-error stx) + (syntax-case stx () + [(_ arg) + (datum->syntax + #'here + (with-handlers ((exn:fail:syntax? exn-message)) + (syntax-local-expand-expression #'arg) + "not-an-error"))])) + +(check-regexp-match #rx"lex-abbrev" (catch-syn-error (define-lex-abbrev))) +(check-regexp-match #rx"lex-abbrev" (catch-syn-error (define-lex-abbrev a))) +(check-regexp-match #rx"lex-abbrev" (catch-syn-error (define-lex-abbrev (a b) v))) +(check-regexp-match #rx"lex-abbrev" (catch-syn-error (define-lex-abbrev 1 1))) +(check-regexp-match #rx"lex-abbrevs" (catch-syn-error (define-lex-abbrevs ()))) + +(check-regexp-match #rx"lex-trans" (catch-syn-error (define-lex-trans))) + +(check-regexp-match #rx"lexer" (catch-syn-error (lexer))) +(check-regexp-match #rx"lexer" (catch-syn-error (lexer ("a" "b" "c")))) +(check-regexp-match #rx"lexer" (catch-syn-error (lexer ()))) +(check-regexp-match #rx"lexer" (catch-syn-error (lexer ("")))) + +(check-regexp-match #rx"regular-expression" (catch-syn-error (lexer (a 1)))) +(check-regexp-match #rx"regular-expression" (catch-syn-error (lexer ((a) 1)))) +(check-regexp-match #rx"regular-expression" (catch-syn-error (let ((a 1)) (lexer ((a) 1))))) + +(check-regexp-match #rx"regular-expression" + (catch-syn-error (let-syntax ((a 1)) + (lexer ((a) 1))))) + +(check-regexp-match #rx"define-lex-trans" + (catch-syn-error + (let () + (define-lex-trans a 1) + (let () + (lexer ((a) 1)))))) + +;; Detecting mutual recursion cycle: +(check-regexp-match #rx"regular-expression" + (catch-syn-error + (let () + (define-lex-abbrev a b) + (define-lex-abbrev b a) + (let () + (lexer (a 1)))))) + +(check-regexp-match #rx"regular-expression" + (catch-syn-error + (let () + (define-lex-abbrev a (repetition 0 1 b)) + (define-lex-abbrev b (repetition 0 1 a)) + (let () + (lexer (a 1)))))) + +;; Detecting cycle within same abbreviation: +(check-regexp-match #rx"regular-expression" + (catch-syn-error + (let () + (define-lex-abbrev balanced + (union (concatenation "(" balanced ")" balanced) + any-char)) + (lexer + [balanced (string-append lexeme (balanced input-port))] + [(eof) ""])))) + + +(check-regexp-match #rx"regular-expression" (catch-syn-error (lexer (1 1)))) +(check-regexp-match #rx"repetition" (catch-syn-error (lexer ((repetition) 1)))) +(check-regexp-match #rx"repetition" (catch-syn-error (lexer ((repetition #\1 #\1 "3") 1)))) +(check-regexp-match #rx"repetition" (catch-syn-error (lexer ((repetition 1 #\1 "3") 1)))) +(check-regexp-match #rx"repetition" (catch-syn-error (lexer ((repetition 1 0 "3") 1)))) +(check-regexp-match #rx"complement" (catch-syn-error (lexer ((complement) 1)))) +(check-regexp-match #rx"char-range" (catch-syn-error (lexer ((char-range) 1)))) +(check-regexp-match #rx"char-range" (catch-syn-error (lexer ((char-range #\9 #\0) 1)))) +(check-regexp-match #rx"char-complement" (catch-syn-error (lexer ((char-complement) 1)))) +(check-regexp-match #rx"char-complement" (catch-syn-error (lexer ((char-complement (concatenation "1" "2")) 1)))) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/front.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/front.rkt new file mode 100644 index 0000000..f74c003 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/front.rkt @@ -0,0 +1,179 @@ +(module front mzscheme + (require (prefix is: mzlib/integer-set) + mzlib/list + syntax/stx + "util.rkt" + "stx.rkt" + "re.rkt" + "deriv.rkt") + + (provide build-lexer) + + (define-syntax time-label + (syntax-rules () + ((_ l e ...) + (begin + (printf "~a: " l) + (time (begin e ...)))))) + + ;; A table is either + ;; - (vector-of (union #f nat)) + ;; - (vector-of (vector-of (vector nat nat nat))) + + (define loc:integer-set-contents is:integer-set-contents) + + ;; dfa->1d-table : dfa -> (same as build-lexer) + (define (dfa->1d-table dfa) + (let ((state-table (make-vector (dfa-num-states dfa) #f)) + (transition-cache (make-hash-table 'equal))) + (for-each + (lambda (trans) + (let* ((from-state (car trans)) + (all-chars/to (cdr trans)) + (flat-all-chars/to + (sort + (apply append + (map (lambda (chars/to) + (let ((char-ranges (loc:integer-set-contents (car chars/to))) + (to (cdr chars/to))) + (map (lambda (char-range) + (let ((entry (vector (car char-range) (cdr char-range) to))) + (hash-table-get transition-cache entry + (lambda () + (hash-table-put! transition-cache + entry + entry) + entry)))) + char-ranges))) + all-chars/to)) + (lambda (a b) + (< (vector-ref a 0) (vector-ref b 0)))))) + (vector-set! state-table from-state (list->vector flat-all-chars/to)))) + (dfa-transitions dfa)) + state-table)) + + + (define loc:foldr is:foldr) + + ;; dfa->2d-table : dfa -> (same as build-lexer) + (define (dfa->2d-table dfa) + (let ( + ;; char-table : (vector-of (union #f nat)) + ;; The lexer table, one entry per state per char. + ;; Each entry specifies a state to transition to. + ;; #f indicates no transition + (char-table (make-vector (* 256 (dfa-num-states dfa)) #f))) + + ;; Fill the char-table vector + (for-each + (lambda (trans) + (let ((from-state (car trans))) + (for-each (lambda (chars/to) + (let ((to-state (cdr chars/to))) + (loc:foldr (lambda (char _) + (vector-set! char-table + (bitwise-ior + char + (arithmetic-shift from-state 8)) + to-state)) + (void) + (car chars/to)))) + (cdr trans)))) + (dfa-transitions dfa)) + char-table)) + + + ;; dfa->actions : dfa -> (vector-of (union #f syntax-object)) + ;; The action for each final state, #f if the state isn't final + (define (dfa->actions dfa) + (let ((actions (make-vector (dfa-num-states dfa) #f))) + (for-each (lambda (state/action) + (vector-set! actions (car state/action) (cdr state/action))) + (dfa-final-states/actions dfa)) + actions)) + + ;; dfa->no-look : dfa -> (vector-of bool) + ;; For each state whether the lexer can ignore the next input. + ;; It can do this only if there are no transitions out of the + ;; current state. + (define (dfa->no-look dfa) + (let ((no-look (make-vector (dfa-num-states dfa) #t))) + (for-each (lambda (trans) + (vector-set! no-look (car trans) #f)) + (dfa-transitions dfa)) + no-look)) + + (test-block ((d1 (make-dfa 1 1 (list) (list))) + (d2 (make-dfa 4 1 (list (cons 2 2) (cons 3 3)) + (list (cons 1 (list (cons (is:make-range 49 50) 1) + (cons (is:make-range 51) 2))) + (cons 2 (list (cons (is:make-range 49) 3)))))) + (d3 (make-dfa 4 1 (list (cons 2 2) (cons 3 3)) + (list (cons 1 (list (cons (is:make-range 100 200) 0) + (cons (is:make-range 49 50) 1) + (cons (is:make-range 51) 2))) + (cons 2 (list (cons (is:make-range 49) 3))))))) + ((dfa->2d-table d1) (make-vector 256 #f)) + ((dfa->2d-table d2) (let ((v (make-vector 1024 #f))) + (vector-set! v 305 1) + (vector-set! v 306 1) + (vector-set! v 307 2) + (vector-set! v 561 3) + v)) + ((dfa->1d-table d1) (make-vector 1 #f)) + ((dfa->1d-table d2) #(#f + #(#(49 50 1) #(51 51 2)) + #(#(49 49 3)) + #f)) + ((dfa->1d-table d3) #(#f + #(#(49 50 1) #(51 51 2) #(100 200 0)) + #(#(49 49 3)) + #f)) + ((dfa->actions d1) (vector #f)) + ((dfa->actions d2) (vector #f #f 2 3)) + ((dfa->no-look d1) (vector #t)) + ((dfa->no-look d2) (vector #t #f #f #t))) + + ;; build-lexer : syntax-object list -> + ;; (values table nat (vector-of (union #f syntax-object)) (vector-of bool) (list-of syntax-object)) + ;; each syntax object has the form (re action) + (define (build-lexer sos) + (let* ((disappeared-uses (box null)) + (s-re-acts (map (lambda (so) + (cons (parse (stx-car so) disappeared-uses) + (stx-car (stx-cdr so)))) + sos)) + + (cache (make-cache)) + + (re-acts (map (lambda (s-re-act) + (cons (->re (car s-re-act) cache) + (cdr s-re-act))) + s-re-acts)) + + (dfa (build-dfa re-acts cache)) + (table (dfa->1d-table dfa))) + ;(print-dfa dfa) + #;(let ((num-states (vector-length table)) + (num-vectors (length (filter values (vector->list table)))) + (num-entries (apply + (map + (lambda (x) (if x (vector-length x) 0)) + (vector->list table)))) + (num-different-entries + (let ((ht (make-hash-table))) + (for-each + (lambda (x) + (when x + (for-each + (lambda (y) + (hash-table-put! ht y #t)) + (vector->list x)))) + (vector->list table)) + (length (hash-table-map ht cons))))) + (printf "~a states, ~aKB\n" + num-states + (/ (* 4.0 (+ 2 num-states (* 2 num-vectors) num-entries + (* 5 num-different-entries))) 1024))) + (values table (dfa-start-state dfa) (dfa->actions dfa) (dfa->no-look dfa) + (unbox disappeared-uses)))) + ) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/re.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/re.rkt new file mode 100644 index 0000000..9da62de --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/re.rkt @@ -0,0 +1,385 @@ +(module re mzscheme + (require mzlib/list + scheme/match + (prefix is: mzlib/integer-set) + "util.rkt") + + (provide ->re build-epsilon build-zero build-char-set build-concat + build-repeat build-or build-and build-neg + epsilonR? zeroR? char-setR? concatR? repeatR? orR? andR? negR? + char-setR-chars concatR-re1 concatR-re2 repeatR-re repeatR-low repeatR-high + orR-res andR-res negR-re + re-nullable? re-index) + + ;; get-index : -> nat + (define get-index (make-counter)) + + ;; An re is either + ;; - (make-epsilonR bool nat) + ;; - (make-zeroR bool nat) + ;; - (make-char-setR bool nat char-set) + ;; - (make-concatR bool nat re re) + ;; - (make-repeatR bool nat nat nat-or-+inf.0 re) + ;; - (make-orR bool nat (list-of re)) Must not directly contain any orRs + ;; - (make-andR bool nat (list-of re)) Must not directly contain any andRs + ;; - (make-negR bool nat re) + ;; + ;; Every re must have an index field globally different from all + ;; other re index fields. + (define-struct re (nullable? index) (make-inspector)) + (define-struct (epsilonR re) () (make-inspector)) + (define-struct (zeroR re) () (make-inspector)) + (define-struct (char-setR re) (chars) (make-inspector)) + (define-struct (concatR re) (re1 re2) (make-inspector)) + (define-struct (repeatR re) (low high re) (make-inspector)) + (define-struct (orR re) (res) (make-inspector)) + (define-struct (andR re) (res) (make-inspector)) + (define-struct (negR re) (re) (make-inspector)) + + ;; e : re + ;; The unique epsilon re + (define e (make-epsilonR #t (get-index))) + + ;; z : re + ;; The unique zero re + (define z (make-zeroR #f (get-index))) + + + ;; s-re = char constant + ;; | string constant (sequence of characters) + ;; | re a precompiled re + ;; | (repetition low high s-re) repetition between low and high times (inclusive) + ;; | (union s-re ...) + ;; | (intersection s-re ...) + ;; | (complement s-re) + ;; | (concatenation s-re ...) + ;; | (char-range rng rng) match any character between two (inclusive) + ;; | (char-complement char-set) match any character not listed + ;; low = natural-number + ;; high = natural-number or +inf.0 + ;; rng = char or string with length 1 + ;; (concatenation) (repetition 0 0 x), and "" match the empty string. + ;; (union) matches no strings. + ;; (intersection) matches any string. + + (define loc:make-range is:make-range) + (define loc:union is:union) + (define loc:split is:split) + (define loc:complement is:complement) + + ;; ->re : s-re cache -> re + (define (->re exp cache) + (match exp + ((? char?) (build-char-set (loc:make-range (char->integer exp)) cache)) + ((? string?) (->re `(concatenation ,@(string->list exp)) cache)) + ((? re?) exp) + (`(repetition ,low ,high ,r) + (build-repeat low high (->re r cache) cache)) + (`(union ,rs ...) + (build-or (flatten-res (map (lambda (r) (->re r cache)) rs) + orR? orR-res loc:union cache) + cache)) + (`(intersection ,rs ...) + (build-and (flatten-res (map (lambda (r) (->re r cache)) rs) + andR? andR-res (lambda (a b) + (let-values (((i _ __) (loc:split a b))) i)) + cache) + cache)) + (`(complement ,r) + (build-neg (->re r cache) cache)) + (`(concatenation ,rs ...) + (foldr (lambda (x y) + (build-concat (->re x cache) y cache)) + e + rs)) + (`(char-range ,c1 ,c2) + (let ((i1 (char->integer (if (string? c1) (string-ref c1 0) c1))) + (i2 (char->integer (if (string? c2) (string-ref c2 0) c2)))) + (if (<= i1 i2) + (build-char-set (loc:make-range i1 i2) cache) + z))) + (`(char-complement ,crs ...) + (let ((cs (->re `(union ,@crs) cache))) + (cond + ((zeroR? cs) (build-char-set (loc:make-range 0 max-char-num) cache)) + ((char-setR? cs) + (build-char-set (loc:complement (char-setR-chars cs) 0 max-char-num) cache)) + (else z)))))) + + + + + ;; flatten-res: (list-of re) (re -> bool) (re -> (list-of re)) + ;; (char-set char-set -> char-set) cache -> (list-of re) + ;; Takes all the char-sets in l and combines them into one char-set using the combine function. + ;; Flattens out the values of type?. get-res only needs to function on things type? returns + ;; true for. + (define (flatten-res l type? get-res combine cache) + (let loop ((res l) + ;; chars : (union #f char-set) + (chars #f) + (no-chars null)) + (cond + ((null? res) + (if chars + (cons (build-char-set chars cache) no-chars) + no-chars)) + ((char-setR? (car res)) + (if chars + (loop (cdr res) (combine (char-setR-chars (car res)) chars) no-chars) + (loop (cdr res) (char-setR-chars (car res)) no-chars))) + ((type? (car res)) + (loop (append (get-res (car res)) (cdr res)) chars no-chars)) + (else (loop (cdr res) chars (cons (car res) no-chars)))))) + + ;; build-epsilon : -> re + (define (build-epsilon) e) + + (define (build-zero) z) + + (define loc:integer-set-contents is:integer-set-contents) + + ;; build-char-set : char-set cache -> re + (define (build-char-set cs cache) + (let ((l (loc:integer-set-contents cs))) + (cond + ((null? l) z) + (else + (cache l + (lambda () + (make-char-setR #f (get-index) cs))))))) + + + + ;; build-concat : re re cache -> re + (define (build-concat r1 r2 cache) + (cond + ((eq? e r1) r2) + ((eq? e r2) r1) + ((or (eq? z r1) (eq? z r2)) z) + (else + (cache (cons 'concat (cons (re-index r1) (re-index r2))) + (lambda () + (make-concatR (and (re-nullable? r1) (re-nullable? r2)) + (get-index) + r1 r2)))))) + + ;; build-repeat : nat nat-or-+inf.0 re cache -> re + (define (build-repeat low high r cache) + (let ((low (if (< low 0) 0 low))) + (cond + ((eq? r e) e) + ((and (= 0 low) (or (= 0 high) (eq? z r))) e) + ((and (= 1 low) (= 1 high)) r) + ((and (repeatR? r) + (eq? (repeatR-high r) +inf.0) + (or (= 0 (repeatR-low r)) + (= 1 (repeatR-low r)))) + (build-repeat (* low (repeatR-low r)) + +inf.0 + (repeatR-re r) + cache)) + (else + (cache (cons 'repeat (cons low (cons high (re-index r)))) + (lambda () + (make-repeatR (or (re-nullable? r) (= 0 low)) (get-index) low high r))))))) + + + ;; build-or : (list-of re) cache -> re + (define (build-or rs cache) + (let ((rs + (filter + (lambda (x) (not (eq? x z))) + (do-simple-equiv (replace rs orR? orR-res null) re-index)))) + (cond + ((null? rs) z) + ((null? (cdr rs)) (car rs)) + ((memq (build-neg z cache) rs) (build-neg z cache)) + (else + (cache (cons 'or (map re-index rs)) + (lambda () + (make-orR (ormap re-nullable? rs) (get-index) rs))))))) + + ;; build-and : (list-of re) cache -> re + (define (build-and rs cache) + (let ((rs (do-simple-equiv (replace rs andR? andR-res null) re-index))) + (cond + ((null? rs) (build-neg z cache)) + ((null? (cdr rs)) (car rs)) + ((memq z rs) z) + (else + (cache (cons 'and (map re-index rs)) + (lambda () + (make-andR (andmap re-nullable? rs) (get-index) rs))))))) + + ;; build-neg : re cache -> re + (define (build-neg r cache) + (cond + ((negR? r) (negR-re r)) + (else + (cache (cons 'neg (re-index r)) + (lambda () + (make-negR (not (re-nullable? r)) (get-index) r)))))) + + ;; Tests for the build-functions + (test-block ((c (make-cache)) + (isc is:integer-set-contents) + (r1 (build-char-set (is:make-range (char->integer #\1)) c)) + (r2 (build-char-set (is:make-range (char->integer #\2)) c)) + (r3 (build-char-set (is:make-range (char->integer #\3)) c)) + (rc (build-concat r1 r2 c)) + (rc2 (build-concat r2 r1 c)) + (rr (build-repeat 0 +inf.0 rc c)) + (ro (build-or `(,rr ,rc ,rr) c)) + (ro2 (build-or `(,rc ,rr ,z) c)) + (ro3 (build-or `(,rr ,rc) c)) + (ro4 (build-or `(,(build-or `(,r1 ,r2) c) + ,(build-or `(,r2 ,r3) c)) c)) + (ra (build-and `(,rr ,rc ,rr) c)) + (ra2 (build-and `(,rc ,rr) c)) + (ra3 (build-and `(,rr ,rc) c)) + (ra4 (build-and `(,(build-and `(,r3 ,r2) c) + ,(build-and `(,r2 ,r1) c)) c)) + (rn (build-neg z c)) + (rn2 (build-neg r1 c))) + + ((isc (char-setR-chars r1)) (isc (is:make-range (char->integer #\1)))) + ((isc (char-setR-chars r2)) (isc (is:make-range (char->integer #\2)))) + ((isc (char-setR-chars r3)) (isc (is:make-range (char->integer #\3)))) + ((build-char-set (is:make-range) c) z) + ((build-concat r1 e c) r1) + ((build-concat e r1 c) r1) + ((build-concat r1 z c) z) + ((build-concat z r1 c) z) + ((build-concat r1 r2 c) rc) + ((concatR-re1 rc) r1) + ((concatR-re2 rc) r2) + ((concatR-re1 rc2) r2) + ((concatR-re2 rc2) r1) + (ro ro2) + (ro ro3) + (ro4 (build-or `(,r1 ,r2 ,r3) c)) + ((orR-res ro) (list rc rr)) + ((orR-res ro4) (list r1 r2 r3)) + ((build-or null c) z) + ((build-or `(,r1 ,z) c) r1) + ((build-repeat 0 +inf.0 rc c) rr) + ((build-repeat 0 1 z c) e) + ((build-repeat 0 0 rc c) e) + ((build-repeat 0 +inf.0 z c) e) + ((build-repeat -1 +inf.0 z c) e) + ((build-repeat 0 +inf.0 (build-repeat 0 +inf.0 rc c) c) + (build-repeat 0 +inf.0 rc c)) + ((build-repeat 20 20 (build-repeat 0 +inf.0 rc c) c) + (build-repeat 0 +inf.0 rc c)) + ((build-repeat 20 20 (build-repeat 1 +inf.0 rc c) c) + (build-repeat 20 +inf.0 rc c)) + ((build-repeat 1 1 rc c) rc) + ((repeatR-re rr) rc) + (ra ra2) + (ra ra3) + (ra4 (build-and `(,r1 ,r2 ,r3) c)) + ((andR-res ra) (list rc rr)) + ((andR-res ra4) (list r1 r2 r3)) + ((build-and null c) (build-neg z c)) + ((build-and `(,r1 ,z) c) z) + ((build-and `(,r1) c) r1) + ((build-neg r1 c) (build-neg r1 c)) + ((build-neg (build-neg r1 c) c) r1) + ((negR-re (build-neg r2 c)) r2) + ((re-nullable? r1) #f) + ((re-nullable? rc) #f) + ((re-nullable? (build-concat rr rr c)) #t) + ((re-nullable? rr) #t) + ((re-nullable? (build-repeat 0 1 rc c)) #t) + ((re-nullable? (build-repeat 1 2 rc c)) #f) + ((re-nullable? (build-repeat 1 2 (build-or (list e r1) c) c)) #t) + ((re-nullable? ro) #t) + ((re-nullable? (build-or `(,r1 ,r2) c)) #f) + ((re-nullable? (build-and `(,r1 ,e) c)) #f) + ((re-nullable? (build-and `(,rr ,e) c)) #t) + ((re-nullable? (build-neg r1 c)) #t) + ((re-nullable? (build-neg rr c)) #f)) + + (test-block ((c (make-cache)) + (isc is:integer-set-contents) + (r1 (->re #\1 c)) + (r2 (->re #\2 c)) + (r3-5 (->re '(char-range #\3 #\5) c)) + (r4 (build-or `(,r1 ,r2) c)) + (r5 (->re `(union ,r3-5 #\7) c)) + (r6 (->re #\6 c))) + ((flatten-res null orR? orR-res is:union c) null) + ((isc (char-setR-chars (car (flatten-res `(,r1) orR? orR-res is:union c)))) + (isc (is:make-range (char->integer #\1)))) + ((isc (char-setR-chars (car (flatten-res `(,r4) orR? orR-res is:union c)))) + (isc (is:make-range (char->integer #\1) (char->integer #\2)))) + ((isc (char-setR-chars (car (flatten-res `(,r6 ,r5 ,r4 ,r3-5 ,r2 ,r1) + orR? orR-res is:union c)))) + (isc (is:make-range (char->integer #\1) (char->integer #\7)))) + ((flatten-res `(,r1 ,r2) andR? andR-res (lambda (x y) + (let-values (((i _ __) + (is:split x y))) + i)) + c) + (list z))) + + ;; ->re + (test-block ((c (make-cache)) + (isc is:integer-set-contents) + (r (->re #\a c)) + (rr (->re `(concatenation ,r ,r) c)) + (rrr (->re `(concatenation ,r ,rr) c)) + (rrr* (->re `(repetition 0 +inf.0 ,rrr) c))) + ((isc (char-setR-chars r)) (isc (is:make-range (char->integer #\a)))) + ((->re "" c) e) + ((->re "asdf" c) (->re `(concatenation #\a #\s #\d #\f) c)) + ((->re r c) r) + ((->re `(repetition 0 +inf.0 ,r) c) (build-repeat 0 +inf.0 r c)) + ((->re `(repetition 1 +inf.0 ,r) c) (build-repeat 1 +inf.0 r c)) + ((->re `(repetition 0 1 ,r) c) (build-repeat 0 1 r c)) + ((->re `(repetition 0 1 ,rrr*) c) rrr*) + ((->re `(union (union (char-range #\a #\c) + (char-complement (char-range #\000 #\110) + (char-range #\112 ,(integer->char max-char-num)))) + (union (repetition 0 +inf.0 #\2))) c) + (build-or (list (build-char-set (is:union (is:make-range 73) + (is:make-range 97 99)) + c) + (build-repeat 0 +inf.0 (build-char-set (is:make-range 50) c) c)) + c)) + ((->re `(union ,rr ,rrr) c) (build-or (list rr rrr) c)) + ((->re `(union ,r) c) r) + ((->re `(union) c) z) + ((->re `(intersection (intersection #\111 + (char-complement (char-range #\000 #\110) + (char-range #\112 ,(integer->char max-char-num)))) + (intersection (repetition 0 +inf.0 #\2))) c) + (build-and (list (build-char-set (is:make-range 73) c) + (build-repeat 0 +inf.0 (build-char-set (is:make-range 50) c) c)) + c)) + ((->re `(intersection (intersection #\000 (char-complement (char-range #\000 #\110) + (char-range #\112 ,(integer->char max-char-num)))) + (intersection (repetition 0 +inf.0 #\2))) c) + z) + ((->re `(intersection ,rr ,rrr) c) (build-and (list rr rrr) c)) + ((->re `(intersection ,r) c) r) + ((->re `(intersection) c) (build-neg z c)) + ((->re `(complement ,r) c) (build-neg r c)) + ((->re `(concatenation) c) e) + ((->re `(concatenation ,rrr*) c) rrr*) + (rr (build-concat r r c)) + ((->re `(concatenation ,r ,rr ,rrr) c) + (build-concat r (build-concat rr rrr c) c)) + ((isc (char-setR-chars (->re `(char-range #\1 #\1) c))) (isc (is:make-range 49))) + ((isc (char-setR-chars (->re `(char-range #\1 #\9) c))) (isc (is:make-range 49 57))) + ((isc (char-setR-chars (->re `(char-range "1" "1") c))) (isc (is:make-range 49))) + ((isc (char-setR-chars (->re `(char-range "1" "9") c))) (isc (is:make-range 49 57))) + ((->re `(char-range "9" "1") c) z) + ((isc (char-setR-chars (->re `(char-complement) c))) + (isc (char-setR-chars (->re `(char-range #\000 ,(integer->char max-char-num)) c)))) + ((isc (char-setR-chars (->re `(char-complement #\001 (char-range #\002 ,(integer->char max-char-num))) c))) + (isc (is:make-range 0))) + ) + + ) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/stx.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/stx.rkt new file mode 100644 index 0000000..1104a87 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/stx.rkt @@ -0,0 +1,220 @@ +#lang racket + +(require "util.rkt" + syntax/id-table) + +(provide parse) + +(define (bad-args stx num) + (raise-syntax-error + #f + (format "incorrect number of arguments (should have ~a)" num) + stx)) + +;; char-range-arg: syntax-object syntax-object -> nat +;; If c contains is a character or length 1 string, returns the integer +;; for the character. Otherwise raises a syntax error. +(define (char-range-arg stx containing-stx) + (let ((c (syntax-e stx))) + (cond + ((char? c) (char->integer c)) + ((and (string? c) (= (string-length c) 1)) + (char->integer (string-ref c 0))) + (else + (raise-syntax-error + #f + "not a char or single-char string" + containing-stx stx))))) +(module+ test + (check-equal? (char-range-arg #'#\1 #'here) (char->integer #\1)) + (check-equal? (char-range-arg #'"1" #'here) (char->integer #\1))) + +(define orig-insp (variable-reference->module-declaration-inspector + (#%variable-reference))) +(define (disarm stx) + (syntax-disarm stx orig-insp)) + + ;; parse : syntax-object (box (list-of syntax-object)) -> s-re (see re.rkt) + ;; checks for errors and generates the plain s-exp form for s + ;; Expands lex-abbrevs and applies lex-trans. + (define (parse stx disappeared-uses) + (let loop ([stx stx] + [disappeared-uses disappeared-uses] + ;; seen-lex-abbrevs: id-table + [seen-lex-abbrevs (make-immutable-free-id-table)]) + (let ([recur (lambda (s) + (loop (syntax-rearm s stx) + disappeared-uses + seen-lex-abbrevs))] + [recur/abbrev (lambda (s id) + (loop (syntax-rearm s stx) + disappeared-uses + (free-id-table-set seen-lex-abbrevs id id)))]) + (syntax-case (disarm stx) (repetition union intersection complement concatenation + char-range char-complement) + (_ + (identifier? stx) + (let ((expansion (syntax-local-value stx (lambda () #f)))) + (unless (lex-abbrev? expansion) + (raise-syntax-error 'regular-expression + "undefined abbreviation" + stx)) + ;; Check for cycles. + (when (free-id-table-ref seen-lex-abbrevs stx (lambda () #f)) + (raise-syntax-error 'regular-expression + "illegal lex-abbrev cycle detected" + stx + #f + (list (free-id-table-ref seen-lex-abbrevs stx)))) + (set-box! disappeared-uses (cons stx (unbox disappeared-uses))) + (recur/abbrev ((lex-abbrev-get-abbrev expansion)) stx))) + (_ + (or (char? (syntax-e stx)) (string? (syntax-e stx))) + (syntax-e stx)) + ((repetition arg ...) + (let ((arg-list (syntax->list (syntax (arg ...))))) + (unless (= 3 (length arg-list)) + (bad-args stx 2)) + (let ((low (syntax-e (car arg-list))) + (high (syntax-e (cadr arg-list))) + (re (caddr arg-list))) + (unless (and (number? low) (exact? low) (integer? low) (>= low 0)) + (raise-syntax-error #f + "not a non-negative exact integer" + stx + (car arg-list))) + (unless (or (and (number? high) (exact? high) (integer? high) (>= high 0)) + (eq? high +inf.0)) + (raise-syntax-error #f + "not a non-negative exact integer or +inf.0" + stx + (cadr arg-list))) + (unless (<= low high) + (raise-syntax-error + #f + "the first argument is not less than or equal to the second argument" + stx)) + `(repetition ,low ,high ,(recur re))))) + ((union re ...) + `(union ,@(map recur (syntax->list (syntax (re ...)))))) + ((intersection re ...) + `(intersection ,@(map recur (syntax->list (syntax (re ...)))))) + ((complement re ...) + (let ((re-list (syntax->list (syntax (re ...))))) + (unless (= 1 (length re-list)) + (bad-args stx 1)) + `(complement ,(recur (car re-list))))) + ((concatenation re ...) + `(concatenation ,@(map recur (syntax->list (syntax (re ...)))))) + ((char-range arg ...) + (let ((arg-list (syntax->list (syntax (arg ...))))) + (unless (= 2 (length arg-list)) + (bad-args stx 2)) + (let ((i1 (char-range-arg (car arg-list) stx)) + (i2 (char-range-arg (cadr arg-list) stx))) + (if (<= i1 i2) + `(char-range ,(integer->char i1) ,(integer->char i2)) + (raise-syntax-error + #f + "the first argument does not precede or equal second argument" + stx))))) + ((char-complement arg ...) + (let ((arg-list (syntax->list (syntax (arg ...))))) + (unless (= 1 (length arg-list)) + (bad-args stx 1)) + (let ((parsed (recur (car arg-list)))) + (unless (char-set? parsed) + (raise-syntax-error #f + "not a character set" + stx + (car arg-list))) + `(char-complement ,parsed)))) + ((op form ...) + (identifier? (syntax op)) + (let* ((o (syntax op)) + (expansion (syntax-local-value o (lambda () #f)))) + (set-box! disappeared-uses (cons o (unbox disappeared-uses))) + (cond + ((lex-trans? expansion) + (recur ((lex-trans-f expansion) (disarm stx)))) + (expansion + (raise-syntax-error 'regular-expression + "not a lex-trans" + stx)) + (else + (raise-syntax-error 'regular-expression + "undefined operator" + stx))))) + (_ + (raise-syntax-error + 'regular-expression + "not a char, string, identifier, or (op args ...)" + stx)))))) + + + + ;; char-set? : s-re -> bool + ;; A char-set is an re that matches only strings of length 1. + ;; char-set? is conservative. + (define (char-set? s-re) + (cond + ((char? s-re) #t) + ((string? s-re) (= (string-length s-re) 1)) + ((list? s-re) + (let ((op (car s-re))) + (case op + ((union intersection) (andmap char-set? (cdr s-re))) + ((char-range char-complement) #t) + ((repetition) + (and (= (cadr s-re) (caddr s-re)) (char-set? (cadddr s-re)))) + ((concatenation) + (and (= 2 (length s-re)) (char-set? (cadr s-re)))) + (else #f)))) + (else #f))) + + (module+ test + (require rackunit)) + (module+ test + (check-equal? (char-set? #\a) #t) + (check-equal? (char-set? "12") #f) + (check-equal? (char-set? "1") #t) + (check-equal? (char-set? '(repetition 1 2 #\1)) #f) + (check-equal? (char-set? '(repetition 1 1 "12")) #f) + (check-equal? (char-set? '(repetition 1 1 "1")) #t) + (check-equal? (char-set? '(union "1" "2" "3")) #t) + (check-equal? (char-set? '(union "1" "" "3")) #f) + (check-equal? (char-set? '(intersection "1" "2" (union "3" "4"))) #t) + (check-equal? (char-set? '(intersection "1" "")) #f) + (check-equal? (char-set? '(complement "1")) #f) + (check-equal? (char-set? '(concatenation "1" "2")) #f) + (check-equal? (char-set? '(concatenation "" "2")) #f) + (check-equal? (char-set? '(concatenation "1")) #t) + (check-equal? (char-set? '(concatenation "12")) #f) + (check-equal? (char-set? '(char-range #\1 #\2)) #t) + (check-equal? (char-set? '(char-complement #\1)) #t)) + + ;; yikes... these test cases all have the wrong arity, now. + ;; and by "now", I mean it's been broken since before we + ;; moved to git. + (module+ test + (check-equal? (parse #'#\a null) #\a) + (check-equal? (parse #'"1" null) "1") + (check-equal? (parse #'(repetition 1 1 #\1) null) + '(repetition 1 1 #\1)) + (check-equal? (parse #'(repetition 0 +inf.0 #\1) null) '(repetition 0 +inf.0 #\1)) + (check-equal? (parse #'(union #\1 (union "2") (union)) null) + '(union #\1 (union "2") (union))) + (check-equal? (parse #'(intersection #\1 (intersection "2") (intersection)) + null) + '(intersection #\1 (intersection "2") (intersection))) + (check-equal? (parse #'(complement (union #\1 #\2)) + null) + '(complement (union #\1 #\2))) + (check-equal? (parse #'(concatenation "1" "2" (concatenation)) null) + '(concatenation "1" "2" (concatenation))) + (check-equal? (parse #'(char-range "1" #\1) null) '(char-range #\1 #\1)) + (check-equal? (parse #'(char-range #\1 "1") null) '(char-range #\1 #\1)) + (check-equal? (parse #'(char-range "1" "3") null) '(char-range #\1 #\3)) + (check-equal? (parse #'(char-complement (union "1" "2")) null) + '(char-complement (union "1" "2")))) +; ) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/token-syntax.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/token-syntax.rkt new file mode 100644 index 0000000..c1f1492 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/token-syntax.rkt @@ -0,0 +1,9 @@ +(module token-syntax mzscheme + + ;; The things needed at compile time to handle definition of tokens + + (provide make-terminals-def terminals-def-t terminals-def? + make-e-terminals-def e-terminals-def-t e-terminals-def?) + (define-struct terminals-def (t)) + (define-struct e-terminals-def (t)) + ) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/token.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/token.rkt new file mode 100644 index 0000000..27b3458 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/token.rkt @@ -0,0 +1,92 @@ +(module token mzscheme + + (require-for-syntax "token-syntax.rkt") + + ;; Defining tokens + + (provide define-tokens define-empty-tokens make-token token? + (protect (rename token-name real-token-name)) + (protect (rename token-value real-token-value)) + (rename token-name* token-name) + (rename token-value* token-value) + (struct position (offset line col)) + (struct position-token (token start-pos end-pos)) + (struct srcloc-token (token srcloc))) + + + ;; A token is either + ;; - symbol + ;; - (make-token symbol any) + (define-struct token (name value) (make-inspector)) + + ;; token-name*: token -> symbol + (define (token-name* t) + (cond + ((symbol? t) t) + ((token? t) (token-name t)) + (else (raise-type-error + 'token-name + "symbol or struct:token" + 0 + t)))) + + ;; token-value*: token -> any + (define (token-value* t) + (cond + ((symbol? t) #f) + ((token? t) (token-value t)) + (else (raise-type-error + 'token-value + "symbol or struct:token" + 0 + t)))) + + (define-for-syntax (make-ctor-name n) + (datum->syntax-object n + (string->symbol (format "token-~a" (syntax-e n))) + n + n)) + + (define-for-syntax (make-define-tokens empty?) + (lambda (stx) + (syntax-case stx () + ((_ name (token ...)) + (andmap identifier? (syntax->list (syntax (token ...)))) + (with-syntax (((marked-token ...) + (map values #;(make-syntax-introducer) + (syntax->list (syntax (token ...)))))) + (quasisyntax/loc stx + (begin + (define-syntax name + #,(if empty? + #'(make-e-terminals-def (quote-syntax (marked-token ...))) + #'(make-terminals-def (quote-syntax (marked-token ...))))) + #,@(map + (lambda (n) + (when (eq? (syntax-e n) 'error) + (raise-syntax-error + #f + "Cannot define a token named error." + stx)) + (if empty? + #`(define (#,(make-ctor-name n)) + '#,n) + #`(define (#,(make-ctor-name n) x) + (make-token '#,n x)))) + (syntax->list (syntax (token ...)))) + #;(define marked-token #f) #;...)))) + ((_ ...) + (raise-syntax-error + #f + "must have the form (define-tokens name (identifier ...)) or (define-empty-tokens name (identifier ...))" + stx))))) + + (define-syntax define-tokens (make-define-tokens #f)) + (define-syntax define-empty-tokens (make-define-tokens #t)) + + (define-struct position (offset line col) #f) + (define-struct position-token (token start-pos end-pos) #f) + + (define-struct srcloc-token (token srcloc) #f) + ) + diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/unicode-chars.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/unicode-chars.rkt new file mode 100644 index 0000000..c21e88c --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/unicode-chars.rkt @@ -0,0 +1,69 @@ +#lang racket + +(require "util.rkt") + +(provide (all-defined-out)) + +;; mapped-chars : (listof (list nat nat bool)) +(define mapped-chars (make-known-char-range-list)) + +;; get-chars-for-x : (nat -> bool) (listof (list nat nat bool)) -> (listof (cons nat nat)) +(define (get-chars-for char-x? mapped-chars) + (cond + ((null? mapped-chars) null) + (else + (let* ((range (car mapped-chars)) + (low (car range)) + (high (cadr range)) + (x (char-x? low))) + (cond + ((caddr range) + (if x + (cons (cons low high) + (get-chars-for char-x? (cdr mapped-chars))) + (get-chars-for char-x? (cdr mapped-chars)))) + (else + (let loop ((range-start low) + (i (car range)) + (parity x)) + (cond + ((> i high) + (if parity + (cons (cons range-start high) (get-chars-for char-x? (cdr mapped-chars))) + (get-chars-for char-x? (cdr mapped-chars)))) + ((eq? parity (char-x? i)) + (loop range-start (add1 i) parity)) + (parity + (cons (cons range-start (sub1 i)) (loop i (add1 i) #f))) + (else + (loop i (add1 i) #t)))))))))) + +(define (compute-ranges x?) + (delay (get-chars-for (lambda (x) (x? (integer->char x))) mapped-chars))) + +(define alphabetic-ranges (compute-ranges char-alphabetic?)) ;; 325 +(define lower-case-ranges (compute-ranges char-lower-case?)) ;; 405 +(define upper-case-ranges (compute-ranges char-upper-case?)) ;; 380 +(define title-case-ranges (compute-ranges char-title-case?)) ;; 10 +(define numeric-ranges (compute-ranges char-numeric?)) ;; 47 +(define symbolic-ranges (compute-ranges char-symbolic?)) ;; 153 +(define punctuation-ranges (compute-ranges char-punctuation?)) ;; 86 +(define graphic-ranges (compute-ranges char-graphic?)) ;; 401 +(define whitespace-ranges (compute-ranges char-whitespace?)) ;; 10 +(define blank-ranges (compute-ranges char-blank?)) ;; 9 +#;(define hexadecimal-ranges (compute-ranges char-hexadecimal?)) +(define iso-control-ranges (compute-ranges char-iso-control?)) ;; 2 + + + +(module+ test + (require rackunit) + (check-equal? (get-chars-for odd? '()) '()) + (check-equal? (get-chars-for odd? '((1 4 #f) (8 13 #f))) + '((1 . 1) (3 . 3) (9 . 9) (11 . 11) (13 . 13))) + (check-equal? (get-chars-for (lambda (x) + (odd? (quotient x 10))) + '((1 5 #t) (17 19 #t) (21 51 #f))) + '((17 . 19) (30 . 39) (50 . 51)))) + + diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/util.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/util.rkt new file mode 100644 index 0000000..a7afc54 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-lex/util.rkt @@ -0,0 +1,127 @@ +#lang racket + +(provide (all-defined-out)) + +(define max-char-num #x10FFFF) + +(define-struct lex-abbrev (get-abbrev)) +(define-struct lex-trans (f)) + +(module+ test + (require rackunit)) + +#;(define-syntax test-block + (syntax-rules () + ((_ defs (code right-ans) ...) + (let* defs + (let ((real-ans code)) + (unless (equal? real-ans right-ans) + (printf "Test failed: ~e gave ~e. Expected ~e\n" + 'code real-ans 'right-ans))) ...)))) + +(define-syntax test-block + (syntax-rules () + ((_ x ...) (void)))) + + +;; A cache is (X ( -> Y) -> Y) +;; make-cache : -> cache +;; table map Xs to Ys. If key is mapped, its value is returned. +;; Otherwise, build is invoked and its result is placed in the table and +;; returned. +;; Xs are compared with equal? +(define (make-cache) + (let ((table (make-hash))) + (lambda (key build) + (hash-ref table key + (lambda () + (let ((new (build))) + (hash-set! table key new) + new)))))) + +(module+ test + (define cache (make-cache)) + (check-equal? (cache '(s 1 2) (lambda () 9)) 9) + (check-equal? (cache '(s 2 1) (lambda () 8)) 8) + (check-equal? (cache '(s 1 2) (lambda () 1)) 9) + (check-equal? (cache (cons 's (cons 0 (cons +inf.0 10))) + (lambda () 22)) 22) + (check-equal? (cache (cons 's (cons 0 (cons +inf.0 10))) + (lambda () 1)) 22)) + + + +;; make-counter : -> -> nat +;; makes a function that returns a higher number by 1, each time +;; it is called. +(define (make-counter) + (let ((counter 0)) + (lambda () + (begin0 + counter + (set! counter (add1 counter)))))) + +(module+ test + (define c (make-counter)) + (define d (make-counter)) + (check-equal? (c) 0) + (check-equal? (d) 0) + (check-equal? (c) 1) + (check-equal? (d) 1) + (check-equal? (c) 2)) + + +;; remove-dups : (list-of X) (X -> number) -> (list-of X) +;; removes the entries from l that have the same index as a +;; previous entry. l must be grouped by indexes. +(define (remove-dups l index acc) + (cond + ((null? l) (reverse acc)) + ((null? acc) (remove-dups (cdr l) index (cons (car l) acc))) + ((= (index (car acc)) (index (car l))) + (remove-dups (cdr l) index acc)) + (else + (remove-dups (cdr l) index (cons (car l) acc))))) + + +(module+ test + (check-equal? (remove-dups '((1 2) (2 2) (1 3) (1 4) + (100 4) (0 5)) cadr null) + '((1 2) (1 3) (1 4) (0 5))) + (check-equal? (remove-dups null error null) null)) + +;; do-simple-equiv : (list-of X) (X -> nat) -> (list-of X) +;; Sorts l according to index and removes the entries with duplicate +;; indexes. +(define (do-simple-equiv l index) + (let ((ordered (sort l (lambda (a b) (< (index a) (index b)))))) + (remove-dups ordered index null))) + +(module+ test + (check-equal? (do-simple-equiv '((2 2) (1 4) (1 2) + (100 4) (1 3) (0 5)) + cadr) + '((2 2) (1 3) (1 4) (0 5))) + (check-equal? (do-simple-equiv null error) null)) + +;; replace : (list-of X) (X -> bool) (X -> (list-of X)) (list-of X) -> +;; (list-of X) +;; If (pred? r) for some r in l, splice (get r) in place of r in the resulting +;; list. +(define (replace l pred? get acc) + (cond + ((null? l) acc) + ((pred? (car l)) (replace (cdr l) pred? get (append (get (car l)) acc))) + (else (replace (cdr l) pred? get (cons (car l) acc))))) + + +(module+ test + (check-equal? (replace null void (lambda () (list 1)) null) null) + (check-equal? (replace '(1 2 3 4 3 5) + (lambda (x) (= x 3)) + (lambda (x) (list 1 2 3)) + null) + '(5 1 2 3 4 1 2 3 2 1))) + + + diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/grammar.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/grammar.rkt new file mode 100644 index 0000000..ebff00d --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/grammar.rkt @@ -0,0 +1,280 @@ +;; Constructs to create and access grammars, the internal +;; representation of the input to the parser generator. + +(module grammar mzscheme + + (require mzlib/class + mzlib/list + "yacc-helper.rkt" + racket/contract) + + ;; Each production has a unique index 0 <= index <= number of productions + (define-struct prod (lhs rhs index prec action) (make-inspector)) + + ;; The dot-pos field is the index of the element in the rhs + ;; of prod that the dot immediately precedes. + ;; Thus 0 <= dot-pos <= (vector-length rhs). + (define-struct item (prod dot-pos) (make-inspector)) + + ;; gram-sym = (union term? non-term?) + ;; Each term has a unique index 0 <= index < number of terms + ;; Each non-term has a unique index 0 <= index < number of non-terms + (define-struct term (sym index prec) (make-inspector)) + (define-struct non-term (sym index) (make-inspector)) + + ;; a precedence declaration. + (define-struct prec (num assoc) (make-inspector)) + + (provide/contract + (make-item (prod? (or/c #f natural-number/c) . -> . item?)) + (make-term (symbol? (or/c #f natural-number/c) (or/c prec? #f) . -> . term?)) + (make-non-term (symbol? (or/c #f natural-number/c) . -> . non-term?)) + (make-prec (natural-number/c (or/c 'left 'right 'nonassoc) . -> . prec?)) + (make-prod (non-term? (vectorof (or/c non-term? term?)) + (or/c #f natural-number/c) (or/c #f prec?) syntax? . -> . prod?))) + + (provide + + + ;; Things that work on items + start-item? item-prod item->string + sym-at-dot move-dot-right itemstring + non-term? term? non-termbit-vector term-index non-term-index + + ;; Things that work on precs + prec-num prec-assoc + + grammar% + + ;; Things that work on productions + prod-index prod-prec prod-rhs prod-lhs prod-action) + + + ;;---------------------- LR items -------------------------- + + ;; item bool + ;; Lexicographic comparison on two items. + (define (item bool + ;; The start production always has index 0 + (define (start-item? i) + (= 0 (non-term-index (prod-lhs (item-prod i))))) + + + ;; move-dot-right: LR-item -> LR-item | #f + ;; moves the dot to the right in the item, unless it is at its + ;; rightmost, then it returns false + (define (move-dot-right i) + (cond + ((= (item-dot-pos i) (vector-length (prod-rhs (item-prod i)))) #f) + (else (make-item (item-prod i) + (add1 (item-dot-pos i)))))) + + ;; sym-at-dot: LR-item -> gram-sym | #f + ;; returns the symbol after the dot in the item or #f if there is none + (define (sym-at-dot i) + (let ((dp (item-dot-pos i)) + (rhs (prod-rhs (item-prod i)))) + (cond + ((= dp (vector-length rhs)) #f) + (else (vector-ref rhs dp))))) + + + ;; print-item: LR-item -> + (define (item->string it) + (let ((print-sym (lambda (i) + (let ((gs (vector-ref (prod-rhs (item-prod it)) i))) + (cond + ((term? gs) (format "~a " (term-sym gs))) + (else (format "~a " (non-term-sym gs)))))))) + (string-append + (format "~a -> " (non-term-sym (prod-lhs (item-prod it)))) + (let loop ((i 0)) + (cond + ((= i (vector-length (prod-rhs (item-prod it)))) + (if (= i (item-dot-pos it)) + ". " + "")) + ((= i (item-dot-pos it)) + (string-append ". " (print-sym i) (loop (add1 i)))) + (else (string-append (print-sym i) (loop (add1 i))))))))) + + ;; --------------------- Grammar Symbols -------------------------- + + (define (non-termstring gs) + (symbol->string (gram-sym-symbol gs))) + + ;; term-list->bit-vector: term list -> int + ;; Creates a number where the nth bit is 1 if the term with index n is in + ;; the list, and whose nth bit is 0 otherwise + (define (term-list->bit-vector terms) + (cond + ((null? terms) 0) + (else + (bitwise-ior (arithmetic-shift 1 (term-index (car terms))) (term-list->bit-vector (cdr terms)))))) + + + ;; ------------------------- Grammar ------------------------------ + + (define grammar% + (class object% + (super-instantiate ()) + ;; prods: production list list + ;; where there is one production list per non-term + (init prods) + ;; init-prods: production list + ;; The productions parsing can start from + ;; nullable-non-terms is indexed by the non-term-index and is true iff non-term is nullable + (init-field init-prods terms non-terms end-terms) + + ;; list of all productions + (define all-prods (apply append prods)) + (define num-prods (length all-prods)) + (define num-terms (length terms)) + (define num-non-terms (length non-terms)) + + (let ((count 0)) + (for-each + (lambda (nt) + (set-non-term-index! nt count) + (set! count (add1 count))) + non-terms)) + + (let ((count 0)) + (for-each + (lambda (t) + (set-term-index! t count) + (set! count (add1 count))) + terms)) + + (let ((count 0)) + (for-each + (lambda (prod) + (set-prod-index! prod count) + (set! count (add1 count))) + all-prods)) + + ;; indexed by the index of the non-term - contains the list of productions for that non-term + (define nt->prods + (let ((v (make-vector (length prods) #f))) + (for-each (lambda (prods) + (vector-set! v (non-term-index (prod-lhs (car prods))) prods)) + prods) + v)) + + (define nullable-non-terms + (nullable all-prods num-non-terms)) + + (define/public (get-num-terms) num-terms) + (define/public (get-num-non-terms) num-non-terms) + + (define/public (get-prods-for-non-term nt) + (vector-ref nt->prods (non-term-index nt))) + (define/public (get-prods) all-prods) + (define/public (get-init-prods) init-prods) + + (define/public (get-terms) terms) + (define/public (get-non-terms) non-terms) + + (define/public (get-num-prods) num-prods) + (define/public (get-end-terms) end-terms) + + (define/public (nullable-non-term? nt) + (vector-ref nullable-non-terms (non-term-index nt))) + + (define/public (nullable-after-dot? item) + (let* ((rhs (prod-rhs (item-prod item))) + (prod-length (vector-length rhs))) + (let loop ((i (item-dot-pos item))) + (cond + ((< i prod-length) + (if (and (non-term? (vector-ref rhs i)) (nullable-non-term? (vector-ref rhs i))) + (loop (add1 i)) + #f)) + ((= i prod-length) #t))))) + + (define/public (nullable-non-term-thunk) + (lambda (nt) + (nullable-non-term? nt))) + (define/public (nullable-after-dot?-thunk) + (lambda (item) + (nullable-after-dot? item))))) + + + ;; nullable: production list * int -> non-term set + ;; determines which non-terminals can derive epsilon + (define (nullable prods num-nts) + (letrec ((nullable (make-vector num-nts #f)) + (added #f) + + ;; possible-nullable: producion list -> production list + ;; Removes all productions that have a terminal + (possible-nullable + (lambda (prods) + (filter (lambda (prod) + (vector-andmap non-term? (prod-rhs prod))) + prods))) + + ;; set-nullables: production list -> production list + ;; makes one pass through the productions, adding the ones + ;; known to be nullable now to nullable and returning a list + ;; of productions that we don't know about yet. + (set-nullables + (lambda (prods) + (cond + ((null? prods) null) + ((vector-ref nullable + (gram-sym-index (prod-lhs (car prods)))) + (set-nullables (cdr prods))) + ((vector-andmap (lambda (nt) + (vector-ref nullable (gram-sym-index nt))) + (prod-rhs (car prods))) + (vector-set! nullable + (gram-sym-index (prod-lhs (car prods))) + #t) + (set! added #t) + (set-nullables (cdr prods))) + (else + (cons (car prods) + (set-nullables (cdr prods)))))))) + + (let loop ((P (possible-nullable prods))) + (cond + ((null? P) nullable) + (else + (set! added #f) + (let ((new-P (set-nullables P))) + (if added + (loop new-P) + nullable))))))) + + +) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/graph.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/graph.rkt new file mode 100644 index 0000000..958acc1 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/graph.rkt @@ -0,0 +1,61 @@ +(module graph mzscheme + + (provide digraph) + + (define (zero-thunk) 0) + + ;; digraph: + ;; ('a list) * ('a -> 'a list) * ('a -> 'b) * ('b * 'b -> 'b) * (-> 'b) + ;; -> ('a -> 'b) + ;; DeRemer and Pennello 1982 + ;; Computes (f x) = (f- x) union Union{(f y) | y in (edges x)} + ;; We use a hash-table to represent the result function 'a -> 'b set, so + ;; the values of type 'a must be comparable with eq?. + (define (digraph nodes edges f- union fail) + (letrec [ + ;; Will map elements of 'a to 'b sets + (results (make-hash-table)) + (f (lambda (x) (hash-table-get results x fail))) + + ;; Maps elements of 'a to integers. + (N (make-hash-table)) + (get-N (lambda (x) (hash-table-get N x zero-thunk))) + (set-N (lambda (x d) (hash-table-put! N x d))) + + (stack null) + (push (lambda (x) + (set! stack (cons x stack)))) + (pop (lambda () + (begin0 + (car stack) + (set! stack (cdr stack))))) + (depth (lambda () (length stack))) + + ;; traverse: 'a -> + (traverse + (lambda (x) + (push x) + (let ((d (depth))) + (set-N x d) + (hash-table-put! results x (f- x)) + (for-each (lambda (y) + (if (= 0 (get-N y)) + (traverse y)) + (hash-table-put! results + x + (union (f x) (f y))) + (set-N x (min (get-N x) (get-N y)))) + (edges x)) + (if (= d (get-N x)) + (let loop ((p (pop))) + (set-N p +inf.0) + (hash-table-put! results p (f x)) + (if (not (eq? x p)) + (loop (pop))))))))] + (for-each (lambda (x) + (if (= 0 (get-N x)) + (traverse x))) + nodes) + f)) + +) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/input-file-parser.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/input-file-parser.rkt new file mode 100644 index 0000000..7309f51 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/input-file-parser.rkt @@ -0,0 +1,374 @@ +(module input-file-parser mzscheme + + ;; routines for parsing the input to the parser generator and producing a + ;; grammar (See grammar.rkt) + + (require "yacc-helper.rkt" + "../private-lex/token-syntax.rkt" + "grammar.rkt" + mzlib/class + racket/contract) + (require-for-template mzscheme) + +(define (is-a-grammar%? x) (is-a? x grammar%)) + (provide/contract + (parse-input ((listof identifier?) (listof identifier?) (listof identifier?) + (or/c #f syntax?) syntax? any/c . -> . is-a-grammar%?)) + (get-term-list ((listof identifier?) . -> . (listof identifier?)))) + + (define stx-for-original-property (read-syntax #f (open-input-string "original"))) + + ;; get-args: ??? -> (values (listof syntax) (or/c #f (cons integer? stx))) + (define (get-args i rhs src-pos term-defs) + (let ((empty-table (make-hash-table)) + (biggest-pos #f)) + (hash-table-put! empty-table 'error #t) + (for-each (lambda (td) + (let ((v (syntax-local-value td))) + (if (e-terminals-def? v) + (for-each (lambda (s) + (hash-table-put! empty-table (syntax-object->datum s) #t)) + (syntax->list (e-terminals-def-t v)))))) + term-defs) + (let ([args + (let get-args ((i i) + (rhs rhs)) + (cond + ((null? rhs) null) + (else + (let ((b (car rhs)) + (name (if (hash-table-get empty-table (syntax-object->datum (car rhs)) (lambda () #f)) + (gensym) + (string->symbol (format "$~a" i))))) + (cond + (src-pos + (let ([start-pos-id + (datum->syntax-object b (string->symbol (format "$~a-start-pos" i)) b stx-for-original-property)] + [end-pos-id + (datum->syntax-object b (string->symbol (format "$~a-end-pos" i)) b stx-for-original-property)]) + (set! biggest-pos (cons start-pos-id end-pos-id)) + `(,(datum->syntax-object b name b stx-for-original-property) + ,start-pos-id + ,end-pos-id + ,@(get-args (add1 i) (cdr rhs))))) + (else + `(,(datum->syntax-object b name b stx-for-original-property) + ,@(get-args (add1 i) (cdr rhs)))))))))]) + (values args biggest-pos)))) + + ;; Given the list of terminal symbols and the precedence/associativity definitions, + ;; builds terminal structures (See grammar.rkt) + ;; build-terms: symbol list * symbol list list -> term list + (define (build-terms term-list precs) + (let ((counter 0) + + ;;(term-list (cons (gensym) term-list)) + + ;; Will map a terminal symbol to its precedence/associativity + (prec-table (make-hash-table))) + + ;; Fill the prec table + (for-each + (lambda (p-decl) + (begin0 + (let ((assoc (car p-decl))) + (for-each + (lambda (term-sym) + (hash-table-put! prec-table term-sym (make-prec counter assoc))) + (cdr p-decl))) + (set! counter (add1 counter)))) + precs) + + ;; Build the terminal structures + (map + (lambda (term-sym) + (make-term term-sym + #f + (hash-table-get prec-table term-sym (lambda () #f)))) + term-list))) + + ;; Retrieves the terminal symbols from a terminals-def (See terminal-syntax.rkt) + ;; get-terms-from-def: identifier? -> (listof identifier?) + (define (get-terms-from-def term-syn) + (let ((t (syntax-local-value term-syn (lambda () #f)))) + (cond + ((terminals-def? t) (syntax->list (terminals-def-t t))) + ((e-terminals-def? t) (syntax->list (e-terminals-def-t t))) + (else + (raise-syntax-error + 'parser-tokens + "undefined token group" + term-syn))))) + + (define (get-term-list term-group-names) + (remove-duplicates + (cons (datum->syntax-object #f 'error) + (apply append + (map get-terms-from-def term-group-names))))) + + (define (parse-input term-defs start ends prec-decls prods src-pos) + (let* ((start-syms (map syntax-e start)) + + (list-of-terms (map syntax-e (get-term-list term-defs))) + + (end-terms + (map + (lambda (end) + (unless (memq (syntax-e end) list-of-terms) + (raise-syntax-error + 'parser-end-tokens + (format "End token ~a not defined as a token" + (syntax-e end)) + end)) + (syntax-e end)) + ends)) + + ;; Get the list of terminals out of input-terms + + (list-of-non-terms + (syntax-case prods () + (((non-term production ...) ...) + (begin + (for-each + (lambda (nts) + (if (memq (syntax-object->datum nts) list-of-terms) + (raise-syntax-error + 'parser-non-terminals + (format "~a used as both token and non-terminal" + (syntax-object->datum nts)) + nts))) + (syntax->list (syntax (non-term ...)))) + + (let ((dup (duplicate-list? (syntax-object->datum + (syntax (non-term ...)))))) + (if dup + (raise-syntax-error + 'parser-non-terminals + (format "non-terminal ~a defined multiple times" + dup) + prods))) + + (syntax-object->datum (syntax (non-term ...))))) + (_ + (raise-syntax-error + 'parser-grammar + "Grammar must be of the form (grammar (non-terminal productions ...) ...)" + prods)))) + + ;; Check the precedence declarations for errors and turn them into data + (precs + (syntax-case prec-decls () + (((type term ...) ...) + (let ((p-terms + (syntax-object->datum (syntax (term ... ...))))) + (cond + ((duplicate-list? p-terms) => + (lambda (d) + (raise-syntax-error + 'parser-precedences + (format "duplicate precedence declaration for token ~a" + d) + prec-decls))) + (else + (for-each + (lambda (a) + (for-each + (lambda (t) + (if (not (memq (syntax-object->datum t) + list-of-terms)) + (raise-syntax-error + 'parser-precedences + (format + "Precedence declared for non-token ~a" + (syntax-object->datum t)) + t))) + (syntax->list a))) + (syntax->list (syntax ((term ...) ...)))) + (for-each + (lambda (type) + (if (not (memq (syntax-object->datum type) + `(left right nonassoc))) + (raise-syntax-error + 'parser-precedences + "Associativity must be left, right or nonassoc" + type))) + (syntax->list (syntax (type ...)))) + (syntax-object->datum prec-decls))))) + (#f null) + (_ + (raise-syntax-error + 'parser-precedences + "Precedence declaration must be of the form (precs (assoc term ...) ...) where assoc is left, right or nonassoc" + prec-decls)))) + + (terms (build-terms list-of-terms precs)) + + (non-terms (map (lambda (non-term) (make-non-term non-term #f)) + list-of-non-terms)) + (term-table (make-hash-table)) + (non-term-table (make-hash-table))) + + (for-each (lambda (t) + (hash-table-put! term-table (gram-sym-symbol t) t)) + terms) + + (for-each (lambda (nt) + (hash-table-put! non-term-table (gram-sym-symbol nt) nt)) + non-terms) + + (let* ( + ;; parse-prod: syntax-object -> gram-sym vector + (parse-prod + (lambda (prod-so) + (syntax-case prod-so () + ((prod-rhs-sym ...) + (andmap identifier? (syntax->list prod-so)) + (begin + (for-each (lambda (t) + (if (memq (syntax-object->datum t) end-terms) + (raise-syntax-error + 'parser-production-rhs + (format "~a is an end token and cannot be used in a production" + (syntax-object->datum t)) + t))) + (syntax->list prod-so)) + (list->vector + (map (lambda (s) + (hash-table-get + term-table + (syntax-object->datum s) + (lambda () + (hash-table-get + non-term-table + (syntax-object->datum s) + (lambda () + (raise-syntax-error + 'parser-production-rhs + (format + "~a is not declared as a terminal or non-terminal" + (syntax-object->datum s)) + s)))))) + (syntax->list prod-so))))) + (_ + (raise-syntax-error + 'parser-production-rhs + "production right-hand-side must have form (symbol ...)" + prod-so))))) + + ;; parse-action: syntax-object * syntax-object -> syntax-object + (parse-action + (lambda (rhs act) + (let-values ([(args biggest) (get-args 1 (syntax->list rhs) src-pos term-defs)]) + (let ([act + (if biggest + (with-syntax ([$n-start-pos (datum->syntax-object (car biggest) '$n-start-pos)] + [$n-end-pos (datum->syntax-object (cdr biggest) '$n-end-pos)]) + #`(let ([$n-start-pos #,(car biggest)] + [$n-end-pos #,(cdr biggest)]) + #,act)) + act)]) + (quasisyntax/loc act + (lambda #,args + #,act)))))) + + ;; parse-prod+action: non-term * syntax-object -> production + (parse-prod+action + (lambda (nt prod-so) + (syntax-case prod-so () + ((prod-rhs action) + (let ((p (parse-prod (syntax prod-rhs)))) + (make-prod + nt + p + #f + (let loop ((i (sub1 (vector-length p)))) + (if (>= i 0) + (let ((gs (vector-ref p i))) + (if (term? gs) + (term-prec gs) + (loop (sub1 i)))) + #f)) + (parse-action (syntax prod-rhs) (syntax action))))) + ((prod-rhs (prec term) action) + (identifier? (syntax term)) + (let ((p (parse-prod (syntax prod-rhs)))) + (make-prod + nt + p + #f + (term-prec + (hash-table-get + term-table + (syntax-object->datum (syntax term)) + (lambda () + (raise-syntax-error + 'parser-production-rhs + (format + "unrecognized terminal ~a in precedence declaration" + (syntax-object->datum (syntax term))) + (syntax term))))) + (parse-action (syntax prod-rhs) (syntax action))))) + (_ + (raise-syntax-error + 'parser-production-rhs + "production must have form [(symbol ...) expression] or [(symbol ...) (prec symbol) expression]" + prod-so))))) + + ;; parse-prod-for-nt: syntax-object -> production list + (parse-prods-for-nt + (lambda (prods-so) + (syntax-case prods-so () + ((nt productions ...) + (> (length (syntax->list (syntax (productions ...)))) 0) + (let ((nt (hash-table-get non-term-table + (syntax-object->datum (syntax nt))))) + (map (lambda (p) (parse-prod+action nt p)) + (syntax->list (syntax (productions ...)))))) + (_ + (raise-syntax-error + 'parser-productions + "A production for a non-terminal must be (non-term right-hand-side ...) with at least 1 right hand side" + prods-so)))))) + + (for-each + (lambda (sstx ssym) + (unless (memq ssym list-of-non-terms) + (raise-syntax-error + 'parser-start + (format "Start symbol ~a not defined as a non-terminal" ssym) + sstx))) + start start-syms) + + (let* ((starts (map (lambda (x) (make-non-term (gensym) #f)) start-syms)) + (end-non-terms (map (lambda (x) (make-non-term (gensym) #f)) start-syms)) + (parsed-prods (map parse-prods-for-nt (syntax->list prods))) + (start-prods + (map (lambda (start end-non-term) + (list (make-prod start (vector end-non-term) #f #f + (syntax (lambda (x) x))))) + starts end-non-terms)) + (prods + `(,@start-prods + ,@(map + (lambda (end-nt start-sym) + (map + (lambda (end) + (make-prod end-nt + (vector + (hash-table-get non-term-table start-sym) + (hash-table-get term-table end)) + #f + #f + (syntax (lambda (x) x)))) + end-terms)) + end-non-terms start-syms) + ,@parsed-prods))) + + (make-object grammar% + prods + (map car start-prods) + terms + (append starts (append end-non-terms non-terms)) + (map (lambda (term-name) + (hash-table-get term-table term-name)) + end-terms))))))) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/lalr.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/lalr.rkt new file mode 100644 index 0000000..e9b4d3b --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/lalr.rkt @@ -0,0 +1,277 @@ +(module lalr mzscheme + + ;; Compute LALR lookaheads from DeRemer and Pennello 1982 + + (require "lr0.rkt" + "grammar.rkt" + mzlib/list + mzlib/class) + + (provide compute-LA) + + ;; compute-DR: LR0-automaton * grammar -> (trans-key -> term set) + ;; computes for each state, non-term transition pair, the terminals + ;; which can transition out of the resulting state + ;; output term set is represented in bit-vector form + (define (compute-DR a g) + (lambda (tk) + (let ((r (send a run-automaton (trans-key-st tk) (trans-key-gs tk)))) + (term-list->bit-vector + (filter + (lambda (term) + (send a run-automaton r term)) + (send g get-terms)))))) + + ;; compute-reads: + ;; LR0-automaton * grammar -> (trans-key -> trans-key list) + (define (compute-reads a g) + (let ((nullable-non-terms + (filter (lambda (nt) (send g nullable-non-term? nt)) + (send g get-non-terms)))) + (lambda (tk) + (let ((r (send a run-automaton (trans-key-st tk) (trans-key-gs tk)))) + (map (lambda (x) (make-trans-key r x)) + (filter (lambda (non-term) (send a run-automaton r non-term)) + nullable-non-terms)))))) + + ;; compute-read: LR0-automaton * grammar -> (trans-key -> term set) + ;; output term set is represented in bit-vector form + (define (compute-read a g) + (let* ((dr (compute-DR a g)) + (reads (compute-reads a g))) + (digraph-tk->terml (send a get-mapped-non-term-keys) + reads + dr + (send a get-num-states)))) + ;; returns the list of all k such that state k transitions to state start on the + ;; transitions in rhs (in order) + (define (run-lr0-backward a rhs dot-pos start num-states) + (let loop ((states (list start)) + (i (sub1 dot-pos))) + (cond + ((< i 0) states) + (else (loop (send a run-automaton-back states (vector-ref rhs i)) + (sub1 i)))))) + + ;; prod->items-for-include: grammar * prod * non-term -> lr0-item list + ;; returns the list of all (B -> beta . nt gamma) such that prod = (B -> beta nt gamma) + ;; and gamma =>* epsilon + (define (prod->items-for-include g prod nt) + (let* ((rhs (prod-rhs prod)) + (rhs-l (vector-length rhs))) + (append (if (and (> rhs-l 0) (eq? nt (vector-ref rhs (sub1 rhs-l)))) + (list (make-item prod (sub1 rhs-l))) + null) + (let loop ((i (sub1 rhs-l))) + (cond + ((and (> i 0) + (non-term? (vector-ref rhs i)) + (send g nullable-non-term? (vector-ref rhs i))) + (if (eq? nt (vector-ref rhs (sub1 i))) + (cons (make-item prod (sub1 i)) + (loop (sub1 i))) + (loop (sub1 i)))) + (else null)))))) + + ;; prod-list->items-for-include: grammar * prod list * non-term -> lr0-item list + ;; return the list of all (B -> beta . nt gamma) such that (B -> beta nt gamma) in prod-list + ;; and gamma =>* epsilon + (define (prod-list->items-for-include g prod-list nt) + (apply append (map (lambda (prod) (prod->items-for-include g prod nt)) prod-list))) + + ;; comput-includes: lr0-automaton * grammar -> (trans-key -> trans-key list) + (define (compute-includes a g) + (let ((num-states (send a get-num-states)) + (items-for-input-nt (make-vector (send g get-num-non-terms) null))) + (for-each + (lambda (input-nt) + (vector-set! items-for-input-nt (non-term-index input-nt) + (prod-list->items-for-include g (send g get-prods) input-nt))) + (send g get-non-terms)) + (lambda (tk) + (let* ((goal-state (trans-key-st tk)) + (non-term (trans-key-gs tk)) + (items (vector-ref items-for-input-nt (non-term-index non-term)))) + (trans-key-list-remove-dups + (apply append + (map (lambda (item) + (let* ((prod (item-prod item)) + (rhs (prod-rhs prod)) + (lhs (prod-lhs prod))) + (map (lambda (state) + (make-trans-key state lhs)) + (run-lr0-backward a + rhs + (item-dot-pos item) + goal-state + num-states)))) + items))))))) + + ;; compute-lookback: lr0-automaton * grammar -> (kernel * proc -> trans-key list) + (define (compute-lookback a g) + (let ((num-states (send a get-num-states))) + (lambda (state prod) + (map (lambda (k) (make-trans-key k (prod-lhs prod))) + (run-lr0-backward a (prod-rhs prod) (vector-length (prod-rhs prod)) state num-states))))) + + ;; compute-follow: LR0-automaton * grammar -> (trans-key -> term set) + ;; output term set is represented in bit-vector form + (define (compute-follow a g includes) + (let ((read (compute-read a g))) + (digraph-tk->terml (send a get-mapped-non-term-keys) + includes + read + (send a get-num-states)))) + + ;; compute-LA: LR0-automaton * grammar -> kernel * prod -> term set + ;; output term set is represented in bit-vector form + (define (compute-LA a g) + (let* ((includes (compute-includes a g)) + (lookback (compute-lookback a g)) + (follow (compute-follow a g includes))) + (lambda (k p) + (let* ((l (lookback k p)) + (f (map follow l))) + (apply bitwise-ior (cons 0 f)))))) + + (define (print-DR dr a g) + (print-input-st-sym dr "DR" a g print-output-terms)) + (define (print-Read Read a g) + (print-input-st-sym Read "Read" a g print-output-terms)) + (define (print-includes i a g) + (print-input-st-sym i "includes" a g print-output-st-nt)) + (define (print-lookback l a g) + (print-input-st-prod l "lookback" a g print-output-st-nt)) + (define (print-follow f a g) + (print-input-st-sym f "follow" a g print-output-terms)) + (define (print-LA l a g) + (print-input-st-prod l "LA" a g print-output-terms)) + + (define (print-input-st-sym f name a g print-output) + (printf "~a:\n" name) + (send a for-each-state + (lambda (state) + (for-each + (lambda (non-term) + (let ((res (f (make-trans-key state non-term)))) + (if (not (null? res)) + (printf "~a(~a, ~a) = ~a\n" + name + state + (gram-sym-symbol non-term) + (print-output res))))) + (send g get-non-terms)))) + (newline)) + + (define (print-input-st-prod f name a g print-output) + (printf "~a:\n" name) + (send a for-each-state + (lambda (state) + (for-each + (lambda (non-term) + (for-each + (lambda (prod) + (let ((res (f state prod))) + (if (not (null? res)) + (printf "~a(~a, ~a) = ~a\n" + name + (kernel-index state) + (prod-index prod) + (print-output res))))) + (send g get-prods-for-non-term non-term))) + (send g get-non-terms))))) + + (define (print-output-terms r) + (map + (lambda (p) + (gram-sym-symbol p)) + r)) + + (define (print-output-st-nt r) + (map + (lambda (p) + (list + (kernel-index (trans-key-st p)) + (gram-sym-symbol (trans-key-gs p)))) + r)) + + ;; init-tk-map : int -> (vectorof hashtable?) + (define (init-tk-map n) + (let ((v (make-vector n #f))) + (let loop ((i (sub1 (vector-length v)))) + (when (>= i 0) + (vector-set! v i (make-hash-table)) + (loop (sub1 i)))) + v)) + + ;; lookup-tk-map : (vectorof (symbol? int hashtable)) -> trans-key? -> int + (define (lookup-tk-map map) + (lambda (tk) + (let ((st (trans-key-st tk)) + (gs (trans-key-gs tk))) + (hash-table-get (vector-ref map (kernel-index st)) + (gram-sym-symbol gs) + (lambda () 0))))) + + ;; add-tk-map : (vectorof (symbol? int hashtable)) -> trans-key int -> + (define (add-tk-map map) + (lambda (tk v) + (let ((st (trans-key-st tk)) + (gs (trans-key-gs tk))) + (hash-table-put! (vector-ref map (kernel-index st)) + (gram-sym-symbol gs) + v)))) + + ;; digraph-tk->terml: + ;; (trans-key list) * (trans-key -> trans-key list) * (trans-key -> term list) * int * int * int + ;; -> (trans-key -> term list) + ;; DeRemer and Pennello 1982 + ;; Computes (f x) = (f- x) union Union{(f y) | y in (edges x)} + ;; A specialization of digraph in the file graph.rkt + (define (digraph-tk->terml nodes edges f- num-states) + (letrec [ + ;; Will map elements of trans-key to term sets represented as bit vectors + (results (init-tk-map num-states)) + + ;; Maps elements of trans-keys to integers. + (N (init-tk-map num-states)) + + (get-N (lookup-tk-map N)) + (set-N (add-tk-map N)) + (get-f (lookup-tk-map results)) + (set-f (add-tk-map results)) + + (stack null) + (push (lambda (x) + (set! stack (cons x stack)))) + (pop (lambda () + (begin0 + (car stack) + (set! stack (cdr stack))))) + (depth (lambda () (length stack))) + + ;; traverse: 'a -> + (traverse + (lambda (x) + (push x) + (let ((d (depth))) + (set-N x d) + (set-f x (f- x)) + (for-each (lambda (y) + (when (= 0 (get-N y)) + (traverse y)) + (set-f x (bitwise-ior (get-f x) (get-f y))) + (set-N x (min (get-N x) (get-N y)))) + (edges x)) + (when (= d (get-N x)) + (let loop ((p (pop))) + (set-N p +inf.0) + (set-f p (get-f x)) + (unless (equal? x p) + (loop (pop))))))))] + (for-each (lambda (x) + (when (= 0 (get-N x)) + (traverse x))) + nodes) + get-f)) +) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/lr0.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/lr0.rkt new file mode 100644 index 0000000..f237735 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/lr0.rkt @@ -0,0 +1,372 @@ +(module lr0 mzscheme + + ;; Handle the LR0 automaton + + (require "grammar.rkt" + "graph.rkt" + mzlib/list + mzlib/class) + + (provide build-lr0-automaton lr0% + (struct trans-key (st gs)) trans-key-list-remove-dups + kernel-items kernel-index) + + ;; kernel = (make-kernel (LR1-item list) index) + ;; the list must be kept sorted according to item + ;; (vectorof (symbol X hashtable)) + (define (build-transition-table num-states assoc) + (let ((transitions (make-vector num-states #f))) + (let loop ((i (sub1 (vector-length transitions)))) + (when (>= i 0) + (vector-set! transitions i (make-hash-table)) + (loop (sub1 i)))) + (for-each + (lambda (trans-key/kernel) + (let ((tk (car trans-key/kernel))) + (hash-table-put! (vector-ref transitions (kernel-index (trans-key-st tk))) + (gram-sym-symbol (trans-key-gs tk)) + (cdr trans-key/kernel)))) + assoc) + transitions)) + + ;; reverse-assoc : (listof (cons/c trans-key? kernel?)) -> + ;; (listof (cons/c trans-key? (listof kernel?))) + (define (reverse-assoc assoc) + (let ((reverse-hash (make-hash-table 'equal)) + (hash-table-add! + (lambda (ht k v) + (hash-table-put! ht k (cons v (hash-table-get ht k (lambda () null))))))) + (for-each + (lambda (trans-key/kernel) + (let ((tk (car trans-key/kernel))) + (hash-table-add! reverse-hash + (make-trans-key (cdr trans-key/kernel) + (trans-key-gs tk)) + (trans-key-st tk)))) + assoc) + (hash-table-map reverse-hash cons))) + + + ;; kernel-list-remove-duplicates + ;; LR0-automaton = object of class lr0% + (define lr0% + (class object% + (super-instantiate ()) + ;; term-assoc : (listof (cons/c trans-key? kernel?)) + ;; non-term-assoc : (listof (cons/c trans-key? kernel?)) + ;; states : (vectorof kernel?) + ;; epsilons : ??? + (init-field term-assoc non-term-assoc states epsilons) + + (define transitions (build-transition-table (vector-length states) + (append term-assoc non-term-assoc))) + + (define reverse-term-assoc (reverse-assoc term-assoc)) + (define reverse-non-term-assoc (reverse-assoc non-term-assoc)) + (define reverse-transitions + (build-transition-table (vector-length states) + (append reverse-term-assoc reverse-non-term-assoc))) + + (define mapped-non-terms (map car non-term-assoc)) + + (define/public (get-mapped-non-term-keys) + mapped-non-terms) + + (define/public (get-num-states) + (vector-length states)) + + (define/public (get-epsilon-trans) + epsilons) + + (define/public (get-transitions) + (append term-assoc non-term-assoc)) + + ;; for-each-state : (state ->) -> + ;; Iteration over the states in an automaton + (define/public (for-each-state f) + (let ((num-states (vector-length states))) + (let loop ((i 0)) + (if (< i num-states) + (begin + (f (vector-ref states i)) + (loop (add1 i))))))) + + ;; run-automaton: kernel? gram-sym? -> (union kernel #f) + ;; returns the state reached from state k on input s, or #f when k + ;; has no transition on s + (define/public (run-automaton k s) + (hash-table-get (vector-ref transitions (kernel-index k)) + (gram-sym-symbol s) + (lambda () #f))) + + ;; run-automaton-back : (listof kernel?) gram-sym? -> (listof kernel) + ;; returns the list of states that can reach k by transitioning on s. + (define/public (run-automaton-back k s) + (apply append + (map + (lambda (k) + (hash-table-get (vector-ref reverse-transitions (kernel-index k)) + (gram-sym-symbol s) + (lambda () null))) + k))))) + + (define (union comp (eq? a b) + (define (kernel->string k) + (apply string-append + `("{" ,@(map (lambda (i) (string-append (item->string i) ", ")) + (kernel-items k)) + "}"))) + + ;; build-LR0-automaton: grammar -> LR0-automaton + ;; Constructs the kernels of the sets of LR(0) items of g + (define (build-lr0-automaton grammar) +; (printf "LR(0) automaton:\n") + (letrec ( + (epsilons (make-hash-table 'equal)) + (grammar-symbols (append (send grammar get-non-terms) + (send grammar get-terms))) + ;; first-non-term: non-term -> non-term list + ;; given a non-terminal symbol C, return those non-terminal + ;; symbols A s.t. C -> An for some string of terminals and + ;; non-terminals n where -> means a rightmost derivation in many + ;; steps. Assumes that each non-term can be reduced to a string + ;; of terms. + (first-non-term + (digraph (send grammar get-non-terms) + (lambda (nt) + (filter non-term? + (map (lambda (prod) + (sym-at-dot (make-item prod 0))) + (send grammar get-prods-for-non-term nt)))) + (lambda (nt) (list nt)) + (union non-term LR1-item list + ;; Creates a set of items containing i s.t. if A -> n.Xm is in it, + ;; X -> .o is in it too. + (LR0-closure + (lambda (i) + (cond + ((null? i) null) + (else + (let ((next-gsym (sym-at-dot (car i)))) + (cond + ((non-term? next-gsym) + (cons (car i) + (append + (apply append + (map (lambda (non-term) + (map (lambda (x) + (make-item x 0)) + (send grammar + get-prods-for-non-term + non-term))) + (first-non-term next-gsym))) + (LR0-closure (cdr i))))) + (else + (cons (car i) (LR0-closure (cdr i)))))))))) + + + ;; maps trans-keys to kernels + (automaton-term null) + (automaton-non-term null) + + ;; keeps the kernels we have seen, so we can have a unique + ;; list for each kernel + (kernels (make-hash-table 'equal)) + + (counter 0) + + ;; goto: LR1-item list -> LR1-item list list + ;; creates new kernels by moving the dot in each item in the + ;; LR0-closure of kernel to the right, and grouping them by + ;; the term/non-term moved over. Returns the kernels not + ;; yet seen, and places the trans-keys into automaton + (goto + (lambda (kernel) + (let ( + ;; maps a gram-syms to a list of items + (table (make-hash-table)) + + ;; add-item!: + ;; (symbol (listof item) hashtable) item? -> + ;; adds i into the table grouped with the grammar + ;; symbol following its dot + (add-item! + (lambda (table i) + (let ((gs (sym-at-dot i))) + (cond + (gs + (let ((already + (hash-table-get table + (gram-sym-symbol gs) + (lambda () null)))) + (unless (member i already) + (hash-table-put! table + (gram-sym-symbol gs) + (cons i already))))) + ((= 0 (vector-length (prod-rhs (item-prod i)))) + (let ((current (hash-table-get epsilons + kernel + (lambda () null)))) + (hash-table-put! epsilons + kernel + (cons i current))))))))) + + ;; Group the items of the LR0 closure of the kernel + ;; by the character after the dot + (for-each (lambda (item) + (add-item! table item)) + (LR0-closure (kernel-items kernel))) + + ;; each group is a new kernel, with the dot advanced. + ;; sorts the items in a kernel so kernels can be compared + ;; with equal? for using the table kernels to make sure + ;; only one representitive of each kernel is created + (filter + (lambda (x) x) + (map + (lambda (i) + (let* ((gs (car i)) + (items (cadr i)) + (new #f) + (new-kernel (sort + (filter (lambda (x) x) + (map move-dot-right items)) + item ~a on ~a\n" + (kernel->string kernel) + (kernel->string unique-kernel) + (gram-sym-symbol gs)) + (if new + unique-kernel + #f))) + (let loop ((gsyms grammar-symbols)) + (cond + ((null? gsyms) null) + (else + (let ((items (hash-table-get table + (gram-sym-symbol (car gsyms)) + (lambda () null)))) + (cond + ((null? items) (loop (cdr gsyms))) + (else + (cons (list (car gsyms) items) + (loop (cdr gsyms)))))))))))))) + + (starts + (map (lambda (init-prod) (list (make-item init-prod 0))) + (send grammar get-init-prods))) + (startk + (map (lambda (start) + (let ((k (make-kernel start counter))) + (hash-table-put! kernels start k) + (set! counter (add1 counter)) + k)) + starts)) + (new-kernels (make-queue))) + + (let loop ((old-kernels startk) + (seen-kernels null)) + (cond + ((and (empty-queue? new-kernels) (null? old-kernels)) + (make-object lr0% + automaton-term + automaton-non-term + (list->vector (reverse seen-kernels)) + epsilons)) + ((null? old-kernels) + (loop (deq! new-kernels) seen-kernels)) + (else + (enq! new-kernels (goto (car old-kernels))) + (loop (cdr old-kernels) (cons (car old-kernels) seen-kernels))))))) + + (define-struct q (f l) (make-inspector)) + (define (empty-queue? q) + (null? (q-f q))) + (define (make-queue) + (make-q null null)) + (define (enq! q i) + (if (empty-queue? q) + (let ((i (mcons i null))) + (set-q-l! q i) + (set-q-f! q i)) + (begin + (set-mcdr! (q-l q) (mcons i null)) + (set-q-l! q (mcdr (q-l q)))))) + (define (deq! q) + (begin0 + (mcar (q-f q)) + (set-q-f! q (mcdr (q-f q))))) + +) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/parser-actions.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/parser-actions.rkt new file mode 100644 index 0000000..2a39b36 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/parser-actions.rkt @@ -0,0 +1,54 @@ +(module parser-actions mzscheme + (require "grammar.rkt") + (provide (all-defined-except make-reduce make-reduce*) + (rename make-reduce* make-reduce)) + + ;; An action is + ;; - (make-shift int) + ;; - (make-reduce prod runtime-action) + ;; - (make-accept) + ;; - (make-goto int) + ;; - (no-action) + ;; A reduce contains a runtime-reduce so that sharing of the reduces can + ;; be easily transferred to sharing of runtime-reduces. + + (define-struct action () (make-inspector)) + (define-struct (shift action) (state) (make-inspector)) + (define-struct (reduce action) (prod runtime-reduce) (make-inspector)) + (define-struct (accept action) () (make-inspector)) + (define-struct (goto action) (state) (make-inspector)) + (define-struct (no-action action) () (make-inspector)) + + (define (make-reduce* p) + (make-reduce p + (vector (prod-index p) + (gram-sym-symbol (prod-lhs p)) + (vector-length (prod-rhs p))))) + + ;; A runtime-action is + ;; non-negative-int (shift) + ;; (vector int symbol int) (reduce) + ;; 'accept (accept) + ;; negative-int (goto) + ;; #f (no-action) + + (define (action->runtime-action a) + (cond + ((shift? a) (shift-state a)) + ((reduce? a) (reduce-runtime-reduce a)) + ((accept? a) 'accept) + ((goto? a) (- (+ (goto-state a) 1))) + ((no-action? a) #f))) + + (define (runtime-shift? x) (and (integer? x) (>= x 0))) + (define runtime-reduce? vector?) + (define (runtime-accept? x) (eq? x 'accept)) + (define (runtime-goto? x) (and (integer? x) (< x 0))) + + (define runtime-shift-state values) + (define (runtime-reduce-prod-num x) (vector-ref x 0)) + (define (runtime-reduce-lhs x) (vector-ref x 1)) + (define (runtime-reduce-rhs-length x) (vector-ref x 2)) + (define (runtime-goto-state x) (- (+ x 1))) + + ) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/parser-builder.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/parser-builder.rkt new file mode 100644 index 0000000..1be421c --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/parser-builder.rkt @@ -0,0 +1,113 @@ +(module parser-builder mzscheme + + (require "input-file-parser.rkt" + "grammar.rkt" + "table.rkt" + mzlib/class + racket/contract) + (require-for-template mzscheme) + + (provide/contract + (build-parser (-> string? any/c any/c + (listof identifier?) + (listof identifier?) + (listof identifier?) + (or/c syntax? #f) + syntax? + (values any/c any/c any/c any/c)))) + + ;; fix-check-syntax : (listof identifier?) (listof identifier?) (listof identifier?) + ;; (union syntax? false/c) syntax?) -> syntax? + (define (fix-check-syntax input-terms start ends assocs prods) + (let* ((term-binders (get-term-list input-terms)) + (get-term-binder + (let ((t (make-hash-table))) + (for-each + (lambda (term) + (hash-table-put! t (syntax-e term) term)) + term-binders) + (lambda (x) + (let ((r (hash-table-get t (syntax-e x) (lambda () #f)))) + (if r + (syntax-local-introduce (datum->syntax-object r (syntax-e x) x x)) + x))))) + (rhs-list + (syntax-case prods () + (((_ rhs ...) ...) + (syntax->list (syntax (rhs ... ...))))))) + (with-syntax (((tmp ...) (map syntax-local-introduce term-binders)) + ((term-group ...) + (map (lambda (tg) + (syntax-property + (datum->syntax-object tg #f) + 'disappeared-use + tg)) + input-terms)) + ((end ...) + (map get-term-binder ends)) + ((start ...) + (map get-term-binder start)) + ((bind ...) + (syntax-case prods () + (((bind _ ...) ...) + (syntax->list (syntax (bind ...)))))) + (((bound ...) ...) + (map + (lambda (rhs) + (syntax-case rhs () + (((bound ...) (_ pbound) __) + (map get-term-binder + (cons (syntax pbound) + (syntax->list (syntax (bound ...)))))) + (((bound ...) _) + (map get-term-binder + (syntax->list (syntax (bound ...))))))) + rhs-list)) + ((prec ...) + (if assocs + (map get-term-binder + (syntax-case assocs () + (((__ term ...) ...) + (syntax->list (syntax (term ... ...)))))) + null))) + #`(when #f + (let ((bind void) ... (tmp void) ...) + (void bound ... ... term-group ... start ... end ... prec ...)))))) + (require mzlib/list "parser-actions.rkt") + (define (build-parser filename src-pos suppress input-terms start end assocs prods) + (let* ((grammar (parse-input input-terms start end assocs prods src-pos)) + (table (build-table grammar filename suppress)) + (all-tokens (make-hash-table)) + (actions-code + `(vector ,@(map prod-action (send grammar get-prods))))) + (for-each (lambda (term) + (hash-table-put! all-tokens (gram-sym-symbol term) #t)) + (send grammar get-terms)) + #;(let ((num-states (vector-length table)) + (num-gram-syms (+ (send grammar get-num-terms) + (send grammar get-num-non-terms))) + (num-ht-entries (apply + (map length (vector->list table)))) + (num-reduces + (let ((ht (make-hash-table))) + (for-each + (lambda (x) + (when (reduce? x) + (hash-table-put! ht x #t))) + (map cdr (apply append (vector->list table)))) + (length (hash-table-map ht void))))) + (printf "~a states, ~a grammar symbols, ~a hash-table entries, ~a reduces\n" + num-states num-gram-syms num-ht-entries num-reduces) + (printf "~a -- ~aKB, previously ~aKB\n" + (/ (+ 2 num-states + (* 4 num-states) (* 2 1.5 num-ht-entries) + (* 5 num-reduces)) 256.0) + (/ (+ 2 num-states + (* 4 num-states) (* 2 2.3 num-ht-entries) + (* 5 num-reduces)) 256.0) + (/ (+ 2 (* num-states num-gram-syms) (* 5 num-reduces)) 256.0))) + (values table + all-tokens + actions-code + (fix-check-syntax input-terms start end assocs prods)))) + + ) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/table.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/table.rkt new file mode 100644 index 0000000..f97e4d2 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/table.rkt @@ -0,0 +1,290 @@ +#lang scheme/base + + ;; Routine to build the LALR table + + (require "grammar.rkt" + "lr0.rkt" + "lalr.rkt" + "parser-actions.rkt" + racket/contract + mzlib/list + mzlib/class) + + (define (is-a-grammar%? x) (is-a? x grammar%)) + (provide/contract + (build-table (-> is-a-grammar%? string? any/c + (vectorof (listof (cons/c (or/c term? non-term?) action?)))))) + + ;; A parse-table is (vectorof (listof (cons/c gram-sym? action))) + ;; A grouped-parse-table is (vectorof (listof (cons/c gram-sym? (listof action)))) + + ;; make-parse-table : int -> parse-table + (define (make-parse-table num-states) + (make-vector num-states null)) + + ;; table-add!: parse-table nat symbol action -> + (define (table-add! table state-index symbol val) + (vector-set! table state-index (cons (cons symbol val) + (vector-ref table state-index)))) + + ;; group-table : parse-table -> grouped-parse-table + (define (group-table table) + (list->vector + (map + (lambda (state-entry) + (let ((ht (make-hash))) + (for-each + (lambda (gs/actions) + (let ((group (hash-ref ht (car gs/actions) (lambda () null)))) + (unless (member (cdr gs/actions) group) + (hash-set! ht (car gs/actions) (cons (cdr gs/actions) group))))) + state-entry) + (hash-map ht cons))) + (vector->list table)))) + + ;; table-map : (vectorof (listof (cons/c gram-sym? X))) (gram-sym? X -> Y) -> + ;; (vectorof (listof (cons/c gram-sym? Y))) + (define (table-map f table) + (list->vector + (map + (lambda (state-entry) + (map + (lambda (gs/X) + (cons (car gs/X) (f (car gs/X) (cdr gs/X)))) + state-entry)) + (vector->list table)))) + + + (define (bit-vector-for-each f bv) + (letrec ((for-each + (lambda (bv number) + (cond + ((= 0 bv) (void)) + ((= 1 (bitwise-and 1 bv)) + (f number) + (for-each (arithmetic-shift bv -1) (add1 number))) + (else (for-each (arithmetic-shift bv -1) (add1 number))))))) + (for-each bv 0))) + + + ;; print-entry: symbol action output-port -> + ;; prints the action a for lookahead sym to the given port + (define (print-entry sym a port) + (let ((s "\t~a\t\t\t\t\t~a\t~a\n")) + (cond + ((shift? a) + (fprintf port s sym "shift" (shift-state a))) + ((reduce? a) + (fprintf port s sym "reduce" (prod-index (reduce-prod a)))) + ((accept? a) + (fprintf port s sym "accept" "")) + ((goto? a) + (fprintf port s sym "goto" (goto-state a)))))) + + + ;; count: ('a -> bool) * 'a list -> num + ;; counts the number of elements in list that satisfy pred + (define (count pred list) + (cond + ((null? list) 0) + ((pred (car list)) (+ 1 (count pred (cdr list)))) + (else (count pred (cdr list))))) + + ;; display-parser: LR0-automaton grouped-parse-table (listof prod?) output-port -> + ;; Prints out the parser given by table. + (define (display-parser a grouped-table prods port) + (let* ((SR-conflicts 0) + (RR-conflicts 0)) + (for-each + (lambda (prod) + (fprintf port + "~a\t~a\t=\t~a\n" + (prod-index prod) + (gram-sym-symbol (prod-lhs prod)) + (map gram-sym-symbol (vector->list (prod-rhs prod))))) + prods) + (send a for-each-state + (lambda (state) + (fprintf port "State ~a\n" (kernel-index state)) + (for-each (lambda (item) + (fprintf port "\t~a\n" (item->string item))) + (kernel-items state)) + (newline port) + (for-each + (lambda (gs/action) + (let ((sym (gram-sym-symbol (car gs/action))) + (act (cdr gs/action))) + (cond + ((null? act) (void)) + ((null? (cdr act)) + (print-entry sym (car act) port)) + (else + (fprintf port "begin conflict:\n") + (when (> (count reduce? act) 1) + (set! RR-conflicts (add1 RR-conflicts))) + (when (> (count shift? act) 0) + (set! SR-conflicts (add1 SR-conflicts))) + (map (lambda (x) (print-entry sym x port)) act) + (fprintf port "end conflict\n"))))) + (vector-ref grouped-table (kernel-index state))) + (newline port))) + + (when (> SR-conflicts 0) + (fprintf port "~a shift/reduce conflict~a\n" + SR-conflicts + (if (= SR-conflicts 1) "" "s"))) + (when (> RR-conflicts 0) + (fprintf port "~a reduce/reduce conflict~a\n" + RR-conflicts + (if (= RR-conflicts 1) "" "s"))))) + + ;; resolve-conflict : (listof action?) -> action? bool bool + (define (resolve-conflict actions) + (cond + ((null? actions) (values (make-no-action) #f #f)) + ((null? (cdr actions)) + (values (car actions) #f #f)) + (else + (let ((SR-conflict? (> (count shift? actions) 0)) + (RR-conflict? (> (count reduce? actions) 1))) + (let loop ((current-guess #f) + (rest actions)) + (cond + ((null? rest) (values current-guess SR-conflict? RR-conflict?)) + ((shift? (car rest)) (values (car rest) SR-conflict? RR-conflict?)) + ((not current-guess) + (loop (car rest) (cdr rest))) + ((and (reduce? (car rest)) + (< (prod-index (reduce-prod (car rest))) + (prod-index (reduce-prod current-guess)))) + (loop (car rest) (cdr rest))) + ((accept? (car rest)) + (eprintf "accept/reduce or accept/shift conflicts. Check the grammar for useless cycles of productions\n") + (loop current-guess (cdr rest))) + (else (loop current-guess (cdr rest))))))))) + + ;; resolve-conflicts : grouped-parse-table bool -> parse-table + (define (resolve-conflicts grouped-table suppress) + (let* ((SR-conflicts 0) + (RR-conflicts 0) + (table (table-map + (lambda (gs actions) + (let-values (((action SR? RR?) + (resolve-conflict actions))) + (when SR? + (set! SR-conflicts (add1 SR-conflicts))) + (when RR? + (set! RR-conflicts (add1 RR-conflicts))) + action)) + grouped-table))) + (unless suppress + (when (> SR-conflicts 0) + (eprintf "~a shift/reduce conflict~a\n" + SR-conflicts + (if (= SR-conflicts 1) "" "s"))) + (when (> RR-conflicts 0) + (eprintf "~a reduce/reduce conflict~a\n" + RR-conflicts + (if (= RR-conflicts 1) "" "s")))) + table)) + + + ;; resolve-sr-conflict : (listof action) (union int #f) -> (listof action) + ;; Resolves a single shift-reduce conflict, if precedences are in place. + (define (resolve-sr-conflict/prec actions shift-prec) + (let* ((shift (if (shift? (car actions)) + (car actions) + (cadr actions))) + (reduce (if (shift? (car actions)) + (cadr actions) + (car actions))) + (reduce-prec (prod-prec (reduce-prod reduce)))) + (cond + ((and shift-prec reduce-prec) + (cond + ((< (prec-num shift-prec) (prec-num reduce-prec)) + (list reduce)) + ((> (prec-num shift-prec) (prec-num reduce-prec)) + (list shift)) + ((eq? 'left (prec-assoc shift-prec)) + (list reduce)) + ((eq? 'right (prec-assoc shift-prec)) + (list shift)) + (else null))) + (else actions)))) + + + ;; resolve-prec-conflicts : parse-table -> grouped-parse-table + (define (resolve-prec-conflicts table) + (table-map + (lambda (gs actions) + (cond + ((and (term? gs) + (= 2 (length actions)) + (or (shift? (car actions)) + (shift? (cadr actions)))) + (resolve-sr-conflict/prec actions (term-prec gs))) + (else actions))) + (group-table table))) + + ;; build-table: grammar string bool -> parse-table + (define (build-table g file suppress) + (let* ((a (build-lr0-automaton g)) + (term-vector (list->vector (send g get-terms))) + (end-terms (send g get-end-terms)) + (table (make-parse-table (send a get-num-states))) + (get-lookahead (compute-LA a g)) + (reduce-cache (make-hash))) + + (for-each + (lambda (trans-key/state) + (let ((from-state-index (kernel-index (trans-key-st (car trans-key/state)))) + (gs (trans-key-gs (car trans-key/state))) + (to-state (cdr trans-key/state))) + (table-add! table from-state-index gs + (cond + ((non-term? gs) + (make-goto (kernel-index to-state))) + ((member gs end-terms) + (make-accept)) + (else + (make-shift + (kernel-index to-state))))))) + (send a get-transitions)) + + (send a for-each-state + (lambda (state) + (for-each + (lambda (item) + (let ((item-prod (item-prod item))) + (bit-vector-for-each + (lambda (term-index) + (unless (start-item? item) + (let ((r (hash-ref reduce-cache item-prod + (lambda () + (let ((r (make-reduce item-prod))) + (hash-set! reduce-cache item-prod r) + r))))) + (table-add! table + (kernel-index state) + (vector-ref term-vector term-index) + r)))) + (get-lookahead state item-prod)))) + (append (hash-ref (send a get-epsilon-trans) state (lambda () null)) + (filter (lambda (item) + (not (move-dot-right item))) + (kernel-items state)))))) + + (let ((grouped-table (resolve-prec-conflicts table))) + (unless (string=? file "") + (with-handlers [(exn:fail:filesystem? + (lambda (e) + (eprintf + "Cannot write debug output to file \"~a\": ~a\n" + file + (exn-message e))))] + (call-with-output-file file + (lambda (port) + (display-parser a grouped-table (send g get-prods) port)) + #:exists 'truncate))) + (resolve-conflicts grouped-table suppress)))) diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/yacc-helper.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/yacc-helper.rkt new file mode 100644 index 0000000..31b3cc6 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/private-yacc/yacc-helper.rkt @@ -0,0 +1,118 @@ +(module yacc-helper mzscheme + + (require mzlib/list + "../private-lex/token-syntax.rkt") + + ;; General helper routines + + (provide duplicate-list? remove-duplicates overlap? vector-andmap display-yacc) + + (define (vector-andmap f v) + (let loop ((i 0)) + (cond + ((= i (vector-length v)) #t) + (else (if (f (vector-ref v i)) + (loop (add1 i)) + #f))))) + + ;; duplicate-list?: symbol list -> #f | symbol + ;; returns a symbol that exists twice in l, or false if no such symbol + ;; exists + (define (duplicate-list? l) + (letrec ((t (make-hash-table)) + (dl? (lambda (l) + (cond + ((null? l) #f) + ((hash-table-get t (car l) (lambda () #f)) => + (lambda (x) x)) + (else + (hash-table-put! t (car l) (car l)) + (dl? (cdr l))))))) + (dl? l))) + + ;; remove-duplicates: syntax-object list -> syntax-object list + ;; removes the duplicates from the lists + (define (remove-duplicates sl) + (let ((t (make-hash-table))) + (letrec ((x + (lambda (sl) + (cond + ((null? sl) sl) + ((hash-table-get t (syntax-object->datum (car sl)) (lambda () #f)) + (x (cdr sl))) + (else + (hash-table-put! t (syntax-object->datum (car sl)) #t) + (cons (car sl) (x (cdr sl)))))))) + (x sl)))) + + ;; overlap?: symbol list * symbol list -> #f | symbol + ;; Returns an symbol in l1 intersect l2, or #f is no such symbol exists + (define (overlap? l1 l2) + (let/ec ret + (let ((t (make-hash-table))) + (for-each (lambda (s1) + (hash-table-put! t s1 s1)) + l1) + (for-each (lambda (s2) + (cond + ((hash-table-get t s2 (lambda () #f)) => + (lambda (o) (ret o))))) + l2) + #f))) + + + (define (display-yacc grammar tokens start precs port) + (let-syntax ((p (syntax-rules () + ((_ args ...) (fprintf port args ...))))) + (let* ((tokens (map syntax-local-value tokens)) + (eterms (filter e-terminals-def? tokens)) + (terms (filter terminals-def? tokens)) + (term-table (make-hash-table)) + (display-rhs + (lambda (rhs) + (for-each (lambda (sym) (p "~a " (hash-table-get term-table sym (lambda () sym)))) + (car rhs)) + (if (= 3 (length rhs)) + (p "%prec ~a" (cadadr rhs))) + (p "\n")))) + (for-each + (lambda (t) + (for-each + (lambda (t) + (hash-table-put! term-table t (format "'~a'" t))) + (syntax-object->datum (e-terminals-def-t t)))) + eterms) + (for-each + (lambda (t) + (for-each + (lambda (t) + (p "%token ~a\n" t) + (hash-table-put! term-table t (format "~a" t))) + (syntax-object->datum (terminals-def-t t)))) + terms) + (if precs + (for-each (lambda (prec) + (p "%~a " (car prec)) + (for-each (lambda (tok) + (p " ~a" (hash-table-get term-table tok))) + (cdr prec)) + (p "\n")) + precs)) + (p "%start ~a\n" start) + (p "%%\n") + + (for-each (lambda (prod) + (let ((nt (car prod))) + (p "~a: " nt) + (display-rhs (cadr prod)) + (for-each (lambda (rhs) + (p "| ") + (display-rhs rhs)) + (cddr prod)) + (p ";\n"))) + grammar) + (p "%%\n")))) + + +) + diff --git a/br-parser-tools/br-parser-tools-lib/br-parser-tools/yacc-to-scheme.rkt b/br-parser-tools/br-parser-tools-lib/br-parser-tools/yacc-to-scheme.rkt new file mode 100644 index 0000000..7f766eb --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/br-parser-tools/yacc-to-scheme.rkt @@ -0,0 +1,135 @@ +(module yacc-to-scheme mzscheme + (require br-parser-tools/lex + (prefix : br-parser-tools/lex-sre) + br-parser-tools/yacc + syntax/readerr + mzlib/list) + (provide trans) + + (define match-double-string + (lexer + ((:+ (:~ #\" #\\)) (append (string->list lexeme) + (match-double-string input-port))) + ((:: #\\ any-char) (cons (string-ref lexeme 1) (match-double-string input-port))) + (#\" null))) + + (define match-single-string + (lexer + ((:+ (:~ #\' #\\)) (append (string->list lexeme) + (match-single-string input-port))) + ((:: #\\ any-char) (cons (string-ref lexeme 1) (match-single-string input-port))) + (#\' null))) + + (define-lex-abbrevs + (letter (:or (:/ "a" "z") (:/ "A" "Z"))) + (digit (:/ "0" "9")) + (initial (:or letter (char-set "!$%&*/<=>?^_~@"))) + (subsequent (:or initial digit (char-set "+-.@"))) + (comment (:: "/*" (complement (:: any-string "*/" any-string)) "*/"))) + + (define-empty-tokens x + (EOF PIPE |:| SEMI |%%| %prec)) + (define-tokens y + (SYM STRING)) + + (define get-token-grammar + (lexer-src-pos + ("%%" '|%%|) + (":" (string->symbol lexeme)) + ("%prec" (string->symbol lexeme)) + (#\| 'PIPE) + ((:+ (:or #\newline #\tab " " comment (:: "{" (:* (:~ "}")) "}"))) + (return-without-pos (get-token-grammar input-port))) + (#\; 'SEMI) + (#\' (token-STRING (string->symbol (list->string (match-single-string input-port))))) + (#\" (token-STRING (string->symbol (list->string (match-double-string input-port))))) + ((:: initial (:* subsequent)) (token-SYM (string->symbol lexeme))))) + + (define (parse-grammar enter-term enter-empty-term enter-non-term) + (parser + (tokens x y) + (src-pos) + (error (lambda (tok-ok tok-name tok-value start-pos end-pos) + (raise-read-error + (format "Error Parsing YACC grammar at token: ~a with value: ~a" tok-name tok-value) + (file-path) + (position-line start-pos) + (position-col start-pos) + (position-offset start-pos) + (- (position-offset end-pos) (position-offset start-pos))))) + + (end |%%|) + (start gram) + (grammar + (gram + ((production) (list $1)) + ((production gram) (cons $1 $2))) + (production + ((SYM |:| prods SEMI) + (begin + (enter-non-term $1) + (cons $1 $3)))) + (prods + ((rhs) (list `(,$1 #f))) + ((rhs prec) (list `(,$1 ,$2 #f))) + ((rhs PIPE prods) (cons `(,$1 #f) $3)) + ((rhs prec PIPE prods) (cons `(,$1 ,$2 #f) $4))) + (prec + ((%prec SYM) + (begin + (enter-term $2) + (list 'prec $2))) + ((%prec STRING) + (begin + (enter-empty-term $2) + (list 'prec $2)))) + (rhs + (() null) + ((SYM rhs) + (begin + (enter-term $1) + (cons $1 $2))) + ((STRING rhs) + (begin + (enter-empty-term $1) + (cons $1 $2))))))) + + (define (symbolstring a) (symbol->string b))) + + (define (trans filename) + (let* ((i (open-input-file filename)) + (terms (make-hash-table)) + (eterms (make-hash-table)) + (nterms (make-hash-table)) + (enter-term + (lambda (s) + (if (not (hash-table-get nterms s (lambda () #f))) + (hash-table-put! terms s #t)))) + (enter-empty-term + (lambda (s) + (if (not (hash-table-get nterms s (lambda () #f))) + (hash-table-put! eterms s #t)))) + (enter-non-term + (lambda (s) + (hash-table-remove! terms s) + (hash-table-remove! eterms s) + (hash-table-put! nterms s #t)))) + (port-count-lines! i) + (file-path filename) + (regexp-match "%%" i) + (begin0 + (let ((gram ((parse-grammar enter-term enter-empty-term enter-non-term) + (lambda () + (let ((t (get-token-grammar i))) + t))))) + `(begin + (define-tokens t ,(sort (hash-table-map terms (lambda (k v) k)) symbol +;; (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)))))))))) diff --git a/br-parser-tools/br-parser-tools-lib/info.rkt b/br-parser-tools/br-parser-tools-lib/info.rkt new file mode 100644 index 0000000..f9f9e11 --- /dev/null +++ b/br-parser-tools/br-parser-tools-lib/info.rkt @@ -0,0 +1,11 @@ +#lang info + +(define collection 'multi) +(define deps '("scheme-lib" + "base" + "compatibility-lib")) +(define build-deps '("rackunit-lib")) + +(define pkg-desc "implementation (no documentation) part of \"br-parser-tools\"") + +(define pkg-authors '(mflatt)) diff --git a/br-parser-tools/br-parser-tools/LICENSE.txt b/br-parser-tools/br-parser-tools/LICENSE.txt new file mode 100644 index 0000000..d012f58 --- /dev/null +++ b/br-parser-tools/br-parser-tools/LICENSE.txt @@ -0,0 +1,11 @@ +parser-tools +Copyright (c) 2010-2014 PLT Design Inc. + +This package is distributed under the GNU Lesser General Public +License (LGPL). This means that you can link this package into proprietary +applications, provided you follow the rules stated in the LGPL. You +can also modify this package; if you distribute a modified version, +you must distribute it under the terms of the LGPL, which in +particular means that you must release the source code for the +modified software. See http://www.gnu.org/copyleft/lesser.html +for more information. diff --git a/br-parser-tools/br-parser-tools/info.rkt b/br-parser-tools/br-parser-tools/info.rkt new file mode 100644 index 0000000..6a692a8 --- /dev/null +++ b/br-parser-tools/br-parser-tools/info.rkt @@ -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))