Import Nyacc 0.72.0.
authorJan Nieuwenhuizen <janneke@gnu.org>
Sat, 17 Dec 2016 21:34:43 +0000 (22:34 +0100)
committerJan Nieuwenhuizen <janneke@gnu.org>
Sat, 17 Dec 2016 21:34:43 +0000 (22:34 +0100)
* module/nyacc: Import module/nyacc.

30 files changed:
module/nyacc/BUGS [new file with mode: 0644]
module/nyacc/ChangeLog [new file with mode: 0644]
module/nyacc/README [new file with mode: 0644]
module/nyacc/bison.scm [new file with mode: 0644]
module/nyacc/export.scm [new file with mode: 0644]
module/nyacc/import.scm [new file with mode: 0644]
module/nyacc/lalr.scm [new file with mode: 0644]
module/nyacc/lang/c99/BUGS [new file with mode: 0644]
module/nyacc/lang/c99/README [new file with mode: 0644]
module/nyacc/lang/c99/body.scm [new file with mode: 0644]
module/nyacc/lang/c99/cpp.scm [new file with mode: 0644]
module/nyacc/lang/c99/cppbody.scm [new file with mode: 0644]
module/nyacc/lang/c99/cppmach.scm [new file with mode: 0644]
module/nyacc/lang/c99/mach.d/c99act.scm [new file with mode: 0644]
module/nyacc/lang/c99/mach.d/c99tab.scm [new file with mode: 0644]
module/nyacc/lang/c99/mach.d/c99xact.scm [new file with mode: 0644]
module/nyacc/lang/c99/mach.d/c99xtab.scm [new file with mode: 0644]
module/nyacc/lang/c99/mach.d/cppact.scm [new file with mode: 0644]
module/nyacc/lang/c99/mach.d/cpptab.scm [new file with mode: 0644]
module/nyacc/lang/c99/mach.scm [new file with mode: 0644]
module/nyacc/lang/c99/parser.scm [new file with mode: 0644]
module/nyacc/lang/c99/pprint.scm [new file with mode: 0644]
module/nyacc/lang/c99/util1.scm [new file with mode: 0644]
module/nyacc/lang/c99/util2.scm [new file with mode: 0644]
module/nyacc/lang/c99/xparser.scm [new file with mode: 0644]
module/nyacc/lang/calc/parser.scm [new file with mode: 0644]
module/nyacc/lang/util.scm [new file with mode: 0644]
module/nyacc/lex.scm [new file with mode: 0644]
module/nyacc/parse.scm [new file with mode: 0644]
module/nyacc/util.scm [new file with mode: 0644]

diff --git a/module/nyacc/BUGS b/module/nyacc/BUGS
new file mode 100644 (file)
index 0000000..d8223d4
--- /dev/null
@@ -0,0 +1,22 @@
+Copyright (C) 2016 Matthew R. Wette
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.  This file is offered as-is,
+without any warranty.
+
+BUG-004        <= next bug id
+
+BUG-003        If using phony prec token then it ends up in match table.
+       For example, "then" appears in the match table for lang/c99.
+
+=fixed=        
+
+BUG-001        In lalr.scm, hashify-machine, if pat contains a rrconf then the output
+       is unspecified
+   todo        I think this was already fixed
+
+BUG-002        If mach has a conflict and hashify followed by pp-lalr-machine then
+       error because hashify puts #f, not integer, for pat-v.
+  fixed        fixed pp-lalr-machine to check for #f
+
diff --git a/module/nyacc/ChangeLog b/module/nyacc/ChangeLog
new file mode 100644 (file)
index 0000000..482df16
--- /dev/null
@@ -0,0 +1,18 @@
+2016-04-09  Matt Wette  <mwette@nautilus>
+
+       * bison.scm: new file providing make-lalr-machin/bison.  It is
+       similar to make-lalr-machine but uses external bison program
+       instead of the default from-scratch lalr code.
+
+2016-03-04  Matt Wette  <mwette@nautilus>
+
+       * lalr.scm: changed grammar parser to interpret $string as
+       terminal.  This saves typing a quote in front.
+
+Copyright (C) 2015,2016 Matthew R. Wette
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.  This file is offered as-is,
+without any warranty.
+
diff --git a/module/nyacc/README b/module/nyacc/README
new file mode 100644 (file)
index 0000000..cdd1491
--- /dev/null
@@ -0,0 +1,54 @@
+nyacc/README
+
+   Copyright (C) 2016 Matthew R. Wette
+
+   Copying and distribution of this file, with or without modification,
+   are permitted in any medium without royalty provided the copyright
+   notice and this notice are preserved.  This file is offered as-is,
+   without any warranty.
+
+
+strategy for generating parsers and other stuff
+
+guile -s mach.scm -c '(@ (nyacc lang c99 mach) gen-mach-files)'
+=> .scm/{actions.scm,tables.scm}
+#guild compile 
+
+eval-when?
+
+use-case: dist mach-files and parser
+
+dist:
+       mach.scm
+
+
+===============================================================================
+
+dev-parser.scm: mach.scm pbody.scm mk-parser.scm
+parser.scm: mach.scm pbody.scm mk-parser.scm
+expr-parser.scm: mach.scm pbody.scm mk-parser.scm
+
+$ guile -l cppmach.scm -c '(@ (nyacc lang c99 cppmach) gen-cpp-files)'
+> cppact.scm cpptab.scm
+
+$ guile -l mach.scm -c '(@ (nyacc lang c99 mach) gen-c99-files)'
+> c99act.scm c99tab.scm
+
+$ guile -l mach.scm -c '(@ (nyacc lang c99 mach) gen-c99x-files)'
+> c99xact.scm c99xtab.scm 
+
+===============================================================================
+
+install:
+       cpp.go
+       mach.go
+       parser.go
+       xparser.go
+       pprint.go
+       util1.go
+       util1.go
+
+cpp.scm: cppmach.scm
+
+#cppmach.scm (export-files
+
diff --git a/module/nyacc/bison.scm b/module/nyacc/bison.scm
new file mode 100644 (file)
index 0000000..6bb15df
--- /dev/null
@@ -0,0 +1,215 @@
+;;; nyacc/bison.scm
+;;;
+;;; Copyright (C) 2016 Matthew R. Wette
+;;;
+;;; This library is free software; you can redistribute it and/or
+;;; modify it under the terms of the GNU Lesser General Public
+;;; License as published by the Free Software Foundation; either
+;;; version 3 of the License, or (at your option) any later version.
+;;;
+;;; This library is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;;; Lesser General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+(define-module (nyacc bison)
+  #:export (make-lalr-machine/bison)
+  #:use-module (sxml simple)
+  #:use-module (sxml match)
+  #:use-module (sxml xpath)
+  #:use-module (ice-9 pretty-print)
+  #:use-module ((srfi srfi-1) #:select (fold))
+  #:use-module ((srfi srfi-43) #:select (vector-for-each vector-map))
+  #:use-module (nyacc export)
+  #:use-module (nyacc lalr)            ; gen-match-table
+  )
+
+;; @deffn chew-on-grammar tree lhs-v rhs-v terms => a-list
+;; Generate a-list that maps bison rule index to NYACC rule index.
+(define (chew-on-grammar tree lhs-v rhs-v terms) ;; bison-rule => nyacc-rule map
+
+  ;; match rule index, if no match return @code{-1}
+  ;; could be improved by starting with last rule number and wrapping
+  (define (match-rule lhs rhs)
+    (let iter ((ix 0))
+      (if (eqv? ix (vector-length lhs-v)) -1
+         (if (and (equal? lhs (elt->bison (vector-ref lhs-v ix) terms))
+                  (equal? rhs (vector->list
+                               (vector-map
+                                (lambda (ix val) (elt->bison val terms))
+                                (vector-ref rhs-v ix)))))
+             ix
+             (iter (1+ ix))))))
+
+  ;; this is a fold
+  (define (rule->index-al tree seed)
+    (sxml-match tree
+      ;; Skip first bison rule: always $accept.
+      ((rule (@ (number "0")) (lhs "$accept") . ,rest)
+       (acons 0 0 seed))
+      ;; This matches all others.
+      ((rule (@ (number ,n)) (lhs ,lhs) (rhs (symbol ,rhs) ...))
+       (acons (string->number n) (match-rule lhs rhs) seed))
+      (,otherwise seed)))
+
+  (fold rule->index-al '() ((sxpath '(// rule)) tree)))
+
+;; @deffn chew-on-automaton tree gx-al bs->ns => a-list
+;; This digests the automaton and generated the @code{pat-v} and @code{kis-v}
+;; vectors for the NYACC automaton.
+(define (chew-on-automaton tree gx-al bs->ns)
+
+  (define st-numb
+    (let ((xsnum (sxpath '(@ number *text*))))
+      (lambda (state)
+       (string->number (car (xsnum state))))))
+
+  (define (do-state state)
+    (let* ((b-items ((sxpath '(// item)) state))
+          (n-items (fold
+                    (lambda (tree seed)
+                      (sxml-match tree
+                        ((item (@ (rule-number ,rns) (point ,pts)) . ,rest)
+                         (let ((rn (string->number rns))
+                               (pt (string->number pts)))
+                           (if (and (positive? rn) (zero? pt)) seed
+                               (acons (assq-ref gx-al rn) pt seed))))
+                        (,otherwise (error "broken item")))) '() b-items))
+          (b-trans ((sxpath '(// transition)) state))
+          (n-trans (map
+                    (lambda (tree)
+                      (sxml-match tree
+                        ((transition (@ (symbol ,symb) (state ,dest)))
+                         (cons* (bs->ns symb) 'shift (string->number dest)))
+                        (,otherwise (error "broken tran")))) b-trans))
+          (b-redxs ((sxpath '(// reduction)) state))
+          (n-redxs (map
+                    (lambda (tree)
+                      (sxml-match tree
+                        ((reduction (@ (symbol ,symb) (rule "accept")))
+                         (cons* (bs->ns symb) 'accept 0))
+                        ((reduction (@ (symbol ,symb) (rule ,rule)))
+                         (cons* (bs->ns symb) 'reduce
+                                (assq-ref gx-al (string->number rule))))
+                        (,otherwise (error "broken redx" tree)))) b-redxs))
+          )
+      (list
+       (st-numb state)
+       (cons 'kis n-items)
+       (cons 'pat (append n-trans n-redxs)))))
+
+  (let ((xsf (sxpath '(itemset item (@ (rule-number (equal? "0"))
+                                      (point (equal? "2")))))))
+    (let iter ((data '()) (xtra #f) (states (cdr tree)))
+      (cond
+       ((null? states) (cons xtra data))
+       ((pair? (xsf (car states)))
+       (iter data (st-numb (car states)) (cdr states)))
+       (else
+       (iter (cons (do-state (car states)) data) xtra (cdr states)))))))
+
+;; @deffn atomize symbol => string
+;; This is copied from the module @code{(nyacc lalr)}.
+(define (atomize terminal)             ; from lalr.scm
+  (if (string? terminal)
+      (string->symbol (string-append "$:" terminal))
+      terminal))
+
+;; @deffn make-bison->nyacc-symbol-mapper terminals non-terminals => proc
+;; This generates a procedure to map bison symbol names, generated by the
+;; NYACC @code{lalr->bison} procedure, (back) to nyacc symbols names.
+(define (make-bison->nyacc-symbol-mapper terms non-ts)
+  (let ((bs->ns-al
+        (cons*
+         '("$default" . $default)
+         '("$end" . $end)
+         (map (lambda (symb) (cons (elt->bison symb terms) symb))
+              (append (map atomize terms) non-ts)))))
+    (lambda (name) (assoc-ref bs->ns-al name))))
+
+;; fix-pa
+;; fix parse action
+(define (fix-pa pa xs)
+  (cond
+   ((and (eqv? 'shift (cadr pa))
+        (> (cddr pa) xs))
+    (cons* (car pa) (cadr pa) (1- (cddr pa))))
+   ((and (eqv? 'shift (cadr pa))
+        (= (cddr pa) xs))
+    (cons* (car pa) 'accept 0))
+   (else pa)))
+
+;; @deffn fix-is is xs rhs-v
+;; Convert xxx
+(define (fix-is is xs rhs-v)
+  (let* ((gx (car is))
+        (rx (cdr is))
+        (gl (vector-length (vector-ref rhs-v gx))))
+    (if (= rx gl) (cons gx -1) is)))
+
+;; @deffn spec->mac-sxml spec
+;; Write bison-converted @var{spec} to file, run bison on it, and load
+;; the bison-generated automaton as a SXML tree using the @code{-x} option.
+(define (spec->mach-sxml spec)
+  (let* ((basename (tmpnam))
+        (bisname (string-append basename ".y"))
+        (xmlname (string-append basename ".xml"))
+        (tabname (string-append basename ".tab.c")))
+    (with-output-to-file bisname
+      (lambda () (lalr->bison spec)))
+    (system (string-append "bison" " --xml=" xmlname " --output=" tabname
+                          " " bisname))
+    (let ((sx (call-with-input-file xmlname
+               (lambda (p) (xml->sxml p #:trim-whitespace? #t)))))
+      (delete-file bisname)
+      (delete-file xmlname)
+      (delete-file tabname)
+      sx)))
+
+;; @deffn make-lalr-machine/bison spec => mach
+;; Make a LALR automaton, consistent with that from @code{make-lalr-machine}
+;; using external @code{bison} program.
+(define (make-lalr-machine/bison spec)
+  (let* ((terminals (assq-ref spec 'terminals))
+        (non-terms (assq-ref spec 'non-terms))
+        (lhs-v (assq-ref spec 'lhs-v))
+        (rhs-v (assq-ref spec 'rhs-v))
+        (s0 (spec->mach-sxml spec))
+        (sG ((sxpath '(bison-xml-report grammar)) s0))
+        (sG (if (pair? sG) (car sG) sG))
+        (sA ((sxpath '(bison-xml-report automaton)) s0))
+        (sA (if (pair? sA) (car sA) sA))
+        (pG (chew-on-grammar sG lhs-v rhs-v terminals))
+        (bsym->nsym (make-bison->nyacc-symbol-mapper terminals non-terms))
+        (pA (chew-on-automaton sA pG bsym->nsym))
+        (xs (car pA))
+        (ns (caadr pA))
+        (pat-v (make-vector ns #f))
+        (kis-v (make-vector ns #f))
+        )
+    ;;(pretty-print sA)
+    (for-each
+     (lambda (state)
+       (let* ((sx (car state))
+             (sx (if (>= sx xs) (1- sx) sx))
+             (pat (assq-ref (cdr state) 'pat))
+             (pat (map (lambda (pa) (fix-pa pa xs)) pat))
+             (kis (assq-ref (cdr state) 'kis))
+             (kis (map (lambda (is) (fix-is is xs rhs-v)) kis)))
+        (vector-set! pat-v sx pat)
+        (vector-set! kis-v sx kis)))
+     (cdr pA))
+    (gen-match-table
+     (cons*
+      (cons 'pat-v pat-v)
+      (cons 'kis-v kis-v)
+      (cons 'len-v (vector-map (lambda (i v) (vector-length v)) rhs-v))
+      (cons 'rto-v (vector-copy lhs-v))
+      spec))))
+
+
+;; --- last line ---
diff --git a/module/nyacc/export.scm b/module/nyacc/export.scm
new file mode 100644 (file)
index 0000000..23584bd
--- /dev/null
@@ -0,0 +1,200 @@
+;;; nyacc/export.scm
+;;;
+;;; Copyright (C) 2015 Matthew R. Wette
+;;;
+;;; This library is free software; you can redistribute it and/or
+;;; modify it under the terms of the GNU Lesser General Public
+;;; License as published by the Free Software Foundation; either
+;;; version 3 of the License, or (at your option) any later version.
+;;;
+;;; This library is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;;; Lesser General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+(define-module (nyacc export)
+  #:export (lalr->bison
+           lalr->guile
+           c-char token->bison elt->bison
+           )
+  #:use-module ((nyacc lalr) #:select (find-terminal pp-rule))
+  #:use-module (nyacc lex)
+  #:use-module (nyacc util)
+  #:use-module ((srfi srfi-1) #:select (fold))
+  #:use-module ((srfi srfi-43) #:select (vector-for-each))
+  #:use-module (ice-9 regex)
+  )
+
+;; The code below, for exporting to guile and bison, should be moved to
+;; an "export" module.
+
+;; terminal:
+;; ident-like-string -> caps
+;; non-ident-like-string -> ChSeq_#_# ...
+;; symbol -> if $, use _, otherwise ???
+
+;; breakdown:
+;; 1 terminal, or non-terminal:
+;; 2 if non-terminal,
+;;   replace - with _, replace $ with _
+;; 3 if terminal, (output of @code{find-terminal})
+;;   if symbol, use 2
+;;   replace char with (c-char .)
+;;   if length-1 string replace with (c-char .)
+;;   if like-c-ident string, replace with CAPS
+;;   otherwise use ChSeq
+
+(define re/g regexp-substitute/global)
+
+(define (chseq->name cs)
+  (let* ((iseq (string-fold (lambda (c s) (cons* (char->integer c) s)) '() cs))
+        (tail (string-join (map number->string iseq) "_"))
+        (name (string-append "ChSeq_" tail)))
+    name))
+
+;; Convert char to string that works inside single quotes for C.
+(define (c-char ch)
+  (case ch
+    ((#\') "'\\''")
+    ((#\\) "'\\\\'")
+    ((#\newline) "'\\n'")
+    ((#\tab) "'\\t'")
+    ((#\return) "\\r")
+    (else (string #\' ch #\'))))
+
+(define (token->bison tok)
+  (cond
+   ((eqv? tok '$error) "error")
+   ((symbol? tok) (symbol->bison tok))
+   ((char? tok) (c-char tok))
+   ((string? tok)
+    (cond
+     ((like-c-ident? tok) (string-upcase tok))
+     ((= 1 (string-length tok)) (c-char (string-ref tok 0)))
+     (else (chseq->name tok))))
+   (else (error "what?"))))
+
+(define (symbol->bison symb)
+  (let* ((str0 (symbol->string symb))
+        (str1 (re/g #f "-" str0 'pre "_" 'post))
+        (str2 (re/g #f "\\$" str1 'pre "_" 'post)))
+    str2))
+
+(define (elt->bison symb terms)
+  (let ((term (find-terminal symb terms)))
+    (if term
+       (token->bison term)
+       (symbol->bison symb))))
+
+;; @deffn lalr->bison spec => to current output port
+;; needs cleanup: tokens working better but p-rules need fix.
+(define (lalr->bison spec . rest)
+
+  (define (setup-assc assc)
+    (fold (lambda (al seed)
+           (append (x-flip al) seed)) '() assc))
+
+  (let* ((port (if (pair? rest) (car rest) (current-output-port)))
+        (lhs-v (assq-ref spec 'lhs-v))
+        (rhs-v (assq-ref spec 'rhs-v))
+        (prp-v (assq-ref spec 'prp-v))
+        (assc (setup-assc (assq-ref spec 'assc)))
+        (nrule (vector-length lhs-v))
+        (terms (assq-ref spec 'terminals)))
+    ;; Generate copyright notice.
+    (let* ((notice (assq-ref (assq-ref spec 'attr) 'notice))
+          (lines (if notice (string-split notice #\newline) '())))
+      (for-each (lambda (l) (fmt port "// ~A\n" l))
+               lines))
+    ;; Write out the tokens.
+    (for-each 
+     (lambda (term)
+       (unless (eqv? term '$error)
+        (fmt port "%token ~A\n" (token->bison term))))
+     terms)
+    ;; Write the associativity and prececences.
+    (let iter ((pl '()) (ppl (assq-ref spec 'prec)))
+      (cond
+       ((pair? pl)
+       (fmt port "%~A" (or (assq-ref assc (caar pl)) "precedence"))
+       (let iter2 ((pl (car pl)))
+         (unless (null? pl)
+           (fmt port " ~A" (elt->bison (car pl) terms))
+           (iter2 (cdr pl))))
+       (fmt port "\n")
+       (iter (cdr pl) ppl))
+       ((pair? ppl) (iter (car ppl) (cdr ppl)))))
+    ;; Don't compact tables.
+    (fmt port "%define lr.default-reduction accepting\n")
+    ;; Provide start symbol.
+    (fmt port "%start ~A\n%%\n" (elt->bison (assq-ref spec 'start) terms))
+    ;;
+    (do ((i 1 (1+ i))) ((= i nrule))
+      (let* ((lhs (vector-ref lhs-v i)) (rhs (vector-ref rhs-v i)))
+       (fmt port "~A:" (elt->bison lhs terms))
+       (vector-for-each
+        (lambda (ix e) (fmt port " ~A" (elt->bison e terms)))
+        rhs)
+       (if (zero? (vector-length rhs)) (fmt port " %empty"))
+       (and=> (vector-ref prp-v i)
+              (lambda (tok) (fmt port " %prec ~A" (elt->bison tok terms))))
+       (fmt port " ;\n")))
+    (newline port)
+    (values)))
+
+;; @item pp-guile-input spec => to current output port
+;; total hack right now
+(define (lalr->guile spec . rest)
+  (let* ((port (if (pair? rest) (car rest) (current-output-port)))
+        (lhs-v (assq-ref spec 'lhs-v))
+        (rhs-v (assq-ref spec 'rhs-v))
+        (act-v (assq-ref spec 'act-v))
+        (nrule (vector-length lhs-v))
+        (terms (assq-ref spec 'terminals))
+        (lhsP #f))
+    ;;
+    (fmt port "(use-modules (system base lalr))\n")
+    (fmt port "(define parser\n")
+    (fmt port "  (lalr-parser\n   (")
+    (for-each
+     (lambda (s)
+       (if (> (port-column port) 60) (fmt port "\n    "))
+       (cond
+       ((equal? #\; s) (fmt port " C-semi"))
+       ((symbol? s) (fmt port " ~A" s))
+       (else (fmt port " C-~A" s))))
+     terms)
+    (fmt port ")\n")
+    ;;
+    (do ((i 1 (1+ i))) ((= i nrule))
+      (let* ((lhs (vector-ref lhs-v i)) (rhs (vector-ref rhs-v i)))
+       (if #f
+           (pp-rule 0 i)
+           (begin
+             (if lhsP
+                 (if (not (eqv? lhs lhsP))
+                     (fmt port "    )\n   (~S\n" lhs))
+                 (fmt port "   (~S\n" lhs))
+             (fmt port "    (")
+             (do ((j 0 (1+ j) )) ((= j (vector-length rhs)))
+               (let ((e (vector-ref rhs j)))
+                 (if (positive? j) (fmt port " "))
+                 (fmt
+                  port "~A" 
+                  (cond
+                   ((equal? #\; e) (fmtstr "C-semi"))
+                   ((char? e) (fmtstr "C-~A" e))
+                   (else e)))
+                 ))
+             (fmt port ") ")
+             (fmt port ": ~S" `(begin ,@(vector-ref act-v i)))
+             (fmt port "\n")
+             (set! lhsP lhs)))))
+    (fmt port "   ))\n")
+    (fmt port "  )\n")
+    (values)))
+
+;;; --- last line ---
diff --git a/module/nyacc/import.scm b/module/nyacc/import.scm
new file mode 100644 (file)
index 0000000..5492c35
--- /dev/null
@@ -0,0 +1,106 @@
+;;; nyacc/import.scm
+;;;
+;;; Copyright (C) 2015 Matthew R. Wette
+;;;
+;;; This library is free software; you can redistribute it and/or
+;;; modify it under the terms of the GNU Lesser General Public
+;;; License as published by the Free Software Foundation; either
+;;; version 3 of the License, or (at your option) any later version.
+;;;
+;;; This library is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;;; Lesser General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU Lesser General Public
+;;; License along with this library; if not, write to the Free Software
+;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+;; Convert guile lalr grammar to nyacc grammar.
+
+;; What is *eoi* for?
+
+(define-module (nyacc import)
+  #:export-syntax (lalr-parser)
+  #:export (guile-lalr->nyacc-lalr)
+  #:use-module ((srfi srfi-1) #:select (fold-right))
+  )
+
+(define (convert-tree spec0)
+  (let* ((terms (cons '*eoi* (car spec0)))
+        (start (caadr spec0))
+        (wrap-symb
+         (lambda (s) (cons (if (memq s terms) 'terminal 'non-terminal) s))))
+    (let iter ((prl1 '())              ; new production rules
+              (prl0 (cdr spec0))       ; old production rules
+              (lhs #f)                 ; LHS
+              (rhs1-l #f)              ; new RHS list
+              (rhs0-l #f))             ; old RHS list
+      (cond
+       ((pair? rhs0-l) ;; convert RHS
+       (iter prl1 prl0 lhs
+             (cons
+              (fold-right ;; s1 ... : a => (('terminal . s) ... ('$$ . a))
+               (lambda (symb seed) (cons (wrap-symb symb) seed))
+               (list (list '$$ (cdar rhs0-l)))
+               (caar rhs0-l))
+              rhs1-l)
+             (cdr rhs0-l)))
+       ((null? rhs0-l) ;; roll up LHS+RHSs to new rule
+       (iter (cons (cons lhs (reverse rhs1-l)) prl1) prl0 #f #f #f))
+       ((pair? prl0) ;; next production rule
+       (iter prl1 (cdr prl0) (caar prl0) '() (cdar prl0)))
+       (else ;; return spec in preliminary form
+       (list
+        'lalr-spec
+        `(start ,start)
+        `(grammar ,(reverse prl1))))))))
+
+(define-syntax parse-rhs-list
+  (syntax-rules (:)
+    ((_ (<rhs0sym> ...) : <rhs0act> <rhs1> ...)
+     (cons (cons '(<rhs0sym> ...) '<rhs0act>)
+          (parse-rhs-list <rhs1> ...)))
+    ((_) (list))))
+
+(define-syntax parse-prod-list
+  (syntax-rules ()
+    ((_ (<lhs> <rhs> ...) <prod1> ...)
+     (cons (cons '<lhs> (parse-rhs-list <rhs> ...))
+          (parse-prod-list <prod1> ...)))
+    ((_) (list))))
+
+
+(define-syntax lalr-parser
+  (syntax-rules ()
+    ((_ <tokens> <prod0> ...)
+     (convert-tree
+      (cons '<tokens> (parse-prod-list <prod0> ...))))))
+
+
+(define (guile-lalr->nyacc-lalr match-table spec)
+  (letrec
+      ((mark (lambda (s) (if (symbol? s) `(quote ,s) s)))
+       (rmt (map (lambda (p) (cons (cdr p) (mark (car p)))) match-table))
+       (clean
+       (lambda (dt)
+         (cond
+          ((null? dt) '())
+          ((pair? dt)
+           (case (car dt)
+             ((non-terminal) (cdr dt))
+             ((terminal)
+              (cond
+               ((assq-ref rmt (cdr dt)))
+               ((symbol? (cdr dt)) (simple-format #f "~A" (cdr dt)))
+               (else (cdr dt))))
+             ((start) dt)
+             (else
+              (cons (clean (car dt)) (clean (cdr dt))))))
+          (else
+           dt))))
+       )
+    (clean spec)))
+
+
+;;; --- last line ---
diff --git a/module/nyacc/lalr.scm b/module/nyacc/lalr.scm
new file mode 100644 (file)
index 0000000..2bbb39a
--- /dev/null
@@ -0,0 +1,2030 @@
+;;; nyacc/lalr.scm
+;;;
+;;; Copyright (C) 2014-2016 Matthew R. Wette
+;;;
+;;; This library is free software; you can redistribute it and/or
+;;; modify it under the terms of the GNU Lesser General Public
+;;; License as published by the Free Software Foundation; either
+;;; version 3 of the License, or (at your option) any later version.
+;;;
+;;; This library is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;;; Lesser General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU Lesser General Public
+;;; License along with this library; if not, write to the Free Software
+;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+;; I need to find way to preserve srconf, rrconf after hashify.
+;; compact needs to deal with it ...
+
+(define-module (nyacc lalr)
+  #:export-syntax (lalr-spec)
+  #:export (*nyacc-version*
+           make-lalr-machine compact-machine hashify-machine 
+           lalr-match-table
+           restart-spec add-recovery-logic!
+           pp-lalr-notice pp-lalr-grammar pp-lalr-machine
+           write-lalr-actions write-lalr-tables
+           pp-rule find-terminal gen-match-table ; used by (nyacc bison)
+
+           ;; for debugging:
+           with-spec make-LR0-machine
+           its-member its-trans
+           looking-at first-item
+           terminal? non-terminal?
+           range-next
+           )
+  #:use-module ((srfi srfi-1) #:select (fold fold-right remove lset-union
+                                            lset-intersection lset-difference))
+  #:use-module ((srfi srfi-9) #:select (define-record-type))
+  #:use-module ((srfi srfi-43) #:select (vector-map vector-for-each vector-any))
+  #:use-module (nyacc util)
+  )
+
+(define *nyacc-version* "0.72.0")
+
+
+;; @deffn proxy-? sym rhs
+;; @example
+;; (LHS (($? RHS))
+;; ($P (($$ #f))
+;;     ($P RHS ($$ (set-cdr! (last-pair $1) (list $2)) $1)))
+;; @end example
+(define (proxy-? sym rhs)
+  (list sym
+       (list '(action #f #f (list)))
+       rhs))
+
+;; @deffn proxy-+ sym rhs
+;; @example
+;; (LHS (($* RHS))
+;; ($P (($$ '()))
+;;     ($P RHS ($$ (set-cdr! (last-pair $1) (list $2)) $1)))
+;; @end example
+(define (proxy-* sym rhs)
+  (if (pair? (filter (lambda (elt) (eqv? 'action (car elt))) rhs))
+      (error "no RHS action allowed")) ;; rhs
+  (list
+   sym
+   (list '(action #f #f (list)))
+   (append (cons (cons 'non-terminal sym) rhs)
+          (list '(action #f #f
+                         (set-cdr! (last-pair $1) (list $2))
+                         $1)))))
+
+;; @deffn proxy-+ sym rhs
+;; @example
+;; (LHS (($+ RHS))
+;; ($P (RHS ($$ (list $1)))
+;;     ($P RHS ($$ (set-cdr! (last-pair $1) (list $2)) $1)))
+;; @end example
+(define (proxy-+ sym rhs)
+  (if (pair? (filter (lambda (elt) (eq? 'action (car elt))) rhs))
+      (error "no RHS action allowed")) ;; rhs
+  (list
+   sym
+   (append rhs (list '(action #f #f (list $1))))
+   (append (cons (cons 'non-terminal sym) rhs)
+          (list '(action #f #f
+                         (set-cdr! (last-pair $1) (list $2))
+                         $1)))))
+
+;; @deffn reserved? grammar-symbol
+;; Determine whether the syntax argument is a reserved symbol, that is.
+;; So instead of writing @code{'$fixed} for syntax one can write
+;; @code{$fixed}.  We may want to change this to
+;; @example
+;; (reserved-terminal? grammar-symbol)
+;; (reserved-non-term? grammar-symbol)
+;; @end example
+(define (reserved? grammar-symbol)
+  ;; If the first character `$' then it's reserved.
+  (eqv? #\$ (string-ref (symbol->string (syntax->datum grammar-symbol)) 0)))
+  
+;; @deffn lalr-spec grammar => spec
+;; This routine reads a grammar in a scheme-like syntax and returns an a-list.
+;; This spec' can be an input for @item{make-parser-generator} or 
+;; @item{pp-spec}.
+;;.This will return the specification.  Notably the grammar will have rhs
+;; arguments decorated with type (e.g., @code{(terminal . #\,)}).
+;; Each production rule in the grammar will be of the form
+;; @code{(lhs rhs1 rhs2 ...)} where each element of the RHS is one of
+;; @itemize
+;; @item @code{('terminal . atom)}
+;; @item @code{('non-terminal . symbol)}
+;; @item @code{('action . (ref narg guts)}
+;; @item @code{('proxy . production-rule)}
+;; @end itemize
+;; Currently, the number of arguments for items is computed in the routine
+;; @code{process-grammar}.
+(define-syntax lalr-spec
+  (syntax-rules +++ () 
+    ((_ <expr> +++)
+     (let* ()
+       (letrec-syntax
+          ((with-attr-list
+            (syntax-rules ($prune)
+              ((_ ($prune <symb>) <ex> ...)
+               (cons '(prune . <symb>) (with-attr-list <ex> ...)))
+              ((_) '())))
+           (parse-rhs
+            (lambda (x)
+              ;; The following is syntax-case because we use a fender.
+              (syntax-case x (quote $$ $$/ref $$-ref $prec $with $empty
+                                    $? $* $+)
+                ;; action specifications
+                ((_ ($$ <guts> ...) <e2> ...)
+                 #'(cons '(action #f #f <guts> ...) (parse-rhs <e2> ...)))
+                ((_ ($$-ref <ref>) <e2> ...)
+                 ;;#'(cons '(action #f <ref> #f) (parse-rhs <e2> ...)))
+                 #'(cons `(action #f ,<ref> . #f) (parse-rhs <e2> ...)))
+                ((_ ($$/ref <ref> <guts> ...) <e2> ...)
+                 #'(cons `(action #f ,<ref> <guts> ...) (parse-rhs <e2> ...)))
+
+                ;; other internal $-syntax
+                ((_ ($prec <tok>) <e2> ...)
+                 #'(cons (cons 'prec (tokenize <tok>)) (parse-rhs <e2> ...)))
+                ((_ ($with <lhs-ref> <ex> ...) <e2> ...)
+                 #'(cons `(with <lhs-ref> ,@(with-attr-list <ex> ...))
+                         (parse-rhs <e2> ...)))
+                ((_ $empty <e2> ...)   ; TODO: propagate to processor
+                 #'(parse-rhs <e2> ...))
+                
+                ;; (experimental) proxies
+                ((_ ($? <s1> <s2> ...) <e2> ...)
+                 #'(cons (cons* 'proxy proxy-? (parse-rhs <s1> <s2> ...))
+                         (parse-rhs <e2> ...)))
+                ((_ ($+ <s1> <s2> ...) <e2> ...)
+                 #'(cons (cons* 'proxy proxy-+ (parse-rhs <s1> <s2> ...))
+                         (parse-rhs <e2> ...)))
+                ((_ ($* <s1> <s2> ...) <e2> ...)
+                 #'(cons (cons* 'proxy proxy-* (parse-rhs <s1> <s2> ...))
+                         (parse-rhs <e2> ...)))
+                
+                ;; terminals and non-terminals
+                ((_ (quote <e1>) <e2> ...)
+                 #'(cons '(terminal . <e1>) (parse-rhs <e2> ...)))
+                ((_ (<f> ...) <e2> ...)
+                 #'(cons (<f> ...) (parse-rhs <e2> ...)))
+                ((_ <e1> <e2> ...)
+                 (identifier? (syntax <e1>)) ; fender to trap non-term's
+                 (if (reserved? (syntax <e1>))
+                     #'(cons '(terminal . <e1>) (parse-rhs <e2> ...))
+                     #'(cons '(non-terminal . <e1>) (parse-rhs <e2> ...))))
+                ((_ <e1> <e2> ...)
+                 #'(cons '(terminal . <e1>) (parse-rhs <e2> ...)))
+                ((_) #'(list)))))
+           (parse-rhs-list
+            (syntax-rules ()
+              ((_ (<ex> ...) <rhs> ...)
+               (cons (parse-rhs <ex> ...)
+                     (parse-rhs-list <rhs> ...)))
+              ((_) '())))
+           (parse-grammar
+            (syntax-rules ()
+              ((_ (<lhs> <rhs> ...) <prod> ...)
+               (cons (cons '<lhs> (parse-rhs-list <rhs> ...))
+                     (parse-grammar <prod> ...)))
+              ((_) '())))
+           (tokenize
+            (lambda (x)
+              (syntax-case x ()
+                ((_ <tk>) (identifier? (syntax <tk>)) #'(quote <tk>))
+                ((_ <tk>) #'<tk>))))
+           (tokenize-list
+            (syntax-rules ()
+              ((_ <tk1> <tk2> ...)
+               (cons (tokenize <tk1>) (tokenize-list <tk2> ...)))
+              ((_) '())))
+           (parse-precedence
+            (syntax-rules (left right nonassoc)
+              ((_ (left <tk> ...) <ex> ...)
+               (cons (cons 'left (tokenize-list <tk> ...))
+                     (parse-precedence <ex> ...)))
+              ((_ (right <tk> ...) <ex> ...)
+               (cons (cons 'right (tokenize-list <tk> ...))
+                     (parse-precedence <ex> ...)))
+              ((_ (nonassoc <tk> ...) <ex> ...)
+               (cons (cons 'nonassoc (tokenize-list <tk> ...))
+                     (parse-precedence <ex> ...)))
+              ((_ <tk> <ex> ...)
+               (cons (list 'undecl (tokenize <tk>))
+                     (parse-precedence <ex> ...)))
+              ((_) '())))
+           (lalr-spec-1
+            (syntax-rules (start expect notice prec< prec> grammar)
+              ((_ (start <symb>) <e> ...)
+               (cons (cons 'start '<symb>) (lalr-spec-1 <e> ...)))
+              ((_ (expect <n>) <e> ...)
+               (cons (cons 'expect <n>) (lalr-spec-1 <e> ...)))
+              ((_ (notice <str>) <e> ...)
+               (cons (cons 'notice <str>) (lalr-spec-1 <e> ...)))
+              ((_ (prec< <ex> ...) <e> ...)
+               (cons (cons 'precedence (parse-precedence <ex> ...))
+                     (lalr-spec-1 <e> ...)))
+              ((_ (prec> <ex> ...) <e> ...)
+               (cons (cons 'precedence (reverse (parse-precedence <ex> ...)))
+                     (lalr-spec-1 <e> ...)))
+              ((_ (grammar <prod> ...) <e> ...)
+               (cons (cons 'grammar (parse-grammar <prod> ...))
+                     (lalr-spec-1 <e> ...))) 
+              ((_) '()))))
+        (process-spec (lalr-spec-1 <expr> +++)))))))
+
+;; @deffn atomize terminal => object
+;; Generate an atomic object for a terminal.   Expected terminals are strings,
+;; characters and symbols.  This will convert the strings @code{s} to symbols
+;; of the form @code{'$:s}.
+(define (atomize terminal)
+  (if (string? terminal)
+      (string->symbol (string-append "$:" terminal))
+      terminal))
+
+;; @deffn normize terminal => char|symbol
+;; Normalize a token. This routine will normalize tokens in order to check
+;; for similarities. For example, @code{"+"} and @code{#\+} are similar,
+;; @code{'foo} and @code{"foo"} are similar.
+(define (normize terminal)
+  (if (not (string? terminal)) terminal
+      (if (= 1 (string-length terminal))
+         (string-ref terminal 0)
+         (string->symbol terminal))))
+
+;; @deffn eqv-terminal? a b
+;; This is a predicate to determine if the terminals @code{a} and @code{b}
+;; are equivalent.
+(define (eqv-terminal? a b)
+  (eqv? (atomize a) (atomize b)))
+
+;; @deffn find-terminal symb term-l => term-symb
+;; Find the terminal in @code{term-l} that is equivalent to @code{symb}.
+(define (find-terminal symb term-l)
+  (let iter ((tl term-l))
+    (if (null? tl) #f
+       (if (eqv-terminal? symb (car tl)) (car tl)
+           (iter (cdr tl))))))
+  
+;; @deffn process-spec tree => specification (as a-list)
+;; Here we sweep through the production rules. We flatten and order the rules
+;; and place all p-rules with like LHSs together.  There is a non-trivial
+;; amount of extra code to deal with mid-rule actions (MRAs).
+(define (process-spec tree)
+
+  ;; Make a new symbol. This is a helper for proxies and mid-rule-actions.
+  ;; The counter here is the only @code{set!} in @code{process-spec}.
+  ;; Otherwise, I believe @code{process-spec} is referentially transparent.
+  (define maksy
+    (let ((cntr 1))
+      (lambda ()
+       (let ((c cntr))
+         (set! cntr (1+ cntr))
+         (string->symbol (string-append "$P" (number->string c)))))))
+
+  ;; Canonicalize precedence and associativity. Precedence will appear
+  ;; as sets of equivalent items in increasing order of precedence
+  ;; (e.g., @code{((+ -) (* /)}).  The input tree has nodes that look like
+  ;; @example
+  ;; '(precedence (left "+" "-") (left "*" "/"))
+  ;; '(precedence ('then "else")
+  ;; @end example
+  ;; @noindent
+  ;; =>
+  ;; @example
+  ;; (prec ((+ -) (* /)) ((then) (else)))
+  ;; @end example
+  (define (prec-n-assc tree)
+    ;; prec-l; lt-assc-l rt-assc-l non-assc-l pspec
+    (let iter ((pll '()) (pl '()) (la '()) (ra '()) (na '())
+              (spec '()) (tree tree))
+      (cond
+       ((pair? spec)
+       ;; item ~ ('left "+" "-") => a ~ 'left, tl ~ (#\+ #\-)
+       (let* ((item (car spec)) (as (car item)) (tl (map atomize (cdr item))))
+         (case as
+           ((left)
+            (iter pll (cons tl pl) (append tl la) ra na (cdr spec) tree))
+           ((right)
+            (iter pll (cons tl pl) la (append tl ra) na (cdr spec) tree))
+           ((nonassoc)
+            (iter pll (cons tl pl) la ra (append tl na) (cdr spec) tree))
+           ((undecl)
+            (iter pll (cons tl pl) la ra na (cdr spec) tree)))))
+       ((pair? pl)
+       (iter (cons (reverse pl) pll) '() la ra na spec tree))
+       ((pair? tree)
+       (iter pll pl la ra na
+             (if (eqv? 'precedence (caar tree)) (cdar tree) '()) (cdr tree)))
+       (else
+       (list
+        `(prec . ,(reverse pll))
+        `(assc (left ,@la) (right ,@ra) (nonassoc ,@na)))))))
+
+  ;;.@deffn make-mra-proxy sy pel act => ???
+  ;; Generate a mid-rule-action proxy.
+  (define (make-mra-proxy sy pel act)
+    (list sy (list (cons* 'action (length pel) (cdr act)))))
+
+  ;; @deffn gram-check-2 tl nl err-l
+  ;; Check for fatal: symbol used as terminal and non-terminal.
+  (define (gram-check-2 tl nl err-l)
+    (let ((cf (lset-intersection eqv? (map atomize tl) nl)))
+      (if (pair? cf)
+         (cons (fmtstr "*** symbol is terminal and non-terminal: ~S" cf)
+               err-l) err-l)))
+              
+  ;; @deffn gram-check-3 ll nl err-l
+  ;; Check for fatal: non-terminal's w/o production rule.
+  (define (gram-check-3 ll nl err-l)
+    (fold
+     (lambda (n l)
+       (if (not (memq n ll))
+          (cons (fmtstr "*** non-terminal with no production rule: ~A" n) l)
+          l))
+     err-l nl))
+
+  ;; @deffn gram-check-4 ll nl err-l
+  ;; Check for warning: unused LHS.
+  ;; TODO: which don't appear in OTHER RHS, e.g., (foo (foo))
+  (define (gram-check-4 ll nl err-l)
+    (fold
+     (lambda (s l) (cons (fmtstr "+++ LHS not used in any RHS: ~A" s) l))
+     err-l
+     (let iter ((ull '()) (all ll)) ; unused LHSs, all LHS's
+       (if (null? all) ull
+          (iter (if (or (memq (car all) nl)
+                        (memq (car all) ull)
+                        (eq? (car all) '$start))
+                    ull (cons (car all) ull))
+                (cdr all))))))
+
+  ;; TODO: check for repeated tokens in precedence spec's: prec<, prec>
+              
+  (let* ((gram (assq-ref tree 'grammar))
+        (start-symbol (and=> (assq-ref tree 'start) atomize))
+        (start-rule (lambda () (list start-symbol)))
+        (add-el (lambda (e l) (if (memq e l) l (cons e l))))
+        (pna (prec-n-assc tree)))
+    ;; We sweep through the grammar to generate a canonical specification.
+    ;; Note: the local rhs is used to hold RHS terms, but a
+    ;; value of @code{'()} is used to signal "add rule", and a value of
+    ;; @code{#f} is used to signal ``done, proceed to next rule.''
+    ;; We use @code{tail} below to go through all remaining rules so that any
+    ;; like LHS get absorbed before proceeding: This keeps LHS in sequence.
+    ;; Note: code-comm and lone-comm are added to terminals so that they end
+    ;; up in the match-table.  The parser will skip these if the automoton has
+    ;; no associated transitions for these.  This allows users to parse for
+    ;; comments in some rules but skip the rest.
+    (let iter ((ll '($start))          ; LHS list
+              (@l (list                ; attributes per prod' rule
+                   `((rhs . ,(vector start-symbol))
+                     (ref . all) (act 1 $1))))
+              (tl '($code-comm $lone-comm $error $end)) ; set of terminals
+              (nl (list start-symbol)) ; set of non-terminals
+              ;;
+              (head gram)             ; head of unprocessed productions
+              (prox '())              ; proxy productions for MRA
+              (lhs #f)                ; current LHS (symbol)
+              (tail '())              ; tail of grammar productions
+              (rhs-l '())             ; list of RHSs being processed
+              (attr '())              ; per-rule attributes (action, prec)
+              (pel '())               ; processed RHS terms: '$:if ...
+              (rhs #f))               ; elts to process: (terminal . '$:if) ...
+      (cond
+       ((pair? rhs)
+       ;; Capture info on RHS term.
+       (case (caar rhs)
+         ((terminal)
+          (iter ll @l (add-el (cdar rhs) tl) nl head prox lhs tail
+                rhs-l attr (cons (atomize (cdar rhs)) pel) (cdr rhs)))
+         ((non-terminal)
+          (iter ll @l tl (add-el (cdar rhs) nl) head prox lhs tail
+                rhs-l attr (cons (cdar rhs) pel) (cdr rhs)))
+         ((action)
+          (if (pair? (cdr rhs))
+              ;; mid-rule action: generate a proxy (car act is # args)
+              (let* ((sy (maksy))
+                     (pr (make-mra-proxy sy pel (cdar rhs))))
+                (iter ll @l tl (cons sy nl) head (cons pr prox)
+                      lhs tail rhs-l attr (cons sy pel) (cdr rhs)))
+              ;; end-rule action
+              (iter ll @l tl nl head prox lhs tail
+                    rhs-l (acons 'action (cdar rhs) attr) pel (cdr rhs))))
+         ((proxy)
+          (let* ((sy (maksy))
+                 (pf (cadar rhs))      ; proxy function
+                 (p1 (pf sy (cddar rhs))))
+            (iter ll @l tl (cons sy nl) head (cons p1 prox) lhs
+                  tail rhs-l attr (cons sy pel) (cdr rhs))))
+         ((prec)
+          (iter ll @l (add-el (cdar rhs) tl) nl head prox lhs tail rhs-l
+                (acons 'prec (atomize (cdar rhs)) attr) pel (cdr rhs)))
+         ((with)
+          (let* ((psy (maksy))               ; proxy symbol
+                 (rhsx (cadar rhs))          ; symbol to expand
+                 (p-l (map cdr (cddar rhs))) ; prune list
+                 (p1 (list psy `((non-terminal . ,rhsx)
+                                 (action #f #f $1)))))
+            (iter ll @l tl (cons psy nl) head (cons p1 prox) lhs tail rhs-l
+                  (acons 'with (cons psy p-l) attr) (cons psy pel) (cdr rhs))))
+         (else
+          (error (fmtstr "bug=~S" (caar rhs))))))
+
+       ((null? rhs)
+       ;; End of RHS items for current rule.
+       ;; Add the p-rules items to the lists ll, rl, xl, and @@l.
+       ;; @code{act} is now:
+       ;; @itemize
+       ;; @item for mid-rule-action: (narg ref code)
+       ;; @item for end-rule-action: (#f ref code)
+       ;; @end itemize
+       (let* ((ln (length pel))
+              (action (assq-ref attr 'action))
+              (with (assq-ref attr 'with))
+              (nrg (if action (or (car action) ln) ln))  ; number of args
+              (ref (if action (cadr action) #f))
+              (act (cond
+                    ((and action (cddr action)) (cddr action))
+                    ;; if error rule then default action is print err msg:
+                    ((memq '$error pel) '((display "syntax error\n")))
+                    ((zero? nrg) '((list)))
+                    (else '($1)))))
+         (if with (simple-format #t "WITH WHAT?\n"))
+         (iter (cons lhs ll)
+               (cons
+                (cons* (cons 'rhs (list->vector (reverse pel)))
+                       (cons* 'act nrg act) (cons 'ref ref) attr)
+                @l)
+               tl nl head prox lhs tail rhs-l attr pel #f)))
+
+       ((pair? rhs-l)
+       ;; Work through next RHS.
+       (iter ll @l tl nl head prox lhs tail
+             (cdr rhs-l) '() '() (car rhs-l)))
+
+       ((pair? tail)
+       ;; Check the next CAR of the tail.  If it matches
+       ;; the current LHS process it, else skip it.
+       (iter ll @l tl nl head prox lhs (cdr tail) 
+             (if (eqv? (caar tail) lhs) (cdar tail) '())
+             attr pel #f))
+
+       ((pair? prox)
+       ;; If a proxy then we have ((lhs RHS) (lhs RHS))
+       (iter ll @l tl nl (cons (car prox) head) (cdr prox)
+             lhs tail rhs-l attr pel rhs))
+
+       ((pair? head)
+       ;; Check the next rule-set.  If the lhs has aready
+       ;; been processed, then skip.  Otherwise, copy copy
+       ;; to tail and process.
+       (let ((lhs (caar head)) (rhs-l (cdar head))
+             (rest (cdr head)))
+         (if (memq lhs ll)
+             (iter ll @l tl nl rest prox #f '() '() attr pel #f)
+             (iter ll @l tl nl rest prox lhs rest rhs-l attr pel rhs))))
+
+       (else
+       (let* ((al (reverse @l))        ; attribute list
+              (err-1 '()) ;; not used
+              ;; symbol used as terminal and non-terminal:
+              (err-2 (gram-check-2 tl nl err-1))
+              ;; non-terminal's w/o production rule:
+              (err-3 (gram-check-3 ll nl err-2))
+              ;; TODO: which don't appear in OTHER RHS, e.g., (foo (foo))
+              (err-4 (gram-check-4 ll nl err-3))
+              ;; todo: Check that with withs are not mixed
+              (err-l err-4))
+         (for-each (lambda (e) (fmterr "~A\n" e)) err-l)
+         (if (pair? (filter (lambda (s) (char=? #\* (string-ref s 0))) err-l))
+             #f
+             (list
+              ;; most referenced
+              (cons 'non-terms nl)
+              (cons 'lhs-v (list->vector (reverse ll)))
+              (cons 'rhs-v (map-attr->vector al 'rhs))
+              (cons 'terminals tl)
+              (cons 'start start-symbol)
+              (cons 'attr (list
+                           (cons 'expect (or (assq-ref tree 'expect) 0))
+                           (cons 'notice (assq-ref tree 'notice))))
+              (cons 'prec (assq-ref pna 'prec)) ; lowest-to-highest
+              (cons 'assc (assq-ref pna 'assc))
+              (cons 'prp-v (map-attr->vector al 'prec)) ; per-rule precedence
+              (cons 'act-v (map-attr->vector al 'act))
+              (cons 'ref-v (map-attr->vector al 'ref))
+              (cons 'err-l err-l)))))))))
+  
+;;; === Code for processing the specification. ================================
+
+;; @subsubheading Note
+;; The fluid @code{*lalr-core*} is used during the machine generation
+;; cycles to access core parameters of the specification.  This includes
+;; the list of non-terminals, the vector of left-hand side symbols and the
+;; vector of vector of right-hand side symbols.
+(define *lalr-core* (make-fluid #f))
+
+;; This record holds the minimum data from the grammar needed to build the
+;; machine from the grammar specification.
+(define-record-type lalr-core-type
+  (make-lalr-core non-terms terminals start lhs-v rhs-v eps-l)
+  lalr-core-type?
+  (non-terms core-non-terms)         ; list of non-terminals
+  (terminals core-terminals)         ; list of non-terminals
+  (start core-start)                 ; start non-terminal
+  (lhs-v core-lhs-v)                 ; vec of left hand sides
+  (rhs-v core-rhs-v)                 ; vec of right hand sides
+  (eps-l core-eps-l))                ; non-terms w/ eps prod's
+
+;; @deffn make-core spec => lalr-core-type
+(define (make-core spec)
+  (make-lalr-core (assq-ref spec 'non-terms)
+                 (assq-ref spec 'terminals)
+                 (assq-ref spec 'start)
+                 (assq-ref spec 'lhs-v)
+                 (assq-ref spec 'rhs-v)
+                 '()))
+
+;; @deffn make-core/extras spec => lalr-core-type
+;; Add list of symbols with epsilon productions.
+(define (make-core/extras spec)
+  (let ((non-terms (assq-ref spec 'non-terms))
+       (terminals (assq-ref spec 'terminals))
+       (start (assq-ref spec 'start))
+       (lhs-v (assq-ref spec 'lhs-v))
+       (rhs-v (assq-ref spec 'rhs-v)))
+    (make-lalr-core non-terms terminals start lhs-v rhs-v
+                   (find-eps non-terms lhs-v rhs-v))))
+
+
+;; @section Routines
+
+;; @deffn <? a b po => #t | #f
+;; Given tokens @code{a} and @code{b} and partial ordering @code{po} report
+;; if precedence of @code{b} is greater than @code{a}?
+(define (<? a b po)
+  (if (member (cons a b) po) #t
+      (let iter ((po po))
+       (if (null? po) #f
+           (if (and (eqv? (caar po) a)
+                    (<? (cdar po) b po))
+               #t
+               (iter (cdr po)))))))
+
+;; @deffn prece a b po
+;; Return precedence for @code{a,b} given the partial order @code{po} as
+;; @code{#\<}, @code{#\>}, @code{#\=} or @code{#f}.
+;; This is not a true partial order as we can have a<b and b<a => a=b.
+;; @example
+;; @code{(prece a a po)} => @code{#\=}.
+;; @end example
+(define (prece a b po)
+  (cond
+   ((eqv? a b) #\=)
+   ((eqv? a '$error) #\<)
+   ((eqv? b '$error) #\>)
+   ((<? a b po)  (if (<? b a po) #\= #\<))
+   (else (if (<? b a po) #\> #f))))
+  
+;; @deffn non-terminal? symb
+(define (non-terminal? symb)
+  (cond
+   ((eqv? symb '$epsilon) #t)
+   ((eqv? symb '$end) #f)
+   ((eqv? symb '$@) #f)
+   ((string? symb) #f)
+   (else
+    (memq symb (core-non-terms (fluid-ref *lalr-core*))))))
+
+;; @deffn terminal? symb
+(define (terminal? symb)
+  (not (non-terminal? symb)))
+
+;; @deffn prule-range lhs => (start-ix . (1+ end-ix))
+;; Find the range of productiion rules for the lhs.
+;; If not found raise error.
+(define (prule-range lhs)
+  ;; If this needs to be really fast then we move to where lhs is an integer
+  ;; and that used to index into a table that provides the ranges.
+  (let* ((core (fluid-ref *lalr-core*))
+        (lhs-v (core-lhs-v core))
+        (n (vector-length lhs-v))
+        (match? (lambda (ix symb) (eqv? (vector-ref lhs-v ix) symb))))
+    (cond
+     ((terminal? lhs) '())
+     ((eq? lhs '$epsilon) '())
+     (else
+      (let iter-st ((st 0))
+       ;; Iterate to find the start index.
+       (if (= st n) '()                ; not found
+           (if (match? st lhs)
+               ;; Start found, now iteratate to find end index.
+               (let iter-nd ((nd st))
+                 (if (= nd n) (cons st nd)
+                     (if (not (match? nd lhs)) (cons st nd)
+                         (iter-nd (1+ nd)))))
+               (iter-st (1+ st)))))))))
+
+;; @deffn range-next rng -> rng
+;; Given a range in the form of @code{(cons start (1+ end))} return the next
+;; value or '() if at end.  That is @code{(3 . 4)} => @code{'()}.
+(define (range-next rng)
+  (if (null? rng) '()
+      (let ((nxt (cons (1+ (car rng)) (cdr rng))))
+       (if (= (car nxt) (cdr nxt)) '() nxt))))
+
+;; @deffn range-last? rng
+;; Predicate to indicate last p-rule in range.
+;; If off end (i.e., null rng) then #f.
+(define (range-last? rng)
+  (and (pair? rng) (= (1+ (car rng)) (cdr rng))))
+
+;; @deffn lhs-symb prod-ix
+;; Return the LHS symbol for the production at index @code{prod-id}.
+(define (lhs-symb gx)
+  (vector-ref (core-lhs-v (fluid-ref *lalr-core*)) gx))
+
+;; @deffn looking-at (p-rule-ix . rhs-ix)
+;; Return symbol we are looking at for this item state.
+;; If at the end (position = -1) (or rule is zero-length) then return
+;; @code{'$epsilon}.
+(define (looking-at item)
+  (let* ((core (fluid-ref *lalr-core*))
+        (rhs-v (core-rhs-v core))
+        (rule (vector-ref rhs-v (car item))))
+    (if (last-item? item)
+       '$epsilon
+       (vector-ref rule (cdr item)))))
+
+;; @deffn first-item gx
+;; Given grammar rule index return the first item.
+;; This will return @code{(gx . 0)}, or @code{(gx . -1)} if the rule has
+;; no RHS elements.
+(define (first-item gx)
+  (let* ((core (fluid-ref *lalr-core*))
+        (rlen (vector-length (vector-ref (core-rhs-v core) gx))))
+    (cons gx (if (zero? rlen) -1 0))))
+
+;; @deffn last-item? item
+;; Predictate to indicate last item in (or end of) production rule.
+(define (last-item? item)
+  (negative? (cdr item)))
+
+;; @deffn next-item item
+;; Return the next item in the production rule.
+;; A position of @code{-1} means the end.  If at end, then @code{'()}
+(define (next-item item)
+  (let* ((core (fluid-ref *lalr-core*))
+        (gx (car item)) (rx (cdr item)) (rxp1 (1+ rx))
+        (rlen (vector-length (vector-ref (core-rhs-v core) gx))))
+    (cond
+     ((negative? rx) '())
+     ((eqv? rxp1 rlen) (cons gx -1))
+     (else (cons gx rxp1)))))
+
+;; @deffn prev-item item
+;; Return the previous item in the grammar.
+;; prev (0 . 0) is currently (0 . 0)
+(define (prev-item item)
+  (let* ((core (fluid-ref *lalr-core*))
+        (rhs-v (core-rhs-v core))
+        (p-ix (car item))
+        (p-ixm1 (1- p-ix))
+        (r-ix (cdr item))
+        (r-ixm1 (if (negative? r-ix)
+                    (1- (vector-length (vector-ref rhs-v p-ix)))
+                    (1- r-ix))))
+    (if (zero? r-ix)
+       (if (zero? p-ix) item           ; start, i.e., (0 . 0)
+           (cons p-ixm1 -1))           ; prev p-rule
+       (cons p-ix r-ixm1))))
+
+;; @deffn error-rule? gx => #t|#f
+;; Predicate to indicate if gx rule has @code{$error} as rhs member.
+(define (error-rule? gx)
+  (let* ((core (fluid-ref *lalr-core*))
+        (rhs-v (core-rhs-v core)))
+    (vector-any (lambda (e) (eqv? e '$error)) (vector-ref rhs-v gx))))
+     
+;; @deffn non-kernels symb => list of prule indices
+;; Compute the set of non-kernel rules for symbol @code{symb}.  If grammar
+;; looks like
+;; @example
+;; 1: A => Bcd
+;; ...
+;; 5: B => Cde
+;; ...
+;; 7: B => Abe
+;; @end example
+;; @noindent
+;; then @code{non-kernels 'A} results in @code{(1 5 7)}.
+;; Note: To support pruning this routine will need to be rewritten.
+(define (non-kernels symb)
+  (let* ((core (fluid-ref *lalr-core*))
+        (lhs-v (core-lhs-v core))
+        (rhs-v (core-rhs-v core))
+        (glen (vector-length lhs-v))
+        (lhs-symb (lambda (gx) (vector-ref lhs-v gx))))
+    (let iter ((rslt '())              ; result is set of p-rule indices
+              (done '())               ; symbols completed or queued
+              (next '())               ; next round of symbols to process
+              (curr (list symb))       ; this round of symbols to process
+              (gx 0))                  ; p-rule index
+      (cond
+       ((< gx glen)
+       (cond
+        ((memq (lhs-symb gx) curr)
+         ;; Add rhs to next and rslt if not already done.
+         (let* ((rhs1 (looking-at (first-item gx))) ; 1st-RHS-sym|$eps
+                (rslt1 (if (memq gx rslt) rslt (cons gx rslt)))
+                (done1 (if (memq rhs1 done) done (cons rhs1 done)))
+                (next1 (cond ((memq rhs1 done) next)
+                             ((terminal? rhs1) next)
+                             (else (cons rhs1 next)))))
+           (iter rslt1 done1 next1 curr (1+ gx))))
+        (else
+         ;; Nothing to check; process next rule.
+         (iter rslt done next curr (1+ gx)))))
+       ((pair? next)
+       ;; Start another sweep throught the grammar.
+       (iter rslt done '() next 0))
+       (else
+       ;; Done, so return.
+       (reverse rslt))))))
+
+;; @deffn expand-k-item => item-set
+;; Expand a kernel-item into a list with the non-kernels.
+(define (expand-k-item k-item)
+  (reverse
+   (fold (lambda (gx items) (cons (first-item gx) items))
+             (list k-item)
+             (non-kernels (looking-at k-item)))))
+
+;; @deffn its-equal?
+;; Helper for step1
+(define (its-equal? its-1 its-2)
+  (let iter ((its1 its-1) (its2 its-2)) ; cdr to strip off the ind
+    (if (and (null? its1) (null? its2)) #t ; completed run through => #f
+       (if (or (null? its1) (null? its2)) #f ; lists not equal length => #f
+           (if (not (member (car its1) its-2)) #f ; mismatch => #f
+               (iter (cdr its1) (cdr its2)))))))
+
+;; @deffn its-member its its-l
+;; Helper for step1
+;; If itemset @code{its} is a member of itemset list @code{its-l} return the
+;; index, else return #f.
+(define (its-member its its-l)
+  (let iter ((itsl its-l))
+    (if (null? itsl) #f
+       (if (its-equal? its (cdar itsl)) (caar itsl)
+           (iter (cdr itsl))))))
+  
+;; @deffn its-trans itemset => alist of (symb . itemset)
+;; Compute transitions from an itemset.   Thatis, map a list of kernel
+;; items to a list of (symbol post-shift items).
+;; @example
+;; ((0 . 1) (2 . 3) => ((A (0 . 2) (2 . 4)) (B (2 . 4) ...))
+;; @end example
+(define (its-trans items)
+  (let iter ((rslt '())                        ; result
+            (k-items items)            ; items
+            (itl '()))                 ; one k-item w/ added non-kernels
+    (cond
+     ((pair? itl)
+      (let* ((it (car itl))            ; item
+            (sy (looking-at it))       ; symbol
+            (nx (next-item it))
+            (sq (assq sy rslt)))       ; if we have seen it
+       (cond
+        ((eq? sy '$epsilon)
+         ;; don't transition end-of-rule items
+         (iter rslt k-items (cdr itl)))
+        ((not sq)
+         ;; haven't seen this symbol yet
+         (iter (acons sy (list nx) rslt) k-items (cdr itl)))
+        ((member nx (cdr sq))
+         ;; repeat
+         (iter rslt k-items (cdr itl)))
+        (else
+         ;; SY is in RSLT and item not yet in: add it.
+         (set-cdr! sq (cons nx (cdr sq)))
+         (iter rslt k-items (cdr itl))))))
+     ((pair? k-items)
+      (iter rslt (cdr k-items) (expand-k-item (car k-items))))
+     (else
+      rslt))))
+
+;; @deffn step1 [input-a-list] => p-mach-1
+;; Compute the sets of LR(0) kernel items and the transitions associated with
+;; spec.  These are returned as vectors in the alist with keys @code{'kis-v}
+;; and @code{'kix-v}, repspectively.   Each entry in @code{kis-v} is a list of
+;; items in the form @code{(px . rx)} where @code{px} is the production rule
+;; index and @code{rx} is the index of the RHS symbol.  Each entry in the
+;; vector @code{kix-v} is an a-list with entries @code{(sy . kx)} where
+;; @code{sy} is a (terminal or non-terminal) symbol and @code{kx} is the
+;; index of the kernel itemset.  The basic algorithm is discussed on
+;; pp. 228-229 of the DB except that we compute non-kernel items on the fly
+;; using @code{expand-k-item}.  See Example 4.46 on p. 241 of the DB.
+(define (step1 . rest)
+  (let* ((al-in (if (pair? rest) (car rest) '()))
+        (add-kset (lambda (upd kstz)   ; give upd a ks-ix and add to kstz
+                    (acons (1+ (caar kstz)) upd kstz)))
+        (init '(0 (0 . 0))))
+    (let iter ((ksets (list init))     ; w/ index
+              (ktrnz '())              ; ((symb src dst) (symb src dst) ...)
+              (next '())               ; w/ index
+              (todo (list init))       ; w/ index
+              (curr #f)                ; current state ix
+              (trans '()))             ; ((symb it1 it2 ...) (symb ...))
+      (cond
+       ((pair? trans)
+       ;; Check next symbol for transitions (symb . (item1 item2 ...)).
+       (let* ((dst (cdar trans))              ; destination item
+              (dst-ix (its-member dst ksets)) ; return ix else #f
+              (upd (if dst-ix '() (cons (1+ (caar ksets)) dst)))
+              (ksets1 (if dst-ix ksets (cons upd ksets)))
+              (next1 (if dst-ix next (cons upd next)))
+              (dsx (if dst-ix dst-ix (car upd))) ; dest state index
+              (ktrnz1 (cons (list (caar trans) curr dsx) ktrnz)))
+         (iter ksets1 ktrnz1 next1 todo curr (cdr trans))))
+       ((pair? todo)
+       ;; Process the next state (aka itemset).
+       (iter ksets ktrnz next (cdr todo) (caar todo) (its-trans (cdar todo))))
+       ((pair? next)
+       ;; Sweep throught the grammar again.
+       (iter ksets ktrnz '() next curr '()))
+       (else
+       (let* ((nkis (length ksets))    ; also (caar ksets)
+              (kisv (make-vector nkis #f))
+              (kitv (make-vector nkis '())))
+         ;; Vectorize kernel sets
+         (for-each
+          (lambda (kis) (vector-set! kisv (car kis) (cdr kis)))
+          ksets)
+         ;; Vectorize transitions (by src kx).
+         (for-each
+          (lambda (kit)
+            (vector-set! kitv (cadr kit)
+                         (acons (car kit) (caddr kit)
+                                (vector-ref kitv (cadr kit)))))
+          ktrnz)
+         ;; Return kis-v, kernel itemsets, and kix-v transitions.
+         (cons* (cons 'kis-v kisv) (cons 'kix-v kitv) al-in)))))))
+
+;; @deffn find-eps non-terms lhs-v rhs-v => eps-l
+;; Generate a list of non-terminals which have epsilon productions.
+(define (find-eps nterms lhs-v rhs-v)
+  (let* ((nprod (vector-length lhs-v))
+        (find-new
+         (lambda (e l)
+           (let iter ((ll l) (gx 0) (lhs #f) (rhs #()) (rx 0))
+             (cond
+              ((< rx (vector-length rhs))
+               (if (and (memq (vector-ref rhs rx) nterms) ; non-term
+                        (memq (vector-ref rhs rx) ll))    ; w/ eps prod
+                   (iter ll gx lhs rhs (1+ rx)) ; yes: check next
+                   (iter ll (1+ gx) #f #() 0))) ; no: next p-rule
+              ((and lhs (= rx (vector-length rhs))) ; we have eps-prod
+               (iter (if (memq lhs ll) ll (cons lhs ll)) (1+ gx) #f #() 0))
+              ((< gx nprod)            ; check next p-rule if not on list
+               (if (memq (vector-ref lhs-v gx) ll)
+                   (iter ll (1+ gx) #f #() 0)
+                   (iter ll gx (vector-ref lhs-v gx) (vector-ref rhs-v gx) 0)))
+              (else ll))))))
+    (fixed-point find-new (find-new #f '()))))
+
+;; @deffn merge1 v l
+;; add v to l if not in l
+(define        (merge1 v l)
+  (if (memq v l) l (cons v l)))
+
+;; @deffn merge2 v l al
+;; add v to l if not in l or al
+(define (merge2 v l al)        
+  (if (memq v l) l (if (memq v al) l (cons v l))))
+
+;; @deffn first symbol-list end-token-list
+;; Return list of terminals starting the string @code{symbol-list}
+;; (see DB, p. 188).  If the symbol-list can generate epsilon then the
+;; result will include @code{end-token-list}.
+(define (first symbol-list end-token-list)
+  (let* ((core (fluid-ref *lalr-core*))
+        (eps-l (core-eps-l core)))
+    ;; This loop strips off the leading symbol from stng and then adds to
+    ;; todo list, which results in range of p-rules getting checked for
+    ;; terminals.
+    (let iter ((rslt '())              ; terminals collected
+              (stng symbol-list)       ; what's left of input string
+              (hzeps #t)               ; if eps-prod so far
+              (done '())               ; non-terminals checked
+              (todo '())               ; non-terminals to assess
+              (p-range '())            ; range of p-rules to check
+              (item '()))              ; item in production
+      (cond
+       ((pair? item)
+       (let ((sym (looking-at item)))
+         (cond
+          ((eq? sym '$epsilon)         ; at end of rule, go next
+           (iter rslt stng hzeps done todo p-range '()))
+          ((terminal? sym)             ; terminal, log it
+           (iter (merge1 sym rslt) stng hzeps done todo p-range '()))
+          ((memq sym eps-l)            ; symbol has eps prod
+           (iter rslt stng hzeps (merge1 sym done) (merge2 sym todo done)
+                 p-range (next-item item)))
+          (else ;; non-terminal, add to todo/done, goto next
+           (iter rslt stng hzeps
+                 (merge1 sym done) (merge2 sym todo done) p-range '())))))
+       
+       ((pair? p-range)                        ; next one to do
+       ;; run through next rule
+       (iter rslt stng hzeps done todo
+             (range-next p-range) (first-item (car p-range))))
+
+       ((pair? todo)
+       (iter rslt stng hzeps done (cdr todo) (prule-range (car todo)) '()))
+
+       ((and hzeps (pair? stng))
+       ;; Last pass saw an $epsilon so check the next input symbol,
+       ;; with saweps reset to #f.
+       (let* ((symb (car stng)) (stng1 (cdr stng)) (symbl (list symb)))
+         (if (terminal? symb)
+             (iter (cons symb rslt) stng1
+                   (and hzeps (memq symb eps-l))
+                   done todo p-range '())
+             (iter rslt stng1
+                   (or (eq? symb '$epsilon) (memq symb eps-l))
+                   symbl symbl '() '()))))
+       (hzeps
+       ;; $epsilon passes all the way through.
+       ;; If end-token-list provided use that.
+       (if (pair? end-token-list)
+           (lset-union eqv? rslt end-token-list)
+           (cons '$epsilon rslt)))
+       (else
+       rslt)))))
+
+;; @deffn item->stng item => list-of-symbols
+;; Convert item (e.g., @code{(1 . 2)}) to list of symbols to the end of the
+;; production(?). If item is at the end of the rule then return
+;; @code{'$epsilon}.  The term "stng" is used to avoid confusion about the
+;; term string.
+(define (item->stng item)
+  (if (eqv? (cdr item) -1)
+      (list '$epsilon)
+      (let* ((core (fluid-ref *lalr-core*))
+            (rhs-v (core-rhs-v core))
+            (rhs (vector-ref rhs-v (car item))))
+       (let iter ((res '()) (ix (1- (vector-length rhs))))
+         (if (< ix (cdr item)) res
+             (iter (cons (vector-ref rhs ix) res) (1- ix)))))))
+
+;; add (item . toks) to (front of) la-item-l
+;; i.e., la-item-l is unmodified
+(define (merge-la-item la-item-l item toks)
+  (let* ((pair (assoc item la-item-l))
+        (tokl (if (pair? pair) (cdr pair) '()))
+        (allt ;; union of toks and la-item-l toks
+         (let iter ((tl tokl) (ts toks))
+           (if (null? ts) tl
+               (iter (if (memq (car ts) tl) tl (cons (car ts) tl))
+                     (cdr ts))))))
+    (if (not pair) (acons item allt la-item-l)
+       (if (eqv? tokl allt) la-item-l
+           (acons item allt la-item-l)))))
+
+;; @deffn first-following item toks => token-list
+;; For la-item A => x.By,z (where  @code{item}, @code{toks}), this
+;; procedure computes @code{FIRST(yz)}.
+(define (first-following item toks)
+  (first (item->stng (next-item item)) toks))
+
+;; @deffn closure la-item-l => la-item-l
+;; Compute the closure of a list of la-items.
+;; Ref: DB, Fig 4.38, Sec. 4.7, p. 232
+(define (closure la-item-l)
+  ;; Compute the fixed point of I, aka @code{la-item-l}, with procedure
+  ;;    for each item [A => x.By, a] in I
+  ;;      each production B => z in G
+  ;;      and each terminal b in FIRST(ya)
+  ;;      such that [B => .z, b] is not in I do
+  ;;        add [B => .z, b] to I
+  ;; The routine @code{fixed-point} operates on one element of the input set.
+  (prune-assoc
+   (fixed-point
+    (lambda (la-item seed)
+      (let* ((item (car la-item)) (toks (cdr la-item)) (symb (looking-at item)))
+       (cond
+        ((last-item? (car la-item)) seed)
+        ((terminal? (looking-at (car la-item))) seed)
+        (else
+         (let iter ((seed seed) (pr (prule-range symb)))
+           (cond
+            ((null? pr) seed)
+            (else
+             (iter (merge-la-item seed (first-item (car pr))
+                                  (first-following item toks))
+                   (range-next pr)))))))))
+    la-item-l)))
+
+;; @deffn kit-add kit-v tokens sx item
+;; Add @code{tokens} to the list of lookaheads for the (kernel) @code{item}
+;; in state @code{sx}.   This is a helper for @code{step2}.
+(define (kit-add kit-v tokens kx item)
+  (let* ((al (vector-ref kit-v kx))    ; a-list for k-set kx
+        (ar (assoc item al))           ; tokens for item
+        (sd (if (pair? ar)             ; set difference
+                (lset-difference eqv? tokens (cdr ar))
+                tokens)))
+    (cond ; no entry, update entry, no update
+     ((null? tokens) #f)
+     ((not ar) (vector-set! kit-v kx (acons item tokens al)) #t)
+     ((pair? sd) (set-cdr! ar (append sd (cdr ar))) #t)
+     (else #f))))
+
+;; @deffn kip-add kip-v sx0 it0 sx1 it1
+;; This is a helper for step2.  It updates kip-v with a propagation from
+;; state @code{sx0}, item @code{it0} to state @code{sx1}, item @code{it1}.
+;; [kip-v sx0] -> (it0 . ((sx1 . it1)
+(define (kip-add kip-v sx0 it0 sx1 it1)
+  (let* ((al (vector-ref kip-v sx0)) (ar (assoc it0 al)))
+    (cond
+     ((not ar)
+      (vector-set! kip-v sx0 (acons it0 (list (cons sx1 it1)) al)) #t)
+     ((member it1 (cdr ar)) #f)
+     (else
+      (set-cdr! ar (acons sx1 it1 (cdr ar))) #t))))
+
+;; @deffn step2 p-mach-1 => p-mach-2
+;; This implements steps 2 and 3 of Algorithm 4.13 on p. 242 of the DB.
+;; The a-list @code{p-mach-1} includes the kernel itemsets and transitions
+;; from @code{step1}.   This routine adds two entries to the a-list:
+;; the initial set of lookahead tokens in a vector associated with key
+;; @code{'kit-v} and a vector of spontaneous propagations associated with
+;; key @code{'kip-v}.
+;; @example
+;; for-each item I in some itemset
+;;   for-each la-item J in closure(I,#)
+;;     for-each token T in lookaheads(J)
+;;       if LA is #, then add to J propagate-to list
+;;       otherwise add T to spontaneously-generated list
+;; @end example
+(define (step2 p-mach)
+  (let* ((kis-v (assq-ref p-mach 'kis-v))
+        (kix-v (assq-ref p-mach 'kix-v)) ; transitions?
+        (nkset (vector-length kis-v))  ; number of k-item-sets
+        ;; kernel-itemset tokens
+        (kit-v (make-vector nkset '())) ; sx => alist: (item latoks)
+        ;; kernel-itemset propagations
+        (kip-v (make-vector nkset '()))) ; sx0 => ((ita (sx1a . it1a) (sx2a
+    (vector-set! kit-v 0 (closure (list (list '(0 . 0) '$end))))
+    (let iter ((kx -1) (kset '()))
+      (cond
+       ((pair? kset)
+       (for-each
+        (lambda (la-item)
+          (let* ((item (car la-item))     ; closure item
+                 (tokl (cdr la-item))     ; tokens
+                 (sym (looking-at item))  ; transition symbol
+                 (item1 (next-item item)) ; next item after sym
+                 (sx1 (assq-ref (vector-ref kix-v kx) sym)) ; goto(I,sym)
+                 (item0 (car kset)))      ; kernel item
+            (kit-add kit-v (delq '$@ tokl) sx1 item1) ; spontaneous
+            (if (memq '$@ tokl)        ; propagates
+                (kip-add kip-v kx item0 sx1 item1))))
+        (remove ;; todo: check this remove
+         (lambda (li) (last-item? (car li)))
+         (closure (list (cons (car kset) '($@))))))
+       (iter kx (cdr kset)))
+
+       ((< (1+ kx) nkset)
+       (iter (1+ kx)
+             ;; End-items don't shift, so don't propagate.
+             (remove last-item? (vector-ref kis-v (1+ kx)))))))
+    ;;(when #f (pp-kip-v kip-v) (pp-kit-v kit-v)) ; for debugging
+    (cons* (cons 'kit-v kit-v) (cons 'kip-v kip-v) p-mach)))
+
+;; debug for step2
+(define (pp-kit ix kset)
+  (fmtout "~S:\n" ix)
+  (for-each
+   (lambda (item) (fmtout "    ~A, ~S\n" (pp-item (car item)) (cdr item)))
+   kset))
+(define (pp-kit-v kit-v)
+  (fmtout "spontaneous:\n")
+  (vector-for-each pp-kit kit-v))
+(define (pp-kip ix kset)
+  (for-each
+   (lambda (x)
+     (fmtout "~S: ~A\n" ix (pp-item (car x)))
+     (for-each
+      (lambda (y) (fmtout "   => ~S: ~A\n" (car y) (pp-item (cdr y))))
+      (cdr x)))
+   kset))
+(define (pp-kip-v kip-v)
+  (fmtout "propagate:\n")
+  (vector-for-each pp-kip kip-v))
+
+;; @deffn step3 p-mach-2 => p-mach-3
+;; Execute nyacc step 3, where p-mach means ``partial machine''.
+;; This implements step 4 of Algorithm 4.13 from the DB.
+(define (step3 p-mach)
+  (let* ((kit-v (assq-ref p-mach 'kit-v))
+        (kip-v (assq-ref p-mach 'kip-v))
+        (nkset (vector-length kit-v)))
+    (let iter ((upd #t)                        ; token propagated?
+              (kx -1)                  ; current index
+              (ktal '())               ; (item . LA) list for kx
+              (toks '())               ; LA tokens being propagated
+              (item '())               ; from item 
+              (prop '()))              ; to items
+      (cond
+       ((pair? prop)
+       ;; Propagate lookaheads.
+       (let* ((sx1 (caar prop)) (it1 (cdar prop)))
+         (iter (or (kit-add kit-v toks sx1 it1) upd)
+               kx ktal toks item (cdr prop))))
+
+       ((pair? ktal)
+       ;; Process the next (item . tokl) in the alist ktal.
+       (iter upd kx (cdr ktal) (cdar ktal) (caar ktal)
+             (assoc-ref (vector-ref kip-v kx) (caar ktal))))
+
+       ((< (1+ kx) nkset)
+       ;; Process the next itemset.
+       (iter upd (1+ kx) (vector-ref kit-v (1+ kx)) '() '() '()))
+
+       (upd
+       ;; Have updates, rerun.
+       (iter #f 0 '() '() '() '()))))
+    p-mach))
+
+;; @deffn reductions kit-v sx => ((tokA gxA1 ...) (tokB gxB1 ...) ...)
+;; This is a helper for @code{step4}.
+;; Return an a-list of reductions for state @code{sx}.
+;; The a-list pairs are make of a token and a list of prule indicies.
+;; CHECK the following.  We are brute-force using @code{closure} here.
+;; It works, but there should be a better algorithm.
+;; Note on reductions: We reduce if the kernel-item is an end-item or a 
+;; non-kernel item with an epsilon-production.  That is, if we have a
+;; kernel item of the form
+;; @example
+;; A => abc.
+;; @end example
+;; or if we have the non-kernel item of the form
+;; @example
+;; B => .de
+;; @end example
+;; where FIRST(de,#) includes #.  See the second paragraph under ``Efficient
+;; Construction of LALR Parsing Tables'' in DB Sec 4.7.
+(define (old-reductions kit-v sx)
+  (let iter ((ral '())                   ; result: reduction a-list
+            (lais (vector-ref kit-v sx)) ; la-item list
+            (toks '())                   ; kernel la-item LA tokens
+            (itms '())                   ; all items
+            (gx #f)                      ; rule reduced by tl
+            (tl '()))                    ; LA-token list
+    (cond
+     ((pair? tl) ;; add (token . p-rule) to reduction list
+      (let* ((tk (car tl)) (rp (assq tk ral)))
+       (cond
+        ;; already have this, skip to next token
+        ((and rp (memq gx (cdr rp)))
+         (iter ral lais toks itms gx (cdr tl)))
+        (rp
+         ;; have token, add prule
+         (set-cdr! rp (cons gx (cdr rp)))
+         (iter ral lais toks itms gx (cdr tl)))
+        (else
+         ;; add token w/ prule
+         (iter (cons (list tk gx) ral) lais toks itms gx (cdr tl))))))
+
+     ((pair? itms)
+      (if (last-item? (car itms))
+         ;; last item, add it 
+         (iter ral lais toks (cdr itms) (caar itms) toks)
+         ;; skip to next
+         (iter ral lais toks (cdr itms) 0 '())))
+
+     ((pair? lais) ;; process next la-item
+      (iter ral (cdr lais) (cdar lais) (expand-k-item (caar lais)) 0 '()))
+
+     (else ral))))
+;; I think the above is broken because I'm not including the proper tail
+;; string.  The following just uses closure to do the job.  It works but
+;; may not be very efficient: seems a bit brute force.
+(define (new-reductions kit-v sx)
+  (let iter ((ral '())                   ; result: reduction a-list
+            (klais (vector-ref kit-v sx)) ; kernel la-item list
+            (laits '())                   ; all la-items
+            (gx #f)                       ; rule reduced by tl
+            (tl '()))                    ; LA-token list
+    (cond
+     ((pair? tl) ;; add (token . p-rule) to reduction list
+      (let* ((tk (car tl)) (rp (assq tk ral)))
+       (cond
+        ((and rp (memq gx (cdr rp)))
+         ;; already have this, skip to next token
+         (iter ral klais laits gx (cdr tl)))
+        (rp
+         ;; have token, add prule
+         (set-cdr! rp (cons gx (cdr rp)))
+         (iter ral klais laits gx (cdr tl)))
+        (else
+         ;; add token w/ prule
+         (iter (cons (list tk gx) ral) klais laits gx (cdr tl))))))
+
+     ((pair? laits) ;; process a la-itemset
+      (if (last-item? (caar laits))
+         ;; last item, add it 
+         (iter ral klais (cdr laits) (caaar laits) (cdar laits))
+         ;; else skip to next
+         (iter ral klais (cdr laits) 0 '())))
+
+     ((pair? klais) ;; expand next kernel la-item
+      ;; There is a cheaper way than closure to do this but for now ...
+      (iter ral (cdr klais) (closure (list (car klais))) 0 '()))
+
+     (else
+      ral))))
+(define reductions new-reductions)
+
+;; Generate parse-action-table from the shift a-list and reduce a-list.
+;; This is a helper for @code{step4}.  It converts a list of state transitions
+;; and a list of reductions into a parse-action table of shift, reduce,
+;; accept, shift-reduce conflict or reduce-reduce conflict.
+;; The actions take the form:
+;; @example
+;; (shift . <dst-state>)
+;; (reduce . <rule-index>)
+;; (accept . 0)
+;; (srconf . (<dst-state> . <p-rule>))
+;; (rrconf . <list of p-rules indices>)
+;; @end example
+;; If a shift has multiple reduce conflicts we report only one reduction.
+(define (gen-pat sft-al red-al)
+  (let iter ((res '()) (sal sft-al) (ral red-al))
+    (cond
+     ((pair? sal)
+      (let* ((term (caar sal))          ; terminal 
+            (goto (cdar sal))           ; target state
+            (redp (assq term ral))      ; a-list entry, may be removed
+            ;;(redl (if redp (cdr redp) #f))) ; reductions on terminal
+            (redl (and=> redp cdr)))   ; reductions on terminal
+       (cond
+        ((and redl (pair? (cdr redl)))
+         ;; This means we have a shift-reduce and reduce-reduce conflicts.
+         ;; We record only one shift-reduce and keep the reduce-reduce.
+         (iter (cons (cons* term 'srconf goto (car redl)) res)
+               (cdr sal) ral))
+        (redl
+         ;; The terminal (aka token) signals a single reduction.  This means
+         ;; we have one shift-reduce conflict.  We have a chance to repair
+         ;; the parser using precedence/associativity rules so we remove the
+         ;; reduction from the reduction-list.
+         (iter (cons (cons* term 'srconf goto (car redl)) res)
+               (cdr sal) (delete redp ral)))
+        (else
+         ;; The terminal (aka token) signals a shift only.
+         (iter (cons (cons* term 'shift goto) res)
+               (cdr sal) ral)))))
+     ((pair? ral)
+      (let ((term (caar ral)) (rest (cdar ral)))
+       ;; We keep 'accept as explict action.  Another option is to reduce and
+       ;; have 0-th p-rule action generate return from parser (via prompt?).
+       (iter
+        (cons (cons term
+                    (cond ;; => action and arg(s)
+                     ((zero? (car rest)) (cons 'accept 0))
+                     ((zero? (car rest)) (cons 'reduce (car rest)))
+                     ((> (length rest) 1) (cons 'rrconf rest))
+                     (else (cons 'reduce (car rest)))))
+              res) sal (cdr ral))))
+     (else res))))
+
+
+;; @deffn step4 p-mach-0 => p-mach-1
+;; This generates the parse action table from the itemsets and then applies
+;; precedence and associativity rules to eliminate shift-reduce conflicts
+;; where possible.  The output includes the parse action table (entry
+;; @code{'pat-v} and TBD (list of errors in @code{'err-l}).
+;;.per-state: alist by symbol:
+;;   (symb <id>) if <id> > 0 SHIFT to <id>, else REDUCE by <id> else
+;; so ('$end . 0) means ACCEPT!
+;; but 0 for SHIFT and REDUCE, but reduce 0 is really ACCEPT
+;; if reduce by zero we are done. so never hit state zero accept on ACCEPT?
+;; For each state, the element of pat-v looks like
+;; ((tokenA . (reduce . 79)) (tokenB . (reduce . 91)) ... )
+(define (step4 p-mach)
+
+  (define (setup-assc assc)
+    (fold (lambda (al seed)
+           (append (x-flip al) seed)) '() assc))
+
+  (define (setup-prec prec)
+    (let iter ((res '()) (rl '()) (hd '()) (pl '()) (pll prec))
+      (cond
+       ((pair? pl)
+       (let* ((p (car pl)) (hdp (x-comb hd p))
+              (pp (remove (lambda (p) (eqv? (car p) (cdr p))) (x-comb p p))))
+         (iter res (append rl hdp pp) (car pl) (cdr pl) pll)))
+       ((pair? rl) (iter (append res rl) '() hd pl pll))
+       ((pair? pll) (iter res rl '() (car pll) (cdr pll)))
+       (else res))))
+
+  (define (prev-sym act its)
+    (let* ((a act)
+          (tok (car a)) (sft (caddr a)) (red (cdddr a))
+          ;; @code{pit} is the end-item in the p-rule to be reduced.
+          (pit (prev-item (prev-item (cons red -1))))
+          ;; @code{psy} is the last symbol in the p-rule to be reduced.
+          (psy (looking-at pit)))
+      psy))
+
+  (let* ((kis-v (assq-ref p-mach 'kis-v)) ; states
+        (kit-v (assq-ref p-mach 'kit-v)) ; la-toks
+        (kix-v (assq-ref p-mach 'kix-v)) ; transitions
+        (assc (assq-ref p-mach 'assc))   ; associativity rules
+        (assc (setup-assc assc))         ; trying it
+        (prec (assq-ref p-mach 'prec))   ; precedence rules
+        (prec (setup-prec prec))         ; trying it
+        (nst (vector-length kis-v))      ; number of states
+        (pat-v (make-vector nst '()))    ; parse-act tab /state
+        (rat-v (make-vector nst '()))    ; removed-act tab /state
+        (gen-pat-ix (lambda (ix)         ; pat from shifts & reduc's
+                      (gen-pat (vector-ref kix-v ix) (reductions kit-v ix))))
+        (prp-v (assq-ref p-mach 'prp-v))  ; per-rule precedence
+        (tl (assq-ref p-mach 'terminals)) ; for error msgs
+        )
+    ;; We run through each itemset.
+    ;; @enumerate
+    ;; @item We have a-list of symbols to shift state (i.e., @code{kix-v}).
+    ;; @item We generate a list of tokens to reduction from @code{kit-v}.
+    ;; @end enumerate
+    ;; Q: should '$end be edited out of shifts?
+    ;; kit-v is vec of a-lists of form ((item tok1 tok2 ...) ...)
+    ;; turn to (tok1 item1 item2 ...)
+    (let iter ((ix 0)          ; state index
+              (pat '())        ; parse-action table
+              (rat '())        ; removed-action table
+              (wrn '())        ; warnings on unsolicited removals
+              (ftl '())        ; fatal conflicts
+              (actl (gen-pat-ix 0))) ; action list
+      (cond
+       ((pair? actl)
+       (case (cadar actl)
+         ((shift reduce accept)
+          (iter ix (cons (car actl) pat) rat wrn ftl (cdr actl)))
+         ((srconf)
+          (let* ((act (car actl))
+                 (tok (car act)) (sft (caddr act)) (red (cdddr act))
+                 (prp (vector-ref prp-v red))
+                 (psy (prev-sym act (vector-ref kis-v ix)))
+                 (preced (or (and prp (prece prp tok prec)) ; rule-based
+                             (prece psy tok prec))) ; oper-based
+                 (sft-a (cons* tok 'shift sft))
+                 (red-a (cons* tok 'reduce red)))
+            (call-with-values
+                (lambda ()
+                  ;; Use precedence or, if =, associativity.
+                  (case preced
+                    ((#\>)
+                     (values red-a (cons sft-a 'pre) #f #f))
+                    ((#\<)
+                     (values sft-a (cons red-a 'pre) #f #f))
+                    ((#\=) ;; Now use associativity
+                     (case (assq-ref assc tok)
+                       ((left)
+                        (values red-a (cons sft-a 'ass) #f #f))
+                       ((right)
+                        (values sft-a (cons red-a 'ass) #f #f))
+                       ((nonassoc)
+                        (values (cons* tok 'error red) #f #f (cons ix act)))
+                       (else
+                        (values sft-a (cons red-a 'def) (cons ix act) #f))))
+                    (else ;; Or default, which is shift.
+                     (values sft-a (cons red-a 'def) (cons ix act) #f))))
+              (lambda (a r w f)
+                (iter ix
+                      (if a (cons a pat) pat)
+                      (if r (cons r rat) rat)
+                      (if w (cons w wrn) wrn)
+                      (if f (cons f ftl) ftl)
+                      (cdr actl))))))
+         ((rrconf)
+          #;(fmterr "*** reduce-reduce conflict: in state ~A on ~A: ~A\n"
+                  ix (obj->str (find-terminal (caar actl) tl)) (cddar actl))
+          (iter ix (cons (car actl) pat) rat wrn
+                (cons (cons ix (car actl)) ftl) (cdr actl)))
+         (else
+          (error "PROBLEM"))))
+       ((null? actl)
+       (vector-set! pat-v ix pat)
+       (vector-set! rat-v ix rat)
+       (iter ix pat rat wrn ftl #f))
+       ((< (1+ ix) nst)
+       (iter (1+ ix) '() '() wrn ftl (gen-pat-ix (1+ ix))))
+       (else
+       (let* ((attr (assq-ref p-mach 'attr))
+              (expect (assq-ref attr 'expect))) ; expected # srconf
+         (if (not (= (length wrn) expect))
+             (for-each (lambda (m) (fmterr "+++ warning: ~A\n" (conf->str m)))
+                       (reverse wrn)))
+         (for-each
+          (lambda (m) (fmterr "*** fatal: ~A\n" (conf->str m)))
+          (reverse ftl))
+         ))))
+    ;; Return mach with parse-action and removed-action tables.
+    (cons* (cons 'pat-v pat-v) (cons 'rat-v rat-v) p-mach)))
+
+;; @deffn conf->str cfl => string
+;; map conflict (e.g., @code{('rrconf 1 . 2}) to string.
+(define (conf->str cfl)
+  (let* ((st (list-ref cfl 0)) (tok (list-ref cfl 1)) (typ (list-ref cfl 2))
+        (core (fluid-ref *lalr-core*)) (terms (core-terminals core)))
+    (fmtstr "in state ~A, ~A conflict on ~A"
+           st
+           (case typ
+             ((srconf) "shift-reduce")
+             ((rrconf) "reduce-reduce")
+             (else "unknown"))
+           (obj->str (find-terminal tok terms)))))
+                    
+;; @deffn gen-match-table mach => mach
+;; Generate the match-table for a machine.  The match table is a list of
+;; pairs: the car is the token used in the grammar specification, the cdr
+;; is the symbol that should be returned by the lexical analyzer.
+;;
+;; The match-table may be passed to
+;; the lexical analyzer builder to identify strings or string-types as tokens.
+;; The associated key in the machine is @code{mtab}. 
+;; @enumerate
+;; @item
+;; @sc{nyacc}-reserved symbols are provided as symbols
+;; @example
+;; $ident -> ($ident . $ident)
+;; @end example
+;; @item
+;; Terminals used as symbols (@code{'comment} versus @code{"comment"}) are
+;; provided as symbols.  The spec parser will provide a warning if symbols
+;; are used in both ways.
+;; @item
+;; Others are provided as strings.
+;; @end enumerate
+;; The procedure @code{hashify-machine} will convert the cdrs to integers.
+;; Test: "$abc" => ("$abc" '$abc) '$abc => ('$abc . '$abc)
+(define (gen-match-table mach)
+  (cons
+   (cons 'mtab (map (lambda (term) (cons term (atomize term)))
+                   (assq-ref mach 'terminals)))
+   mach))
+
+
+;; @deffn add-recovery-logic! mach => mach
+;; Target of transition from @code{'$error} should have a default rule that
+;; loops back.
+(define (add-recovery-logic-1 mach)
+  (let* ((kis-v (assq-ref mach 'kis-v))
+        (rhs-v (assq-ref mach 'rhs-v))
+        (pat-v (assq-ref mach 'pat-v))
+        (n (vector-length pat-v))
+        )
+    (vector-for-each
+     (lambda (kx kis)
+       ;;(fmtout "kis=~S\n " kis)
+       (for-each
+       (lambda (ki)
+         (let* ((pi (prev-item ki))
+                (rhs (vector-ref rhs-v (car pi))))
+           (when (and (not (negative? (cdr pi)))
+                      (eqv? '$error (looking-at pi)))
+             (vector-set! pat-v kx
+                          (append
+                           (vector-ref pat-v kx)
+                           `(($default shift . ,kx))))
+             #;(fmtout " => ~S\n" (vector-ref pat-v kx)))))
+       kis)
+       ;;(fmtout "\n")
+       #f)
+     kis-v)
+    mach))
+
+(define (add-recovery-logic! mach)
+  (let ((prev-core (fluid-ref *lalr-core*)))
+    (dynamic-wind
+       (lambda () (fluid-set! *lalr-core* (make-core/extras mach)))
+       (lambda () (add-recovery-logic-1 mach))
+       (lambda () (fluid-set! *lalr-core* prev-core)))))
+
+;; to build parser, need:
+;;   pat-v - parse action table
+;;   ref-v - references
+;;   len-v - rule lengths
+;;   rto-v - hashed lhs symbols
+;; to print itemsets need:
+;;   kis-v - itemsets
+;;   lhs-v - left hand sides
+;;   rhs-v - right hand sides
+;;   pat-v - action table
+
+;; @deffn restart-spec spec start => spec
+;; This generates a new spec with a different start.
+;; @example
+;; (restart-spec clang-spec 'expression) => cexpr-spec
+;; @end example
+(define (restart-spec spec start)
+  (let* ((rhs-v (vector-copy (assq-ref spec 'rhs-v))))
+    (vector-set! rhs-v 0 (vector start))
+    (cons* (cons 'start start)
+          (cons 'rhs-v rhs-v)
+          spec)))
+
+;; @deffn make-lalr-machine spec => pgen
+;; Generate a-list of items used for building/debugging parsers.
+;; It might be useful to add hashify and compact with keyword arguments.
+(define (make-lalr-machine spec)
+  (if (not spec) (error "make-lalr-machine: expecting valid specification"))
+  (let ((prev-core (fluid-ref *lalr-core*)))
+    (dynamic-wind
+       (lambda () (fluid-set! *lalr-core* (make-core/extras spec)))
+       (lambda ()
+         (let* ((sm1 (step1 spec))
+                (sm2 (step2 sm1))
+                (sm3 (step3 sm2))
+                (sm4 (step4 sm3))
+                (sm5 (gen-match-table sm4)))
+           (cons*
+            (cons 'len-v (vector-map (lambda (i v) (vector-length v))
+                                     (assq-ref sm5 'rhs-v)))
+            (cons 'rto-v (vector-copy (assq-ref sm5 'lhs-v)))
+            sm5)))
+       (lambda () (fluid-set! *lalr-core* prev-core)))))
+
+;; for debugging
+(define (make-LR0-machine spec)
+  (if (not spec) (error "make-LR0-machine: expecting valid specification"))
+  (let ((prev-core (fluid-ref *lalr-core*)))
+    (dynamic-wind
+       (lambda () (fluid-set! *lalr-core* (make-core/extras spec)))
+       (lambda () (step1 spec))
+       (lambda () (fluid-set! *lalr-core* prev-core)))))
+
+;; @deffn with-spec spec proc arg ...
+;; Execute with spec or mach.
+(define (with-spec spec proc . args)
+  (if (not spec) (error "with-spec: expecting valid specification"))
+  (let ((prev-core (fluid-ref *lalr-core*)))
+    (dynamic-wind
+       (lambda () (fluid-set! *lalr-core* (make-core/extras spec)))
+       (lambda () (apply proc args))
+       (lambda () (fluid-set! *lalr-core* prev-core)))))
+
+;; @deffn lalr-match-table mach => match-table
+;; Get the match-table
+(define (lalr-match-table mach)
+  (assq-ref mach 'mtab))
+
+;; @deffn machine-compacted? mach => #t|#f
+;; Indicate if the machine has been compacted.
+;; TODO: needs update to deal with error recovery hooks.
+(define (machine-compacted? mach)
+  ;; Works by searching for $default phony-token.
+  (call-with-prompt 'got-it
+    ;; Search for '$default.  If not found return #f.
+    (lambda ()
+      (vector-for-each
+       (lambda (ix pat)
+        (for-each
+         (lambda (a) (if (or (eqv? (car a) '$default) (eqv? (car a) -1))
+                         (abort-to-prompt 'got-it)))
+         pat))
+       (assq-ref mach 'pat-v))
+      #f)
+    ;; otherwise, return #t.
+    (lambda () #t)))
+
+;; @deffn compact-machine mach [#:keep 3] => mach
+;; A "filter" to compact the parse table.  For each state this will replace
+;; the most populus set of reductions of the same production rule with a
+;; default production.  However, reductions triggered by keepers like
+;; @code{'$error}, @code{'$lone-comm} or @code{'$lone-comm} are not counted.
+;; The parser will want to treat errors and comments separately so that they
+;; can be trapped (e.g., unaccounted comments are skipped).
+(define* (compact-machine mach #:key (keep 3))
+  (let* ((pat-v (assq-ref mach 'pat-v))
+        (nst (vector-length pat-v))
+        (hashed (number? (caar (vector-ref pat-v 0)))) ; been hashified?
+        (reduce? (if hashed
+                     (lambda (a) (and (number? a) (negative? a)))
+                     (lambda (a) (eq? 'reduce (car a)))))
+        (reduce-pr (if hashed abs cdr))
+        (reduce-to? (if hashed
+                        (lambda (a r) (eqv? (- r) a))
+                        (lambda (a r) (and (eq? 'reduce (car a))
+                                           (eqv? r (cdr a))))))
+        (mk-default (if hashed
+                        (lambda (r) (cons -1 (- r)))
+                        (lambda (r) `($default reduce . ,r))))
+        (mtab (assq-ref mach 'mtab))
+        (keepers (list (assq-ref mtab '$lone-comm)
+                       (assq-ref mtab '$code-comm)
+                       (assq-ref mtab '$error))))
+
+    ;; Keep an a-list mapping reduction prod-rule => count.
+    (let iter ((sx nst) (trn-l #f) (cnt-al '()) (p-max '(0 . 0)))
+      (cond
+       ((pair? trn-l)
+       (cond
+       ((not (reduce? (cdar trn-l)))
+        ;; A shift, so not a candidate for default reduction.
+        (iter sx (cdr trn-l) cnt-al p-max))
+       ((memq (caar trn-l) keepers)
+        ;; Don't consider keepers because these will not be included.
+        (iter sx (cdr trn-l) cnt-al p-max))
+       (else
+        ;; A reduction, so update the count for reducing this prod-rule.
+        (let* ((ix (reduce-pr (cdar trn-l)))
+               (cnt (1+ (or (assq-ref cnt-al ix) 0)))
+               (cnt-p (cons ix cnt)))
+          (iter sx (cdr trn-l) (cons cnt-p cnt-al)
+                (if (> cnt (cdr p-max)) cnt-p p-max))))))
+             
+       ((null? trn-l)
+       ;; We have processed all transitions. If more than @code{keep} common
+       ;; reductions then generate default rule to replace those.
+       (if (> (cdr p-max) keep)
+           (vector-set!
+            pat-v sx
+            (fold-right
+             (lambda (trn pat) ;; transition action
+               ;; If not a comment and reduces to the most-popular prod-rule
+               ;; then transfer to the default transition.
+               (if (and (not (memq (car trn) keepers))
+                        (reduce-to? (cdr trn) (car p-max)))
+                   pat
+                   (cons trn pat)))
+             (list (mk-default (car p-max))) ;; default is last
+             (vector-ref pat-v sx))))
+       (iter sx #f #f #f))
+       ((positive? sx) ;; next state
+       (iter (1- sx) (vector-ref pat-v (1- sx)) '() '(0 . 0)))))
+    mach))
+
+;;.@section Using hash tables
+;; The lexical analyzer will generate tokens.  The parser generates state
+;; transitions based on these tokens.  When we build a lexical analyzer
+;; (via @code{make-lexer}) we provide a list of strings to detect along with
+;; associated tokens to return to the parser.  By default the tokens returned
+;; are symbols or characters.  But these could as well be integers.  Also,
+;; the parser uses symbols to represent non-terminals, which are also used
+;; to trigger state transitions.  We could use integers instead of symbols
+;; and characters by mapping via a hash table.   We will bla bla bla.
+;; There are also standard tokens we need to worry about.  These are
+;; @enumerate
+;; @item the @code{$end} marker
+;; @item identifiers (using the symbolic token @code{$ident}
+;; @item non-negative integers (using the symbolic token @code{$fixed})
+;; @item non-negative floats (using the symbolic token @code{$float})
+;; @item @code{$default} => 0
+;; @end enumerate
+;; And action
+;; @enumerate
+;; @item positive => shift
+;; @item negative => reduce
+;; @item zero => accept
+;; @end enumerate
+;; However, if these are used they should appear in the spec's terminal list.
+;; For the hash table we use positive integers for terminals and negative
+;; integers for non-terminals.  To apply such a hash table we need to:
+;; @enumerate
+;; @item from the spec's list of terminals (aka tokens), generate a list of
+;; terminal to integer pairs (and vice versa)
+;; @item from the spec's list of non-terminals generate a list of symbols
+;; to integers and vice versa.
+;; @item Go through the parser-action table and convert symbols and characters
+;; to integers
+;; @item Go through the XXX list passed to the lexical analyizer and replace
+;; symbols and characters with integers.
+;; @end enumerate
+;; One issue we need to deal with is separating out the identifier-like
+;; terminals (aka keywords) from those that are not identifier-like.  I guess
+;; this should be done as part of @code{make-lexer}, by filtering the token
+;; list through the ident-reader.
+;; NOTE: The parser is hardcoded to assume that the phony token for the
+;; default (reduce) action is @code{'$default} for unhashed machine or
+;; @code{-1} for a hashed machine.
+
+;; NEW: need to add reduction of ERROR
+
+;; @deffn machine-hashed? mach => #t|#f
+;; Indicate if the machine has been hashed.
+(define (machine-hashed? mach)
+  ;; If hashed, the parse action for rule 0 will always be a number.
+  (number? (caar (vector-ref (assq-ref mach 'pat-v) 0))))
+
+;; @deffn hashify-machine mach => mach
+(define (hashify-machine mach)
+  (if (machine-hashed? mach) mach
+      (let* ((terminals (assq-ref mach 'terminals))
+            (non-terms (assq-ref mach 'non-terms))
+            (lhs-v (assq-ref mach 'lhs-v))
+            (sm ;; = (cons sym->int int->sym)
+             (let iter ((si (list (cons '$default -1)))
+                        (is (list (cons -1 '$default)))
+                        (ix 1) (tl terminals) (nl non-terms))
+               (if (null? nl) (cons (reverse si) (reverse is))
+                   (let* ((s (atomize (if (pair? tl) (car tl) (car nl))))
+                          (tl1 (if (pair? tl) (cdr tl) tl))
+                          (nl1 (if (pair? tl) nl (cdr nl))))
+                     (iter (acons s ix si) (acons ix s is) (1+ ix) tl1 nl1)))))
+            (sym->int (lambda (s) (assq-ref (car sm) s)))
+            ;;
+            (pat-v0 (assq-ref mach 'pat-v))
+            (npat (vector-length pat-v0))
+            (pat-v1 (make-vector npat '())))
+       ;; replace symbol/chars with integers
+       (let iter1 ((ix 0))
+         (unless (= ix npat)
+           (let iter2 ((al1 '()) (al0 (vector-ref pat-v0 ix)))
+             (if (null? al0) (vector-set! pat-v1 ix (reverse al1))
+                 (let* ((a0 (car al0))
+                        ;; tk: token; ac: action; ds: destination
+                        (tk (car a0)) (ac (cadr a0)) (ds (cddr a0))
+                        ;; t: encoded token; d: encoded destination
+                        (t (sym->int tk))
+                        (d (case ac
+                             ((shift) ds) ((reduce) (- ds))
+                             ((accept) 0) (else #f))))
+                   (unless t
+                     (fmterr "~S ~S ~S\n" tk ac ds)
+                     (error "expect something"))
+                   (iter2 (acons t d al1) (cdr al0)))))
+           (iter1 (1+ ix))))
+       ;;
+       (cons*
+        (cons 'pat-v pat-v1)
+        (cons 'siis sm) ;; sm = (cons sym->int int->sym)
+        (cons 'mtab
+              (let iter ((mt1 '()) (mt0 (assq-ref mach 'mtab)))
+                (if (null? mt0) (reverse mt1)
+                    (iter (cons (cons (caar mt0) (sym->int (cdar mt0))) mt1)
+                          (cdr mt0)))))
+        ;; reduction symbols = lhs:
+        (cons 'rto-v (vector-map (lambda (i v) (sym->int v)) lhs-v))
+        mach))))
+
+;; === grammar/machine printing ======
+
+;; @deffn elt->str elt terms => string
+(define (elt->str elt terms)
+  (or (and=> (find-terminal elt terms) obj->str)
+      (symbol->string elt)))
+
+;; @deffn pp-rule indent gx [port]
+;; Pretty-print a production rule.
+(define (pp-rule il gx . rest)
+  (let* ((port (if (pair? rest) (car rest) (current-output-port)))
+        (core (fluid-ref *lalr-core*))
+        (lhs (vector-ref (core-lhs-v core) gx))
+        (rhs (vector-ref (core-rhs-v core) gx))
+        (tl (core-terminals core)))
+    (display (substring "                     " 0 (min il 20)) port)
+    (fmt port "~A =>" lhs)
+    (vector-for-each (lambda (ix e) (fmt port " ~A" (elt->str e tl))) rhs)
+    (newline port)))
+        
+;; @deffn pp-item item => string
+;; This could be called item->string.
+;; This needs terminals to work correctly, like pp-lalr-grammar.
+(define (pp-item item) 
+  (let* ((core (fluid-ref *lalr-core*))
+        (tl (core-terminals core))
+        (gx (car item))
+        (lhs (vector-ref (core-lhs-v core) gx))
+        (rhs (vector-ref (core-rhs-v core) gx))
+        (rhs-len (vector-length rhs)))
+    (apply
+     string-append
+     (let iter ((rx 0) (sl (list (fmtstr "~S =>" lhs))))
+       (if (= rx rhs-len)
+          (append sl (if (= -1 (cdr item)) '(" .") '()))
+          (iter (1+ rx)
+                (append
+                 sl (if (= rx (cdr item)) '(" .") '())
+                 (let ((e (vector-ref rhs rx)))
+                   (list (string-append " " (elt->str e tl)))))))))))
+
+;; @deffn pp-lalr-notice spec [port]
+(define (pp-lalr-notice spec . rest)
+  (let* ((port (if (pair? rest) (car rest) (current-output-port)))
+        (notice (assq-ref (assq-ref spec 'attr) 'notice))
+        (lines (if notice (string-split notice #\newline) '())))
+    (for-each (lambda (l) (simple-format port "  ~A\n" l)) lines)
+    (newline)))
+
+;; @deffn pp-lalr-grammar spec [port]
+;; Pretty-print the grammar to the specified port, or current output.
+(define (pp-lalr-grammar spec . rest)
+  (let* ((port (if (pair? rest) (car rest) (current-output-port)))
+        (lhs-v (assq-ref spec 'lhs-v))
+        (rhs-v (assq-ref spec 'rhs-v))
+        (nrule (vector-length lhs-v))
+        (act-v (assq-ref spec 'act-v))
+        ;;(prp-v (assq-ref mach 'prp-v)) ; per-rule precedence
+        (terms (assq-ref spec 'terminals))
+        (prev-core (fluid-ref *lalr-core*)))
+    (fluid-set! *lalr-core* (make-core spec)) ; OR dynamic-wind ???
+    ;; Print out the grammar.
+    (do ((i 0 (1+ i))) ((= i nrule))
+      (let* ((lhs (vector-ref lhs-v i)) (rhs (vector-ref rhs-v i)))
+       (if #f
+           (pp-rule 0 i)
+           (begin
+             (fmt port "~A ~A =>" i lhs)
+             (vector-for-each
+              (lambda (ix e) (fmt port " ~A" (elt->str e terms)))
+              rhs)
+             ;;(fmt port "\t~S" (vector-ref act-v i))
+             (newline port)))))
+    (newline port)
+    (fluid-set! *lalr-core* prev-core)))
+
+;; @deffn pp-lalr-machine mach [port]
+;; Print the states of the parser with items and shift/reduce actions.
+(define (pp-lalr-machine mach . rest)
+  (let* ((port (if (pair? rest) (car rest) (current-output-port)))
+        (lhs-v (assq-ref mach 'lhs-v))
+        (rhs-v (assq-ref mach 'rhs-v))
+        (nrule (vector-length lhs-v))
+        (pat-v (assq-ref mach 'pat-v))
+        (rat-v (assq-ref mach 'rat-v))
+        (kis-v (assq-ref mach 'kis-v))
+        (kit-v (assq-ref mach 'kit-v))
+        (nst (vector-length kis-v))    ; number of states
+        (i->s (or (and=> (assq-ref mach 'siis) cdr) '()))
+        (terms (assq-ref mach 'terminals))
+        (prev-core (fluid-ref *lalr-core*)))
+    (fluid-set! *lalr-core* (make-core mach))
+    ;; Print out the itemsets and shift reduce actions.
+    (do ((i 0 (1+ i))) ((= i nst))
+      (let* ((state (vector-ref kis-v i))
+            (pat (vector-ref pat-v i))
+            (rat (if rat-v (vector-ref rat-v i) '())))
+       (fmt port "~A:" i)           ; itemset index (aka state index)
+       (for-each
+        (lambda (k-item)
+          (for-each                    ; item, print it
+           (lambda (item)
+             (fmt port "\t~A" (pp-item item))
+             ;; show lookaheads:
+             (if (and #f (negative? (cdr item)) kit-v (equal? item k-item))
+                 (fmt port " ~A"
+                      (map (lambda (tok) (elt->str tok terms))
+                           (assoc-ref (vector-ref kit-v i) k-item))))
+             (fmt port "\n"))
+           (expand-k-item k-item)))
+        state)
+       (for-each                       ; action, print it
+        (lambda (act)
+          (if (pair? (cdr act))
+              (let ((sy (car act)) (pa (cadr act)) (gt (cddr act)))
+                (case pa
+                  ((srconf)
+                   (fmt port "\t\t~A => CONFLICT: shift ~A, reduce ~A\n"
+                        (elt->str sy terms) (car gt) (cdr gt)))
+                  ((rrconf)
+                   (fmt port "\t\t~A => CONFLICT: reduce ~A\n"
+                        (elt->str sy terms)
+                        (string-join (map number->string gt) ", reduce ")))
+                  (else
+                   (fmt port "\t\t~A => ~A ~A\n" (elt->str sy terms) pa gt))))
+              (let* ((sy (car act)) (p (cdr act))
+                     (pa (cond ((eq? #f p) 'CONFLICT)
+                               ((positive? p) 'shift)
+                               ((negative? p) 'reduce)
+                               (else 'accept)))
+                     (gt (and=> p abs)))
+                (fmt port "\t\t~A => ~A ~A\n"
+                     (elt->str (assq-ref i->s sy) terms)
+                     pa gt))))
+        pat)
+       (for-each                       ; action, print it
+        (lambda (ra)
+          ;; FIX: should indicate if precedence removed user rule or default
+          (fmt port "\t\t[~A => ~A ~A] REMOVED by ~A\n"
+               (elt->str (caar ra) terms) (cadar ra) (cddar ra)
+               (case (cdr ra)
+                 ((pre) "precedence")
+                 ((ass) "associativity")
+                 ((def) "default shift")
+                 (else (cdr ra)))))
+        rat)
+       (newline)))
+    (fluid-set! *lalr-core* prev-core)
+    (values)))
+
+;; === output routines ===============
+
+(use-modules (ice-9 pretty-print))
+(use-modules (ice-9 regex))
+
+(define (write-notice mach port)
+  (let* ((comm-leader ";; ")
+        (notice (assq-ref (assq-ref mach 'attr) 'notice))
+        (lines (if notice (string-split notice #\newline) '())))
+    (for-each
+     (lambda (l) (fmt port "~A~A\n" comm-leader l))
+     lines)
+    (if (pair? lines) (newline port))))
+
+(define (string-sub str pat repl)
+  (let ((m (string-match pat str)))
+    (if m
+       (regexp-substitute #f m 'pre repl 'post)
+       str)))
+
+;; @deffn write-lalr-tables mach filename [#:lang output-lang]
+;; For example,
+;; @example
+;; write-lalr-tables mach "tables.scm"
+;; write-lalr-tables mach "tables.tcl" #:lang 'tcl
+;; @end example
+(define* (write-lalr-tables mach filename #:key (lang 'scheme))
+
+  (define (write-table mach name port)
+    (fmt port "(define ~A\n  " name)
+    (ugly-print (assq-ref mach name) port)
+    (fmt port ")\n\n"))
+
+  (call-with-output-file filename
+    (lambda (port)
+      (fmt port ";; ~A\n\n" (string-sub filename ".new$" ""))
+      (write-notice mach port)
+      (write-table mach 'len-v port)
+      (write-table mach 'pat-v port)
+      (write-table mach 'rto-v port)
+      (write-table mach 'mtab port)
+      (display ";;; end tables" port)
+      (newline port))))
+
+
+;; @deffn write-lalr-actions mach filename [#:lang output-lang]
+;; For example,
+;; @example
+;; write-lalr-actions mach "actions.scm"
+;; write-lalr-actions mach "actions.tcl" #:lang 'tcl
+;; @end example
+(define* (write-lalr-actions mach filename #:key (lang 'scheme))
+
+  (define (pp-rule/ts gx)
+    (let* ((core (fluid-ref *lalr-core*))
+          (lhs (vector-ref (core-lhs-v core) gx))
+          (rhs (vector-ref (core-rhs-v core) gx))
+          (tl (core-terminals core))
+          (line (string-append
+                 (symbol->string lhs) " => "
+                 (string-join 
+                  (map (lambda (elt) (elt->str elt tl))
+                       (vector->list rhs))
+                  " "))))
+      (if (> (string-length line) 72)
+         (string-append (substring/shared line 0 69) "...")
+         line)))
+  (define (NEW-pp-rule/ts gx)
+    ;; TBD: use start for zeroth rule
+    (let* ((core (fluid-ref *lalr-core*))
+          (lhs (vector-ref (core-lhs-v core) gx))
+          (rhs (vector-ref (core-rhs-v core) gx))
+          (tl (core-terminals core))
+          (line (string-append
+                 (symbol->string lhs) " => "
+                 (string-join 
+                  (map (lambda (elt) (elt->str elt tl))
+                       (vector->list rhs))
+                  " "))))
+      (if (> (string-length line) 72)
+         (string-append (substring/shared line 0 69) "...")
+         line)))
+    
+  (define (write-actions mach port)
+    (with-fluid*
+     *lalr-core* (make-core mach)
+     (lambda ()
+       (fmt port "(define act-v\n  (vector\n")
+       (vector-for-each
+       (lambda (gx actn)
+         (fmt port "   ;; ~A\n" (pp-rule/ts gx))
+         (pretty-print (wrap-action actn) port #:per-line-prefix "   "))
+       (assq-ref mach 'act-v))
+       (fmt port "   ))\n\n"))))
+
+  (call-with-output-file filename
+    (lambda (port)
+      (fmt port ";; ~A\n\n" (string-sub filename ".new$" ""))
+      (write-notice mach port)
+      (write-actions mach port)
+      (display ";;; end tables" port)
+      (newline port))))
+
+;; @end itemize
+;;; --- last line ---
diff --git a/module/nyacc/lang/c99/BUGS b/module/nyacc/lang/c99/BUGS
new file mode 100644 (file)
index 0000000..9c11149
--- /dev/null
@@ -0,0 +1,39 @@
+C99-007        <= next id
+
+C99-006        06 Aug 2016, M.Wette
+        code "val = '\0';" gets pprinted to "val = '^@;';"
+
+C99-005        26 Jun 2016, M.Wette
+       in util2.scm, tree->udecl needs to return "struct" and "union"
+       entries for stuff like
+               struct foo { int x; };
+
+C99-004        xdef arg to gen-c-lexer may be too simple
+       it is currently a predicate.  Maybe it should return three values
+       #f => don't expand
+       #t => expand
+       string => use string
+
+C99-003 util2.scm/tree->udict should return declarations in order
+
+=== RESOLVED ===================
+
+C99-001        cpp breaks on the following, I think:
+       #define ABC 123 /* this is a var */
+       #if ABC > 100
+       # error "bla"
+       #endif
+13Apr16        works
+
+C99-002 CPP redesign is not working for ifdef and defined:
+       #define A 1
+       #ifdef A
+       ...
+       breaks because it gets expanded as (if "defined(1)")
+       see cppbody.scm, near line 133:
+            ((read-c-ident ch) =>
+             (lambda (iden)
+25Jun16 fixed
+
+
+--- last line ---
diff --git a/module/nyacc/lang/c99/README b/module/nyacc/lang/c99/README
new file mode 100644 (file)
index 0000000..0051ee9
--- /dev/null
@@ -0,0 +1,45 @@
+nyacc/lang/c99/
+
+Copyright (C) 2015,2016 Matthew R. Wette
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.  This file is offered as-is,
+without any warranty.
+
+manifest:
+
+cpp.scm                C preprocessor using tables
+               includes: cppbody.scm cppact.scm,cpptab.scm
+cppbody.scm    eval-cpp-expr procedure
+cppmach.scm    CPP expression grammer, machine and act/tab file generation
+
+mach.scm       C grammer, machine and act/tab file generation
+               include: pbody.scm
+               depends: cpp.scm
+parser.scm     C file parser, using tables 
+               includes: body.scm, c99act.scm, c99tab.scm
+               depends: cpp.scm
+xparser.scm    C expression parser
+               includes: body.scm, c99xact.scm, c99xtab.scm
+               depends: cpp.scm
+
+pprint.scm     C pretty printer, from SXML output of above parsers
+
+util1.scm      utilities merge, remove trees from included files
+util2.scm      utilities to process information in trees
+
+mach.d/
+  cppact.scm   cpp expression parser actions, generated from cppmach.scm
+  cpptab.scm   cpp expression parser tables, generated from cppmach.scm
+
+  c99act.scm   parser actions, generated from mach.scm
+  c99tab.scm   C99 parser tables, generated from mach.scm
+
+  c99xact.scm  expression parser actions, generated from mach.scm
+  c99xtab.scm  C99 expression parser tables, generated from mach.scm
+
+
+==== cpp ================================
+
+parse-cpp-line line => tree
\ No newline at end of file
diff --git a/module/nyacc/lang/c99/body.scm b/module/nyacc/lang/c99/body.scm
new file mode 100644 (file)
index 0000000..c3571e3
--- /dev/null
@@ -0,0 +1,423 @@
+;;; lang/c99/body.scm
+;;;
+;;; Copyright (C) 2015 Matthew R. Wette
+;;;
+;;; This program is free software: you can redistribute it and/or modify
+;;; it under the terms of the GNU General Public License as published by 
+;;; the Free Software Foundation, either version 3 of the License, or 
+;;; (at your option) any later version.
+;;;
+;;; This program is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of 
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;; C parser body, with cpp and tables makes a parser
+
+(define-record-type cpi
+  (make-cpi-1)
+  cpi?
+  (debug cpi-debug set-cpi-debug!)     ; debug #t #f
+  (defines cpi-defs set-cpi-defs!)     ; #defines
+  (incdirs cpi-incs set-cpi-incs!)     ; #includes
+  (tn-dict cpi-tynd set-cpi-tynd!)     ; typename dict (("<x>" foo_t ..
+  ;;
+  ;;(typnams cpi-tyns set-cpi-tyns!)   ; typedef names
+  ;;
+  (ptl cpi-ptl set-cpi-ptl!)           ; parent typename list
+  (ctl cpi-ctl set-cpi-ctl!)           ; current typename list
+  ;;
+  ;;(typdcls cpi-tdls set-cpi-tdls!)   ; typedef decls
+  )
+
+(define std-dict
+  '(("time.h" "time_t" "clock_t" "size_t")
+    ("stdio.h" "FILE" "size_t")
+    ("string.h" "size_t")
+    ("stddef.h" "ptrdiff_t" "size_t" "wchar_t")
+    ("inttypes.h"
+     "int8_t" "uint8_t" "int16_t" "uint16_t" "int32_t" "uint32_t"
+     "int64_t" "uint64_t" "uintptr_t" "intptr_t" "intmax_t" "uintmax_t"
+     "int_least8_t" "uint_least8_t" "int_least16_t" "uint_least16_t"
+     "int_least32_t" "uint_least32_t" "int_least64_t" "uint_least64_t"
+     "imaxdiv_t")
+    ("stdint.h"
+     "int8_t" "uint8_t" "int16_t" "uint16_t" "int32_t" "uint32_t"
+     "int64_t" "uint64_t" "uintptr_t" "intptr_t" "intmax_t" "uintmax_t"
+     "int_least8_t" "uint_least8_t" "int_least16_t" "uint_least16_t"
+     "int_least32_t" "uint_least32_t" "int_least64_t" "uint_least64_t")
+    ("stdlib.h" "div_t" "ldiv_t" "lldiv_t" "wchar_t")
+    ("stdarg.h" "va_list")
+    ;;("unistd.h" "div_t" "ldiv_t")
+    ("signal.h" "sig_atomic_t")
+    ("setjmp.h" "jmp_buf")
+    ("float.h" "float_t")
+    ("fenv.h" "fenv_t" "fexcept_t")
+    ("complex.h" "complex" "imaginary")
+    ("wchar.h" "wchar_t" "wint_t" "mbstate_t" "size_t")
+    ("wctype.h" "wctrans_t" "wctype_t" "wint_t")
+    ("math.h")
+    ))
+
+(define (make-cpi debug defines incdirs tn-dict)
+  (let* ((cpi (make-cpi-1)))
+    (set-cpi-debug! cpi debug)
+    (set-cpi-defs! cpi defines)
+    (set-cpi-incs! cpi incdirs)
+    (set-cpi-tynd! cpi (append tn-dict std-dict))
+    (set-cpi-ptl! cpi '())             ; list of lists of strings
+    (set-cpi-ctl! cpi '())             ; list of strings ?
+    cpi))
+
+;; Need to have a "CPI" stack to deal with types (re)defined in multiple
+;; branches of a #if...#endif statement.  If we are in "code" mode then we
+;; may be skipping code so need to track when to shift and when not to.
+
+(define *info* (make-fluid #f))
+
+;; given tyns
+;; cadr is next level
+;; caar is list of sibs
+;; search (caar car tyns), then (caar cadr tyns), then ...
+
+;; @deffn typename? name
+;; Called by lexer to determine if symbol is a typename.
+;; Check current sibling for each generation.
+(define (typename? name)
+  ;;(simple-format #t "typename? ~S\n" name)
+  (let ((cpi (fluid-ref *info*)))
+    (when #f ;;(string=? name "SpiceInt")
+      (simple-format #t "tn? ~S  ~S\n" (cpi-ctl cpi) (cpi-ptl cpi)))
+    (if (member name (cpi-ctl cpi)) #t
+        (let iter ((ptl (cpi-ptl cpi)))
+         (if (null? ptl) #f
+             (if (member name (car ptl)) #t
+                 (iter (cdr ptl))))))))
+
+;; @deffn add-typename name
+;; Helper for @code{save-typenames}.
+(define (add-typename name)
+  ;;(simple-format #t "add-typename ~S\n" name)
+  (let ((cpi (fluid-ref *info*)))
+    (set-cpi-ctl! cpi (cons name (cpi-ctl cpi)))
+    ;;(simple-format #t "at: ~S  ~S\n" (cpi-ctl cpi) (cpi-ptl cpi))
+    ))
+
+(define (cpi-push)     ;; on #if
+  (let ((cpi (fluid-ref *info*)))
+    (set-cpi-ptl! cpi (cons (cpi-ctl cpi) (cpi-ptl cpi)))
+    (set-cpi-ctl! cpi '())
+    ;;(simple-format #t "pu: ~S\n" (cpi-ctl cpi))
+    ))
+
+(define (cpi-shift)    ;; on #elif #else
+  (set-cpi-ctl! (fluid-ref *info*) '()))
+
+(define (cpi-pop)      ;; on #endif
+  (let ((cpi (fluid-ref *info*)))
+    ;;(simple-format #t "po<: ~S ~S\n" (cpi-ctl cpi) (cpi-ptl cpi))
+    (set-cpi-ctl! cpi (append (cpi-ctl cpi) (car (cpi-ptl cpi))))
+    (set-cpi-ptl! cpi (cdr (cpi-ptl cpi)))
+    ;;(simple-format #t "po>: ~S ~S\n" (cpi-ctl cpi) (cpi-ptl cpi))
+    ))
+
+(use-modules (ice-9 pretty-print))
+
+;; @deffn find-new-typenames decl
+;; Helper for @code{save-typenames}.
+;; Given declaration return a list of new typenames (via @code{typedef}).
+(define (find-new-typenames decl)
+
+  ;; like declr->ident in util2.scm
+  (define (declr->id-name declr)
+    (case (car declr)
+      ((ident) (sx-ref declr 1))
+      ((init-declr) (declr->id-name (sx-ref declr 1)))
+      ((comp-declr) (declr->id-name (sx-ref declr 1)))
+      ((array-of) (declr->id-name (sx-ref declr 1)))
+      ((ptr-declr) (declr->id-name (sx-ref declr 2)))
+      ((ftn-declr) (declr->id-name (sx-ref declr 1)))
+      ((scope) (declr->id-name (sx-ref declr 1)))
+      (else (error "coding bug: " declr))))
+       
+  (let* ((spec (sx-ref decl 1))
+        (stor (sx-find 'stor-spec spec))
+        (id-l (sx-ref decl 2)))
+    (if (and stor (eqv? 'typedef (caadr stor)))
+       (let iter ((res '()) (idl (cdr id-l)))
+         (if (null? idl) res
+             (iter (cons (declr->id-name (sx-ref (car idl) 1)) res)
+                   (cdr idl))))
+       '())))
+
+;; @deffn save-typenames decl
+;; Save the typenames for the lexical analyzer and return the decl.
+(define (save-typenames decl)
+  ;; This finds typenames using @code{find-new-typenames} and adds via
+  ;; @code{add-typename}.  Then return the decl.
+  (for-each add-typename (find-new-typenames decl))
+  decl)
+
+
+;; ------------------------------------------------------------------------
+
+;; @deffn read-cpp-line ch => #f | (cpp-xxxx)??
+;; Given if ch is #\# read a cpp-statement
+;; includes BUG: #define ABC 123 /* \n
+(define (read-cpp-line ch)
+  (if (not (eq? ch #\#)) #f
+      (let iter ((cl '()) (ch (read-char)))
+       (cond
+        ((eq? ch #\newline) (list->string (reverse cl)))
+        ((eq? ch #\\)
+         (let ((c2 (read-char)))
+           (if (eq? c2 #\newline)
+               (iter cl (read-char))
+               (iter (cons* c2 ch cl) (read-char)))))
+        ((eq? ch #\/) ;; swallow comments, event w/ newlines
+         (let ((c2 (read-char)))
+           (cond
+            ((eqv? c2 #\*)
+             (let iter2 ((cl2 (cons* #\* #\/ cl)) (ch (read-char)))
+               (cond
+                ((eq? ch #\*)
+                 (let ((c2 (read-char)))
+                   (if (eqv? c2 #\/)
+                       (iter (cons* #\/ #\* cl2) (read-char)) ;; keep comment
+                       ;;(iter cl (read-char)) ;; toss comment
+                       (iter2 (cons #\* cl2) c2))))
+                (else
+                 (iter2 (cons ch cl2) (read-char))))))
+            (else
+             (iter (cons #\/ cl) c2)))))
+        (else (iter (cons ch cl) (read-char)))))))
+
+;; @deffn find-file-in-dirl file dirl => path
+(define (find-file-in-dirl file dirl)
+  (let iter ((dirl dirl))
+    (if (null? dirl) #f
+       (let ((p (string-append (car dirl) "/" file)))
+         (if (access? p R_OK) p (iter (cdr dirl)))))))
+
+
+;; @subsubsection CPP If-Else Processing
+;; States are
+;; @table code
+;; @item skip
+;; skip code
+;; @item skip-look
+;; skipping code, but still looking for true at this level
+;; @item keep
+;; keep code
+;; @item keep1
+;; NOT USED keep one token and pop skip-stack
+;; @item skip-one
+;; skip one token and pop skip-stack
+;; @end table
+
+;; NOTE: if file mode we usually keep #ifdefs.  The lone exception is
+;; @code{#if 0}
+
+;; @deffn gen-c-lexer [#:mode mode] => thunk
+;; Generate a context-sensitive lexer for the C language.
+;; The key-arg @var{mode} can be @code{'code} or @code{'file}.  If @code{'code}
+;; @enumerate
+;; @item
+;; CPP defines are expanded (future work)
+;; @item
+;; CPP if/def is executed
+;; @end enumerate
+(define (def-xdef? name mode)
+  (eqv? mode 'code))
+
+;; @deffn gen-c-lexer [#:mode mode] [#:xdef? proc] => thunk
+(define gen-c-lexer
+  ;; This gets ugly in order to handle cpp.
+  ;;.need to add support for num's w/ letters like @code{14L} and @code{1.3f}.
+  ;; todo: I think there is a bug wrt the comment reader because // ... \n
+  ;; will end up in same mode...  so after
+  ;; int x; // comment
+  ;; the lexer will think we are not at BOL.
+  (let* ((match-table mtab)
+        (read-ident read-c-ident)
+        (read-comm read-c-comm)
+        ;;
+        (ident-like? (make-ident-like-p read-ident))
+        ;;
+        (strtab (filter-mt string? match-table)) ; strings in grammar
+        (kwstab (filter-mt ident-like? strtab))  ; keyword strings =>
+        (keytab (map-mt string->symbol kwstab))  ; keywords in grammar
+        (chrseq (remove-mt ident-like? strtab))  ; character sequences
+        (symtab (filter-mt symbol? match-table)) ; symbols in grammar
+        (chrtab (filter-mt char? match-table))   ; characters in grammar
+        ;;
+        (read-chseq (make-chseq-reader chrseq))
+        (assc-$ (lambda (pair) (cons (assq-ref symtab (car pair)) (cdr pair))))
+        ;;
+        (t-ident (assq-ref symtab '$ident))
+        (t-typename (assq-ref symtab 'typename))
+        (xp1 (sxpath '(cpp-stmt define)))
+        (xp2 (sxpath '(decl))))
+    ;; mode: 'code|'file
+    ;; xdef?: (proc name mode) => #t|#f  : do we expand #define?
+    ;; ppev?: (proc ???) => #t|#f : do we eval-and-honor #if/#else ?
+    (lambda* (#:key (mode 'code) (xdef? #f))
+      (let ((bol #t)                 ; begin-of-line condition
+           (skip (list 'keep))       ; CPP skip-input stack
+           (info (fluid-ref *info*)) ; assume make and run in same thread
+           (pstk '())                ; port stack
+           (x-def? (or xdef? (lambda (name mode) (eqv? mode 'code)))))
+       ;; Return the first (tval lval) pair not excluded by the CPP.
+       (lambda ()
+
+         (define (eval-flow?)
+           (eqv? mode 'code))
+      
+         (define (add-define tree)
+           (let* ((tail (cdr tree))
+                  (name (car (assq-ref tail 'name)))
+                  (args (assq-ref tail 'args))
+                  (repl (car (assq-ref tail 'repl)))
+                  (cell (cons name (if args (cons args repl) repl))))
+             (set-cpi-defs! info (cons cell (cpi-defs info)))))
+         
+         (define (rem-define name)
+             (set-cpi-defs! info (delete name (cpi-defs info))))
+         
+         (define (exec-cpp line)
+           ;; Parse the line into a CPP stmt, execute it, and return it.
+           (let* ((stmt (read-cpp-stmt line))
+                  (perr (lambda (file)
+                          (throw 'parse-error "file not found: ~S" file))))
+             (case (car stmt)
+               ((include)
+                (let* ((parg (cadr stmt)) (leng (string-length parg))
+                       (file (substring parg 1 (1- leng)))
+                       (tynd (assoc-ref (cpi-tynd info) file)))
+                  (if tynd
+                      (for-each add-typename tynd)
+                      (let* ((pth (find-file-in-dirl file (cpi-incs info)))
+                             (tree (if pth ; path exists
+                                       (or (with-input-from-file pth run-parse)
+                                           (throw 'parse-error "~A" pth))
+                                       (perr file))))
+                        (for-each add-define (xp1 tree)) ; add def's 
+                        ;; Attach tree onto "include" statement.
+                        (if (pair? tree) (set! stmt (append stmt (list tree))))
+                        ))))
+               ((define)
+                (add-define stmt))
+               ((undef)
+                (rem-define (cadr stmt)))
+               ((if) ;; and ifdef, ifndef
+                (cpi-push)
+                (if (eval-flow?)
+                    (let* ((defs (cpi-defs info))
+                           (rhs (cpp-expand-text (cadr stmt) defs))
+                           ;; rhs = "defined(1)" :(
+                           (exp (parse-cpp-expr rhs))
+                           (val (eval-cpp-expr exp defs)))
+                      (cond
+                       ((not val)
+                        (throw 'parse-error "unresolved: ~S" (cadr stmt)))
+                       ((zero? val)
+                        (set! skip (cons* 'skip-one 'skip-look skip)))
+                       (else
+                        (set! skip (cons* 'skip-one (car skip) skip)))))))
+               ((elif)
+                (if (eval-flow?)
+                    (let* ((defs (cpi-defs info))
+                           (rhs (cpp-expand-text (cadr stmt) defs))
+                           (exp (parse-cpp-expr rhs))
+                           (val (eval-cpp-expr exp defs)))
+                      (cond
+                       ((not val)
+                        (throw 'parse-error "unresolved: ~S" (cadr stmt)))
+                       ((eq? 'keep (car skip))
+                        (set! skip (cons* 'skip-one 'skip (cdr skip))))
+                       ((zero? val)
+                        (set! skip (cons* 'skip-one skip)))
+                       ((eq? 'skip-look (car skip))
+                        (cpi-shift)
+                        (set! skip (cons* 'skip-one 'keep (cdr skip))))
+                       (else
+                        (cpi-shift)
+                        (set! skip (cons* 'skip-one 'skip (cdr skip))))))
+                    (cpi-shift)))
+               ((else)
+                (if (eval-flow?)
+                    (cond
+                     ((eq? 'skip-look (car skip))
+                      (cpi-shift)
+                      (set! skip (cons* 'skip-one 'keep (cdr skip))))
+                     (else
+                      (set! skip (cons* 'skip-one 'skip (cdr skip)))))
+                    (cpi-shift)))
+               ((endif)
+                (cpi-pop)
+                (if (eval-flow?)
+                    (set! skip (cons 'skip-one (cdr skip)))))
+               ((error)
+                stmt)
+               (else
+                (error "unhandled cpp stmt")))
+             (cons 'cpp-stmt stmt)))
+         
+         ;; Composition of @code{read-cpp-line} and @code{exec-cpp}.
+         (define (read-cpp ch)
+           (and=> (read-cpp-line ch) exec-cpp))
+
+         (define (read-token)
+           (let iter ((ch (read-char)))
+             (cond
+              ((eof-object? ch)
+               (if (pop-input) (iter (read-char)) (assc-$ '($end . ""))))
+              ((eq? ch #\newline) (set! bol #t) (iter (read-char)))
+              ((char-set-contains? c:ws ch) (iter (read-char)))
+              (bol
+               (cond
+                ((read-comm ch bol) => assc-$)
+                ((read-cpp ch) => assc-$)
+                (else (set! bol #f) (iter ch))))
+              ((read-ident ch) =>
+               (lambda (name)
+                 (let ((symb (string->symbol name)))
+                   (cond
+                    ((and (x-def? name mode)
+                          (expand-cpp-mref name (cpi-defs info)))
+                     => (lambda (st)
+                          (push-input (open-input-string st))
+                          (iter (read-char))))
+                    ((assq-ref keytab symb)
+                     => (lambda (t) (cons t name)))
+                    ((typename? name)
+                     (cons (assq-ref symtab 'typename) name))
+                    (else
+                     (cons (assq-ref symtab '$ident) name))))))
+              ((read-c-num ch) => assc-$)
+              ((read-c-string ch) => assc-$)
+              ((read-c-chlit ch) => assc-$)
+              ((read-comm ch bol) => assc-$)
+              ((read-chseq ch) => identity)
+              ((assq-ref chrtab ch) => (lambda (t) (cons t (string ch))))
+              ((eqv? ch #\\) ;; C allows \ at end of line to continue
+               (let ((ch (read-char)))
+                 (cond ((eqv? #\newline ch) (iter (read-char))) ;; extend line
+                       (else (unread-char ch) (cons #\\ "\\"))))) ;; parse err
+              (else (cons ch (string ch))))))
+
+         ;; Loop between reading tokens and skipping tokens.
+         ;; The use of "delayed pop" is not clean IMO.  Cleaner way?
+         (let loop ((pair (read-token)))
+           (case (car skip)
+             ((keep) pair)
+             ((skip skip-look) (loop (read-token)))
+             ((skip-one)
+              (set! skip (cdr skip))
+              (loop (read-token)))))
+         )))))
+
+;; --- last line ---
diff --git a/module/nyacc/lang/c99/cpp.scm b/module/nyacc/lang/c99/cpp.scm
new file mode 100644 (file)
index 0000000..a00eec3
--- /dev/null
@@ -0,0 +1,138 @@
+;;; lang/c/cpp.scm
+;;;
+;;; Copyright (C) 2015 Matthew R. Wette
+;;;
+;;; This program is free software: you can redistribute it and/or modify
+;;; it under the terms of the GNU General Public License as published by 
+;;; the Free Software Foundation, either version 3 of the License, or 
+;;; (at your option) any later version.
+;;;
+;;; This program is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of 
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;; C preprocessor.  This is not complete.
+
+(define-module (nyacc lang c99 cpp)
+  #:export (parse-cpp-stmt
+           read-cpp-stmt
+           parse-cpp-expr
+           eval-cpp-expr
+           cpp-expand-text
+           expand-cpp-mref
+           )
+  #:use-module (nyacc parse)
+  #:use-module (nyacc lex)
+  #:use-module (nyacc lang util)
+  #:use-module (rnrs arithmetic bitwise)
+  )
+
+#|
+  #define  #undef  #include  #if  #ifdef  #ifndef  #else  #endif  #elif
+  #line  defined  #-operator  ##-operator  #pragma  #error
+
+strategy:
+  don't expand macro calls -- treat like function calls, but provide dict
+todo:
+  pragma
+  #-op ##-op
+  provide dict of #defines
+  provide util to expand defines
+|#
+
+;;.@deffn skip-ws ch
+;; Helper for 
+(define (skip-ws ch)
+  (if (eof-object? ch) ch
+      (if (char-set-contains? c:ws ch)
+         (skip-ws (read-char))
+         ch)))
+;; @deffn cpp-define => #f|???
+(define (cpp-define)
+  ;; The (weak?) parse architecture is "unread la argument if no match"
+  (letrec
+      ((p-cppd ;; parse all
+       (lambda ()
+         (let* ((iden (read-c-ident (skip-ws (read-char))))
+                ;;(args (or (p-args (skip-ws (read-char))) '()))
+                ;; "define ABC(ARG)" not the same as "define ABC (ARG)"
+                (args (or (p-args (read-char)) '()))
+                (rest (or (p-rest (skip-ws (read-char))) " ")))
+           (if (pair? args)
+               `(define (name ,iden) ,(cons 'args args) (repl ,rest))
+               `(define (name ,iden) (repl ,rest))))))
+       (p-args ;; parse args
+       (lambda (la) ;; unread la if no match :(
+         (if (eq? la #\()
+             (let iter ((args '()) (la (skip-ws (read-char))))
+               (cond
+                ((eq? la #\)) (reverse args))
+                ((read-c-ident la) =>
+                 (lambda (arg) (iter (cons arg args) (skip-ws (read-char)))))
+                ((eq? la #\,)
+                 (iter args (skip-ws (read-char))))))
+             (begin (if (char? la) (unread-char la)) #f)))) ;; CLEANUP
+       (p-rest ;; parse rest
+       (lambda (la)
+         (cond ((char? la) (unread-char la) (drain-input (current-input-port)))
+               (else #f)))))
+    (p-cppd)))
+
+;; @deffn cpp-include
+;; Parse CPP include statement.
+(define (cpp-include)
+  (let* ((beg-ch (skip-ws (read-char)))
+        (end-ch (if (eq? beg-ch #\<) #\> #\"))
+        (path (let iter ((cl (list beg-ch)) (ch (read-char)))
+                (if (eq? ch end-ch) (list->string (reverse (cons ch cl)))
+                    (iter (cons ch cl) (read-char))))))
+    `(include ,path)))
+
+;; @deffn read-cpp-stmt line defs => (stmt-type text)
+;; Parse a line from a CPP statement and return a parse tree.
+;; @example
+;; (parse-cpp-stmt "define X 123") => (define "X" "123")
+;; (parse-cpp-stmt "if defined(A) && defined(B) && defined(C)"
+;; => (if "defined(A) && defined(B) && defined(C)")
+;; @end example
+;; To evaluate the @code{if} statements use @code{parse-cpp-expr} and
+;; @code{eval-cpp-expr}.
+(define (read-cpp-stmt line)
+  (define (rd-ident) (read-c-ident (skip-ws (read-char))))
+  (define (rd-num) (and=> (read-c-num (skip-ws (read-char))) cdr))
+  (define (rd-rest) (let ((ch (skip-ws (read-char))))
+                     (if (not (eof-object? ch)) (unread-char ch))
+                     (drain-input (current-input-port))))
+  (with-input-from-string line
+    (lambda ()
+      (let ((cmd (string->symbol (read-c-ident (skip-ws (read-char))))))
+        (case cmd
+          ((include) (cpp-include))
+          ((define) (cpp-define))
+          ((undef) `(undef ,(rd-ident)))
+          ((ifdef)
+           `(if ,(string-append "defined(" (rd-ident) ")" (rd-rest))))
+          ((ifndef)
+           `(if ,(string-append "!defined(" (rd-ident) ")" (rd-rest))))
+          ((if elif else endif line error pragma) (list cmd (rd-rest)))
+          (else '(unknown "")))))))
+    
+(include-from-path "nyacc/lang/c99/mach.d/cpptab.scm")
+(include-from-path "nyacc/lang/c99/mach.d/cppact.scm")
+
+(define raw-parser
+  (make-lalr-parser
+   (list (cons 'len-v len-v) (cons 'pat-v pat-v) (cons 'rto-v rto-v)
+        (cons 'mtab mtab) (cons 'act-v act-v))))
+
+;; The included file "cppbody.scm" provides:
+;; gen-cpp-lexer
+;; parse-cpp-expr
+;; eval-cpp-expr
+(include-from-path "nyacc/lang/c99/cppbody.scm")
+;; --- last line ---
diff --git a/module/nyacc/lang/c99/cppbody.scm b/module/nyacc/lang/c99/cppbody.scm
new file mode 100644 (file)
index 0000000..bd8a2bd
--- /dev/null
@@ -0,0 +1,209 @@
+;;; nyacc/lang/c99/cppbody.scm
+;;;
+;;; Copyright (C) 2016 Matthew R. Wette
+;;;
+;;; This program is free software: you can redistribute it and/or modify
+;;; it under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation, either version 3 of the License, or
+;;; (at your option) any later version.
+;;;
+;;; This program is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+(define gen-cpp-lexer (make-lexer-generator mtab))
+
+;; @deffn parse-cpp-expr text => tree
+;; Given a string returns a cpp parse tree.  This is called by
+;; @code{parse-cpp-stmt} and @code{eval-cpp-expr}.  The latter because the
+;; parsed expression may include terms which are cpp-defined
+;; and should be evaluated lazy mode.
+(define (parse-cpp-expr text)
+  (with-input-from-string text
+    (lambda () (raw-parser (gen-cpp-lexer)))))
+
+;; @deffn eval-cpp-expr tree dict => datum
+;; Evaluate a tree produced from
+;; This should be updated to use @code{expand-cpp-def}.  See below.
+(use-modules (ice-9 pretty-print))
+(define (eval-cpp-expr tree dict)
+  ;;(display "eval-cpp-expr:\n") (pretty-print tree)
+  (letrec
+      ((tx (lambda (tr ix) (list-ref tr ix)))
+       (tx1 (lambda (tr) (tx tr 1)))
+       (ev (lambda (ex ix) (eval-expr (list-ref ex ix))))
+       (ev1 (lambda (ex) (ev ex 1)))
+       (ev2 (lambda (ex) (ev ex 2)))
+       (ev3 (lambda (ex) (ev ex 3)))
+       #;(parse-and-eval
+       (lambda (str)
+         (if (not (string? str)) (throw 'parse-error "cpp-eval"))
+         (let ((idtr (parse-cpp-expr str)))
+           (eval-cpp-expr idtr dict))))
+       (eval-expr
+       (lambda (tree)
+         (case (car tree)
+           ;;((ident) (parse-and-eval (assoc-ref dict (tx1 tree))))
+           ((fixed) (string->number (tx1 tree)))
+           ((char) (char->integer (tx1 tree)))
+           ((defined) (if (assoc-ref dict (tx1 tree)) 1 0))
+           ;;
+           ((pre-inc post-inc) (1+ (ev1 tree)))
+           ((pre-dec post-dec) (1- (ev1 tree)))
+           ((pos) (ev1 tree))
+           ((neg) (- (ev1 tree)))
+           ((bw-not) (bitwise-not (ev1 tree)))
+           ((not) (if (zero? (ev1 tree)) 1 0))
+           ((mul) (* (ev1 tree) (ev2 tree)))
+           ((div) (/ (ev1 tree) (ev2 tree)))
+           ((mod) (modulo (ev1 tree) (ev2 tree)))
+           ((add) (+ (ev1 tree) (ev2 tree)))
+           ((sub) (- (ev1 tree) (ev2 tree)))
+           ((lshift) (bitwise-arithmetic-shift-left (ev1 tree) (ev2 tree)))
+           ((rshift) (bitwise-arithmetic-shift-right (ev1 tree) (ev2 tree)))
+           ((lt) (if (< (ev1 tree) (ev2 tree)) 1 0))
+           ((le) (if (<= (ev1 tree) (ev2 tree)) 1 0))
+           ((gt) (if (> (ev1 tree) (ev2 tree)) 1 0))
+           ((ge) (if (>= (ev1 tree) (ev2 tree)) 1 0))
+           ((equal) (if (= (ev1 tree) (ev2 tree)) 1 0))
+           ((noteq) (if (= (ev1 tree) (ev2 tree)) 0 1))
+           ((bw-or) (bitwise-ior (ev1 tree) (ev2 tree)))
+           ((bw-xor) (bitwise-xor (ev1 tree) (ev2 tree)))
+           ((bw-and) (bitwise-and (ev1 tree) (ev2 tree)))
+           ((or) (if (and (zero? (ev1 tree)) (zero? (ev2 tree))) 0 1))
+           ((and) (if (or (zero? (ev1 tree)) (zero? (ev2 tree))) 0 1))
+           ((cond-expr) (if (zero? (ev1 tree)) (ev3 tree) (ev2 tree)))
+           (else (error "incomplete implementation"))))))
+    (catch 'parse-error
+          (lambda () (eval-expr tree))
+          (lambda () #f))))
+
+
+;; @deffn scan-cpp-input argd used dict for-argl => string
+;; Process the replacement text and generate a (reversed) token-list.
+;; If for-argl, stop at, and push back, @code{,} or @code{)}.
+(define (scan-cpp-input argd dict used for-argl)
+  ;; Works like this: scan tokens (comments, parens, strings, char's, etc).
+  ;; Tokens (i.e., strings) are collected in a (reverse ordered) list (stl)
+  ;; and merged together on return.  Lone characters are collected in the
+  ;; list @code{chl}.  Once a non-char token is found the character list is
+  ;; converted to a string and added to the string list first, followed by
+  ;; the new token.
+
+  ;; Turn reverse chl into a string and insert it into the string list stl.
+  (define (add-chl chl stl)
+    (if (null? chl) stl (cons (list->string (reverse chl)) stl)))
+
+  ;; We just scanned "defined", not need to scan the arg to inhibit expansion.
+  ;; E.g., scanned "defined", now scan "(FOO)", and return "defined(FOO)".
+  (define (scan-defined)
+    (let iter ((chl '()) (ch (read-char)))
+      (cond ((eof-object? ch) (throw 'parse-error "bad CPP defined"))
+           ((char=? #\) ch)
+            (string-append "defined" (list->string (reverse (cons ch chl)))))
+           (else (iter (cons ch chl) (read-char))))))
+  
+  ;; 
+  (let iter ((stl '())         ; string list (i.e., tokens)
+            (chl '())          ; char-list (current list of input chars)
+            (nxt #f)           ; next string 
+            (lvl 0)            ; level
+            (ch (read-char)))  ; next character
+    ;;(simple-format #t "iter stl=~S chl=~S nxt=~S ch=~S\n" stl chl nxt ch)
+    (cond
+     ;; have item to add, but first add in char's
+     (nxt (iter (cons nxt (add-chl chl stl)) '() #f lvl ch))
+     ;; If end of string or see end-ch at level 0, then return.
+     ((eof-object? ch)  ;; CHECK (ab++)
+      (apply string-append (reverse (add-chl chl stl))))
+     ((and for-argl (memq ch '(#\) #\,)) (zero? lvl))
+      (unread-char ch) (apply string-append (reverse (add-chl chl stl))))
+     ((read-c-comm ch #f) =>
+      (lambda (cp) (iter stl chl (string-append "/*" (cdr cp) "*/")
+                        lvl (read-char))))
+     ((char=? #\( ch) (iter stl (cons ch chl) nxt (1+ lvl) (read-char)))
+     ((char=? #\) ch) (iter stl (cons ch chl) nxt (1- lvl) (read-char)))
+     ((char=? #\# ch)
+      (let ((ch (read-char)))
+       (if (eqv? ch #\#)
+           (iter (cons "##" stl) chl #f lvl (read-char))
+           (iter (cons "#" stl) chl #f lvl ch))))
+     ((read-c-string ch) =>
+      (lambda (st) (iter stl chl st lvl (read-char))))
+     ((read-c-ident ch) =>
+      (lambda (iden)
+       ;;(simple-format #t "    iden=~S\n" iden)
+       (if (equal? iden "defined")
+           ;; "defined" is a special case
+           (iter stl chl (scan-defined) lvl (read-char))
+           ;; otherwise ...
+           (let* ((aval (assoc-ref argd iden))  ; lookup argument
+                  (rval (assoc-ref dict iden))) ; lookup macro def
+             (cond
+              ((member iden used)      ; name used
+               (iter stl chl iden lvl (read-char)))
+              (aval                    ; arg ref
+               (iter stl chl aval lvl (read-char)))
+              ((string? rval)          ; cpp repl
+               (iter stl chl rval lvl (read-char)))
+              ((pair? rval)            ; cpp macro
+               (let* ((argl (car rval)) (text (cdr rval))
+                      (argv (collect-args argd dict used))
+                      (argd (map cons argl argv))
+                      (newl (expand-cpp-repl text argd dict (cons iden used))))
+                 (iter stl chl newl lvl (read-char))))
+              (else                    ; normal identifier
+               (iter stl chl iden lvl (read-char))))))))
+     (else
+      (iter stl (cons ch chl) #f lvl (read-char))))))
+  
+(define (collect-args argd dict used)
+  ;;(simple-format #t "collect-args\n")
+  (if (not (eqv? (read-char) #\()) (throw 'parse-error "collect-args"))
+  (let iter ((argl (list (scan-cpp-input argd dict used #t))))
+    (simple-format #t "args: ~S\n" argl)
+    (let ((ch (read-char)))
+      (if (eqv? ch #\)) (reverse argl)
+         (iter (cons (scan-cpp-input argd dict used #t) argl))))))
+    
+(define (expand-cpp-repl repl argd dict used)
+  ;;(simple-format #t "expand-cpp-repl repl=~S argd=~S\n" repl argd)
+  (with-input-from-string repl
+    (lambda () (scan-cpp-input argd dict used #f))))
+
+;; @deffn cpp-expand-text text dict => string
+(define (cpp-expand-text text dict)
+  ;;(simple-format #t "cpp-expand-text: ~S\n" text)
+  (with-input-from-string text
+    (lambda () (scan-cpp-input '() dict '() #f))))
+
+;; @deffn expand-cpp-mref ident dict => repl|#f
+;; Given an identifier seen in C99 input, this checks for associated
+;; definition in @var{dict} (generated from CPP defines).  If found,
+;; the expansion is returned as a string.  If @var{ident} refers
+;; to a macro with arguments, then the arguments will be read from the
+;; current input.
+(define (expand-cpp-mref ident dict . rest)
+
+  (let ((used (if (pair? rest) (car rest) '()))
+       (rval (assoc-ref dict ident)))
+    (cond
+     ((not rval) #f)
+     ((member ident used) ident)
+     ((string? rval)
+      (let ((expd (expand-cpp-repl rval '() dict (cons ident used))))
+       ;;(simple-format #t "expand ~S => ~S\n" ident expd)
+       expd))
+     ((pair? rval)
+      (let* ((args (car rval)) (repl (cdr rval))
+            (argv (collect-args '() dict '()))
+            (argd (map cons args argv))
+            (expd (expand-cpp-repl repl argd dict (cons ident used))))
+       ;;(simple-format #t "expand ~S => ~S\n" ident expd)
+       expd)))))
+
+;;; --- last line ---
diff --git a/module/nyacc/lang/c99/cppmach.scm b/module/nyacc/lang/c99/cppmach.scm
new file mode 100644 (file)
index 0000000..4c4c776
--- /dev/null
@@ -0,0 +1,142 @@
+;;; lang/c99/cppmach.scm
+;;;
+;;; Copyright (C) 2015,2016 Matthew R. Wette
+;;;
+;;; This program is free software: you can redistribute it and/or modify
+;;; it under the terms of the GNU General Public License as published by 
+;;; the Free Software Foundation, either version 3 of the License, or 
+;;; (at your option) any later version.
+;;;
+;;; This program is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of 
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;; C preprocessor expression parser generator
+
+(define-module (nyacc lang c99 cppmach)
+  #:export (cpp-spec
+           cpp-mach
+           dev-parse-cpp-expr dev-eval-cpp-expr
+           gen-cpp-files)
+  #:use-module (nyacc lalr)
+  #:use-module (nyacc parse)
+  #:use-module (nyacc lex)
+  #:use-module (nyacc lang util)
+  #:use-module ((srfi srfi-43) #:select (vector-map))
+  #:use-module (rnrs arithmetic bitwise)
+  )
+
+(define cpp-spec
+  (lalr-spec
+   (notice lang-crn-lic)
+   (expect 0)
+   (start conditional-expression)
+   (grammar
+    (conditional-expression
+     (logical-or-expression)
+     (logical-or-expression "?" logical-or-expression ":" conditional-expression
+                           ($$ `(cond-expr ,$1 ,$3 ,$5))))
+    (logical-or-expression
+     (logical-and-expression)
+     (logical-or-expression "||" logical-and-expression ($$ `(or ,$1 ,$3))))
+    (logical-and-expression
+     (bitwise-or-expression)
+     (logical-and-expression "&&" bitwise-or-expression ($$ `(and ,$1 ,$3))))
+    (bitwise-or-expression
+     (bitwise-xor-expression)
+     (bitwise-or-expression "|" bitwise-xor-expression
+                           ($$ `(bitwise-or ,$1 ,$3))))
+    (bitwise-xor-expression
+     (bitwise-and-expression)
+     (bitwise-xor-expression "^" bitwise-and-expression
+                            ($$ `(bitwise-xor ,$1 ,$3))))
+    (bitwise-and-expression
+     (equality-expression)
+     (bitwise-and-expression "&" equality-expression
+                            ($$ `(bitwise-and ,$1 ,$3))))
+    (equality-expression
+     (relational-expression)
+     (equality-expression "==" relational-expression ($$ `(equal ,$1 ,$3)))
+     (equality-expression "!=" relational-expression ($$ `(noteq ,$1 ,$3))))
+    (relational-expression
+     (shift-expression)
+     (relational-expression "<" shift-expression ($$ `(lt ,$1 ,$3)))
+     (relational-expression "<=" shift-expression ($$ `(le ,$1 ,$3)))
+     (relational-expression ">" shift-expression ($$ `(gt ,$1 ,$3)))
+     (relational-expression ">=" shift-expression ($$ `(ge ,$1 ,$3))))
+    (shift-expression
+     (additive-expression)
+     (shift-expression "<<" additive-expression ($$ `(lshift ,$1 ,$3)))
+     (shift-expression ">>" additive-expression ($$ `(rshift ,$1 ,$3))))
+    (additive-expression
+     (multiplicative-expression)
+     (additive-expression "+" multiplicative-expression ($$ `(add ,$1 ,$3)))
+     (additive-expression "-" multiplicative-expression ($$ `(sub ,$1 ,$3))))
+    (multiplicative-expression
+     (unary-expression)
+     (multiplicative-expression "*" unary-expression ($$ `(mul ,$1 ,$3)))
+     (multiplicative-expression "/" unary-expression ($$ `(div ,$1 ,$3)))
+     (multiplicative-expression "%" unary-expression ($$ `(mod ,$1 ,$3))))
+    (unary-expression
+     (postfix-expression)
+     ("-" unary-expression ($$ `(neg ,$2)))
+     ("+" unary-expression ($$ `(pos ,$2)))
+     ("!" unary-expression ($$ `(not ,$2)))
+     ("~" unary-expression ($$ `(bitwise-not ,$2)))
+     ("++" unary-expression ($$ `(pre-inc ,$2)))
+     ("--" unary-expression ($$ `(pre-dec ,$2))))
+    (postfix-expression
+     (primary-expression)
+     (postfix-expression "++" ($$ `(post-inc ,$1)))
+     (postfix-expression "--" ($$ `(post-dec ,$1))))
+    (primary-expression
+     ;;($ident ($$ `(ident ,$1)))
+     ($fixed ($$ `(fixed ,$1)))        ; integer-constant
+     ($chlit ($$ `(char ,$1)))         ; char-constant
+     ("defined" "(" $ident ")" ($$ `(defined ,$3)))
+     ("(" expression-list ")" ($$ $2)))
+    (expression-list
+     (conditional-expression)
+     (expression-list "," conditional-expression ($$ $3)))
+    )))
+
+(define cpp-mach
+  (compact-machine
+   (hashify-machine
+    (make-lalr-machine cpp-spec))))
+
+(define mtab (assq-ref cpp-mach 'mtab))
+(define raw-parser (make-lalr-parser cpp-mach))
+
+(include-from-path "nyacc/lang/c99/cppbody.scm")
+
+(define dev-parse-cpp-expr parse-cpp-expr)
+(define dev-eval-cpp-expr eval-cpp-expr)
+
+;;; =====================================
+
+;; @item gen-cpp-files [dir] => #t
+;; Update or generate the files @quot{cppact.scm} and @quot{cpptab.scm}.
+;; If there are no changes to existing files, no update occurs.
+(define (gen-cpp-files . rest)
+  (define (lang-dir path)
+    (if (pair? rest) (string-append (car rest) "/" path) path))
+  (define (xtra-dir path)
+    (lang-dir (string-append "mach.d/" path)))
+
+  (write-lalr-actions cpp-mach (xtra-dir "cppact.scm.new"))
+  (write-lalr-tables cpp-mach (xtra-dir "cpptab.scm.new"))
+  (let ((a (move-if-changed (xtra-dir "cppact.scm.new")
+                           (xtra-dir "cppact.scm")))
+       (b (move-if-changed (xtra-dir "cpptab.scm.new")
+                           (xtra-dir "cpptab.scm"))))
+    (when (or a b) 
+      (system (string-append "touch " (lang-dir "cpp.scm")))
+      #;(compile-file (lang-dir "cpp.scm"))
+      )))
+
+;; --- last line ---
diff --git a/module/nyacc/lang/c99/mach.d/c99act.scm b/module/nyacc/lang/c99/mach.d/c99act.scm
new file mode 100644 (file)
index 0000000..78b845e
--- /dev/null
@@ -0,0 +1,762 @@
+;; ./mach.d/c99act.scm
+
+;; Copyright (C) 2015,2016 Matthew R. Wette
+;; 
+;; This software is covered by the GNU GENERAL PUBLIC LICENCE, Version 3,
+;; or any later version published by the Free Software Foundation.  See the
+;; file COPYING included with the this distribution.
+
+(define act-v
+  (vector
+   ;; $start => translation-unit-proxy
+   (lambda ($1 . $rest) $1)
+   ;; translation-unit-proxy => translation-unit
+   (lambda ($1 . $rest) (tl->list $1))
+   ;; primary-expression => identifier
+   (lambda ($1 . $rest) `(p-expr ,$1))
+   ;; primary-expression => constant
+   (lambda ($1 . $rest) `(p-expr ,$1))
+   ;; primary-expression => string-literal
+   (lambda ($1 . $rest) `(p-expr ,(tl->list $1)))
+   ;; primary-expression => "(" expression ")"
+   (lambda ($3 $2 $1 . $rest) $2)
+   ;; postfix-expression => primary-expression
+   (lambda ($1 . $rest) $1)
+   ;; postfix-expression => postfix-expression "[" expression "]"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(array-ref ,$3 ,$1))
+   ;; postfix-expression => postfix-expression "(" argument-expression-list...
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(fctn-call ,$1 ,(tl->list $3)))
+   ;; postfix-expression => postfix-expression "(" ")"
+   (lambda ($3 $2 $1 . $rest)
+     `(fctn-call ,$1 (expr-list)))
+   ;; postfix-expression => postfix-expression "." identifier
+   (lambda ($3 $2 $1 . $rest) `(d-sel ,$3 ,$1))
+   ;; postfix-expression => postfix-expression "->" identifier
+   (lambda ($3 $2 $1 . $rest) `(i-sel ,$3 ,$1))
+   ;; postfix-expression => postfix-expression "++"
+   (lambda ($2 $1 . $rest) `(post-inc ,$1))
+   ;; postfix-expression => postfix-expression "--"
+   (lambda ($2 $1 . $rest) `(post-dec ,$1))
+   ;; postfix-expression => "(" type-name ")" "{" initializer-list "}"
+   (lambda ($6 $5 $4 $3 $2 $1 . $rest)
+     `(comp-lit ,$2 ,(tl->list $5)))
+   ;; postfix-expression => "(" type-name ")" "{" initializer-list "," "}"
+   (lambda ($7 $6 $5 $4 $3 $2 $1 . $rest)
+     `(comp-lit ,$2 ,(tl->list $5)))
+   ;; argument-expression-list => assignment-expression
+   (lambda ($1 . $rest) (make-tl 'expr-list $1))
+   ;; argument-expression-list => argument-expression-list "," assignment-e...
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; argument-expression-list => arg-expr-hack
+   (lambda ($1 . $rest) (make-tl 'expr-list $1))
+   ;; argument-expression-list => argument-expression-list "," arg-expr-hack
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; arg-expr-hack => declaration-specifiers abstract-declarator
+   (lambda ($2 $1 . $rest)
+     `(param-decl ,(tl->list $1) $2))
+   ;; arg-expr-hack => declaration-specifiers
+   (lambda ($1 . $rest)
+     `(param-decl ,(tl->list $1)))
+   ;; unary-expression => postfix-expression
+   (lambda ($1 . $rest) $1)
+   ;; unary-expression => "++" unary-expression
+   (lambda ($2 $1 . $rest) `(pre-inc ,$2))
+   ;; unary-expression => "--" unary-expression
+   (lambda ($2 $1 . $rest) `(pre-dec ,$2))
+   ;; unary-expression => unary-operator cast-expression
+   (lambda ($2 $1 . $rest) (list $1 $2))
+   ;; unary-expression => "sizeof" unary-expression
+   (lambda ($2 $1 . $rest) `(sizeof-expr ,$2))
+   ;; unary-expression => "sizeof" "(" type-name ")"
+   (lambda ($4 $3 $2 $1 . $rest) `(sizeof-type ,$3))
+   ;; unary-operator => "&"
+   (lambda ($1 . $rest) 'ref-to)
+   ;; unary-operator => "*"
+   (lambda ($1 . $rest) 'de-ref)
+   ;; unary-operator => "+"
+   (lambda ($1 . $rest) 'pos)
+   ;; unary-operator => "-"
+   (lambda ($1 . $rest) 'neg)
+   ;; unary-operator => "~"
+   (lambda ($1 . $rest) 'bitwise-not)
+   ;; unary-operator => "!"
+   (lambda ($1 . $rest) 'not)
+   ;; cast-expression => unary-expression
+   (lambda ($1 . $rest) $1)
+   ;; cast-expression => "(" type-name ")" cast-expression
+   (lambda ($4 $3 $2 $1 . $rest) `(cast ,$2 ,$4))
+   ;; multiplicative-expression => cast-expression
+   (lambda ($1 . $rest) $1)
+   ;; multiplicative-expression => multiplicative-expression "*" cast-expre...
+   (lambda ($3 $2 $1 . $rest) `(mul ,$1 ,$3))
+   ;; multiplicative-expression => multiplicative-expression "/" cast-expre...
+   (lambda ($3 $2 $1 . $rest) `(div ,$1 ,$3))
+   ;; multiplicative-expression => multiplicative-expression "%" cast-expre...
+   (lambda ($3 $2 $1 . $rest) `(mod ,$1 ,$3))
+   ;; additive-expression => multiplicative-expression
+   (lambda ($1 . $rest) $1)
+   ;; additive-expression => additive-expression "+" multiplicative-expression
+   (lambda ($3 $2 $1 . $rest) `(add ,$1 ,$3))
+   ;; additive-expression => additive-expression "-" multiplicative-expression
+   (lambda ($3 $2 $1 . $rest) `(sub ,$1 ,$3))
+   ;; shift-expression => additive-expression
+   (lambda ($1 . $rest) $1)
+   ;; shift-expression => shift-expression "<<" additive-expression
+   (lambda ($3 $2 $1 . $rest) `(lshift ,$1 ,$3))
+   ;; shift-expression => shift-expression ">>" additive-expression
+   (lambda ($3 $2 $1 . $rest) `(rshift ,$1 ,$3))
+   ;; relational-expression => shift-expression
+   (lambda ($1 . $rest) $1)
+   ;; relational-expression => relational-expression "<" shift-expression
+   (lambda ($3 $2 $1 . $rest) `(lt ,$1 ,$3))
+   ;; relational-expression => relational-expression ">" shift-expression
+   (lambda ($3 $2 $1 . $rest) `(gt ,$1 ,$3))
+   ;; relational-expression => relational-expression "<=" shift-expression
+   (lambda ($3 $2 $1 . $rest) `(le ,$1 ,$3))
+   ;; relational-expression => relational-expression ">=" shift-expression
+   (lambda ($3 $2 $1 . $rest) `(ge ,$1 ,$3))
+   ;; equality-expression => relational-expression
+   (lambda ($1 . $rest) $1)
+   ;; equality-expression => equality-expression "==" relational-expression
+   (lambda ($3 $2 $1 . $rest) `(eq ,$1 ,$3))
+   ;; equality-expression => equality-expression "!=" relational-expression
+   (lambda ($3 $2 $1 . $rest) `(ne ,$1 ,$3))
+   ;; bitwise-and-expression => equality-expression
+   (lambda ($1 . $rest) $1)
+   ;; bitwise-and-expression => bitwise-and-expression "&" equality-expression
+   (lambda ($3 $2 $1 . $rest)
+     `(bitwise-and ,$1 ,$3))
+   ;; bitwise-xor-expression => bitwise-and-expression
+   (lambda ($1 . $rest) $1)
+   ;; bitwise-xor-expression => bitwise-xor-expression "^" bitwise-and-expr...
+   (lambda ($3 $2 $1 . $rest)
+     `(bitwise-xor ,$1 ,$3))
+   ;; bitwise-or-expression => bitwise-xor-expression
+   (lambda ($1 . $rest) $1)
+   ;; bitwise-or-expression => bitwise-or-expression "|" bitwise-xor-expres...
+   (lambda ($3 $2 $1 . $rest) `(bitwise-or ,$1 ,$3))
+   ;; logical-and-expression => bitwise-or-expression
+   (lambda ($1 . $rest) $1)
+   ;; logical-and-expression => logical-and-expression "&&" bitwise-or-expr...
+   (lambda ($3 $2 $1 . $rest) `(and ,$1 ,$3))
+   ;; logical-or-expression => logical-and-expression
+   (lambda ($1 . $rest) $1)
+   ;; logical-or-expression => logical-or-expression "||" logical-and-expre...
+   (lambda ($3 $2 $1 . $rest) `(or ,$1 ,$3))
+   ;; conditional-expression => logical-or-expression
+   (lambda ($1 . $rest) $1)
+   ;; conditional-expression => logical-or-expression "?" expression ":" co...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(cond-expr ,$1 ,$2 ,$3))
+   ;; assignment-expression => conditional-expression
+   (lambda ($1 . $rest) $1)
+   ;; assignment-expression => unary-expression assignment-operator assignm...
+   (lambda ($3 $2 $1 . $rest)
+     `(assn-expr ,$1 (op ,$2) ,$3))
+   ;; assignment-operator => "="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "+="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "-="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "*="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "/="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "%="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "<<="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => ">>="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "&="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "^="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "|="
+   (lambda ($1 . $rest) $1)
+   ;; expression => assignment-expression
+   (lambda ($1 . $rest) $1)
+   ;; expression => expression "," assignment-expression
+   (lambda ($3 $2 $1 . $rest)
+     (if (eqv? 'comma-expr (sx-tag $1))
+       (append $1 (list $3))
+       `(comma-expr ,$1 ,$3)))
+   ;; constant-expression => conditional-expression
+   (lambda ($1 . $rest) $1)
+   ;; declaration => declaration-specifiers init-declarator-list $P1 ";" op...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     (if (pair? $5) (append $3 (list $5)) $3))
+   ;; declaration => declaration-specifiers ";" opt-code-comment
+   (lambda ($3 $2 $1 . $rest)
+     (if (pair? $3)
+       `(decl ,(tl->list $1) ,(list $3))
+       `(decl ,(tl->list $1))))
+   ;; $P1 => 
+   (lambda ($2 $1 . $rest)
+     (save-typenames
+       `(decl ,(tl->list $1) ,(tl->list $2))))
+   ;; declaration-specifiers => storage-class-specifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; declaration-specifiers => storage-class-specifier declaration-specifiers
+   (lambda ($2 $1 . $rest) (tl-insert $2 $1))
+   ;; declaration-specifiers => type-specifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; declaration-specifiers => type-specifier declaration-specifiers
+   (lambda ($2 $1 . $rest) (tl-insert $2 $1))
+   ;; declaration-specifiers => type-qualifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; declaration-specifiers => type-qualifier declaration-specifiers
+   (lambda ($2 $1 . $rest) (tl-insert $2 $1))
+   ;; declaration-specifiers => function-specifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; declaration-specifiers => function-specifier declaration-specifiers
+   (lambda ($2 $1 . $rest) (tl-insert $2 $1))
+   ;; init-declarator-list => init-declarator
+   (lambda ($1 . $rest)
+     (make-tl 'init-declr-list $1))
+   ;; init-declarator-list => init-declarator-list "," init-declarator
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; init-declarator => declarator
+   (lambda ($1 . $rest) `(init-declr ,$1))
+   ;; init-declarator => declarator "=" initializer
+   (lambda ($3 $2 $1 . $rest) `(init-declr ,$1 ,$3))
+   ;; storage-class-specifier => "auto"
+   (lambda ($1 . $rest) '(stor-spec (auto)))
+   ;; storage-class-specifier => "extern"
+   (lambda ($1 . $rest) '(stor-spec (extern)))
+   ;; storage-class-specifier => "register"
+   (lambda ($1 . $rest) '(stor-spec (register)))
+   ;; storage-class-specifier => "static"
+   (lambda ($1 . $rest) '(stor-spec (static)))
+   ;; storage-class-specifier => "typedef"
+   (lambda ($1 . $rest) '(stor-spec (typedef)))
+   ;; type-specifier => "void"
+   (lambda ($1 . $rest) '(type-spec (void)))
+   ;; type-specifier => fixed-type-specifier
+   (lambda ($1 . $rest) `(type-spec ,$1))
+   ;; type-specifier => float-type-specifier
+   (lambda ($1 . $rest) `(type-spec ,$1))
+   ;; type-specifier => "_Bool"
+   (lambda ($1 . $rest)
+     '(type-spec (fixed-type "_Bool")))
+   ;; type-specifier => complex-type-specifier
+   (lambda ($1 . $rest) `(type-spec ,$1))
+   ;; type-specifier => struct-or-union-specifier
+   (lambda ($1 . $rest) `(type-spec ,$1))
+   ;; type-specifier => enum-specifier
+   (lambda ($1 . $rest) `(type-spec ,$1))
+   ;; type-specifier => typedef-name
+   (lambda ($1 . $rest) `(type-spec ,$1))
+   ;; fixed-type-specifier => "short"
+   (lambda ($1 . $rest) '(fixed-type "short"))
+   ;; fixed-type-specifier => "short" "int"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "short int"))
+   ;; fixed-type-specifier => "signed" "short"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "signed short"))
+   ;; fixed-type-specifier => "signed" "short" "int"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "signed short int"))
+   ;; fixed-type-specifier => "int"
+   (lambda ($1 . $rest) '(fixed-type "int"))
+   ;; fixed-type-specifier => "signed"
+   (lambda ($1 . $rest) '(fixed-type "signed"))
+   ;; fixed-type-specifier => "signed" "int"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "signed int"))
+   ;; fixed-type-specifier => "long"
+   (lambda ($1 . $rest) '(fixed-type "long"))
+   ;; fixed-type-specifier => "long" "int"
+   (lambda ($2 $1 . $rest) '(fixed-type "long int"))
+   ;; fixed-type-specifier => "signed" "long"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "signed long"))
+   ;; fixed-type-specifier => "signed" "long" "int"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "signed long int"))
+   ;; fixed-type-specifier => "long" "long"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "long long"))
+   ;; fixed-type-specifier => "long" "long" "int"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "long long int"))
+   ;; fixed-type-specifier => "signed" "long" "long"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "signed long long"))
+   ;; fixed-type-specifier => "signed" "long" "long" "int"
+   (lambda ($4 $3 $2 $1 . $rest)
+     '(fixed-type "signed long long int"))
+   ;; fixed-type-specifier => "unsigned" "short" "int"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "unsigned short int"))
+   ;; fixed-type-specifier => "unsigned" "short"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "unsigned short"))
+   ;; fixed-type-specifier => "unsigned" "int"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "unsigned int"))
+   ;; fixed-type-specifier => "unsigned"
+   (lambda ($1 . $rest) '(fixed-type "unsigned"))
+   ;; fixed-type-specifier => "unsigned" "long" "int"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "unsigned long"))
+   ;; fixed-type-specifier => "unsigned" "long"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "unsigned long"))
+   ;; fixed-type-specifier => "unsigned" "long" "long" "int"
+   (lambda ($4 $3 $2 $1 . $rest)
+     '(fixed-type "unsigned long long int"))
+   ;; fixed-type-specifier => "unsigned" "long" "long"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "unsigned long long"))
+   ;; fixed-type-specifier => "char"
+   (lambda ($1 . $rest) '(fixed-type "char"))
+   ;; fixed-type-specifier => "signed" "char"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "signed char"))
+   ;; fixed-type-specifier => "unsigned" "char"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "unsigned char"))
+   ;; float-type-specifier => "float"
+   (lambda ($1 . $rest) '(float-type "float"))
+   ;; float-type-specifier => "double"
+   (lambda ($1 . $rest) '(float-type "double"))
+   ;; float-type-specifier => "long" "double"
+   (lambda ($2 $1 . $rest)
+     '(float-type "long double"))
+   ;; complex-type-specifier => "_Complex"
+   (lambda ($1 . $rest) '(complex-type "_Complex"))
+   ;; complex-type-specifier => "float" "_Complex"
+   (lambda ($2 $1 . $rest)
+     '(complex-type "float _Complex"))
+   ;; complex-type-specifier => "double" "_Complex"
+   (lambda ($2 $1 . $rest)
+     '(complex-type "double _Complex"))
+   ;; complex-type-specifier => "long" "double" "_Complex"
+   (lambda ($3 $2 $1 . $rest)
+     '(complex-type "long double _Complex"))
+   ;; struct-or-union-specifier => "struct" ident-like "{" struct-declarati...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(struct-def ,$2 ,(tl->list $4)))
+   ;; struct-or-union-specifier => "struct" "{" struct-declaration-list "}"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(struct-def ,(tl->list $3)))
+   ;; struct-or-union-specifier => "struct" ident-like
+   (lambda ($2 $1 . $rest) `(struct-ref ,$2))
+   ;; struct-or-union-specifier => "union" ident-like "{" struct-declaratio...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(union-def ,$2 ,(tl->list $4)))
+   ;; struct-or-union-specifier => "union" "{" struct-declaration-list "}"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(union-def ,(tl->list $3)))
+   ;; struct-or-union-specifier => "union" ident-like
+   (lambda ($2 $1 . $rest) `(union-ref ,$2))
+   ;; ident-like => identifier
+   (lambda ($1 . $rest) $1)
+   ;; ident-like => typedef-name
+   (lambda ($1 . $rest) `(ident ,(cdr $1)))
+   ;; struct-declaration-list => struct-declaration
+   (lambda ($1 . $rest) (make-tl 'field-list $1))
+   ;; struct-declaration-list => lone-comment
+   (lambda ($1 . $rest) (make-tl 'field-list $1))
+   ;; struct-declaration-list => struct-declaration-list struct-declaration
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; struct-declaration-list => struct-declaration-list lone-comment
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; struct-declaration => specifier-qualifier-list struct-declarator-list...
+   (lambda ($4 $3 $2 $1 . $rest)
+     (if (pair? $4)
+       `(comp-decl ,(tl->list $1) ,(tl->list $2) ,$4)
+       `(comp-decl ,(tl->list $1) ,(tl->list $2))))
+   ;; specifier-qualifier-list => type-specifier specifier-qualifier-list
+   (lambda ($2 $1 . $rest) (tl-insert $2 $1))
+   ;; specifier-qualifier-list => type-specifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; specifier-qualifier-list => type-qualifier specifier-qualifier-list
+   (lambda ($2 $1 . $rest) (tl-insert $2 $1))
+   ;; specifier-qualifier-list => type-qualifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; struct-declarator-list => struct-declarator
+   (lambda ($1 . $rest)
+     (make-tl 'comp-declr-list $1))
+   ;; struct-declarator-list => struct-declarator-list "," struct-declarator
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; struct-declarator => declarator
+   (lambda ($1 . $rest) `(comp-declr ,$1))
+   ;; struct-declarator => declarator ":" constant-expression
+   (lambda ($3 $2 $1 . $rest)
+     `(comp-declr (bit-field ,$1 ,$3)))
+   ;; struct-declarator => ":" constant-expression
+   (lambda ($2 $1 . $rest)
+     `(comp-declr (bit-field ,$2)))
+   ;; enum-specifier => "enum" identifier "{" enumerator-list "}"
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(enum-def ,$2 ,(tl->list $4)))
+   ;; enum-specifier => "enum" identifier "{" enumerator-list "," "}"
+   (lambda ($6 $5 $4 $3 $2 $1 . $rest)
+     `(enum-def ,$2 ,(tl->list $4)))
+   ;; enum-specifier => "enum" "{" enumerator-list "}"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(enum-def ,(tl->list $3)))
+   ;; enum-specifier => "enum" "{" enumerator-list "," "}"
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(enum-def ,(tl->list $3)))
+   ;; enum-specifier => "enum" identifier
+   (lambda ($2 $1 . $rest) `(enum-ref ,$2))
+   ;; enumerator-list => enumerator
+   (lambda ($1 . $rest) (make-tl 'enum-def-list $1))
+   ;; enumerator-list => enumerator-list "," enumerator
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; enumerator => identifier
+   (lambda ($1 . $rest) `(enum-defn ,$1))
+   ;; enumerator => identifier "=" constant-expression
+   (lambda ($3 $2 $1 . $rest) `(enum-defn ,$1 ,$3))
+   ;; type-qualifier => "const"
+   (lambda ($1 . $rest) `(type-qual ,$1))
+   ;; type-qualifier => "volatile"
+   (lambda ($1 . $rest) `(type-qual ,$1))
+   ;; type-qualifier => "restrict"
+   (lambda ($1 . $rest) `(type-qual ,$1))
+   ;; function-specifier => "inline"
+   (lambda ($1 . $rest) `(fctn-spec ,$1))
+   ;; declarator => pointer direct-declarator
+   (lambda ($2 $1 . $rest) `(ptr-declr ,$1 ,$2))
+   ;; declarator => direct-declarator
+   (lambda ($1 . $rest) $1)
+   ;; direct-declarator => identifier
+   (lambda ($1 . $rest) $1)
+   ;; direct-declarator => "(" declarator ")"
+   (lambda ($3 $2 $1 . $rest) `(scope ,$2))
+   ;; direct-declarator => direct-declarator "[" type-qualifier-list assign...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(array-of ,$1 ,$3 ,$4))
+   ;; direct-declarator => direct-declarator "[" type-qualifier-list "]"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(array-of ,$1 ,$3))
+   ;; direct-declarator => direct-declarator "[" assignment-expression "]"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(array-of ,$1 ,$3))
+   ;; direct-declarator => direct-declarator "[" "]"
+   (lambda ($3 $2 $1 . $rest) `(array-of ,$1))
+   ;; direct-declarator => direct-declarator "[" "static" type-qualifier-li...
+   (lambda ($6 $5 $4 $3 $2 $1 . $rest)
+     `(array-of
+        ,$1
+        ,(tl->list (tl-insert '(stor-spec "static") $4))
+        ,$5))
+   ;; direct-declarator => direct-declarator "[" type-qualifier-list "stati...
+   (lambda ($6 $5 $4 $3 $2 $1 . $rest)
+     `(array-of
+        ,$1
+        ,(tl->list (tl-insert '(stor-spec "static") $3))
+        ,$5))
+   ;; direct-declarator => direct-declarator "[" type-qualifier-list "*" "]"
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(array-of ,$1 ,$3 (var-len)))
+   ;; direct-declarator => direct-declarator "[" "*" "]"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(array-of ,$1 (var-len)))
+   ;; direct-declarator => direct-declarator "(" parameter-type-list ")"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(ftn-declr ,$1 ,(tl->list $3)))
+   ;; direct-declarator => direct-declarator "(" identifier-list ")"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(ftn-declr ,$1 ,(tl->list $3)))
+   ;; direct-declarator => direct-declarator "(" ")"
+   (lambda ($3 $2 $1 . $rest)
+     `(ftn-declr ,$1 (param-list)))
+   ;; pointer => "*" type-qualifier-list
+   (lambda ($2 $1 . $rest)
+     `(pointer ,(tl->list $2)))
+   ;; pointer => "*"
+   (lambda ($1 . $rest) '(pointer))
+   ;; pointer => "*" type-qualifier-list pointer
+   (lambda ($3 $2 $1 . $rest)
+     `(pointer ,(tl->list $2) ,$3))
+   ;; pointer => "*" pointer
+   (lambda ($2 $1 . $rest) `(pointer ,$2))
+   ;; type-qualifier-list => type-qualifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; type-qualifier-list => type-qualifier-list type-qualifier
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; parameter-type-list => parameter-list
+   (lambda ($1 . $rest) $1)
+   ;; parameter-type-list => parameter-list "," "..."
+   (lambda ($3 $2 $1 . $rest)
+     (tl-append $1 '(ellipis)))
+   ;; parameter-list => parameter-declaration
+   (lambda ($1 . $rest) (make-tl 'param-list $1))
+   ;; parameter-list => parameter-list "," parameter-declaration
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; parameter-declaration => declaration-specifiers declarator
+   (lambda ($2 $1 . $rest)
+     `(param-decl ,(tl->list $1) (param-declr ,$2)))
+   ;; parameter-declaration => declaration-specifiers abstract-declarator
+   (lambda ($2 $1 . $rest)
+     `(param-decl ,(tl->list $1) (param-declr ,$2)))
+   ;; parameter-declaration => declaration-specifiers
+   (lambda ($1 . $rest)
+     `(param-decl ,(tl->list $1)))
+   ;; identifier-list => identifier
+   (lambda ($1 . $rest) (make-tl 'ident-list $1))
+   ;; identifier-list => identifier-list "," identifier
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; type-name => specifier-qualifier-list abstract-declarator
+   (lambda ($2 $1 . $rest)
+     `(type-name ,(tl->list $1) ,$2))
+   ;; type-name => declaration-specifiers
+   (lambda ($1 . $rest) `(type-name ,(tl->list $1)))
+   ;; abstract-declarator => pointer
+   (lambda ($1 . $rest) `(abs-declr ,$1))
+   ;; abstract-declarator => pointer direct-abstract-declarator
+   (lambda ($2 $1 . $rest) `(abs-declr ,$1 ,$2))
+   ;; abstract-declarator => direct-abstract-declarator
+   (lambda ($1 . $rest) `(abs-declr ,$1))
+   ;; direct-abstract-declarator => "(" abstract-declarator ")"
+   (lambda ($3 $2 $1 . $rest) `(declr-scope ,$2))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" type-qua...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(declr-array ,$3 ,$4))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" type-qua...
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(declr-array ,$1 ,$3))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" assignme...
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(declr-array ,$1 ,$3))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" "]"
+   (lambda ($3 $2 $1 . $rest) `(declr-array ,$1))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" "static"...
+   (lambda ($6 $5 $4 $3 $2 $1 . $rest)
+     `(declr-array
+        ,$1
+        ,(tl->list (tl-insert '(stor-spec "static") $4))
+        ,$5))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" "static"...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(declr-array
+        ,$1
+        ,(tl->list (tl-insert '(stor-spec "static") $4))))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" type-qua...
+   (lambda ($6 $5 $4 $3 $2 $1 . $rest)
+     `(declr-array
+        ,$1
+        ,(tl->list (tl-insert '(stor-spec "static") $3))
+        ,$5))
+   ;; direct-abstract-declarator => "[" type-qualifier-list assignment-expr...
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(declr-anon-array ,$2 ,$3))
+   ;; direct-abstract-declarator => "[" type-qualifier-list "]"
+   (lambda ($3 $2 $1 . $rest)
+     `(declr-anon-array ,$2))
+   ;; direct-abstract-declarator => "[" assignment-expression "]"
+   (lambda ($3 $2 $1 . $rest)
+     `(declr-anon-array ,$2))
+   ;; direct-abstract-declarator => "[" "]"
+   (lambda ($2 $1 . $rest) `(declr-anon-array))
+   ;; direct-abstract-declarator => "[" "static" type-qualifier-list assign...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(declr-anon-array
+        ,(tl->list (tl-insert '(stor-spec "static") $3))
+        ,$4))
+   ;; direct-abstract-declarator => "[" "static" type-qualifier-list "]"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(declr-anon-array
+        ,(tl->list (tl-insert '(stor-spec "static") $3))))
+   ;; direct-abstract-declarator => "[" type-qualifier-list "static" assign...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(declr-anon-array
+        ,(tl->list (tl-insert '(stor-spec "static") $2))
+        ,$4))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" "*" "]"
+   (lambda ($4 $3 $2 $1 . $rest) `(declr-STAR ,$1))
+   ;; direct-abstract-declarator => "[" "*" "]"
+   (lambda ($3 $2 $1 . $rest) '(declr-STAR))
+   ;; direct-abstract-declarator => direct-abstract-declarator "(" paramete...
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(declr-fctn ,$1 ,(tl->list $3)))
+   ;; direct-abstract-declarator => direct-abstract-declarator "(" ")"
+   (lambda ($3 $2 $1 . $rest) `(declr-fctn ,$1))
+   ;; direct-abstract-declarator => "(" parameter-type-list ")"
+   (lambda ($3 $2 $1 . $rest)
+     `(declr-anon-fctn ,(tl->list $2)))
+   ;; direct-abstract-declarator => "(" ")"
+   (lambda ($2 $1 . $rest) '(declr-anon-fctn))
+   ;; typedef-name => 'typename
+   (lambda ($1 . $rest) `(typename ,$1))
+   ;; initializer => assignment-expression
+   (lambda ($1 . $rest) `(initzer ,$1))
+   ;; initializer => "{" initializer-list "}"
+   (lambda ($3 $2 $1 . $rest)
+     `(initzer ,(tl->list $2)))
+   ;; initializer => "{" initializer-list "," "}"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(initzer ,(tl->list $2)))
+   ;; initializer-list => designation initializer
+   (lambda ($2 $1 . $rest)
+     (make-tl 'initzer-list $1 $2))
+   ;; initializer-list => initializer
+   (lambda ($1 . $rest) (make-tl 'initzer-list $1))
+   ;; initializer-list => initializer-list "," designation initializer
+   (lambda ($4 $3 $2 $1 . $rest)
+     (tl-append $1 $3 $4))
+   ;; initializer-list => initializer-list "," initializer
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; designation => designator-list "="
+   (lambda ($2 $1 . $rest) `(desig ,$1))
+   ;; designator-list => designator
+   (lambda ($1 . $rest) (make-tl 'desgr-list $1))
+   ;; designator-list => designator-list designator
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; designator => "[" constant-expression "]"
+   (lambda ($3 $2 $1 . $rest) (list 'array-dsgr $2))
+   ;; designator => "." identifier
+   (lambda ($2 $1 . $rest) (list 'sel-dsgr $2))
+   ;; statement => labeled-statement
+   (lambda ($1 . $rest) $1)
+   ;; statement => compound-statement
+   (lambda ($1 . $rest) $1)
+   ;; statement => expression-statement
+   (lambda ($1 . $rest) $1)
+   ;; statement => selection-statement
+   (lambda ($1 . $rest) $1)
+   ;; statement => iteration-statement
+   (lambda ($1 . $rest) $1)
+   ;; statement => jump-statement
+   (lambda ($1 . $rest) $1)
+   ;; statement => cpp-statement
+   (lambda ($1 . $rest) $1)
+   ;; labeled-statement => identifier ":" statement
+   (lambda ($3 $2 $1 . $rest)
+     `(labeled-stmt ,$1 ,$3))
+   ;; labeled-statement => "case" constant-expression ":" statement
+   (lambda ($4 $3 $2 $1 . $rest) `(case ,$2 ,$4))
+   ;; labeled-statement => "default" ":" statement
+   (lambda ($3 $2 $1 . $rest) `(default ,$3))
+   ;; compound-statement => "{" block-item-list "}"
+   (lambda ($3 $2 $1 . $rest)
+     `(compd-stmt ,(tl->list $2)))
+   ;; compound-statement => "{" "}"
+   (lambda ($2 $1 . $rest)
+     `(compd-stmt (block-item-list)))
+   ;; block-item-list => block-item
+   (lambda ($1 . $rest)
+     (make-tl 'block-item-list $1))
+   ;; block-item-list => block-item-list block-item
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; block-item => declaration
+   (lambda ($1 . $rest) $1)
+   ;; block-item => statement
+   (lambda ($1 . $rest) $1)
+   ;; expression-statement => expression ";"
+   (lambda ($2 $1 . $rest) `(expr-stmt ,$1))
+   ;; expression-statement => ";"
+   (lambda ($1 . $rest) '(expr-stmt))
+   ;; selection-statement => "if" "(" expression ")" statement
+   (lambda ($5 $4 $3 $2 $1 . $rest) `(if ,$3 ,$5))
+   ;; selection-statement => "if" "(" expression ")" statement "else" state...
+   (lambda ($7 $6 $5 $4 $3 $2 $1 . $rest)
+     `(if ,$3 ,$5 ,$7))
+   ;; selection-statement => "switch" "(" expression ")" statement
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(switch ,$3 ,$5))
+   ;; iteration-statement => "while" "(" expression ")" statement
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(while ,$3 ,$5))
+   ;; iteration-statement => "do" statement "while" "(" expression ")" ";"
+   (lambda ($7 $6 $5 $4 $3 $2 $1 . $rest)
+     `(do-while ,$2 ,$5))
+   ;; iteration-statement => "for" "(" initial-clause opt-expression ";" op...
+   (lambda ($8 $7 $6 $5 $4 $3 $2 $1 . $rest)
+     `(for ,$3 ,$4 ,$6 ,$8))
+   ;; initial-clause => expression ";"
+   (lambda ($2 $1 . $rest) $1)
+   ;; initial-clause => ";"
+   (lambda ($1 . $rest) '(expr))
+   ;; initial-clause => declaration
+   (lambda ($1 . $rest) $1)
+   ;; opt-expression => 
+   (lambda $rest '(expr))
+   ;; opt-expression => expression
+   (lambda ($1 . $rest) $1)
+   ;; jump-statement => "goto" identifier ";"
+   (lambda ($3 $2 $1 . $rest) `(goto $2))
+   ;; jump-statement => "continue" ";"
+   (lambda ($2 $1 . $rest) '(continue))
+   ;; jump-statement => "break" ";"
+   (lambda ($2 $1 . $rest) '(break))
+   ;; jump-statement => "return" expression ";"
+   (lambda ($3 $2 $1 . $rest) `(return ,$2))
+   ;; jump-statement => "return" ";"
+   (lambda ($2 $1 . $rest) `(return (expr)))
+   ;; translation-unit => external-declaration
+   (lambda ($1 . $rest) (make-tl 'trans-unit $1))
+   ;; translation-unit => translation-unit external-declaration
+   (lambda ($2 $1 . $rest)
+     (cond ((eqv? 'trans-unit (car $2))
+            (let* ((t1 (tl-append $1 '(extern-C-begin)))
+                   (t2 (tl-extend t1 (cdr $2)))
+                   (t3 (tl-append t2 '(extern-C-end))))
+              t3))
+           (else (tl-append $1 $2))))
+   ;; external-declaration => function-definition
+   (lambda ($1 . $rest) $1)
+   ;; external-declaration => declaration
+   (lambda ($1 . $rest) $1)
+   ;; external-declaration => lone-comment
+   (lambda ($1 . $rest) $1)
+   ;; external-declaration => cpp-statement
+   (lambda ($1 . $rest) $1)
+   ;; external-declaration => "extern" '$string "{" translation-unit "}"
+   (lambda ($5 $4 $3 $2 $1 . $rest) (tl->list $4))
+   ;; function-definition => declaration-specifiers declarator declaration-...
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(knr-fctn-defn
+        ,(tl->list $1)
+        ,$2
+        ,(tl->list $3)
+        ,$4))
+   ;; function-definition => declaration-specifiers declarator compound-sta...
+   (lambda ($3 $2 $1 . $rest)
+     `(fctn-defn ,(tl->list $1) ,$2 ,$3))
+   ;; declaration-list => declaration
+   (lambda ($1 . $rest) (make-tl $1))
+   ;; declaration-list => declaration-list declaration
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; opt-code-comment => 
+   (lambda $rest (list))
+   ;; opt-code-comment => code-comment
+   (lambda ($1 . $rest) $1)
+   ;; identifier => '$ident
+   (lambda ($1 . $rest) `(ident ,$1))
+   ;; identifier => 'cpp-ident
+   (lambda ($1 . $rest) `(ident ,$1))
+   ;; constant => '$fixed
+   (lambda ($1 . $rest) `(fixed ,$1))
+   ;; constant => '$float
+   (lambda ($1 . $rest) `(float ,$1))
+   ;; constant => '$chlit
+   (lambda ($1 . $rest) `(char ,$1))
+   ;; string-literal => '$string
+   (lambda ($1 . $rest) (make-tl 'string $1))
+   ;; string-literal => string-literal '$string
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; code-comment => '$code-comm
+   (lambda ($1 . $rest) `(comment ,$1))
+   ;; lone-comment => '$lone-comm
+   (lambda ($1 . $rest) `(comment ,$1))
+   ;; cpp-statement => 'cpp-stmt
+   (lambda ($1 . $rest) `(cpp-stmt ,$1))
+   ))
+
+;;; end tables
diff --git a/module/nyacc/lang/c99/mach.d/c99tab.scm b/module/nyacc/lang/c99/mach.d/c99tab.scm
new file mode 100644 (file)
index 0000000..b6a93d8
--- /dev/null
@@ -0,0 +1,812 @@
+;; ./mach.d/c99tab.scm
+
+;; Copyright (C) 2015,2016 Matthew R. Wette
+;; 
+;; This software is covered by the GNU GENERAL PUBLIC LICENCE, Version 3,
+;; or any later version published by the Free Software Foundation.  See the
+;; file COPYING included with the this distribution.
+
+(define len-v
+  #(1 1 1 1 1 3 1 4 4 3 3 3 2 2 6 7 1 3 1 3 2 1 1 2 2 2 2 4 1 1 1 1 1 1 1 4 
+    1 3 3 3 1 3 3 1 3 3 1 3 3 3 3 1 3 3 1 3 1 3 1 3 1 3 1 3 1 5 1 3 1 1 1 1 1 
+    1 1 1 1 1 1 1 3 1 5 3 0 1 2 1 2 1 2 1 2 1 3 1 3 1 1 1 1 1 1 1 1 1 1 1 1 1 
+    1 2 2 3 1 1 2 1 2 2 3 2 3 3 4 3 2 2 1 3 2 4 3 1 2 2 1 1 2 1 2 2 3 5 4 2 5 
+    4 2 1 1 1 1 2 2 4 2 1 2 1 1 3 1 3 2 5 6 4 5 2 1 3 1 3 1 1 1 1 2 1 1 3 5 4 
+    4 3 6 6 5 4 4 4 3 2 1 3 2 1 2 1 3 1 3 2 2 1 1 3 2 1 1 2 1 3 5 4 4 3 6 5 6 
+    4 3 3 2 5 4 5 4 3 4 3 3 2 1 1 3 4 2 1 4 3 2 1 2 3 2 1 1 1 1 1 1 1 3 4 3 3 
+    2 1 2 1 1 2 1 5 7 5 5 7 8 2 1 1 0 1 3 2 2 3 2 1 2 1 1 1 1 5 4 3 1 2 0 1 1 
+    1 1 1 1 1 2 1 1 1))
+
+(define pat-v
+  #(((21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8)
+    (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 13) (23 . 14) (24 . 15) (25 
+    . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 20) (138 . 21) (40 . 22) (139
+    . 23) (140 . 24) (41 . 25) (42 . 26) (43 . 27) (44 . 28) (46 . 29) (144 
+    . 30) (145 . 31) (146 . 32) (147 . 33) (1 . 34) (94 . 35) (167 . 36) (45 
+    . 37) (107 . 38) (131 . 39) (103 . 40) (99 . 41) (100 . 42) (179 . 43) (
+    180 . 44)) ((-1 . -234)) ((84 . 83) (5 . 50) (6 . 51) (178 . 84)) ((84 . 
+    81) (5 . 50) (6 . 51) (21 . 1) (135 . 78) (178 . 79) (134 . 82)) ((84 . 77
+    ) (5 . 50) (6 . 51) (21 . 1) (135 . 78) (178 . 79) (134 . 80)) ((-1 . -139
+    )) ((30 . 76) (-1 . -137)) ((30 . 75) (-1 . -136)) ((-1 . -133)) ((39 . 71
+    ) (37 . 72) (35 . 73) (33 . 74) (-1 . -128)) ((37 . 68) (35 . 69) (31 . 70
+    ) (-1 . -117)) ((-1 . -114)) ((39 . 64) (37 . 65) (35 . 66) (33 . 67) (-1 
+    . -115)) ((37 . 63) (-1 . -110)) ((-1 . -177)) ((-1 . -176)) ((-1 . -175))
+    ((-1 . -174)) ((-1 . -109)) ((-1 . -108)) ((-1 . -107)) ((-1 . -106)) ((
+    -1 . -105)) ((-1 . -104)) ((-1 . -103)) ((-1 . -102)) ((-1 . -101)) ((-1 
+    . -100)) ((-1 . -99)) ((-1 . -97)) ((21 . 1) (27 . 2) (28 . 3) (29 . 4) (
+    30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) 
+    (39 . 13) (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (
+    137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (42 . 26) (
+    43 . 27) (44 . 28) (45 . 58) (46 . 29) (144 . 30) (145 . 31) (146 . 32) (
+    147 . 33) (167 . 62) (-1 . -91)) ((21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 
+    . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39
+    . 13) (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 
+    . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (42 . 26) (43 
+    . 27) (44 . 28) (45 . 58) (46 . 29) (144 . 30) (145 . 31) (146 . 32) (147 
+    . 33) (167 . 61) (-1 . -89)) ((21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5)
+    (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 
+    13) (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 
+    20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (42 . 26) (43 . 
+    27) (44 . 28) (45 . 58) (46 . 29) (144 . 30) (145 . 31) (146 . 32) (147 . 
+    33) (167 . 60) (-1 . -87)) ((21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (
+    31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 13)
+    (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 20) 
+    (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (42 . 26) (43 . 27) (
+    44 . 28) (45 . 58) (46 . 29) (144 . 30) (145 . 31) (146 . 32) (147 . 33) (
+    167 . 59) (-1 . -85)) ((94 . -303) (-1 . -303)) ((94 . -302) (-1 . -302)) 
+    ((143 . 47) (150 . 48) (47 . 49) (5 . 50) (6 . 51) (79 . 52) (92 . 53) (
+    178 . 54) (123 . 55) (124 . 56) (142 . 57)) ((7 . 46) (-1 . -98)) ((94 . 
+    -286) (-1 . -286)) ((94 . -285) (-1 . -285)) ((94 . -284) (-1 . -284)) ((
+    94 . -283) (-1 . -283)) ((94 . -281) (-1 . -281)) ((21 . 1) (27 . 2) (28 
+    . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 
+    . 11) (36 . 12) (39 . 13) (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 
+    18) (136 . 19) (137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 
+    . 25) (42 . 26) (43 . 27) (44 . 28) (46 . 29) (144 . 30) (145 . 31) (146 
+    . 32) (147 . 33) (1 . 34) (94 . 35) (167 . 36) (45 . 37) (107 . 38) (131 
+    . 39) (103 . 40) (99 . 41) (100 . 45) (96 . -1)) ((96 . 0)) ((94 . -282) (
+    -1 . -282)) ((84 . 124)) ((47 . -93) (82 . -93)) ((149 . 122) (82 . 123) (
+    47 . -84)) ((93 . 119) (97 . 120) (148 . 121) (94 . -292) (-1 . -292)) ((
+    -1 . -295)) ((-1 . -294)) ((24 . 15) (25 . 16) (26 . 17) (145 . 116) (122 
+    . 117) (79 . 52) (124 . 118) (-1 . -194)) ((5 . 50) (6 . 51) (79 . 52) (92
+    . 53) (178 . 54) (123 . 55) (124 . 56) (142 . 115)) ((-1 . -180)) ((90 . 
+    113) (92 . 114) (-1 . -179)) ((5 . 50) (6 . 51) (92 . 53) (178 . 54) (123 
+    . 112)) ((84 . 106) (112 . 107) (21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 
+    5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 
+    . 13) (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 
+    . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (42 . 26) (43 
+    . 27) (44 . 28) (45 . 58) (46 . 29) (144 . 30) (145 . 31) (146 . 32) (147 
+    . 33) (167 . 108) (103 . 109) (98 . 110) (58 . 111) (47 . -95) (82 . -95))
+    ((-1 . -98)) ((-1 . -86)) ((-1 . -88)) ((-1 . -90)) ((-1 . -92)) ((-1 . 
+    -111)) ((37 . 105) (-1 . -112)) ((-1 . -116)) ((35 . 103) (37 . 104) (-1 
+    . -119)) ((-1 . -134)) ((-1 . -118)) ((37 . 102) (-1 . -121)) ((30 . 101) 
+    (-1 . -138)) ((37 . 100) (-1 . -126)) ((-1 . -127)) ((35 . 98) (37 . 99) (
+    -1 . -130)) ((-1 . -135)) ((-1 . -140)) ((-1 . -141)) ((21 . 1) (27 . 2) (
+    28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (
+    37 . 11) (36 . 12) (39 . 13) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136
+    . 19) (137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (
+    145 . 90) (146 . 91) (94 . 35) (130 . 92) (131 . 93) (132 . 94) (133 . 97)
+    ) ((-1 . -150)) ((-1 . -149)) ((84 . 96) (-1 . -145)) ((21 . 1) (27 . 2) (
+    28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (
+    37 . 11) (36 . 12) (39 . 13) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136
+    . 19) (137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (
+    145 . 90) (146 . 91) (94 . 35) (130 . 92) (131 . 93) (132 . 94) (133 . 95)
+    ) ((84 . 89) (-1 . -148)) ((5 . 50) (6 . 51) (178 . 86) (125 . 87) (126 . 
+    88)) ((84 . 85) (-1 . -169)) ((5 . 50) (6 . 51) (178 . 86) (125 . 87) (126
+    . 226)) ((58 . 225) (83 . -172) (82 . -172)) ((83 . -170) (82 . -170)) ((
+    83 . 223) (82 . 224)) ((21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 
+    6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 13) (24 
+    . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 20) (138 . 21) (40 
+    . 22) (139 . 23) (140 . 24) (41 . 25) (145 . 90) (146 . 91) (94 . 35) (130
+    . 92) (131 . 93) (132 . 94) (133 . 222)) ((21 . 1) (27 . 2) (28 . 3) (29 
+    . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 
+    . 12) (39 . 13) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 
+    . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (145 . 90) (146
+    . 91) (130 . 221) (-1 . -159)) ((21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 
+    . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39
+    . 13) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 20) (138
+    . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (145 . 90) (146 . 91) (
+    130 . 220) (-1 . -157)) ((5 . 50) (6 . 51) (79 . 52) (92 . 53) (178 . 54) 
+    (123 . 55) (124 . 56) (59 . 216) (142 . 217) (128 . 218) (129 . 219)) ((94
+    . -152) (-1 . -152)) ((94 . -151) (-1 . -151)) ((83 . 215) (21 . 1) (27 
+    . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 
+    10) (37 . 11) (36 . 12) (39 . 13) (24 . 15) (25 . 16) (26 . 17) (135 . 18)
+    (136 . 19) (137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25
+    ) (145 . 90) (146 . 91) (130 . 92) (132 . 212) (94 . 35) (131 . 213)) ((21
+    . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 
+    . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 13) (24 . 15) (25 . 16) (26 . 17)
+    (135 . 18) (136 . 19) (137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 
+    24) (41 . 25) (145 . 90) (146 . 91) (94 . 35) (130 . 92) (131 . 93) (132 
+    . 94) (133 . 214)) ((83 . 211) (21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5
+    ) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 
+    13) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 20) (138 . 
+    21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (145 . 90) (146 . 91) (130 
+    . 92) (132 . 212) (94 . 35) (131 . 213)) ((37 . 210) (-1 . -132)) ((-1 . 
+    -129)) ((-1 . -125)) ((-1 . -142)) ((-1 . -122)) ((37 . 209) (-1 . -123)) 
+    ((-1 . -120)) ((-1 . -113)) ((163 . 141) (162 . 142) (161 . 143) (160 . 
+    144) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 
+    . 151) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (154 . 157) (75 . 
+    158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (
+    174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 
+    . 171) (21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 
+    . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 13) (165 . 172) (152 . 
+    173) (5 . 50) (6 . 51) (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 18) 
+    (136 . 19) (137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25)
+    (42 . 26) (43 . 27) (44 . 28) (45 . 58) (46 . 29) (169 . 182) (1 . 34) (8
+    . 183) (9 . 184) (10 . 185) (11 . 186) (12 . 187) (13 . 188) (14 . 189) (
+    15 . 190) (18 . 191) (47 . 192) (175 . 193) (84 . 106) (19 . 194) (20 . 
+    195) (178 . 196) (144 . 30) (145 . 31) (146 . 32) (147 . 33) (107 . 197) (
+    108 . 198) (109 . 199) (110 . 200) (111 . 201) (112 . 202) (113 . 203) (
+    167 . 108) (106 . 204) (103 . 205) (104 . 206) (105 . 207) (83 . 208)) ((
+    94 . -289) (-1 . -289)) ((5 . 50) (6 . 51) (79 . 52) (92 . 53) (178 . 54) 
+    (123 . 55) (124 . 56) (142 . 126) (143 . 47) (150 . 48) (47 . 49)) ((-1 . 
+    -290)) ((84 . 106) (112 . 180) (21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5
+    ) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 
+    13) (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 
+    20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (42 . 26) (43 . 
+    27) (44 . 28) (45 . 58) (46 . 29) (144 . 30) (145 . 31) (146 . 32) (147 . 
+    33) (167 . 108) (103 . 181)) ((163 . 141) (162 . 142) (161 . 143) (160 . 
+    144) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 
+    . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (
+    178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 
+    176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 167) (164 . 168) 
+    (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173) (84 . 177) (169 
+    . 178) (141 . 179)) ((90 . 113) (92 . 114) (-1 . -178)) ((43 . 139) (89 . 
+    140) (163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 
+    146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51)
+    (156 . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (154 . 157) (
+    75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 162) (80 . 163) (92 . 164
+    ) (174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (
+    173 . 171) (165 . 172) (152 . 173) (169 . 174) (24 . 15) (25 . 16) (26 . 
+    17) (145 . 116) (122 . 175)) ((91 . 132) (5 . 50) (6 . 51) (178 . 133) (
+    120 . 134) (21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) 
+    (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 13) (23 . 14) (24 . 
+    15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 20) (138 . 21) (40 . 
+    22) (139 . 23) (140 . 24) (41 . 25) (42 . 26) (43 . 27) (44 . 28) (45 . 58
+    ) (46 . 29) (144 . 30) (145 . 31) (146 . 32) (147 . 33) (167 . 135) (118 
+    . 136) (119 . 137) (121 . 138)) ((91 . 131)) ((-1 . -197)) ((79 . 52) (124
+    . 129) (24 . 15) (25 . 16) (26 . 17) (145 . 130) (-1 . -193)) ((-1 . -196
+    )) ((94 . -301) (-1 . -301)) ((94 . -293) (-1 . -293)) ((94 . -83) (-1 . 
+    -83)) ((47 . 128)) ((5 . 50) (6 . 51) (79 . 52) (92 . 53) (178 . 54) (123 
+    . 55) (124 . 56) (142 . 126) (143 . 127)) ((21 . 1) (27 . 2) (28 . 3) (29 
+    . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 
+    . 12) (39 . 13) (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 
+    19) (137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (42 . 
+    26) (43 . 27) (44 . 28) (46 . 29) (144 . 30) (145 . 31) (146 . 32) (147 . 
+    33) (1 . 34) (94 . 35) (167 . 36) (45 . 37) (107 . 38) (131 . 39) (103 . 
+    40) (99 . 41) (100 . 42) (179 . 125)) ((83 . 332) (21 . 1) (27 . 2) (28 . 
+    3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 
+    11) (36 . 12) (39 . 13) (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 18)
+    (136 . 19) (137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25
+    ) (42 . 26) (43 . 27) (44 . 28) (46 . 29) (144 . 30) (145 . 31) (146 . 32)
+    (147 . 33) (1 . 34) (94 . 35) (167 . 36) (45 . 37) (107 . 38) (131 . 39) 
+    (103 . 40) (99 . 41) (100 . 45)) ((58 . 111) (47 . -95) (82 . -95)) ((47 
+    . -94) (82 . -94)) ((93 . 119) (97 . 120) (148 . 331) (94 . -292) (-1 . 
+    -292)) ((-1 . -195)) ((-1 . -198)) ((-1 . -181)) ((-1 . -192)) ((91 . -206
+    ) (82 . -206)) ((91 . 329) (82 . 330)) ((5 . 50) (6 . 51) (178 . 54) (123 
+    . 55) (142 . 323) (90 . 324) (92 . 325) (79 . 52) (117 . 326) (124 . 327) 
+    (166 . 328) (91 . -205) (82 . -205)) ((82 . -201) (91 . -201)) ((82 . 322)
+    (91 . -199)) ((91 . 321)) ((24 . 15) (25 . 16) (26 . 17) (145 . 116) (122
+    . 320)) ((-1 . -185)) ((-1 . -36)) ((79 . 317) (74 . 318) (73 . 319) (-1 
+    . -40)) ((78 . 315) (77 . 316) (-1 . -43)) ((72 . 313) (71 . 314) (-1 . 
+    -46)) ((70 . 309) (69 . 310) (68 . 311) (67 . 312) (-1 . -51)) ((66 . 307)
+    (65 . 308) (-1 . -54)) ((80 . 306) (-1 . -56)) ((-1 . -299)) ((-1 . -298)
+    ) ((-1 . -297)) ((-1 . -296)) ((64 . 305) (-1 . -58)) ((63 . 304) (-1 . 
+    -60)) ((7 . 303) (-1 . -4)) ((-1 . -3)) ((-1 . -2)) ((62 . 302) (-1 . -62)
+    ) ((-1 . -33)) ((-1 . -32)) ((-1 . -31)) ((-1 . -30)) ((89 . 301) (-1 . 
+    -29)) ((-1 . -28)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 
+    . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 
+    . 50) (6 . 51) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156)
+    (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 
+    163) (92 . 164) (174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) 
+    (86 . 170) (173 . 171) (165 . 172) (152 . 173) (169 . 182) (175 . 295) (21
+    . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 
+    . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 13) (23 . 14) (24 . 15) (25 . 16)
+    (26 . 17) (135 . 18) (136 . 19) (137 . 20) (138 . 21) (40 . 22) (139 . 23
+    ) (140 . 24) (41 . 25) (42 . 26) (43 . 27) (44 . 28) (45 . 58) (46 . 29) (
+    144 . 30) (145 . 296) (146 . 297) (147 . 33) (167 . 298) (130 . 299) (171 
+    . 300)) ((-1 . -6)) ((60 . 293) (61 . 294) (-1 . -64)) ((7 . 148) (2 . 149
+    ) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 155) (178 . 156
+    ) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (174 
+    . 165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 291
+    ) (92 . 292)) ((7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (
+    176 . 154) (177 . 155) (178 . 156) (75 . 158) (76 . 159) (77 . 160) (78 . 
+    161) (79 . 176) (80 . 163) (174 . 165) (81 . 167) (164 . 168) (85 . 169) (
+    86 . 170) (173 . 171) (92 . 164) (165 . 229) (163 . 290)) ((7 . 148) (2 . 
+    149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 155) (178 . 
+    156) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92
+    . 287) (174 . 165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 
+    171) (165 . 289)) ((7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 
+    51) (176 . 154) (177 . 155) (178 . 156) (75 . 158) (76 . 159) (77 . 160) (
+    78 . 161) (79 . 176) (80 . 163) (92 . 287) (174 . 165) (81 . 167) (164 . 
+    168) (85 . 169) (86 . 170) (173 . 171) (165 . 288)) ((90 . 281) (92 . 282)
+    (88 . 283) (87 . 284) (86 . 285) (85 . 286) (-1 . -22)) ((48 . 269) (49 
+    . 270) (50 . 271) (51 . 272) (52 . 273) (53 . 274) (54 . 275) (55 . 276) (
+    56 . 277) (57 . 278) (58 . 279) (151 . 280) (-1 . -34)) ((-1 . -66)) ((89 
+    . 268)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 
+    . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 
+    51) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (154 . 157
+    ) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (80 . 163) (92 . 164) (174 
+    . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171
+    ) (165 . 172) (152 . 173) (169 . 264) (24 . 15) (25 . 16) (26 . 17) (145 
+    . 130) (89 . 265) (43 . 266) (79 . 267)) ((-1 . -29)) ((163 . 141) (162 . 
+    142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 148)
+    (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (
+    176 . 154) (177 . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 
+    . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (88 . 257) 
+    (90 . 258) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 
+    . 171) (114 . 259) (165 . 172) (152 . 173) (115 . 260) (84 . 177) (169 . 
+    178) (141 . 261) (116 . 262) (170 . 263)) ((82 . -235) (83 . -235) (47 . 
+    -235)) ((47 . -96) (82 . -96)) ((94 . -288) (-1 . -288)) ((-1 . -291)) ((
+    -1 . -79)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (
+    158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6
+    . 51) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (154 . 
+    157) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92
+    . 164) (174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 
+    170) (173 . 171) (165 . 172) (152 . 173) (169 . 182) (175 . 255) (47 . 256
+    )) ((47 . 254)) ((47 . 253)) ((5 . 50) (6 . 51) (178 . 252)) ((92 . 251)) 
+    ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (
+    157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (156 . 152) (155 . 153)
+    (176 . 154) (177 . 155) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 
+    . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 167)
+    (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173) (5 
+    . 50) (6 . 51) (169 . 182) (1 . 34) (8 . 183) (9 . 184) (10 . 185) (11 . 
+    186) (12 . 187) (13 . 188) (14 . 189) (15 . 190) (18 . 191) (47 . 192) (
+    175 . 193) (84 . 106) (19 . 194) (20 . 195) (178 . 196) (107 . 197) (108 
+    . 198) (109 . 199) (110 . 200) (111 . 201) (112 . 202) (113 . 203) (106 . 
+    250)) ((92 . 249)) ((92 . 248)) ((92 . 247)) ((-1 . -264)) ((47 . 245) (82
+    . 246)) ((59 . 244)) ((7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6
+    . 51) (176 . 154) (177 . 155) (178 . 156) (75 . 158) (76 . 159) (77 . 160
+    ) (78 . 161) (79 . 176) (80 . 163) (174 . 165) (81 . 167) (164 . 168) (85 
+    . 169) (86 . 170) (173 . 171) (92 . 164) (165 . 229) (163 . 141) (162 . 
+    142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (156 . 
+    152) (155 . 153) (154 . 157) (153 . 166) (152 . 230) (127 . 243)) ((59 . 
+    242) (-1 . -2)) ((-1 . -253)) ((-1 . -252)) ((-1 . -251)) ((-1 . -250)) ((
+    -1 . -249)) ((-1 . -248)) ((-1 . -247)) ((-1 . -262)) ((-1 . -261)) ((-1 
+    . -259)) ((83 . 240) (163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 
+    . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (
+    156 . 152) (155 . 153) (176 . 154) (177 . 155) (154 . 157) (75 . 158) (76 
+    . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) 
+    (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (21 
+    . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 
+    9) (35 . 10) (37 . 11) (36 . 12) (39 . 13) (165 . 172) (152 . 173) (5 . 50
+    ) (6 . 51) (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (
+    137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (42 . 26) (
+    43 . 27) (44 . 28) (45 . 58) (46 . 29) (169 . 182) (1 . 34) (8 . 183) (9 
+    . 184) (10 . 185) (11 . 186) (12 . 187) (13 . 188) (14 . 189) (15 . 190) (
+    18 . 191) (47 . 192) (175 . 193) (84 . 106) (19 . 194) (20 . 195) (178 . 
+    196) (144 . 30) (145 . 31) (146 . 32) (147 . 33) (107 . 197) (108 . 198) (
+    109 . 199) (110 . 200) (111 . 201) (112 . 202) (113 . 203) (167 . 108) (
+    106 . 204) (103 . 205) (104 . 241)) ((94 . -258) (-1 . -258)) ((-1 . -124)
+    ) ((-1 . -131)) ((-1 . -144)) ((94 . -153) (-1 . -153)) ((94 . -154) (-1 
+    . -154)) ((83 . 239) (21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6)
+    (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 13) (24 . 
+    15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 20) (138 . 21) (40 . 
+    22) (139 . 23) (140 . 24) (41 . 25) (145 . 90) (146 . 91) (130 . 92) (132 
+    . 212) (94 . 35) (131 . 213)) ((-1 . -147)) ((7 . 148) (2 . 149) (3 . 150)
+    (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 155) (178 . 156) (75 . 158
+    ) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (174 . 165) (81 
+    . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (92 . 164) (165 . 229
+    ) (163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) 
+    (157 . 147) (156 . 152) (155 . 153) (154 . 157) (153 . 166) (152 . 230) (
+    127 . 238)) ((59 . 237) (47 . -162) (82 . -162)) ((47 . -160) (82 . -160))
+    ((47 . 235) (82 . 236)) ((-1 . -156)) ((-1 . -158)) ((83 . 234) (21 . 1) 
+    (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (
+    35 . 10) (37 . 11) (36 . 12) (39 . 13) (24 . 15) (25 . 16) (26 . 17) (135 
+    . 18) (136 . 19) (137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41
+    . 25) (145 . 90) (146 . 91) (130 . 92) (132 . 212) (94 . 35) (131 . 213))
+    ((-1 . -167)) ((83 . 232) (5 . 50) (6 . 51) (178 . 86) (125 . 233)) ((7 
+    . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 
+    155) (178 . 156) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (
+    80 . 163) (174 . 165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 
+    171) (92 . 164) (165 . 229) (163 . 141) (162 . 142) (161 . 143) (160 . 144
+    ) (159 . 145) (158 . 146) (157 . 147) (156 . 152) (155 . 153) (154 . 157) 
+    (153 . 166) (152 . 230) (127 . 231)) ((82 . 227) (83 . 228)) ((5 . 50) (6 
+    . 51) (178 . 86) (125 . 233) (83 . 410)) ((-1 . -165)) ((-1 . -34)) ((-1 
+    . -81)) ((83 . -173) (82 . -173)) ((-1 . -168)) ((83 . -171) (82 . -171)) 
+    ((-1 . -146)) ((93 . 119) (97 . 120) (148 . 409) (94 . -292) (-1 . -292)) 
+    ((5 . 50) (6 . 51) (79 . 52) (92 . 53) (178 . 54) (123 . 55) (124 . 56) (
+    59 . 216) (142 . 217) (128 . 408)) ((7 . 148) (2 . 149) (3 . 150) (4 . 151
+    ) (5 . 50) (6 . 51) (176 . 154) (177 . 155) (178 . 156) (75 . 158) (76 . 
+    159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (174 . 165) (81 . 167) (
+    164 . 168) (85 . 169) (86 . 170) (173 . 171) (92 . 164) (165 . 229) (163 
+    . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 
+    147) (156 . 152) (155 . 153) (154 . 157) (153 . 166) (152 . 230) (127 . 
+    407)) ((47 . -164) (82 . -164)) ((-1 . -143)) ((94 . -257) (-1 . -257)) ((
+    -1 . -260)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (
+    158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (156 . 152)
+    (155 . 153) (176 . 154) (177 . 155) (154 . 157) (75 . 158) (76 . 159) (77
+    . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166
+    ) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (
+    152 . 173) (5 . 50) (6 . 51) (169 . 182) (1 . 34) (8 . 183) (9 . 184) (10 
+    . 185) (11 . 186) (12 . 187) (13 . 188) (14 . 189) (15 . 190) (18 . 191) (
+    47 . 192) (175 . 193) (84 . 106) (19 . 194) (20 . 195) (178 . 196) (107 . 
+    197) (108 . 198) (109 . 199) (110 . 200) (111 . 201) (112 . 202) (113 . 
+    203) (106 . 406)) ((59 . 405)) ((163 . 141) (162 . 142) (161 . 143) (160 
+    . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (
+    4 . 151) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (154 . 157) (75 
+    . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (
+    174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 
+    . 171) (165 . 172) (152 . 173) (5 . 50) (6 . 51) (169 . 182) (1 . 34) (8 
+    . 183) (9 . 184) (10 . 185) (11 . 186) (12 . 187) (13 . 188) (14 . 189) (
+    15 . 190) (18 . 191) (47 . 192) (175 . 193) (84 . 106) (19 . 194) (20 . 
+    195) (178 . 196) (107 . 197) (108 . 198) (109 . 199) (110 . 200) (111 . 
+    201) (112 . 202) (113 . 203) (106 . 404)) ((-1 . -263)) ((163 . 141) (162 
+    . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 
+    148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 
+    153) (176 . 154) (177 . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 159)
+    (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 
+    . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172
+    ) (152 . 173) (169 . 403)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144
+    ) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 
+    151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (
+    178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 
+    176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 167) (164 . 168) 
+    (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173) (169 . 182) (175
+    . 402)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158
+    . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 
+    51) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (154 . 157
+    ) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 
+    164) (174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) 
+    (173 . 171) (165 . 172) (152 . 173) (169 . 182) (175 . 401)) ((163 . 141) 
+    (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7
+    . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 
+    . 153) (176 . 154) (177 . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 
+    159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (
+    153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 
+    . 172) (152 . 173) (169 . 182) (175 . 400)) ((14 . 399)) ((163 . 141) (162
+    . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 
+    148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 
+    153) (176 . 154) (177 . 155) (178 . 156) (21 . 1) (27 . 2) (28 . 3) (29 . 
+    4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 
+    12) (39 . 13) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 
+    . 176) (80 . 163) (92 . 164) (174 . 165) (23 . 14) (24 . 15) (25 . 16) (26
+    . 17) (135 . 18) (136 . 19) (137 . 20) (138 . 21) (40 . 22) (139 . 23) (
+    140 . 24) (41 . 25) (42 . 26) (43 . 27) (44 . 28) (45 . 58) (46 . 29) (153
+    . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (144 . 30
+    ) (145 . 31) (146 . 32) (147 . 33) (165 . 172) (152 . 173) (167 . 108) (
+    169 . 182) (103 . 395) (47 . 396) (175 . 397) (102 . 398)) ((47 . 394)) ((
+    -1 . -277)) ((-1 . -278)) ((47 . 393) (82 . 246)) ((-1 . -280)) ((5 . 50) 
+    (6 . 51) (178 . 392)) ((7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6
+    . 51) (176 . 154) (177 . 155) (178 . 156) (75 . 158) (76 . 159) (77 . 160
+    ) (78 . 161) (79 . 176) (80 . 163) (174 . 165) (81 . 167) (164 . 168) (85 
+    . 169) (86 . 170) (173 . 171) (92 . 164) (165 . 229) (163 . 141) (162 . 
+    142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (156 . 
+    152) (155 . 153) (154 . 157) (153 . 166) (152 . 230) (127 . 391)) ((58 . 
+    -243) (88 . -243) (90 . -243)) ((58 . 389) (88 . 257) (90 . 258) (114 . 
+    390)) ((82 . -239) (83 . -239)) ((163 . 141) (162 . 142) (161 . 143) (160 
+    . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (
+    4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (176 . 154) (177 . 155)
+    (178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 
+    . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 167) (164 . 168
+    ) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173) (84 . 177) (
+    169 . 178) (141 . 388)) ((82 . 386) (83 . 387)) ((89 . 385)) ((-1 . -183))
+    ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) 
+    (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156
+    . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (154 . 157) (75 . 
+    158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (
+    174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 
+    . 171) (165 . 172) (152 . 173) (169 . 384)) ((89 . 383) (-1 . -29)) ((-1 
+    . -184)) ((-1 . -78)) ((-1 . -77)) ((-1 . -76)) ((-1 . -75)) ((-1 . -74)) 
+    ((-1 . -73)) ((-1 . -72)) ((-1 . -71)) ((-1 . -70)) ((-1 . -69)) ((-1 . 
+    -68)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 
+    146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51)
+    (156 . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (154 . 157) (
+    75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164
+    ) (174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (
+    173 . 171) (165 . 172) (152 . 173) (169 . 382)) ((163 . 141) (162 . 142) (
+    161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 
+    149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (176 . 
+    154) (177 . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 . 160) 
+    (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 
+    167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173)
+    (169 . 182) (175 . 381)) ((91 . 376) (163 . 141) (162 . 142) (161 . 143) 
+    (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 
+    150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (21 . 1) (27 . 2) (28 . 3) (
+    29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (
+    36 . 12) (39 . 13) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (23 . 
+    14) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 20) (138 . 
+    21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (42 . 26) (43 . 27) (44 . 28
+    ) (45 . 58) (46 . 29) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 
+    161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (144 . 30) (145 . 31) (
+    146 . 32) (147 . 33) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 
+    170) (173 . 171) (165 . 172) (152 . 173) (167 . 377) (168 . 378) (169 . 
+    379) (172 . 380)) ((5 . 50) (6 . 51) (178 . 375)) ((5 . 50) (6 . 51) (178 
+    . 374)) ((-1 . -12)) ((-1 . -13)) ((21 . 1) (27 . 2) (28 . 3) (29 . 4) (30
+    . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (
+    39 . 13) (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (
+    137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (42 . 26) (
+    43 . 27) (44 . 28) (45 . 58) (46 . 29) (144 . 30) (145 . 296) (146 . 297) 
+    (147 . 33) (167 . 298) (130 . 299) (171 . 373) (163 . 141) (162 . 142) (
+    161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 
+    149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (176 . 
+    154) (177 . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 . 160) 
+    (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 
+    167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173)
+    (169 . 182) (175 . 295)) ((-1 . -23)) ((-1 . -24)) ((-1 . -25)) ((-1 . 
+    -26)) ((21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 
+    . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 13) (23 . 14) (24 . 15) 
+    (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 20) (138 . 21) (40 . 22) 
+    (139 . 23) (140 . 24) (41 . 25) (42 . 26) (43 . 27) (44 . 28) (45 . 58) (
+    46 . 29) (144 . 30) (145 . 296) (146 . 297) (147 . 33) (167 . 298) (130 . 
+    299) (171 . 372) (163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 
+    145) (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 
+    50) (6 . 51) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (
+    154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 
+    163) (92 . 164) (174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) 
+    (86 . 170) (173 . 171) (165 . 172) (152 . 173) (169 . 182) (175 . 295)) ((
+    163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (
+    157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 
+    . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (154 . 157) (75 . 
+    158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (
+    174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 
+    . 171) (165 . 172) (152 . 173) (169 . 182) (175 . 371)) ((7 . 148) (2 . 
+    149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 155) (178 . 
+    156) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (
+    174 . 165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (92 . 
+    164) (165 . 229) (163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 
+    145) (158 . 146) (157 . 147) (156 . 152) (155 . 153) (154 . 370)) ((91 . 
+    369) (82 . 246)) ((23 . 14) (42 . 26) (43 . 27) (44 . 28) (45 . 58) (46 . 
+    29) (144 . 30) (147 . 33) (167 . 61) (21 . 1) (27 . 2) (28 . 3) (29 . 4) (
+    30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) 
+    (39 . 13) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 20) (
+    138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (145 . 296) (146 . 297
+    ) (130 . 221) (91 . -89) (79 . -159) (90 . -159) (92 . -159)) ((23 . 14) (
+    42 . 26) (43 . 27) (44 . 28) (45 . 58) (46 . 29) (144 . 30) (147 . 33) (
+    167 . 60) (21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (
+    33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 13) (24 . 15) (25 . 
+    16) (26 . 17) (135 . 18) (136 . 19) (137 . 20) (138 . 21) (40 . 22) (139 
+    . 23) (140 . 24) (41 . 25) (145 . 296) (146 . 297) (130 . 220) (91 . -87) 
+    (79 . -157) (90 . -157) (92 . -157)) ((91 . -209)) ((90 . 324) (92 . 366) 
+    (79 . 52) (117 . 326) (124 . 367) (166 . 368)) ((91 . 365)) ((-1 . -189)) 
+    ((7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (
+    177 . 155) (178 . 156) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 
+    176) (80 . 163) (174 . 165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (
+    173 . 171) (92 . 164) (165 . 229) (163 . 141) (162 . 142) (161 . 143) (160
+    . 144) (159 . 145) (158 . 146) (157 . 147) (156 . 152) (155 . 364)) ((-1 
+    . -300)) ((7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 
+    . 154) (177 . 155) (178 . 156) (75 . 158) (76 . 159) (77 . 160) (78 . 161)
+    (79 . 176) (80 . 163) (174 . 165) (81 . 167) (164 . 168) (85 . 169) (86 
+    . 170) (173 . 171) (92 . 164) (165 . 229) (163 . 141) (162 . 142) (161 . 
+    143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (156 . 363)) ((7 . 
+    148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 
+    155) (178 . 156) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (
+    80 . 163) (174 . 165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 
+    171) (92 . 164) (165 . 229) (163 . 141) (162 . 142) (161 . 143) (160 . 144
+    ) (159 . 145) (158 . 146) (157 . 362)) ((7 . 148) (2 . 149) (3 . 150) (4 
+    . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 155) (178 . 156) (75 . 158) (
+    76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (174 . 165) (81 . 
+    167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (92 . 164) (165 . 229) 
+    (163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 361)) (
+    (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177
+    . 155) (178 . 156) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176)
+    (80 . 163) (174 . 165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 
+    . 171) (92 . 164) (165 . 229) (163 . 141) (162 . 142) (161 . 143) (160 . 
+    144) (159 . 360)) ((7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 
+    51) (176 . 154) (177 . 155) (178 . 156) (75 . 158) (76 . 159) (77 . 160) (
+    78 . 161) (79 . 176) (80 . 163) (174 . 165) (81 . 167) (164 . 168) (85 . 
+    169) (86 . 170) (173 . 171) (92 . 164) (165 . 229) (163 . 141) (162 . 142)
+    (161 . 143) (160 . 144) (159 . 359)) ((7 . 148) (2 . 149) (3 . 150) (4 . 
+    151) (5 . 50) (6 . 51) (176 . 154) (177 . 155) (178 . 156) (75 . 158) (76 
+    . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (174 . 165) (81 . 167) 
+    (164 . 168) (85 . 169) (86 . 170) (173 . 171) (92 . 164) (165 . 229) (163 
+    . 141) (162 . 142) (161 . 143) (160 . 358)) ((7 . 148) (2 . 149) (3 . 150)
+    (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 155) (178 . 156) (75 . 158
+    ) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (174 . 165) (81 
+    . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (92 . 164) (165 . 229
+    ) (163 . 141) (162 . 142) (161 . 143) (160 . 357)) ((7 . 148) (2 . 149) (3
+    . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 155) (178 . 156) (
+    75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (174 . 
+    165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (92 . 164) (
+    165 . 229) (163 . 141) (162 . 142) (161 . 143) (160 . 356)) ((7 . 148) (2 
+    . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 155) (178 
+    . 156) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (
+    174 . 165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (92 . 
+    164) (165 . 229) (163 . 141) (162 . 142) (161 . 143) (160 . 355)) ((7 . 
+    148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 
+    155) (178 . 156) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (
+    80 . 163) (174 . 165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 
+    171) (92 . 164) (165 . 229) (163 . 141) (162 . 142) (161 . 354)) ((7 . 148
+    ) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 155) 
+    (178 . 156) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 
+    163) (174 . 165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) 
+    (92 . 164) (165 . 229) (163 . 141) (162 . 142) (161 . 353)) ((7 . 148) (2 
+    . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 155) (178 
+    . 156) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (
+    174 . 165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (92 . 
+    164) (165 . 229) (163 . 141) (162 . 352)) ((7 . 148) (2 . 149) (3 . 150) (
+    4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 155) (178 . 156) (75 . 158) 
+    (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (174 . 165) (81 . 
+    167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (92 . 164) (165 . 229) 
+    (163 . 141) (162 . 351)) ((7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50)
+    (6 . 51) (176 . 154) (177 . 155) (178 . 156) (75 . 158) (76 . 159) (77 . 
+    160) (78 . 161) (79 . 176) (80 . 163) (174 . 165) (81 . 167) (164 . 168) (
+    85 . 169) (86 . 170) (173 . 171) (92 . 164) (165 . 229) (163 . 350)) ((7 
+    . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 
+    155) (178 . 156) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (
+    80 . 163) (174 . 165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 
+    171) (92 . 164) (165 . 229) (163 . 349)) ((7 . 148) (2 . 149) (3 . 150) (4
+    . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 155) (178 . 156) (75 . 158) (
+    76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (174 . 165) (81 . 
+    167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (92 . 164) (165 . 229) 
+    (163 . 348)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) 
+    (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (
+    6 . 51) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (154 
+    . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (
+    92 . 164) (174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 
+    170) (173 . 171) (165 . 172) (152 . 173) (169 . 347) (24 . 15) (25 . 16) (
+    26 . 17) (145 . 130)) ((-1 . -190)) ((21 . 1) (27 . 2) (28 . 3) (29 . 4) (
+    30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) 
+    (39 . 13) (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (
+    137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (42 . 26) (
+    43 . 27) (44 . 28) (45 . 58) (46 . 29) (144 . 30) (145 . 31) (146 . 32) (
+    147 . 33) (167 . 135) (118 . 345) (22 . 346)) ((91 . -203) (82 . -203)) ((
+    163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (
+    157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 
+    . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (154 . 157) (75 . 
+    158) (76 . 159) (77 . 160) (78 . 161) (80 . 163) (92 . 164) (174 . 165) (
+    153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 
+    . 172) (152 . 173) (169 . 340) (89 . 341) (43 . 342) (24 . 15) (25 . 16) (
+    26 . 17) (145 . 116) (122 . 343) (79 . 344)) ((90 . 324) (117 . 326) (166 
+    . 337) (21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 
+    . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 13) (23 . 14) (24 . 15) 
+    (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 20) (138 . 21) (40 . 22) 
+    (139 . 23) (140 . 24) (41 . 25) (42 . 26) (43 . 27) (44 . 28) (45 . 58) (
+    46 . 29) (144 . 30) (145 . 31) (146 . 32) (147 . 33) (167 . 135) (118 . 
+    136) (119 . 137) (121 . 338) (91 . 339) (5 . 50) (6 . 51) (79 . 52) (92 . 
+    325) (178 . 54) (123 . 55) (124 . 327) (142 . 115)) ((90 . 335) (92 . 336)
+    (91 . -212) (82 . -212)) ((90 . 324) (117 . 334) (5 . 50) (6 . 51) (92 . 
+    325) (178 . 54) (123 . 112) (91 . -210) (82 . -210)) ((91 . -204) (82 . 
+    -204)) ((-1 . -191)) ((5 . 50) (6 . 51) (178 . 333)) ((94 . -82) (-1 . -82
+    )) ((94 . -287) (-1 . -287)) ((91 . -207) (82 . -207)) ((90 . 335) (92 . 
+    336) (91 . -211) (82 . -211)) ((43 . 444) (89 . 445) (163 . 141) (162 . 
+    142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 148)
+    (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (
+    176 . 154) (177 . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 
+    . 160) (78 . 161) (79 . 446) (80 . 163) (92 . 164) (174 . 165) (153 . 166)
+    (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152
+    . 173) (169 . 447) (24 . 15) (25 . 16) (26 . 17) (145 . 116) (122 . 448))
+    ((91 . 442) (21 . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7
+    ) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 12) (39 . 13) (23 . 14) (24 
+    . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19) (137 . 20) (138 . 21) (40 
+    . 22) (139 . 23) (140 . 24) (41 . 25) (42 . 26) (43 . 27) (44 . 28) (45 . 
+    58) (46 . 29) (144 . 30) (145 . 31) (146 . 32) (147 . 33) (167 . 135) (118
+    . 136) (119 . 137) (121 . 443)) ((91 . 441)) ((91 . 440)) ((-1 . -233)) (
+    (89 . 439)) ((-1 . -224)) ((24 . 15) (25 . 16) (26 . 17) (145 . 116) (122 
+    . 438)) ((43 . 435) (24 . 15) (25 . 16) (26 . 17) (145 . 130) (89 . 436) (
+    163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (
+    157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 
+    . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (154 . 157) (75 . 
+    158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (
+    174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 
+    . 171) (165 . 172) (152 . 173) (169 . 437)) ((89 . 434) (-1 . -29)) ((82 
+    . -202) (91 . -202)) ((91 . -200)) ((89 . 433)) ((-1 . -39)) ((-1 . -38)) 
+    ((-1 . -37)) ((79 . 317) (74 . 318) (73 . 319) (-1 . -42)) ((79 . 317) (74
+    . 318) (73 . 319) (-1 . -41)) ((78 . 315) (77 . 316) (-1 . -45)) ((78 . 
+    315) (77 . 316) (-1 . -44)) ((72 . 313) (71 . 314) (-1 . -50)) ((72 . 313)
+    (71 . 314) (-1 . -49)) ((72 . 313) (71 . 314) (-1 . -48)) ((72 . 313) (71
+    . 314) (-1 . -47)) ((70 . 309) (69 . 310) (68 . 311) (67 . 312) (-1 . -53
+    )) ((70 . 309) (69 . 310) (68 . 311) (67 . 312) (-1 . -52)) ((66 . 307) (
+    65 . 308) (-1 . -55)) ((80 . 306) (-1 . -57)) ((64 . 305) (-1 . -59)) ((63
+    . 304) (-1 . -61)) ((84 . 431) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5
+    . 50) (6 . 51) (176 . 154) (177 . 155) (178 . 156) (75 . 158) (76 . 159) 
+    (77 . 160) (78 . 161) (79 . 176) (80 . 163) (174 . 165) (81 . 167) (164 . 
+    168) (85 . 169) (86 . 170) (173 . 171) (92 . 164) (165 . 229) (163 . 432))
+    ((90 . 324) (92 . 366) (79 . 52) (117 . 326) (124 . 367) (166 . 337) (21 
+    . 1) (27 . 2) (28 . 3) (29 . 4) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 
+    9) (35 . 10) (37 . 11) (36 . 12) (39 . 13) (23 . 14) (24 . 15) (25 . 16) (
+    26 . 17) (135 . 18) (136 . 19) (137 . 20) (138 . 21) (40 . 22) (139 . 23) 
+    (140 . 24) (41 . 25) (42 . 26) (43 . 27) (44 . 28) (45 . 58) (46 . 29) (
+    144 . 30) (145 . 31) (146 . 32) (147 . 33) (167 . 135) (118 . 136) (119 . 
+    137) (121 . 338) (91 . 339)) ((90 . 324) (92 . 366) (117 . 334) (91 . -210
+    ) (82 . -210)) ((91 . -208)) ((-1 . -5)) ((62 . 302) (-1 . -63)) ((59 . 
+    430) (82 . 246)) ((91 . 429)) ((91 . 428)) ((-1 . -11)) ((-1 . -10)) ((-1 
+    . -9)) ((90 . 324) (92 . 366) (79 . 52) (117 . 326) (124 . 367) (166 . 427
+    ) (91 . -21) (82 . -21)) ((91 . -18) (82 . -18)) ((91 . -16) (82 . -16)) (
+    (91 . 425) (82 . 426)) ((89 . 424) (82 . 246)) ((-1 . -67)) ((-1 . -188)) 
+    ((89 . 423)) ((-1 . -182)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144
+    ) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 
+    151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (
+    178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 
+    176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 167) (164 . 168) 
+    (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173) (84 . 177) (169 
+    . 178) (141 . 420) (88 . 257) (90 . 258) (114 . 259) (115 . 260) (116 . 
+    421) (83 . 422)) ((82 . -236) (83 . -236) (47 . -236)) ((82 . -238) (83 . 
+    -238)) ((-1 . -242)) ((58 . -244) (88 . -244) (90 . -244)) ((89 . 419)) ((
+    58 . -246) (90 . -246) (88 . -246)) ((-1 . -279)) ((-1 . -276)) ((-1 . 
+    -273)) ((-1 . -272)) ((47 . 418) (82 . 246)) ((163 . 141) (162 . 142) (161
+    . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 149
+    ) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (176 . 154
+    ) (177 . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78
+    . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 167
+    ) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173) (
+    169 . 182) (175 . 416) (101 . 417) (47 . -274)) ((92 . 415)) ((91 . 414) (
+    82 . 246)) ((91 . 413) (82 . 246)) ((82 . 246) (91 . 412)) ((-1 . -80)) ((
+    -1 . -256)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (
+    158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (156 . 152)
+    (155 . 153) (176 . 154) (177 . 155) (154 . 157) (75 . 158) (76 . 159) (77
+    . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166
+    ) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (
+    152 . 173) (5 . 50) (6 . 51) (169 . 182) (1 . 34) (8 . 183) (9 . 184) (10 
+    . 185) (11 . 186) (12 . 187) (13 . 188) (14 . 189) (15 . 190) (18 . 191) (
+    47 . 192) (175 . 193) (84 . 106) (19 . 194) (20 . 195) (178 . 196) (107 . 
+    197) (108 . 198) (109 . 199) (110 . 200) (111 . 201) (112 . 202) (113 . 
+    203) (106 . 411)) ((-1 . -254)) ((47 . -163) (82 . -163)) ((47 . -161) (82
+    . -161)) ((94 . -155) (-1 . -155)) ((-1 . -166)) ((-1 . -255)) ((163 . 
+    141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 
+    147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (156 . 152) (155 . 153) (176 
+    . 154) (177 . 155) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 161)
+    (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 167) (164 
+    . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173) (5 . 50) 
+    (6 . 51) (169 . 182) (1 . 34) (8 . 183) (9 . 184) (10 . 185) (11 . 186) (
+    12 . 187) (13 . 188) (14 . 189) (15 . 190) (18 . 191) (47 . 192) (175 . 
+    193) (84 . 106) (19 . 194) (20 . 195) (178 . 196) (107 . 197) (108 . 198) 
+    (109 . 199) (110 . 200) (111 . 201) (112 . 202) (113 . 203) (106 . 469)) (
+    (163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (
+    157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (156 . 152) (155 . 153)
+    (176 . 154) (177 . 155) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 
+    . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 167)
+    (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173) (5 
+    . 50) (6 . 51) (169 . 182) (1 . 34) (8 . 183) (9 . 184) (10 . 185) (11 . 
+    186) (12 . 187) (13 . 188) (14 . 189) (15 . 190) (18 . 191) (47 . 192) (
+    175 . 193) (84 . 106) (19 . 194) (20 . 195) (178 . 196) (107 . 197) (108 
+    . 198) (109 . 199) (110 . 200) (111 . 201) (112 . 202) (113 . 203) (106 . 
+    468)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 
+    146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (156 . 152) (155 
+    . 153) (176 . 154) (177 . 155) (154 . 157) (75 . 158) (76 . 159) (77 . 160
+    ) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 
+    . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 
+    173) (5 . 50) (6 . 51) (169 . 182) (1 . 34) (8 . 183) (9 . 184) (10 . 185)
+    (11 . 186) (12 . 187) (13 . 188) (14 . 189) (15 . 190) (18 . 191) (47 . 
+    192) (175 . 193) (84 . 106) (19 . 194) (20 . 195) (178 . 196) (107 . 197) 
+    (108 . 198) (109 . 199) (110 . 200) (111 . 201) (112 . 202) (113 . 203) (
+    106 . 467)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (
+    158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6
+    . 51) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (154 . 
+    157) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92
+    . 164) (174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 
+    170) (173 . 171) (165 . 172) (152 . 173) (169 . 182) (175 . 466)) ((82 . 
+    246) (47 . -275) (91 . -275)) ((47 . 465)) ((-1 . -271)) ((58 . -245) (90 
+    . -245) (88 . -245)) ((82 . -241) (83 . -241)) ((163 . 141) (162 . 142) (
+    161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 
+    149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (176 . 
+    154) (177 . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 . 160) 
+    (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 
+    167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173)
+    (84 . 177) (169 . 178) (141 . 464)) ((82 . -237) (83 . -237) (47 . -237))
+    ((-1 . -187)) ((-1 . -7)) ((-1 . -8)) ((21 . 1) (27 . 2) (28 . 3) (29 . 4
+    ) (30 . 5) (31 . 6) (32 . 7) (33 . 8) (34 . 9) (35 . 10) (37 . 11) (36 . 
+    12) (39 . 13) (23 . 14) (24 . 15) (25 . 16) (26 . 17) (135 . 18) (136 . 19
+    ) (137 . 20) (138 . 21) (40 . 22) (139 . 23) (140 . 24) (41 . 25) (42 . 26
+    ) (43 . 27) (44 . 28) (45 . 58) (46 . 29) (144 . 30) (145 . 31) (146 . 32)
+    (147 . 33) (167 . 377) (168 . 462) (163 . 141) (162 . 142) (161 . 143) (
+    160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 
+    150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (176 . 154) (177 
+    . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 161)
+    (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 167) (164 
+    . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173) (169 . 
+    463)) ((91 . -20) (82 . -20)) ((84 . 431)) ((84 . 431) (-1 . -27)) ((7 . 
+    148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (176 . 154) (177 . 
+    155) (178 . 156) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (
+    80 . 163) (174 . 165) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 
+    171) (92 . 164) (165 . 229) (163 . 141) (162 . 142) (161 . 143) (160 . 144
+    ) (159 . 145) (158 . 146) (157 . 147) (156 . 152) (155 . 153) (154 . 157) 
+    (153 . 166) (152 . 461)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144) 
+    (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151
+    ) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (178 
+    . 156) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) 
+    (80 . 163) (92 . 164) (174 . 165) (88 . 257) (90 . 258) (153 . 166) (81 . 
+    167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (114 . 259) (165 . 172)
+    (152 . 173) (115 . 260) (84 . 177) (169 . 178) (141 . 261) (116 . 262) (
+    170 . 460)) ((-1 . -35)) ((-1 . -186)) ((-1 . -229)) ((163 . 141) (162 . 
+    142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 148)
+    (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (
+    176 . 154) (177 . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 
+    . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166)
+    (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152
+    . 173) (169 . 459)) ((-1 . -222)) ((89 . 458)) ((163 . 141) (162 . 142) (
+    161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 
+    149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (176 . 
+    154) (177 . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 . 160) 
+    (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 
+    167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173)
+    (169 . 456) (24 . 15) (25 . 16) (26 . 17) (145 . 130) (89 . 457)) ((-1 . 
+    -223)) ((-1 . -232)) ((-1 . -213)) ((-1 . -231)) ((91 . 455)) ((24 . 15) (
+    25 . 16) (26 . 17) (145 . 116) (122 . 454)) ((-1 . -217)) ((89 . 453) (-1 
+    . -29)) ((89 . 452)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159
+    . 145) (158 . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5
+    . 50) (6 . 51) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156
+    ) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 
+    . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169
+    ) (86 . 170) (173 . 171) (165 . 172) (152 . 173) (169 . 449) (24 . 15) (25
+    . 16) (26 . 17) (145 . 130) (89 . 450) (43 . 451)) ((89 . 480)) ((-1 . 
+    -215)) ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 
+    . 146) (157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 
+    51) (156 . 152) (155 . 153) (176 . 154) (177 . 155) (178 . 156) (154 . 157
+    ) (75 . 158) (76 . 159) (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 
+    164) (174 . 165) (153 . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) 
+    (173 . 171) (165 . 172) (152 . 173) (169 . 479)) ((-1 . -216)) ((-1 . -228
+    )) ((89 . 477) (24 . 15) (25 . 16) (26 . 17) (145 . 130) (163 . 141) (162 
+    . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 
+    148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 
+    153) (176 . 154) (177 . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 159)
+    (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 
+    . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172
+    ) (152 . 173) (169 . 478)) ((-1 . -230)) ((89 . 476)) ((-1 . -226)) ((-1 
+    . -221)) ((89 . 475)) ((83 . 473) (82 . 474)) ((-1 . -65)) ((91 . -19) (82
+    . -19)) ((91 . -17) (82 . -17)) ((82 . -240) (83 . -240)) ((163 . 141) (
+    162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 
+    . 148) (2 . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 
+    153) (176 . 154) (177 . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 159)
+    (77 . 160) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 
+    . 166) (81 . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172
+    ) (152 . 173) (169 . 182) (175 . 416) (101 . 472) (91 . -274)) ((91 . 471)
+    (82 . 246)) ((-1 . -268)) ((-1 . -267)) ((16 . 470) (-1 . -265)) ((163 . 
+    141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 
+    147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (156 . 152) (155 . 153) (176 
+    . 154) (177 . 155) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 . 161)
+    (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 167) (164 
+    . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173) (5 . 50) 
+    (6 . 51) (169 . 182) (1 . 34) (8 . 183) (9 . 184) (10 . 185) (11 . 186) (
+    12 . 187) (13 . 188) (14 . 189) (15 . 190) (18 . 191) (47 . 192) (175 . 
+    193) (84 . 106) (19 . 194) (20 . 195) (178 . 196) (107 . 197) (108 . 198) 
+    (109 . 199) (110 . 200) (111 . 201) (112 . 202) (113 . 203) (106 . 486)) (
+    (47 . 485)) ((91 . 484)) ((-1 . -14)) ((83 . 483) (163 . 141) (162 . 142) 
+    (161 . 143) (160 . 144) (159 . 145) (158 . 146) (157 . 147) (7 . 148) (2 
+    . 149) (3 . 150) (4 . 151) (5 . 50) (6 . 51) (156 . 152) (155 . 153) (176 
+    . 154) (177 . 155) (178 . 156) (154 . 157) (75 . 158) (76 . 159) (77 . 160
+    ) (78 . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 
+    . 167) (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 
+    173) (84 . 177) (169 . 178) (141 . 420) (88 . 257) (90 . 258) (114 . 259) 
+    (115 . 260) (116 . 421)) ((-1 . -227)) ((-1 . -225)) ((-1 . -219)) ((89 . 
+    482)) ((89 . 481)) ((-1 . -214)) ((-1 . -220)) ((-1 . -218)) ((-1 . -15)) 
+    ((163 . 141) (162 . 142) (161 . 143) (160 . 144) (159 . 145) (158 . 146) (
+    157 . 147) (7 . 148) (2 . 149) (3 . 150) (4 . 151) (156 . 152) (155 . 153)
+    (176 . 154) (177 . 155) (154 . 157) (75 . 158) (76 . 159) (77 . 160) (78 
+    . 161) (79 . 176) (80 . 163) (92 . 164) (174 . 165) (153 . 166) (81 . 167)
+    (164 . 168) (85 . 169) (86 . 170) (173 . 171) (165 . 172) (152 . 173) (5 
+    . 50) (6 . 51) (169 . 182) (1 . 34) (8 . 183) (9 . 184) (10 . 185) (11 . 
+    186) (12 . 187) (13 . 188) (14 . 189) (15 . 190) (18 . 191) (47 . 192) (
+    175 . 193) (84 . 106) (19 . 194) (20 . 195) (178 . 196) (107 . 197) (108 
+    . 198) (109 . 199) (110 . 200) (111 . 201) (112 . 202) (113 . 203) (106 . 
+    487)) ((-1 . -269)) ((-1 . -266)) ((-1 . -270))))
+
+(define rto-v
+  #(#f 180 174 174 174 174 173 173 173 173 173 173 173 173 173 173 172 172 
+    172 172 168 168 165 165 165 165 165 165 164 164 164 164 164 164 163 163 
+    162 162 162 162 161 161 161 160 160 160 159 159 159 159 159 158 158 158 
+    157 157 156 156 155 155 154 154 153 153 152 152 169 169 151 151 151 151 
+    151 151 151 151 151 151 151 175 175 127 103 103 149 167 167 167 167 167 
+    167 167 167 150 150 143 143 147 147 147 147 147 146 146 146 146 146 146 
+    146 146 140 140 140 140 140 140 140 140 140 140 140 140 140 140 140 140 
+    140 140 140 140 140 140 140 140 140 140 139 139 139 138 138 138 138 137 
+    137 137 137 137 137 134 134 133 133 133 133 132 130 130 130 130 129 129 
+    128 128 128 136 136 136 136 136 126 126 125 125 145 145 145 144 142 142 
+    123 123 123 123 123 123 123 123 123 123 123 123 123 124 124 124 124 122 
+    122 121 121 119 119 118 118 118 120 120 171 171 166 166 166 117 117 117 
+    117 117 117 117 117 117 117 117 117 117 117 117 117 117 117 117 117 117 
+    135 141 141 141 170 170 170 170 116 115 115 114 114 106 106 106 106 106 
+    106 106 113 113 113 112 112 105 105 104 104 111 111 110 110 110 109 109 
+    109 102 102 102 101 101 108 108 108 108 108 179 179 100 100 100 100 100 99
+    99 98 98 148 148 178 178 177 177 177 176 176 97 131 107))
+
+(define mtab
+  '((cpp-stmt . 1) ($chlit . 2) ($float . 3) ($fixed . 4) (cpp-ident . 5) (
+    $ident . 6) ($string . 7) ("return" . 8) ("break" . 9) ("continue" . 10) (
+    "goto" . 11) ("for" . 12) ("do" . 13) ("while" . 14) ("switch" . 15) (
+    "else" . 16) (then . 17) ("if" . 18) ("default" . 19) ("case" . 20) (
+    typename . 21) ("..." . 22) ("inline" . 23) ("restrict" . 24) ("volatile" 
+    . 25) ("const" . 26) ("enum" . 27) ("union" . 28) ("struct" . 29) (
+    "_Complex" . 30) ("double" . 31) ("float" . 32) ("char" . 33) ("unsigned" 
+    . 34) ("long" . 35) ("signed" . 36) ("int" . 37) (imp . 38) ("short" . 39)
+    ("_Bool" . 40) ("void" . 41) ("typedef" . 42) ("static" . 43) ("register"
+    . 44) ("extern" . 45) ("auto" . 46) (";" . 47) ("|=" . 48) ("^=" . 49) (
+    "&=" . 50) (">>=" . 51) ("<<=" . 52) ("%=" . 53) ("/=" . 54) ("*=" . 55) (
+    "-=" . 56) ("+=" . 57) ("=" . 58) (":" . 59) ("?" . 60) ("||" . 61) ("&&" 
+    . 62) ("|" . 63) ("^" . 64) ("!=" . 65) ("==" . 66) (">=" . 67) ("<=" . 68
+    ) (">" . 69) ("<" . 70) (">>" . 71) ("<<" . 72) ("%" . 73) ("/" . 74) ("!"
+    . 75) ("~" . 76) ("-" . 77) ("+" . 78) ("*" . 79) ("&" . 80) ("sizeof" . 
+    81) ("," . 82) ("}" . 83) ("{" . 84) ("--" . 85) ("++" . 86) ("->" . 87) (
+    "." . 88) ("]" . 89) ("[" . 90) (")" . 91) ("(" . 92) ($code-comm . 93) (
+    $lone-comm . 94) ($error . 95) ($end . 96)))
+
+;;; end tables
diff --git a/module/nyacc/lang/c99/mach.d/c99xact.scm b/module/nyacc/lang/c99/mach.d/c99xact.scm
new file mode 100644 (file)
index 0000000..923858b
--- /dev/null
@@ -0,0 +1,762 @@
+;; ./mach.d/c99xact.scm
+
+;; Copyright (C) 2015,2016 Matthew R. Wette
+;; 
+;; This software is covered by the GNU GENERAL PUBLIC LICENCE, Version 3,
+;; or any later version published by the Free Software Foundation.  See the
+;; file COPYING included with the this distribution.
+
+(define act-v
+  (vector
+   ;; $start => expression
+   (lambda ($1 . $rest) $1)
+   ;; translation-unit-proxy => translation-unit
+   (lambda ($1 . $rest) (tl->list $1))
+   ;; primary-expression => identifier
+   (lambda ($1 . $rest) `(p-expr ,$1))
+   ;; primary-expression => constant
+   (lambda ($1 . $rest) `(p-expr ,$1))
+   ;; primary-expression => string-literal
+   (lambda ($1 . $rest) `(p-expr ,(tl->list $1)))
+   ;; primary-expression => "(" expression ")"
+   (lambda ($3 $2 $1 . $rest) $2)
+   ;; postfix-expression => primary-expression
+   (lambda ($1 . $rest) $1)
+   ;; postfix-expression => postfix-expression "[" expression "]"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(array-ref ,$3 ,$1))
+   ;; postfix-expression => postfix-expression "(" argument-expression-list...
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(fctn-call ,$1 ,(tl->list $3)))
+   ;; postfix-expression => postfix-expression "(" ")"
+   (lambda ($3 $2 $1 . $rest)
+     `(fctn-call ,$1 (expr-list)))
+   ;; postfix-expression => postfix-expression "." identifier
+   (lambda ($3 $2 $1 . $rest) `(d-sel ,$3 ,$1))
+   ;; postfix-expression => postfix-expression "->" identifier
+   (lambda ($3 $2 $1 . $rest) `(i-sel ,$3 ,$1))
+   ;; postfix-expression => postfix-expression "++"
+   (lambda ($2 $1 . $rest) `(post-inc ,$1))
+   ;; postfix-expression => postfix-expression "--"
+   (lambda ($2 $1 . $rest) `(post-dec ,$1))
+   ;; postfix-expression => "(" type-name ")" "{" initializer-list "}"
+   (lambda ($6 $5 $4 $3 $2 $1 . $rest)
+     `(comp-lit ,$2 ,(tl->list $5)))
+   ;; postfix-expression => "(" type-name ")" "{" initializer-list "," "}"
+   (lambda ($7 $6 $5 $4 $3 $2 $1 . $rest)
+     `(comp-lit ,$2 ,(tl->list $5)))
+   ;; argument-expression-list => assignment-expression
+   (lambda ($1 . $rest) (make-tl 'expr-list $1))
+   ;; argument-expression-list => argument-expression-list "," assignment-e...
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; argument-expression-list => arg-expr-hack
+   (lambda ($1 . $rest) (make-tl 'expr-list $1))
+   ;; argument-expression-list => argument-expression-list "," arg-expr-hack
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; arg-expr-hack => declaration-specifiers abstract-declarator
+   (lambda ($2 $1 . $rest)
+     `(param-decl ,(tl->list $1) $2))
+   ;; arg-expr-hack => declaration-specifiers
+   (lambda ($1 . $rest)
+     `(param-decl ,(tl->list $1)))
+   ;; unary-expression => postfix-expression
+   (lambda ($1 . $rest) $1)
+   ;; unary-expression => "++" unary-expression
+   (lambda ($2 $1 . $rest) `(pre-inc ,$2))
+   ;; unary-expression => "--" unary-expression
+   (lambda ($2 $1 . $rest) `(pre-dec ,$2))
+   ;; unary-expression => unary-operator cast-expression
+   (lambda ($2 $1 . $rest) (list $1 $2))
+   ;; unary-expression => "sizeof" unary-expression
+   (lambda ($2 $1 . $rest) `(sizeof-expr ,$2))
+   ;; unary-expression => "sizeof" "(" type-name ")"
+   (lambda ($4 $3 $2 $1 . $rest) `(sizeof-type ,$3))
+   ;; unary-operator => "&"
+   (lambda ($1 . $rest) 'ref-to)
+   ;; unary-operator => "*"
+   (lambda ($1 . $rest) 'de-ref)
+   ;; unary-operator => "+"
+   (lambda ($1 . $rest) 'pos)
+   ;; unary-operator => "-"
+   (lambda ($1 . $rest) 'neg)
+   ;; unary-operator => "~"
+   (lambda ($1 . $rest) 'bitwise-not)
+   ;; unary-operator => "!"
+   (lambda ($1 . $rest) 'not)
+   ;; cast-expression => unary-expression
+   (lambda ($1 . $rest) $1)
+   ;; cast-expression => "(" type-name ")" cast-expression
+   (lambda ($4 $3 $2 $1 . $rest) `(cast ,$2 ,$4))
+   ;; multiplicative-expression => cast-expression
+   (lambda ($1 . $rest) $1)
+   ;; multiplicative-expression => multiplicative-expression "*" cast-expre...
+   (lambda ($3 $2 $1 . $rest) `(mul ,$1 ,$3))
+   ;; multiplicative-expression => multiplicative-expression "/" cast-expre...
+   (lambda ($3 $2 $1 . $rest) `(div ,$1 ,$3))
+   ;; multiplicative-expression => multiplicative-expression "%" cast-expre...
+   (lambda ($3 $2 $1 . $rest) `(mod ,$1 ,$3))
+   ;; additive-expression => multiplicative-expression
+   (lambda ($1 . $rest) $1)
+   ;; additive-expression => additive-expression "+" multiplicative-expression
+   (lambda ($3 $2 $1 . $rest) `(add ,$1 ,$3))
+   ;; additive-expression => additive-expression "-" multiplicative-expression
+   (lambda ($3 $2 $1 . $rest) `(sub ,$1 ,$3))
+   ;; shift-expression => additive-expression
+   (lambda ($1 . $rest) $1)
+   ;; shift-expression => shift-expression "<<" additive-expression
+   (lambda ($3 $2 $1 . $rest) `(lshift ,$1 ,$3))
+   ;; shift-expression => shift-expression ">>" additive-expression
+   (lambda ($3 $2 $1 . $rest) `(rshift ,$1 ,$3))
+   ;; relational-expression => shift-expression
+   (lambda ($1 . $rest) $1)
+   ;; relational-expression => relational-expression "<" shift-expression
+   (lambda ($3 $2 $1 . $rest) `(lt ,$1 ,$3))
+   ;; relational-expression => relational-expression ">" shift-expression
+   (lambda ($3 $2 $1 . $rest) `(gt ,$1 ,$3))
+   ;; relational-expression => relational-expression "<=" shift-expression
+   (lambda ($3 $2 $1 . $rest) `(le ,$1 ,$3))
+   ;; relational-expression => relational-expression ">=" shift-expression
+   (lambda ($3 $2 $1 . $rest) `(ge ,$1 ,$3))
+   ;; equality-expression => relational-expression
+   (lambda ($1 . $rest) $1)
+   ;; equality-expression => equality-expression "==" relational-expression
+   (lambda ($3 $2 $1 . $rest) `(eq ,$1 ,$3))
+   ;; equality-expression => equality-expression "!=" relational-expression
+   (lambda ($3 $2 $1 . $rest) `(ne ,$1 ,$3))
+   ;; bitwise-and-expression => equality-expression
+   (lambda ($1 . $rest) $1)
+   ;; bitwise-and-expression => bitwise-and-expression "&" equality-expression
+   (lambda ($3 $2 $1 . $rest)
+     `(bitwise-and ,$1 ,$3))
+   ;; bitwise-xor-expression => bitwise-and-expression
+   (lambda ($1 . $rest) $1)
+   ;; bitwise-xor-expression => bitwise-xor-expression "^" bitwise-and-expr...
+   (lambda ($3 $2 $1 . $rest)
+     `(bitwise-xor ,$1 ,$3))
+   ;; bitwise-or-expression => bitwise-xor-expression
+   (lambda ($1 . $rest) $1)
+   ;; bitwise-or-expression => bitwise-or-expression "|" bitwise-xor-expres...
+   (lambda ($3 $2 $1 . $rest) `(bitwise-or ,$1 ,$3))
+   ;; logical-and-expression => bitwise-or-expression
+   (lambda ($1 . $rest) $1)
+   ;; logical-and-expression => logical-and-expression "&&" bitwise-or-expr...
+   (lambda ($3 $2 $1 . $rest) `(and ,$1 ,$3))
+   ;; logical-or-expression => logical-and-expression
+   (lambda ($1 . $rest) $1)
+   ;; logical-or-expression => logical-or-expression "||" logical-and-expre...
+   (lambda ($3 $2 $1 . $rest) `(or ,$1 ,$3))
+   ;; conditional-expression => logical-or-expression
+   (lambda ($1 . $rest) $1)
+   ;; conditional-expression => logical-or-expression "?" expression ":" co...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(cond-expr ,$1 ,$2 ,$3))
+   ;; assignment-expression => conditional-expression
+   (lambda ($1 . $rest) $1)
+   ;; assignment-expression => unary-expression assignment-operator assignm...
+   (lambda ($3 $2 $1 . $rest)
+     `(assn-expr ,$1 (op ,$2) ,$3))
+   ;; assignment-operator => "="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "+="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "-="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "*="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "/="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "%="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "<<="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => ">>="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "&="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "^="
+   (lambda ($1 . $rest) $1)
+   ;; assignment-operator => "|="
+   (lambda ($1 . $rest) $1)
+   ;; expression => assignment-expression
+   (lambda ($1 . $rest) $1)
+   ;; expression => expression "," assignment-expression
+   (lambda ($3 $2 $1 . $rest)
+     (if (eqv? 'comma-expr (sx-tag $1))
+       (append $1 (list $3))
+       `(comma-expr ,$1 ,$3)))
+   ;; constant-expression => conditional-expression
+   (lambda ($1 . $rest) $1)
+   ;; declaration => declaration-specifiers init-declarator-list $P1 ";" op...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     (if (pair? $5) (append $3 (list $5)) $3))
+   ;; declaration => declaration-specifiers ";" opt-code-comment
+   (lambda ($3 $2 $1 . $rest)
+     (if (pair? $3)
+       `(decl ,(tl->list $1) ,(list $3))
+       `(decl ,(tl->list $1))))
+   ;; $P1 => 
+   (lambda ($2 $1 . $rest)
+     (save-typenames
+       `(decl ,(tl->list $1) ,(tl->list $2))))
+   ;; declaration-specifiers => storage-class-specifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; declaration-specifiers => storage-class-specifier declaration-specifiers
+   (lambda ($2 $1 . $rest) (tl-insert $2 $1))
+   ;; declaration-specifiers => type-specifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; declaration-specifiers => type-specifier declaration-specifiers
+   (lambda ($2 $1 . $rest) (tl-insert $2 $1))
+   ;; declaration-specifiers => type-qualifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; declaration-specifiers => type-qualifier declaration-specifiers
+   (lambda ($2 $1 . $rest) (tl-insert $2 $1))
+   ;; declaration-specifiers => function-specifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; declaration-specifiers => function-specifier declaration-specifiers
+   (lambda ($2 $1 . $rest) (tl-insert $2 $1))
+   ;; init-declarator-list => init-declarator
+   (lambda ($1 . $rest)
+     (make-tl 'init-declr-list $1))
+   ;; init-declarator-list => init-declarator-list "," init-declarator
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; init-declarator => declarator
+   (lambda ($1 . $rest) `(init-declr ,$1))
+   ;; init-declarator => declarator "=" initializer
+   (lambda ($3 $2 $1 . $rest) `(init-declr ,$1 ,$3))
+   ;; storage-class-specifier => "auto"
+   (lambda ($1 . $rest) '(stor-spec (auto)))
+   ;; storage-class-specifier => "extern"
+   (lambda ($1 . $rest) '(stor-spec (extern)))
+   ;; storage-class-specifier => "register"
+   (lambda ($1 . $rest) '(stor-spec (register)))
+   ;; storage-class-specifier => "static"
+   (lambda ($1 . $rest) '(stor-spec (static)))
+   ;; storage-class-specifier => "typedef"
+   (lambda ($1 . $rest) '(stor-spec (typedef)))
+   ;; type-specifier => "void"
+   (lambda ($1 . $rest) '(type-spec (void)))
+   ;; type-specifier => fixed-type-specifier
+   (lambda ($1 . $rest) `(type-spec ,$1))
+   ;; type-specifier => float-type-specifier
+   (lambda ($1 . $rest) `(type-spec ,$1))
+   ;; type-specifier => "_Bool"
+   (lambda ($1 . $rest)
+     '(type-spec (fixed-type "_Bool")))
+   ;; type-specifier => complex-type-specifier
+   (lambda ($1 . $rest) `(type-spec ,$1))
+   ;; type-specifier => struct-or-union-specifier
+   (lambda ($1 . $rest) `(type-spec ,$1))
+   ;; type-specifier => enum-specifier
+   (lambda ($1 . $rest) `(type-spec ,$1))
+   ;; type-specifier => typedef-name
+   (lambda ($1 . $rest) `(type-spec ,$1))
+   ;; fixed-type-specifier => "short"
+   (lambda ($1 . $rest) '(fixed-type "short"))
+   ;; fixed-type-specifier => "short" "int"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "short int"))
+   ;; fixed-type-specifier => "signed" "short"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "signed short"))
+   ;; fixed-type-specifier => "signed" "short" "int"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "signed short int"))
+   ;; fixed-type-specifier => "int"
+   (lambda ($1 . $rest) '(fixed-type "int"))
+   ;; fixed-type-specifier => "signed"
+   (lambda ($1 . $rest) '(fixed-type "signed"))
+   ;; fixed-type-specifier => "signed" "int"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "signed int"))
+   ;; fixed-type-specifier => "long"
+   (lambda ($1 . $rest) '(fixed-type "long"))
+   ;; fixed-type-specifier => "long" "int"
+   (lambda ($2 $1 . $rest) '(fixed-type "long int"))
+   ;; fixed-type-specifier => "signed" "long"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "signed long"))
+   ;; fixed-type-specifier => "signed" "long" "int"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "signed long int"))
+   ;; fixed-type-specifier => "long" "long"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "long long"))
+   ;; fixed-type-specifier => "long" "long" "int"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "long long int"))
+   ;; fixed-type-specifier => "signed" "long" "long"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "signed long long"))
+   ;; fixed-type-specifier => "signed" "long" "long" "int"
+   (lambda ($4 $3 $2 $1 . $rest)
+     '(fixed-type "signed long long int"))
+   ;; fixed-type-specifier => "unsigned" "short" "int"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "unsigned short int"))
+   ;; fixed-type-specifier => "unsigned" "short"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "unsigned short"))
+   ;; fixed-type-specifier => "unsigned" "int"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "unsigned int"))
+   ;; fixed-type-specifier => "unsigned"
+   (lambda ($1 . $rest) '(fixed-type "unsigned"))
+   ;; fixed-type-specifier => "unsigned" "long" "int"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "unsigned long"))
+   ;; fixed-type-specifier => "unsigned" "long"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "unsigned long"))
+   ;; fixed-type-specifier => "unsigned" "long" "long" "int"
+   (lambda ($4 $3 $2 $1 . $rest)
+     '(fixed-type "unsigned long long int"))
+   ;; fixed-type-specifier => "unsigned" "long" "long"
+   (lambda ($3 $2 $1 . $rest)
+     '(fixed-type "unsigned long long"))
+   ;; fixed-type-specifier => "char"
+   (lambda ($1 . $rest) '(fixed-type "char"))
+   ;; fixed-type-specifier => "signed" "char"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "signed char"))
+   ;; fixed-type-specifier => "unsigned" "char"
+   (lambda ($2 $1 . $rest)
+     '(fixed-type "unsigned char"))
+   ;; float-type-specifier => "float"
+   (lambda ($1 . $rest) '(float-type "float"))
+   ;; float-type-specifier => "double"
+   (lambda ($1 . $rest) '(float-type "double"))
+   ;; float-type-specifier => "long" "double"
+   (lambda ($2 $1 . $rest)
+     '(float-type "long double"))
+   ;; complex-type-specifier => "_Complex"
+   (lambda ($1 . $rest) '(complex-type "_Complex"))
+   ;; complex-type-specifier => "float" "_Complex"
+   (lambda ($2 $1 . $rest)
+     '(complex-type "float _Complex"))
+   ;; complex-type-specifier => "double" "_Complex"
+   (lambda ($2 $1 . $rest)
+     '(complex-type "double _Complex"))
+   ;; complex-type-specifier => "long" "double" "_Complex"
+   (lambda ($3 $2 $1 . $rest)
+     '(complex-type "long double _Complex"))
+   ;; struct-or-union-specifier => "struct" ident-like "{" struct-declarati...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(struct-def ,$2 ,(tl->list $4)))
+   ;; struct-or-union-specifier => "struct" "{" struct-declaration-list "}"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(struct-def ,(tl->list $3)))
+   ;; struct-or-union-specifier => "struct" ident-like
+   (lambda ($2 $1 . $rest) `(struct-ref ,$2))
+   ;; struct-or-union-specifier => "union" ident-like "{" struct-declaratio...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(union-def ,$2 ,(tl->list $4)))
+   ;; struct-or-union-specifier => "union" "{" struct-declaration-list "}"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(union-def ,(tl->list $3)))
+   ;; struct-or-union-specifier => "union" ident-like
+   (lambda ($2 $1 . $rest) `(union-ref ,$2))
+   ;; ident-like => identifier
+   (lambda ($1 . $rest) $1)
+   ;; ident-like => typedef-name
+   (lambda ($1 . $rest) `(ident ,(cdr $1)))
+   ;; struct-declaration-list => struct-declaration
+   (lambda ($1 . $rest) (make-tl 'field-list $1))
+   ;; struct-declaration-list => lone-comment
+   (lambda ($1 . $rest) (make-tl 'field-list $1))
+   ;; struct-declaration-list => struct-declaration-list struct-declaration
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; struct-declaration-list => struct-declaration-list lone-comment
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; struct-declaration => specifier-qualifier-list struct-declarator-list...
+   (lambda ($4 $3 $2 $1 . $rest)
+     (if (pair? $4)
+       `(comp-decl ,(tl->list $1) ,(tl->list $2) ,$4)
+       `(comp-decl ,(tl->list $1) ,(tl->list $2))))
+   ;; specifier-qualifier-list => type-specifier specifier-qualifier-list
+   (lambda ($2 $1 . $rest) (tl-insert $2 $1))
+   ;; specifier-qualifier-list => type-specifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; specifier-qualifier-list => type-qualifier specifier-qualifier-list
+   (lambda ($2 $1 . $rest) (tl-insert $2 $1))
+   ;; specifier-qualifier-list => type-qualifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; struct-declarator-list => struct-declarator
+   (lambda ($1 . $rest)
+     (make-tl 'comp-declr-list $1))
+   ;; struct-declarator-list => struct-declarator-list "," struct-declarator
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; struct-declarator => declarator
+   (lambda ($1 . $rest) `(comp-declr ,$1))
+   ;; struct-declarator => declarator ":" constant-expression
+   (lambda ($3 $2 $1 . $rest)
+     `(comp-declr (bit-field ,$1 ,$3)))
+   ;; struct-declarator => ":" constant-expression
+   (lambda ($2 $1 . $rest)
+     `(comp-declr (bit-field ,$2)))
+   ;; enum-specifier => "enum" identifier "{" enumerator-list "}"
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(enum-def ,$2 ,(tl->list $4)))
+   ;; enum-specifier => "enum" identifier "{" enumerator-list "," "}"
+   (lambda ($6 $5 $4 $3 $2 $1 . $rest)
+     `(enum-def ,$2 ,(tl->list $4)))
+   ;; enum-specifier => "enum" "{" enumerator-list "}"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(enum-def ,(tl->list $3)))
+   ;; enum-specifier => "enum" "{" enumerator-list "," "}"
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(enum-def ,(tl->list $3)))
+   ;; enum-specifier => "enum" identifier
+   (lambda ($2 $1 . $rest) `(enum-ref ,$2))
+   ;; enumerator-list => enumerator
+   (lambda ($1 . $rest) (make-tl 'enum-def-list $1))
+   ;; enumerator-list => enumerator-list "," enumerator
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; enumerator => identifier
+   (lambda ($1 . $rest) `(enum-defn ,$1))
+   ;; enumerator => identifier "=" constant-expression
+   (lambda ($3 $2 $1 . $rest) `(enum-defn ,$1 ,$3))
+   ;; type-qualifier => "const"
+   (lambda ($1 . $rest) `(type-qual ,$1))
+   ;; type-qualifier => "volatile"
+   (lambda ($1 . $rest) `(type-qual ,$1))
+   ;; type-qualifier => "restrict"
+   (lambda ($1 . $rest) `(type-qual ,$1))
+   ;; function-specifier => "inline"
+   (lambda ($1 . $rest) `(fctn-spec ,$1))
+   ;; declarator => pointer direct-declarator
+   (lambda ($2 $1 . $rest) `(ptr-declr ,$1 ,$2))
+   ;; declarator => direct-declarator
+   (lambda ($1 . $rest) $1)
+   ;; direct-declarator => identifier
+   (lambda ($1 . $rest) $1)
+   ;; direct-declarator => "(" declarator ")"
+   (lambda ($3 $2 $1 . $rest) `(scope ,$2))
+   ;; direct-declarator => direct-declarator "[" type-qualifier-list assign...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(array-of ,$1 ,$3 ,$4))
+   ;; direct-declarator => direct-declarator "[" type-qualifier-list "]"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(array-of ,$1 ,$3))
+   ;; direct-declarator => direct-declarator "[" assignment-expression "]"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(array-of ,$1 ,$3))
+   ;; direct-declarator => direct-declarator "[" "]"
+   (lambda ($3 $2 $1 . $rest) `(array-of ,$1))
+   ;; direct-declarator => direct-declarator "[" "static" type-qualifier-li...
+   (lambda ($6 $5 $4 $3 $2 $1 . $rest)
+     `(array-of
+        ,$1
+        ,(tl->list (tl-insert '(stor-spec "static") $4))
+        ,$5))
+   ;; direct-declarator => direct-declarator "[" type-qualifier-list "stati...
+   (lambda ($6 $5 $4 $3 $2 $1 . $rest)
+     `(array-of
+        ,$1
+        ,(tl->list (tl-insert '(stor-spec "static") $3))
+        ,$5))
+   ;; direct-declarator => direct-declarator "[" type-qualifier-list "*" "]"
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(array-of ,$1 ,$3 (var-len)))
+   ;; direct-declarator => direct-declarator "[" "*" "]"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(array-of ,$1 (var-len)))
+   ;; direct-declarator => direct-declarator "(" parameter-type-list ")"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(ftn-declr ,$1 ,(tl->list $3)))
+   ;; direct-declarator => direct-declarator "(" identifier-list ")"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(ftn-declr ,$1 ,(tl->list $3)))
+   ;; direct-declarator => direct-declarator "(" ")"
+   (lambda ($3 $2 $1 . $rest)
+     `(ftn-declr ,$1 (param-list)))
+   ;; pointer => "*" type-qualifier-list
+   (lambda ($2 $1 . $rest)
+     `(pointer ,(tl->list $2)))
+   ;; pointer => "*"
+   (lambda ($1 . $rest) '(pointer))
+   ;; pointer => "*" type-qualifier-list pointer
+   (lambda ($3 $2 $1 . $rest)
+     `(pointer ,(tl->list $2) ,$3))
+   ;; pointer => "*" pointer
+   (lambda ($2 $1 . $rest) `(pointer ,$2))
+   ;; type-qualifier-list => type-qualifier
+   (lambda ($1 . $rest)
+     (make-tl 'decl-spec-list $1))
+   ;; type-qualifier-list => type-qualifier-list type-qualifier
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; parameter-type-list => parameter-list
+   (lambda ($1 . $rest) $1)
+   ;; parameter-type-list => parameter-list "," "..."
+   (lambda ($3 $2 $1 . $rest)
+     (tl-append $1 '(ellipis)))
+   ;; parameter-list => parameter-declaration
+   (lambda ($1 . $rest) (make-tl 'param-list $1))
+   ;; parameter-list => parameter-list "," parameter-declaration
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; parameter-declaration => declaration-specifiers declarator
+   (lambda ($2 $1 . $rest)
+     `(param-decl ,(tl->list $1) (param-declr ,$2)))
+   ;; parameter-declaration => declaration-specifiers abstract-declarator
+   (lambda ($2 $1 . $rest)
+     `(param-decl ,(tl->list $1) (param-declr ,$2)))
+   ;; parameter-declaration => declaration-specifiers
+   (lambda ($1 . $rest)
+     `(param-decl ,(tl->list $1)))
+   ;; identifier-list => identifier
+   (lambda ($1 . $rest) (make-tl 'ident-list $1))
+   ;; identifier-list => identifier-list "," identifier
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; type-name => specifier-qualifier-list abstract-declarator
+   (lambda ($2 $1 . $rest)
+     `(type-name ,(tl->list $1) ,$2))
+   ;; type-name => declaration-specifiers
+   (lambda ($1 . $rest) `(type-name ,(tl->list $1)))
+   ;; abstract-declarator => pointer
+   (lambda ($1 . $rest) `(abs-declr ,$1))
+   ;; abstract-declarator => pointer direct-abstract-declarator
+   (lambda ($2 $1 . $rest) `(abs-declr ,$1 ,$2))
+   ;; abstract-declarator => direct-abstract-declarator
+   (lambda ($1 . $rest) `(abs-declr ,$1))
+   ;; direct-abstract-declarator => "(" abstract-declarator ")"
+   (lambda ($3 $2 $1 . $rest) `(declr-scope ,$2))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" type-qua...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(declr-array ,$3 ,$4))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" type-qua...
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(declr-array ,$1 ,$3))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" assignme...
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(declr-array ,$1 ,$3))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" "]"
+   (lambda ($3 $2 $1 . $rest) `(declr-array ,$1))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" "static"...
+   (lambda ($6 $5 $4 $3 $2 $1 . $rest)
+     `(declr-array
+        ,$1
+        ,(tl->list (tl-insert '(stor-spec "static") $4))
+        ,$5))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" "static"...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(declr-array
+        ,$1
+        ,(tl->list (tl-insert '(stor-spec "static") $4))))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" type-qua...
+   (lambda ($6 $5 $4 $3 $2 $1 . $rest)
+     `(declr-array
+        ,$1
+        ,(tl->list (tl-insert '(stor-spec "static") $3))
+        ,$5))
+   ;; direct-abstract-declarator => "[" type-qualifier-list assignment-expr...
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(declr-anon-array ,$2 ,$3))
+   ;; direct-abstract-declarator => "[" type-qualifier-list "]"
+   (lambda ($3 $2 $1 . $rest)
+     `(declr-anon-array ,$2))
+   ;; direct-abstract-declarator => "[" assignment-expression "]"
+   (lambda ($3 $2 $1 . $rest)
+     `(declr-anon-array ,$2))
+   ;; direct-abstract-declarator => "[" "]"
+   (lambda ($2 $1 . $rest) `(declr-anon-array))
+   ;; direct-abstract-declarator => "[" "static" type-qualifier-list assign...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(declr-anon-array
+        ,(tl->list (tl-insert '(stor-spec "static") $3))
+        ,$4))
+   ;; direct-abstract-declarator => "[" "static" type-qualifier-list "]"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(declr-anon-array
+        ,(tl->list (tl-insert '(stor-spec "static") $3))))
+   ;; direct-abstract-declarator => "[" type-qualifier-list "static" assign...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(declr-anon-array
+        ,(tl->list (tl-insert '(stor-spec "static") $2))
+        ,$4))
+   ;; direct-abstract-declarator => direct-abstract-declarator "[" "*" "]"
+   (lambda ($4 $3 $2 $1 . $rest) `(declr-STAR ,$1))
+   ;; direct-abstract-declarator => "[" "*" "]"
+   (lambda ($3 $2 $1 . $rest) '(declr-STAR))
+   ;; direct-abstract-declarator => direct-abstract-declarator "(" paramete...
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(declr-fctn ,$1 ,(tl->list $3)))
+   ;; direct-abstract-declarator => direct-abstract-declarator "(" ")"
+   (lambda ($3 $2 $1 . $rest) `(declr-fctn ,$1))
+   ;; direct-abstract-declarator => "(" parameter-type-list ")"
+   (lambda ($3 $2 $1 . $rest)
+     `(declr-anon-fctn ,(tl->list $2)))
+   ;; direct-abstract-declarator => "(" ")"
+   (lambda ($2 $1 . $rest) '(declr-anon-fctn))
+   ;; typedef-name => 'typename
+   (lambda ($1 . $rest) `(typename ,$1))
+   ;; initializer => assignment-expression
+   (lambda ($1 . $rest) `(initzer ,$1))
+   ;; initializer => "{" initializer-list "}"
+   (lambda ($3 $2 $1 . $rest)
+     `(initzer ,(tl->list $2)))
+   ;; initializer => "{" initializer-list "," "}"
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(initzer ,(tl->list $2)))
+   ;; initializer-list => designation initializer
+   (lambda ($2 $1 . $rest)
+     (make-tl 'initzer-list $1 $2))
+   ;; initializer-list => initializer
+   (lambda ($1 . $rest) (make-tl 'initzer-list $1))
+   ;; initializer-list => initializer-list "," designation initializer
+   (lambda ($4 $3 $2 $1 . $rest)
+     (tl-append $1 $3 $4))
+   ;; initializer-list => initializer-list "," initializer
+   (lambda ($3 $2 $1 . $rest) (tl-append $1 $3))
+   ;; designation => designator-list "="
+   (lambda ($2 $1 . $rest) `(desig ,$1))
+   ;; designator-list => designator
+   (lambda ($1 . $rest) (make-tl 'desgr-list $1))
+   ;; designator-list => designator-list designator
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; designator => "[" constant-expression "]"
+   (lambda ($3 $2 $1 . $rest) (list 'array-dsgr $2))
+   ;; designator => "." identifier
+   (lambda ($2 $1 . $rest) (list 'sel-dsgr $2))
+   ;; statement => labeled-statement
+   (lambda ($1 . $rest) $1)
+   ;; statement => compound-statement
+   (lambda ($1 . $rest) $1)
+   ;; statement => expression-statement
+   (lambda ($1 . $rest) $1)
+   ;; statement => selection-statement
+   (lambda ($1 . $rest) $1)
+   ;; statement => iteration-statement
+   (lambda ($1 . $rest) $1)
+   ;; statement => jump-statement
+   (lambda ($1 . $rest) $1)
+   ;; statement => cpp-statement
+   (lambda ($1 . $rest) $1)
+   ;; labeled-statement => identifier ":" statement
+   (lambda ($3 $2 $1 . $rest)
+     `(labeled-stmt ,$1 ,$3))
+   ;; labeled-statement => "case" constant-expression ":" statement
+   (lambda ($4 $3 $2 $1 . $rest) `(case ,$2 ,$4))
+   ;; labeled-statement => "default" ":" statement
+   (lambda ($3 $2 $1 . $rest) `(default ,$3))
+   ;; compound-statement => "{" block-item-list "}"
+   (lambda ($3 $2 $1 . $rest)
+     `(compd-stmt ,(tl->list $2)))
+   ;; compound-statement => "{" "}"
+   (lambda ($2 $1 . $rest)
+     `(compd-stmt (block-item-list)))
+   ;; block-item-list => block-item
+   (lambda ($1 . $rest)
+     (make-tl 'block-item-list $1))
+   ;; block-item-list => block-item-list block-item
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; block-item => declaration
+   (lambda ($1 . $rest) $1)
+   ;; block-item => statement
+   (lambda ($1 . $rest) $1)
+   ;; expression-statement => expression ";"
+   (lambda ($2 $1 . $rest) `(expr-stmt ,$1))
+   ;; expression-statement => ";"
+   (lambda ($1 . $rest) '(expr-stmt))
+   ;; selection-statement => "if" "(" expression ")" statement
+   (lambda ($5 $4 $3 $2 $1 . $rest) `(if ,$3 ,$5))
+   ;; selection-statement => "if" "(" expression ")" statement "else" state...
+   (lambda ($7 $6 $5 $4 $3 $2 $1 . $rest)
+     `(if ,$3 ,$5 ,$7))
+   ;; selection-statement => "switch" "(" expression ")" statement
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(switch ,$3 ,$5))
+   ;; iteration-statement => "while" "(" expression ")" statement
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(while ,$3 ,$5))
+   ;; iteration-statement => "do" statement "while" "(" expression ")" ";"
+   (lambda ($7 $6 $5 $4 $3 $2 $1 . $rest)
+     `(do-while ,$2 ,$5))
+   ;; iteration-statement => "for" "(" initial-clause opt-expression ";" op...
+   (lambda ($8 $7 $6 $5 $4 $3 $2 $1 . $rest)
+     `(for ,$3 ,$4 ,$6 ,$8))
+   ;; initial-clause => expression ";"
+   (lambda ($2 $1 . $rest) $1)
+   ;; initial-clause => ";"
+   (lambda ($1 . $rest) '(expr))
+   ;; initial-clause => declaration
+   (lambda ($1 . $rest) $1)
+   ;; opt-expression => 
+   (lambda $rest '(expr))
+   ;; opt-expression => expression
+   (lambda ($1 . $rest) $1)
+   ;; jump-statement => "goto" identifier ";"
+   (lambda ($3 $2 $1 . $rest) `(goto $2))
+   ;; jump-statement => "continue" ";"
+   (lambda ($2 $1 . $rest) '(continue))
+   ;; jump-statement => "break" ";"
+   (lambda ($2 $1 . $rest) '(break))
+   ;; jump-statement => "return" expression ";"
+   (lambda ($3 $2 $1 . $rest) `(return ,$2))
+   ;; jump-statement => "return" ";"
+   (lambda ($2 $1 . $rest) `(return (expr)))
+   ;; translation-unit => external-declaration
+   (lambda ($1 . $rest) (make-tl 'trans-unit $1))
+   ;; translation-unit => translation-unit external-declaration
+   (lambda ($2 $1 . $rest)
+     (cond ((eqv? 'trans-unit (car $2))
+            (let* ((t1 (tl-append $1 '(extern-C-begin)))
+                   (t2 (tl-extend t1 (cdr $2)))
+                   (t3 (tl-append t2 '(extern-C-end))))
+              t3))
+           (else (tl-append $1 $2))))
+   ;; external-declaration => function-definition
+   (lambda ($1 . $rest) $1)
+   ;; external-declaration => declaration
+   (lambda ($1 . $rest) $1)
+   ;; external-declaration => lone-comment
+   (lambda ($1 . $rest) $1)
+   ;; external-declaration => cpp-statement
+   (lambda ($1 . $rest) $1)
+   ;; external-declaration => "extern" '$string "{" translation-unit "}"
+   (lambda ($5 $4 $3 $2 $1 . $rest) (tl->list $4))
+   ;; function-definition => declaration-specifiers declarator declaration-...
+   (lambda ($4 $3 $2 $1 . $rest)
+     `(knr-fctn-defn
+        ,(tl->list $1)
+        ,$2
+        ,(tl->list $3)
+        ,$4))
+   ;; function-definition => declaration-specifiers declarator compound-sta...
+   (lambda ($3 $2 $1 . $rest)
+     `(fctn-defn ,(tl->list $1) ,$2 ,$3))
+   ;; declaration-list => declaration
+   (lambda ($1 . $rest) (make-tl $1))
+   ;; declaration-list => declaration-list declaration
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; opt-code-comment => 
+   (lambda $rest (list))
+   ;; opt-code-comment => code-comment
+   (lambda ($1 . $rest) $1)
+   ;; identifier => '$ident
+   (lambda ($1 . $rest) `(ident ,$1))
+   ;; identifier => 'cpp-ident
+   (lambda ($1 . $rest) `(ident ,$1))
+   ;; constant => '$fixed
+   (lambda ($1 . $rest) `(fixed ,$1))
+   ;; constant => '$float
+   (lambda ($1 . $rest) `(float ,$1))
+   ;; constant => '$chlit
+   (lambda ($1 . $rest) `(char ,$1))
+   ;; string-literal => '$string
+   (lambda ($1 . $rest) (make-tl 'string $1))
+   ;; string-literal => string-literal '$string
+   (lambda ($2 $1 . $rest) (tl-append $1 $2))
+   ;; code-comment => '$code-comm
+   (lambda ($1 . $rest) `(comment ,$1))
+   ;; lone-comment => '$lone-comm
+   (lambda ($1 . $rest) `(comment ,$1))
+   ;; cpp-statement => 'cpp-stmt
+   (lambda ($1 . $rest) `(cpp-stmt ,$1))
+   ))
+
+;;; end tables
diff --git a/module/nyacc/lang/c99/mach.d/c99xtab.scm b/module/nyacc/lang/c99/mach.d/c99xtab.scm
new file mode 100644 (file)
index 0000000..e47bf8f
--- /dev/null
@@ -0,0 +1,559 @@
+;; ./mach.d/c99xtab.scm
+
+;; Copyright (C) 2015,2016 Matthew R. Wette
+;; 
+;; This software is covered by the GNU GENERAL PUBLIC LICENCE, Version 3,
+;; or any later version published by the Free Software Foundation.  See the
+;; file COPYING included with the this distribution.
+
+(define len-v
+  #(1 1 1 1 1 3 1 4 4 3 3 3 2 2 6 7 1 3 1 3 2 1 1 2 2 2 2 4 1 1 1 1 1 1 1 4 
+    1 3 3 3 1 3 3 1 3 3 1 3 3 3 3 1 3 3 1 3 1 3 1 3 1 3 1 3 1 5 1 3 1 1 1 1 1 
+    1 1 1 1 1 1 1 3 1 5 3 0 1 2 1 2 1 2 1 2 1 3 1 3 1 1 1 1 1 1 1 1 1 1 1 1 1 
+    1 2 2 3 1 1 2 1 2 2 3 2 3 3 4 3 2 2 1 3 2 4 3 1 2 2 1 1 2 1 2 2 3 5 4 2 5 
+    4 2 1 1 1 1 2 2 4 2 1 2 1 1 3 1 3 2 5 6 4 5 2 1 3 1 3 1 1 1 1 2 1 1 3 5 4 
+    4 3 6 6 5 4 4 4 3 2 1 3 2 1 2 1 3 1 3 2 2 1 1 3 2 1 1 2 1 3 5 4 4 3 6 5 6 
+    4 3 3 2 5 4 5 4 3 4 3 3 2 1 1 3 4 2 1 4 3 2 1 2 3 2 1 1 1 1 1 1 1 3 4 3 3 
+    2 1 2 1 1 2 1 5 7 5 5 7 8 2 1 1 0 1 3 2 2 3 2 1 2 1 1 1 1 5 4 3 1 2 0 1 1 
+    1 1 1 1 1 2 1 1 1))
+
+(define pat-v
+  #(((163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (
+    7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (156 . 14) (155 . 15) (
+    176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 . 20) (76 . 21) (77 . 22) (
+    78 . 23) (79 . 24) (80 . 25) (92 . 26) (174 . 27) (153 . 28) (81 . 29) (
+    164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 34) (152 . 35) (169 . 36) 
+    (175 . 37)) ((-1 . -36)) ((79 . 119) (74 . 120) (73 . 121) (-1 . -40)) ((
+    78 . 117) (77 . 118) (-1 . -43)) ((72 . 115) (71 . 116) (-1 . -46)) ((70 
+    . 111) (69 . 112) (68 . 113) (67 . 114) (-1 . -51)) ((66 . 109) (65 . 110)
+    (-1 . -54)) ((80 . 108) (-1 . -56)) ((-1 . -299)) ((-1 . -298)) ((-1 . 
+    -297)) ((-1 . -296)) ((-1 . -295)) ((-1 . -294)) ((64 . 107) (-1 . -58)) (
+    (63 . 106) (-1 . -60)) ((7 . 105) (-1 . -4)) ((-1 . -3)) ((-1 . -2)) ((62 
+    . 104) (-1 . -62)) ((-1 . -33)) ((-1 . -32)) ((-1 . -31)) ((-1 . -30)) ((
+    -1 . -29)) ((-1 . -28)) ((163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5)
+    (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (
+    156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 . 20)
+    (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (92 . 26) (174 . 27) (
+    153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 34) (
+    152 . 35) (169 . 36) (175 . 66) (21 . 67) (27 . 68) (28 . 69) (29 . 70) (
+    30 . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 
+    . 78) (39 . 79) (23 . 80) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 
+    85) (137 . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (42 . 
+    92) (43 . 93) (44 . 94) (45 . 95) (46 . 96) (144 . 97) (145 . 98) (146 . 
+    99) (147 . 100) (167 . 101) (130 . 102) (171 . 103)) ((-1 . -6)) ((60 . 64
+    ) (61 . 65) (-1 . -64)) ((7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 
+    13) (176 . 16) (177 . 17) (178 . 18) (75 . 20) (76 . 21) (77 . 22) (78 . 
+    23) (79 . 24) (80 . 25) (174 . 27) (81 . 29) (164 . 30) (85 . 31) (86 . 32
+    ) (173 . 33) (165 . 62) (92 . 63)) ((7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 
+    . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 18) (75 . 20) (76 . 21) (77 . 
+    22) (78 . 23) (79 . 24) (80 . 25) (174 . 27) (81 . 29) (164 . 30) (85 . 31
+    ) (86 . 32) (173 . 33) (92 . 26) (165 . 60) (163 . 61)) ((7 . 8) (2 . 9) (
+    3 . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 18) (75 . 
+    20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (92 . 57) (174 . 27)
+    (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 59)) ((7 . 8) 
+    (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 
+    18) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (92 . 57) 
+    (174 . 27) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 58))
+    ((90 . 51) (92 . 52) (88 . 53) (87 . 54) (86 . 55) (85 . 56) (-1 . -22)) 
+    ((48 . 39) (49 . 40) (50 . 41) (51 . 42) (52 . 43) (53 . 44) (54 . 45) (55
+    . 46) (56 . 47) (57 . 48) (58 . 49) (151 . 50) (-1 . -34)) ((-1 . -66)) (
+    (-1 . -79)) ((82 . 38) (96 . 0)) ((163 . 1) (162 . 2) (161 . 3) (160 . 4) 
+    (159 . 5) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (
+    6 . 13) (156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 . 18) (154 . 19) 
+    (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (92 . 26) (174
+    . 27) (153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (165
+    . 34) (152 . 35) (169 . 190)) ((-1 . -78)) ((-1 . -77)) ((-1 . -76)) ((-1
+    . -75)) ((-1 . -74)) ((-1 . -73)) ((-1 . -72)) ((-1 . -71)) ((-1 . -70)) 
+    ((-1 . -69)) ((-1 . -68)) ((163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 
+    5) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13)
+    (156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 . 
+    20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (92 . 26) (174 . 27)
+    (153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 34)
+    (152 . 35) (169 . 189)) ((163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5
+    ) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) 
+    (156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 . 20
+    ) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (92 . 26) (174 . 27) (
+    153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 34) (
+    152 . 35) (169 . 36) (175 . 188)) ((91 . 183) (163 . 1) (162 . 2) (161 . 3
+    ) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11
+    ) (5 . 12) (6 . 13) (156 . 14) (21 . 67) (27 . 68) (28 . 69) (29 . 70) (30
+    . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 . 
+    78) (39 . 79) (155 . 15) (176 . 16) (177 . 17) (178 . 18) (23 . 80) (24 . 
+    81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (137 . 86) (138 . 87) (40 . 
+    88) (139 . 89) (140 . 90) (41 . 91) (42 . 92) (43 . 93) (44 . 94) (45 . 95
+    ) (46 . 96) (154 . 19) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (
+    80 . 25) (92 . 26) (174 . 27) (144 . 97) (145 . 146) (146 . 147) (147 . 
+    100) (153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 
+    . 34) (152 . 35) (167 . 184) (168 . 185) (169 . 186) (172 . 187)) ((5 . 12
+    ) (6 . 13) (178 . 182)) ((5 . 12) (6 . 13) (178 . 181)) ((-1 . -12)) ((-1 
+    . -13)) ((21 . 67) (27 . 68) (28 . 69) (29 . 70) (30 . 71) (31 . 72) (32 
+    . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 . 78) (39 . 79) (23 . 80
+    ) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (137 . 86) (138 . 87
+    ) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (42 . 92) (43 . 93) (44 . 94) 
+    (45 . 95) (46 . 96) (144 . 97) (145 . 98) (146 . 99) (147 . 100) (167 . 
+    101) (130 . 102) (171 . 180) (163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 
+    . 5) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 
+    13) (156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 
+    . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (92 . 26) (174 . 
+    27) (153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 
+    34) (152 . 35) (169 . 36) (175 . 66)) ((-1 . -23)) ((-1 . -24)) ((-1 . -34
+    )) ((-1 . -25)) ((-1 . -26)) ((21 . 67) (27 . 68) (28 . 69) (29 . 70) (30 
+    . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 . 78
+    ) (39 . 79) (23 . 80) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) 
+    (137 . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (42 . 92) 
+    (43 . 93) (44 . 94) (45 . 95) (46 . 96) (144 . 97) (145 . 98) (146 . 99) (
+    147 . 100) (167 . 101) (130 . 102) (171 . 179) (163 . 1) (162 . 2) (161 . 
+    3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 
+    11) (5 . 12) (6 . 13) (156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 . 
+    18) (154 . 19) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25)
+    (92 . 26) (174 . 27) (153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) 
+    (173 . 33) (165 . 34) (152 . 35) (169 . 36) (175 . 66)) ((163 . 1) (162 . 
+    2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 
+    10) (4 . 11) (5 . 12) (6 . 13) (156 . 14) (155 . 15) (176 . 16) (177 . 17)
+    (178 . 18) (154 . 19) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (
+    80 . 25) (92 . 26) (174 . 27) (153 . 28) (81 . 29) (164 . 30) (85 . 31) (
+    86 . 32) (173 . 33) (165 . 34) (152 . 35) (169 . 36) (175 . 178)) ((7 . 8)
+    (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 
+    18) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 27)
+    (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 60) 
+    (163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (156
+    . 14) (155 . 15) (154 . 177)) ((91 . 176) (82 . 38)) ((-1 . -234)) ((84 
+    . 174) (5 . 12) (6 . 13) (178 . 175)) ((84 . 172) (5 . 12) (6 . 13) (21 . 
+    67) (135 . 169) (178 . 170) (134 . 173)) ((84 . 168) (5 . 12) (6 . 13) (21
+    . 67) (135 . 169) (178 . 170) (134 . 171)) ((-1 . -139)) ((30 . 167) (-1 
+    . -137)) ((30 . 166) (-1 . -136)) ((-1 . -133)) ((39 . 162) (37 . 163) (35
+    . 164) (33 . 165) (-1 . -128)) ((37 . 159) (35 . 160) (31 . 161) (-1 . 
+    -117)) ((-1 . -114)) ((39 . 155) (37 . 156) (35 . 157) (33 . 158) (-1 . 
+    -115)) ((37 . 154) (-1 . -110)) ((-1 . -177)) ((-1 . -176)) ((-1 . -175)) 
+    ((-1 . -174)) ((-1 . -109)) ((-1 . -108)) ((-1 . -107)) ((-1 . -106)) ((-1
+    . -105)) ((-1 . -104)) ((-1 . -103)) ((-1 . -102)) ((-1 . -101)) ((-1 . 
+    -100)) ((-1 . -99)) ((-1 . -98)) ((-1 . -97)) ((21 . 67) (27 . 68) (28 . 
+    69) (29 . 70) (30 . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) 
+    (37 . 77) (36 . 78) (39 . 79) (23 . 80) (24 . 81) (25 . 82) (26 . 83) (135
+    . 84) (136 . 85) (137 . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90) (
+    41 . 91) (42 . 92) (43 . 93) (44 . 94) (45 . 95) (46 . 96) (144 . 97) (145
+    . 146) (146 . 147) (147 . 100) (167 . 153) (-1 . -91)) ((23 . 80) (42 . 
+    92) (43 . 93) (44 . 94) (45 . 95) (46 . 96) (144 . 97) (147 . 100) (167 . 
+    151) (21 . 67) (27 . 68) (28 . 69) (29 . 70) (30 . 71) (31 . 72) (32 . 73)
+    (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 . 78) (39 . 79) (24 . 81) (25
+    . 82) (26 . 83) (135 . 84) (136 . 85) (137 . 86) (138 . 87) (40 . 88) (
+    139 . 89) (140 . 90) (41 . 91) (145 . 98) (146 . 99) (130 . 152) (91 . -89
+    ) (79 . -159) (90 . -159) (92 . -159)) ((23 . 80) (42 . 92) (43 . 93) (44 
+    . 94) (45 . 95) (46 . 96) (144 . 97) (147 . 100) (167 . 149) (21 . 67) (27
+    . 68) (28 . 69) (29 . 70) (30 . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 
+    75) (35 . 76) (37 . 77) (36 . 78) (39 . 79) (24 . 81) (25 . 82) (26 . 83) 
+    (135 . 84) (136 . 85) (137 . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90
+    ) (41 . 91) (145 . 98) (146 . 99) (130 . 150) (91 . -87) (79 . -157) (90 
+    . -157) (92 . -157)) ((21 . 67) (27 . 68) (28 . 69) (29 . 70) (30 . 71) (
+    31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 . 78) (39 
+    . 79) (23 . 80) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (137 
+    . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (42 . 92) (43 
+    . 93) (44 . 94) (45 . 95) (46 . 96) (144 . 97) (145 . 146) (146 . 147) (
+    147 . 100) (167 . 148) (-1 . -85)) ((91 . -209)) ((90 . 140) (92 . 141) (
+    79 . 142) (117 . 143) (124 . 144) (166 . 145)) ((91 . 139)) ((7 . 8) (2 . 
+    9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 18) (
+    75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 27) (81 
+    . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 60) (163 
+    . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (156 . 14
+    ) (155 . 138)) ((-1 . -300)) ((7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (
+    6 . 13) (176 . 16) (177 . 17) (178 . 18) (75 . 20) (76 . 21) (77 . 22) (78
+    . 23) (79 . 24) (80 . 25) (174 . 27) (81 . 29) (164 . 30) (85 . 31) (86 
+    . 32) (173 . 33) (92 . 26) (165 . 60) (163 . 1) (162 . 2) (161 . 3) (160 
+    . 4) (159 . 5) (158 . 6) (157 . 7) (156 . 137)) ((7 . 8) (2 . 9) (3 . 10) 
+    (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 18) (75 . 20) (76 
+    . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 27) (81 . 29) (164 . 
+    30) (85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 60) (163 . 1) (162 . 2
+    ) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 136)) ((7 . 8) (2 . 9) (3
+    . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 18) (75 . 
+    20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 27) (81 . 29)
+    (164 . 30) (85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 60) (163 . 1) 
+    (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 135)) ((7 . 8) (2 . 9) (3 
+    . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 18) (75 . 20
+    ) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 27) (81 . 29) (
+    164 . 30) (85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 60) (163 . 1) (
+    162 . 2) (161 . 3) (160 . 4) (159 . 134)) ((7 . 8) (2 . 9) (3 . 10) (4 . 
+    11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 18) (75 . 20) (76 . 21)
+    (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 27) (81 . 29) (164 . 30) (
+    85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 60) (163 . 1) (162 . 2) (
+    161 . 3) (160 . 4) (159 . 133)) ((7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12
+    ) (6 . 13) (176 . 16) (177 . 17) (178 . 18) (75 . 20) (76 . 21) (77 . 22) 
+    (78 . 23) (79 . 24) (80 . 25) (174 . 27) (81 . 29) (164 . 30) (85 . 31) (
+    86 . 32) (173 . 33) (92 . 26) (165 . 60) (163 . 1) (162 . 2) (161 . 3) (
+    160 . 132)) ((7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16
+    ) (177 . 17) (178 . 18) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) 
+    (80 . 25) (174 . 27) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (
+    92 . 26) (165 . 60) (163 . 1) (162 . 2) (161 . 3) (160 . 131)) ((7 . 8) (2
+    . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 18)
+    (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 27) (
+    81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 60) (
+    163 . 1) (162 . 2) (161 . 3) (160 . 130)) ((7 . 8) (2 . 9) (3 . 10) (4 . 
+    11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 18) (75 . 20) (76 . 21)
+    (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 27) (81 . 29) (164 . 30) (
+    85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 60) (163 . 1) (162 . 2) (
+    161 . 3) (160 . 129)) ((7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13)
+    (176 . 16) (177 . 17) (178 . 18) (75 . 20) (76 . 21) (77 . 22) (78 . 23) 
+    (79 . 24) (80 . 25) (174 . 27) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (
+    173 . 33) (92 . 26) (165 . 60) (163 . 1) (162 . 2) (161 . 128)) ((7 . 8) (
+    2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 18
+    ) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 27) (
+    81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 60) (
+    163 . 1) (162 . 2) (161 . 127)) ((7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12
+    ) (6 . 13) (176 . 16) (177 . 17) (178 . 18) (75 . 20) (76 . 21) (77 . 22) 
+    (78 . 23) (79 . 24) (80 . 25) (174 . 27) (81 . 29) (164 . 30) (85 . 31) (
+    86 . 32) (173 . 33) (92 . 26) (165 . 60) (163 . 1) (162 . 126)) ((7 . 8) (
+    2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 18
+    ) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 27) (
+    81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 60) (
+    163 . 1) (162 . 125)) ((7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13)
+    (176 . 16) (177 . 17) (178 . 18) (75 . 20) (76 . 21) (77 . 22) (78 . 23) 
+    (79 . 24) (80 . 25) (174 . 27) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (
+    173 . 33) (92 . 26) (165 . 60) (163 . 124)) ((7 . 8) (2 . 9) (3 . 10) (4 
+    . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 18) (75 . 20) (76 . 
+    21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 27) (81 . 29) (164 . 30
+    ) (85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 60) (163 . 123)) ((7 . 8
+    ) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 
+    . 18) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 
+    27) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 
+    60) (163 . 122)) ((-1 . -39)) ((-1 . -38)) ((-1 . -37)) ((79 . 119) (74 . 
+    120) (73 . 121) (-1 . -42)) ((79 . 119) (74 . 120) (73 . 121) (-1 . -41)) 
+    ((78 . 117) (77 . 118) (-1 . -45)) ((78 . 117) (77 . 118) (-1 . -44)) ((72
+    . 115) (71 . 116) (-1 . -50)) ((72 . 115) (71 . 116) (-1 . -49)) ((72 . 
+    115) (71 . 116) (-1 . -48)) ((72 . 115) (71 . 116) (-1 . -47)) ((70 . 111)
+    (69 . 112) (68 . 113) (67 . 114) (-1 . -53)) ((70 . 111) (69 . 112) (68 
+    . 113) (67 . 114) (-1 . -52)) ((66 . 109) (65 . 110) (-1 . -55)) ((80 . 
+    108) (-1 . -57)) ((64 . 107) (-1 . -59)) ((63 . 106) (-1 . -61)) ((84 . 
+    237) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 
+    . 17) (178 . 18) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 
+    25) (174 . 27) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (92 . 
+    26) (165 . 60) (163 . 238)) ((163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 
+    . 5) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 
+    13) (156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 
+    . 20) (76 . 21) (77 . 22) (78 . 23) (80 . 25) (92 . 26) (174 . 27) (153 . 
+    28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 34) (152 . 
+    35) (169 . 232) (89 . 233) (43 . 234) (24 . 81) (25 . 82) (26 . 83) (145 
+    . 223) (122 . 235) (79 . 236)) ((90 . 140) (92 . 141) (79 . 142) (117 . 
+    143) (124 . 144) (166 . 226) (21 . 67) (27 . 68) (28 . 69) (29 . 70) (30 
+    . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 . 78
+    ) (39 . 79) (23 . 80) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) 
+    (137 . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (42 . 92) 
+    (43 . 93) (44 . 94) (45 . 95) (46 . 96) (144 . 97) (145 . 146) (146 . 147)
+    (147 . 100) (167 . 227) (118 . 228) (119 . 229) (121 . 230) (91 . 231)) (
+    (24 . 81) (25 . 82) (26 . 83) (145 . 223) (122 . 224) (79 . 142) (124 . 
+    225) (-1 . -194)) ((90 . 221) (92 . 222) (91 . -212) (82 . -212)) ((90 . 
+    140) (92 . 141) (117 . 220) (91 . -210) (82 . -210)) ((91 . -208)) ((21 . 
+    67) (27 . 68) (28 . 69) (29 . 70) (30 . 71) (31 . 72) (32 . 73) (33 . 74) 
+    (34 . 75) (35 . 76) (37 . 77) (36 . 78) (39 . 79) (23 . 80) (24 . 81) (25 
+    . 82) (26 . 83) (135 . 84) (136 . 85) (137 . 86) (138 . 87) (40 . 88) (139
+    . 89) (140 . 90) (41 . 91) (42 . 92) (43 . 93) (44 . 94) (45 . 95) (46 . 
+    96) (144 . 97) (145 . 146) (146 . 147) (147 . 100) (167 . 151) (-1 . -89))
+    ((21 . 67) (27 . 68) (28 . 69) (29 . 70) (30 . 71) (31 . 72) (32 . 73) (
+    33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 . 78) (39 . 79) (23 . 80) (24 
+    . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (137 . 86) (138 . 87) (40 
+    . 88) (139 . 89) (140 . 90) (41 . 91) (42 . 92) (43 . 93) (44 . 94) (45 . 
+    95) (46 . 96) (144 . 97) (145 . 146) (146 . 147) (147 . 100) (167 . 149) (
+    -1 . -87)) ((-1 . -86)) ((-1 . -88)) ((-1 . -156)) ((-1 . -90)) ((-1 . 
+    -158)) ((-1 . -92)) ((-1 . -111)) ((37 . 219) (-1 . -112)) ((-1 . -116)) (
+    (35 . 217) (37 . 218) (-1 . -119)) ((-1 . -134)) ((-1 . -118)) ((37 . 216)
+    (-1 . -121)) ((30 . 215) (-1 . -138)) ((37 . 214) (-1 . -126)) ((-1 . 
+    -127)) ((35 . 212) (37 . 213) (-1 . -130)) ((-1 . -135)) ((-1 . -140)) ((
+    -1 . -141)) ((21 . 67) (27 . 68) (28 . 69) (29 . 70) (30 . 71) (31 . 72) (
+    32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 . 78) (39 . 79) (24 
+    . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (137 . 86) (138 . 87) (40 
+    . 88) (139 . 89) (140 . 90) (41 . 91) (145 . 203) (146 . 204) (94 . 205) (
+    130 . 206) (131 . 207) (132 . 208) (133 . 211)) ((-1 . -150)) ((-1 . -149)
+    ) ((84 . 210) (-1 . -145)) ((21 . 67) (27 . 68) (28 . 69) (29 . 70) (30 . 
+    71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 . 78) 
+    (39 . 79) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (137 . 86) (
+    138 . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (145 . 203) (146 . 204
+    ) (94 . 205) (130 . 206) (131 . 207) (132 . 208) (133 . 209)) ((84 . 202) 
+    (-1 . -148)) ((5 . 12) (6 . 13) (178 . 199) (125 . 200) (126 . 201)) ((84 
+    . 198) (-1 . -169)) ((-1 . -5)) ((62 . 104) (-1 . -63)) ((59 . 197) (82 . 
+    38)) ((91 . 196)) ((91 . 195)) ((-1 . -11)) ((-1 . -10)) ((-1 . -9)) ((90 
+    . 140) (92 . 141) (79 . 142) (117 . 143) (124 . 144) (166 . 194) (91 . -21
+    ) (82 . -21)) ((91 . -18) (82 . -18)) ((91 . -16) (82 . -16)) ((91 . 192) 
+    (82 . 193)) ((89 . 191) (82 . 38)) ((-1 . -67)) ((-1 . -80)) ((-1 . -7)) (
+    (-1 . -8)) ((21 . 67) (27 . 68) (28 . 69) (29 . 70) (30 . 71) (31 . 72) (
+    32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 . 78) (39 . 79) (23 
+    . 80) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (137 . 86) (138 
+    . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (42 . 92) (43 . 93) (44 . 
+    94) (45 . 95) (46 . 96) (144 . 97) (145 . 146) (146 . 147) (147 . 100) (
+    167 . 184) (168 . 291) (163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (
+    158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (
+    156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 . 20)
+    (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (92 . 26) (174 . 27) (
+    153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 34) (
+    152 . 35) (169 . 292)) ((91 . -20) (82 . -20)) ((84 . 237)) ((84 . 237) (
+    -1 . -27)) ((7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16)
+    (177 . 17) (178 . 18) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (
+    80 . 25) (174 . 27) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (
+    92 . 26) (165 . 60) (163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158
+    . 6) (157 . 7) (156 . 14) (155 . 15) (154 . 19) (153 . 28) (152 . 290)) (
+    (5 . 12) (6 . 13) (178 . 199) (125 . 200) (126 . 289)) ((58 . 288) (83 . 
+    -172) (82 . -172)) ((83 . -170) (82 . -170)) ((83 . 286) (82 . 287)) ((21 
+    . 67) (27 . 68) (28 . 69) (29 . 70) (30 . 71) (31 . 72) (32 . 73) (33 . 74
+    ) (34 . 75) (35 . 76) (37 . 77) (36 . 78) (39 . 79) (24 . 81) (25 . 82) (
+    26 . 83) (135 . 84) (136 . 85) (137 . 86) (138 . 87) (40 . 88) (139 . 89) 
+    (140 . 90) (41 . 91) (145 . 203) (146 . 204) (94 . 205) (130 . 206) (131 
+    . 207) (132 . 208) (133 . 285)) ((21 . 67) (27 . 68) (28 . 69) (29 . 70) (
+    30 . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 
+    . 78) (39 . 79) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (137 
+    . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (145 . 203) (
+    146 . 204) (130 . 152) (-1 . -159)) ((21 . 67) (27 . 68) (28 . 69) (29 . 
+    70) (30 . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) 
+    (36 . 78) (39 . 79) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (
+    137 . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (145 . 203)
+    (146 . 204) (130 . 150) (-1 . -157)) ((94 . -302) (-1 . -302)) ((5 . 12) 
+    (6 . 13) (79 . 142) (92 . 279) (178 . 257) (123 . 258) (124 . 280) (59 . 
+    281) (142 . 282) (128 . 283) (129 . 284)) ((94 . -152) (-1 . -152)) ((94 
+    . -151) (-1 . -151)) ((83 . 278) (21 . 67) (27 . 68) (28 . 69) (29 . 70) (
+    30 . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 
+    . 78) (39 . 79) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (137 
+    . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (145 . 203) (
+    146 . 204) (130 . 206) (132 . 275) (94 . 205) (131 . 276)) ((21 . 67) (27 
+    . 68) (28 . 69) (29 . 70) (30 . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75
+    ) (35 . 76) (37 . 77) (36 . 78) (39 . 79) (24 . 81) (25 . 82) (26 . 83) (
+    135 . 84) (136 . 85) (137 . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90)
+    (41 . 91) (145 . 203) (146 . 204) (94 . 205) (130 . 206) (131 . 207) (132
+    . 208) (133 . 277)) ((83 . 274) (21 . 67) (27 . 68) (28 . 69) (29 . 70) (
+    30 . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 
+    . 78) (39 . 79) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (137 
+    . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (145 . 203) (
+    146 . 204) (130 . 206) (132 . 275) (94 . 205) (131 . 276)) ((37 . 273) (-1
+    . -132)) ((-1 . -129)) ((-1 . -125)) ((-1 . -142)) ((-1 . -122)) ((37 . 
+    272) (-1 . -123)) ((-1 . -120)) ((-1 . -113)) ((90 . 221) (92 . 222) (91 
+    . -211) (82 . -211)) ((43 . 267) (89 . 268) (163 . 1) (162 . 2) (161 . 3) 
+    (160 . 4) (159 . 5) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) 
+    (5 . 12) (6 . 13) (156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 . 18) (
+    154 . 19) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 269) (80 . 25) (92
+    . 26) (174 . 27) (153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173
+    . 33) (165 . 34) (152 . 35) (169 . 270) (24 . 81) (25 . 82) (26 . 83) (
+    145 . 223) (122 . 271)) ((91 . 265) (21 . 67) (27 . 68) (28 . 69) (29 . 70
+    ) (30 . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (
+    36 . 78) (39 . 79) (23 . 80) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136
+    . 85) (137 . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (42
+    . 92) (43 . 93) (44 . 94) (45 . 95) (46 . 96) (144 . 97) (145 . 146) (146
+    . 147) (147 . 100) (167 . 227) (118 . 228) (119 . 229) (121 . 266)) ((-1 
+    . -197)) ((79 . 142) (124 . 264) (24 . 81) (25 . 82) (26 . 83) (145 . 250)
+    (-1 . -193)) ((-1 . -196)) ((91 . 263)) ((5 . 12) (6 . 13) (178 . 257) (
+    123 . 258) (142 . 259) (90 . 140) (92 . 260) (79 . 142) (117 . 143) (124 
+    . 261) (166 . 262) (91 . -205) (82 . -205)) ((82 . -201) (91 . -201)) ((82
+    . 256) (91 . -199)) ((91 . 255)) ((-1 . -233)) ((89 . 254)) ((-1 . -224))
+    ((24 . 81) (25 . 82) (26 . 83) (145 . 223) (122 . 253)) ((43 . 249) (24 
+    . 81) (25 . 82) (26 . 83) (145 . 250) (89 . 251) (163 . 1) (162 . 2) (161 
+    . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 
+    . 11) (5 . 12) (6 . 13) (156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 
+    . 18) (154 . 19) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 
+    25) (92 . 26) (174 . 27) (153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 
+    32) (173 . 33) (165 . 34) (152 . 35) (169 . 252)) ((89 . 248) (-1 . -29)) 
+    ((163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (7 
+    . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (156 . 14) (155 . 15) (
+    176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 . 20) (76 . 21) (77 . 22) (
+    78 . 23) (79 . 24) (80 . 25) (92 . 26) (174 . 27) (88 . 239) (90 . 240) (
+    153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (114 . 241) 
+    (165 . 34) (152 . 35) (115 . 242) (84 . 243) (169 . 244) (141 . 245) (116 
+    . 246) (170 . 247)) ((-1 . -35)) ((5 . 12) (6 . 13) (178 . 329)) ((7 . 8) 
+    (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 
+    18) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 27)
+    (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 60) 
+    (163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (156
+    . 14) (155 . 15) (154 . 19) (153 . 28) (152 . 295) (127 . 328)) ((58 . 
+    -243) (88 . -243) (90 . -243)) ((58 . 326) (88 . 239) (90 . 240) (114 . 
+    327)) ((163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 
+    7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (156 . 14) (155 . 
+    15) (176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 . 20) (76 . 21) (77 . 
+    22) (78 . 23) (79 . 24) (80 . 25) (92 . 26) (174 . 27) (88 . 239) (90 . 
+    240) (153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (114 
+    . 241) (165 . 34) (152 . 35) (115 . 242) (84 . 243) (169 . 244) (141 . 245
+    ) (116 . 246) (170 . 325)) ((83 . -235) (82 . -235)) ((83 . -239) (82 . 
+    -239)) ((163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 
+    . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (156 . 14) (155 
+    . 15) (176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 . 20) (76 . 21) (77 
+    . 22) (78 . 23) (79 . 24) (80 . 25) (92 . 26) (174 . 27) (153 . 28) (81 . 
+    29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 34) (152 . 35) (84 . 
+    243) (169 . 244) (141 . 324)) ((83 . 322) (82 . 323)) ((-1 . -229)) ((163 
+    . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (7 . 8) (
+    2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (156 . 14) (155 . 15) (176 . 16
+    ) (177 . 17) (178 . 18) (154 . 19) (75 . 20) (76 . 21) (77 . 22) (78 . 23)
+    (79 . 24) (80 . 25) (92 . 26) (174 . 27) (153 . 28) (81 . 29) (164 . 30) 
+    (85 . 31) (86 . 32) (173 . 33) (165 . 34) (152 . 35) (169 . 321)) ((-1 . 
+    -198)) ((-1 . -222)) ((89 . 320)) ((163 . 1) (162 . 2) (161 . 3) (160 . 4)
+    (159 . 5) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) 
+    (6 . 13) (156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 . 18) (154 . 19)
+    (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (92 . 26) (
+    174 . 27) (153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (
+    165 . 34) (152 . 35) (169 . 318) (24 . 81) (25 . 82) (26 . 83) (145 . 250)
+    (89 . 319)) ((-1 . -223)) ((-1 . -232)) ((21 . 67) (27 . 68) (28 . 69) (
+    29 . 70) (30 . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 
+    . 77) (36 . 78) (39 . 79) (23 . 80) (24 . 81) (25 . 82) (26 . 83) (135 . 
+    84) (136 . 85) (137 . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90) (41 
+    . 91) (42 . 92) (43 . 93) (44 . 94) (45 . 95) (46 . 96) (144 . 97) (145 . 
+    146) (146 . 147) (147 . 100) (167 . 227) (118 . 316) (22 . 317)) ((-1 . 
+    -180)) ((90 . 314) (92 . 315) (-1 . -179)) ((91 . -203) (82 . -203)) ((90 
+    . 140) (117 . 143) (166 . 226) (21 . 67) (27 . 68) (28 . 69) (29 . 70) (30
+    . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 . 
+    78) (39 . 79) (23 . 80) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85
+    ) (137 . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (42 . 92
+    ) (43 . 93) (44 . 94) (45 . 95) (46 . 96) (144 . 97) (145 . 146) (146 . 
+    147) (147 . 100) (167 . 227) (118 . 228) (119 . 229) (121 . 230) (91 . 231
+    ) (5 . 12) (6 . 13) (79 . 142) (92 . 260) (178 . 257) (123 . 258) (124 . 
+    261) (142 . 305)) ((90 . 140) (117 . 220) (5 . 12) (6 . 13) (92 . 260) (
+    178 . 257) (123 . 304) (91 . -210) (82 . -210)) ((91 . -204) (82 . -204)) 
+    ((-1 . -213)) ((-1 . -195)) ((-1 . -231)) ((91 . 313)) ((24 . 81) (25 . 82
+    ) (26 . 83) (145 . 223) (122 . 312)) ((-1 . -217)) ((89 . 311) (-1 . -29))
+    ((89 . 310)) ((163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6)
+    (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (156 . 14) 
+    (155 . 15) (176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 . 20) (76 . 21)
+    (77 . 22) (78 . 23) (79 . 24) (80 . 25) (92 . 26) (174 . 27) (153 . 28) (
+    81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 34) (152 . 35) (
+    169 . 307) (24 . 81) (25 . 82) (26 . 83) (145 . 250) (89 . 308) (43 . 309)
+    ) ((-1 . -124)) ((-1 . -131)) ((-1 . -144)) ((94 . -153) (-1 . -153)) ((94
+    . -154) (-1 . -154)) ((83 . 306) (21 . 67) (27 . 68) (28 . 69) (29 . 70) 
+    (30 . 71) (31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 
+    . 78) (39 . 79) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (137 
+    . 86) (138 . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (145 . 203) (
+    146 . 204) (130 . 206) (132 . 275) (94 . 205) (131 . 276)) ((-1 . -147)) (
+    (5 . 12) (6 . 13) (79 . 142) (92 . 279) (178 . 257) (123 . 258) (124 . 280
+    ) (142 . 305)) ((5 . 12) (6 . 13) (92 . 279) (178 . 257) (123 . 304)) ((7 
+    . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (
+    178 . 18) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174
+    . 27) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 
+    . 60) (163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7
+    ) (156 . 14) (155 . 15) (154 . 19) (153 . 28) (152 . 295) (127 . 303)) ((
+    59 . 302) (47 . -162) (82 . -162)) ((47 . -160) (82 . -160)) ((47 . 300) (
+    82 . 301)) ((83 . 299) (21 . 67) (27 . 68) (28 . 69) (29 . 70) (30 . 71) (
+    31 . 72) (32 . 73) (33 . 74) (34 . 75) (35 . 76) (37 . 77) (36 . 78) (39 
+    . 79) (24 . 81) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (137 . 86) (138 
+    . 87) (40 . 88) (139 . 89) (140 . 90) (41 . 91) (145 . 203) (146 . 204) (
+    130 . 206) (132 . 275) (94 . 205) (131 . 276)) ((-1 . -167)) ((83 . 297) (
+    5 . 12) (6 . 13) (178 . 199) (125 . 298)) ((7 . 8) (2 . 9) (3 . 10) (4 . 
+    11) (5 . 12) (6 . 13) (176 . 16) (177 . 17) (178 . 18) (75 . 20) (76 . 21)
+    (77 . 22) (78 . 23) (79 . 24) (80 . 25) (174 . 27) (81 . 29) (164 . 30) (
+    85 . 31) (86 . 32) (173 . 33) (92 . 26) (165 . 60) (163 . 1) (162 . 2) (
+    161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (156 . 14) (155 . 15) (
+    154 . 19) (153 . 28) (152 . 295) (127 . 296)) ((82 . 293) (83 . 294)) ((-1
+    . -65)) ((91 . -19) (82 . -19)) ((91 . -17) (82 . -17)) ((5 . 12) (6 . 13
+    ) (178 . 199) (125 . 298) (83 . 357)) ((-1 . -165)) ((-1 . -81)) ((83 . 
+    -173) (82 . -173)) ((-1 . -168)) ((83 . -171) (82 . -171)) ((-1 . -146)) (
+    (93 . 354) (97 . 355) (148 . 356) (94 . -292) (-1 . -292)) ((5 . 12) (6 . 
+    13) (79 . 142) (92 . 279) (178 . 257) (123 . 258) (124 . 280) (59 . 281) (
+    142 . 282) (128 . 353)) ((7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 
+    13) (176 . 16) (177 . 17) (178 . 18) (75 . 20) (76 . 21) (77 . 22) (78 . 
+    23) (79 . 24) (80 . 25) (174 . 27) (81 . 29) (164 . 30) (85 . 31) (86 . 32
+    ) (173 . 33) (92 . 26) (165 . 60) (163 . 1) (162 . 2) (161 . 3) (160 . 4) 
+    (159 . 5) (158 . 6) (157 . 7) (156 . 14) (155 . 15) (154 . 19) (153 . 28) 
+    (152 . 295) (127 . 352)) ((47 . -164) (82 . -164)) ((90 . 314) (92 . 315) 
+    (-1 . -178)) ((91 . 351)) ((-1 . -143)) ((89 . 350)) ((-1 . -215)) ((163 
+    . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (7 . 8) (
+    2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (156 . 14) (155 . 15) (176 . 16
+    ) (177 . 17) (178 . 18) (154 . 19) (75 . 20) (76 . 21) (77 . 22) (78 . 23)
+    (79 . 24) (80 . 25) (92 . 26) (174 . 27) (153 . 28) (81 . 29) (164 . 30) 
+    (85 . 31) (86 . 32) (173 . 33) (165 . 34) (152 . 35) (169 . 349)) ((-1 . 
+    -216)) ((-1 . -228)) ((89 . 347) (24 . 81) (25 . 82) (26 . 83) (145 . 250)
+    (163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (7 
+    . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (156 . 14) (155 . 15) (
+    176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 . 20) (76 . 21) (77 . 22) (
+    78 . 23) (79 . 24) (80 . 25) (92 . 26) (174 . 27) (153 . 28) (81 . 29) (
+    164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 34) (152 . 35) (169 . 348)
+    ) ((-1 . -230)) ((43 . 342) (89 . 343) (163 . 1) (162 . 2) (161 . 3) (160 
+    . 4) (159 . 5) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 
+    12) (6 . 13) (156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 . 18) (154 
+    . 19) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 344) (80 . 25) (92 . 
+    26) (174 . 27) (153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 
+    33) (165 . 34) (152 . 35) (169 . 345) (24 . 81) (25 . 82) (26 . 83) (145 
+    . 223) (122 . 346)) ((91 . 338) (5 . 12) (6 . 13) (178 . 339) (120 . 340) 
+    (21 . 67) (27 . 68) (28 . 69) (29 . 70) (30 . 71) (31 . 72) (32 . 73) (33 
+    . 74) (34 . 75) (35 . 76) (37 . 77) (36 . 78) (39 . 79) (23 . 80) (24 . 81
+    ) (25 . 82) (26 . 83) (135 . 84) (136 . 85) (137 . 86) (138 . 87) (40 . 88
+    ) (139 . 89) (140 . 90) (41 . 91) (42 . 92) (43 . 93) (44 . 94) (45 . 95) 
+    (46 . 96) (144 . 97) (145 . 146) (146 . 147) (147 . 100) (167 . 227) (118 
+    . 228) (119 . 229) (121 . 341)) ((82 . -202) (91 . -202)) ((91 . -200)) ((
+    89 . 337)) ((-1 . -226)) ((-1 . -221)) ((89 . 336)) ((-1 . -14)) ((83 . 
+    333) (163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7)
+    (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (156 . 14) (155 . 15)
+    (176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 . 20) (76 . 21) (77 . 22)
+    (78 . 23) (79 . 24) (80 . 25) (92 . 26) (174 . 27) (153 . 28) (81 . 29) (
+    164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 34) (152 . 35) (84 . 243) 
+    (169 . 244) (141 . 334) (88 . 239) (90 . 240) (114 . 241) (115 . 242) (116
+    . 335)) ((83 . -238) (82 . -238)) ((82 . 331) (83 . 332)) ((-1 . -242)) (
+    (58 . -244) (88 . -244) (90 . -244)) ((89 . 330)) ((58 . -246) (90 . -246)
+    (88 . -246)) ((58 . -245) (90 . -245) (88 . -245)) ((163 . 1) (162 . 2) (
+    161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) 
+    (4 . 11) (5 . 12) (6 . 13) (156 . 14) (155 . 15) (176 . 16) (177 . 17) (
+    178 . 18) (154 . 19) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80
+    . 25) (92 . 26) (174 . 27) (153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 
+    . 32) (173 . 33) (165 . 34) (152 . 35) (84 . 243) (169 . 244) (141 . 334) 
+    (88 . 239) (90 . 240) (114 . 241) (115 . 242) (116 . 335) (83 . 371)) ((83
+    . -236) (82 . -236)) ((-1 . -15)) ((83 . -241) (82 . -241)) ((163 . 1) (
+    162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) (7 . 8) (2 . 9)
+    (3 . 10) (4 . 11) (5 . 12) (6 . 13) (156 . 14) (155 . 15) (176 . 16) (177
+    . 17) (178 . 18) (154 . 19) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 
+    . 24) (80 . 25) (92 . 26) (174 . 27) (153 . 28) (81 . 29) (164 . 30) (85 
+    . 31) (86 . 32) (173 . 33) (165 . 34) (152 . 35) (84 . 243) (169 . 244) (
+    141 . 370)) ((-1 . -227)) ((-1 . -225)) ((-1 . -192)) ((91 . -206) (82 . 
+    -206)) ((91 . 368) (82 . 369)) ((91 . 367)) ((24 . 81) (25 . 82) (26 . 83)
+    (145 . 223) (122 . 366)) ((-1 . -185)) ((89 . 365) (-1 . -29)) ((89 . 364
+    )) ((163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (158 . 6) (157 . 7) 
+    (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (156 . 14) (155 . 15) 
+    (176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 . 20) (76 . 21) (77 . 22) 
+    (78 . 23) (80 . 25) (92 . 26) (174 . 27) (153 . 28) (81 . 29) (164 . 30) (
+    85 . 31) (86 . 32) (173 . 33) (165 . 34) (152 . 35) (169 . 360) (24 . 81) 
+    (25 . 82) (26 . 83) (145 . 250) (89 . 361) (43 . 362) (79 . 363)) ((-1 . 
+    -219)) ((89 . 359)) ((89 . 358)) ((-1 . -214)) ((-1 . -181)) ((47 . -163) 
+    (82 . -163)) ((47 . -161) (82 . -161)) ((94 . -301) (-1 . -301)) ((94 . 
+    -293) (-1 . -293)) ((94 . -155) (-1 . -155)) ((-1 . -166)) ((-1 . -220)) (
+    (-1 . -218)) ((89 . 376)) ((-1 . -183)) ((163 . 1) (162 . 2) (161 . 3) (
+    160 . 4) (159 . 5) (158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (
+    5 . 12) (6 . 13) (156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 . 18) (
+    154 . 19) (75 . 20) (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (92 
+    . 26) (174 . 27) (153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 
+    . 33) (165 . 34) (152 . 35) (169 . 375)) ((89 . 374) (-1 . -29)) ((-1 . 
+    -184)) ((-1 . -189)) ((163 . 1) (162 . 2) (161 . 3) (160 . 4) (159 . 5) (
+    158 . 6) (157 . 7) (7 . 8) (2 . 9) (3 . 10) (4 . 11) (5 . 12) (6 . 13) (
+    156 . 14) (155 . 15) (176 . 16) (177 . 17) (178 . 18) (154 . 19) (75 . 20)
+    (76 . 21) (77 . 22) (78 . 23) (79 . 24) (80 . 25) (92 . 26) (174 . 27) (
+    153 . 28) (81 . 29) (164 . 30) (85 . 31) (86 . 32) (173 . 33) (165 . 34) (
+    152 . 35) (169 . 373) (24 . 81) (25 . 82) (26 . 83) (145 . 250)) ((-1 . 
+    -190)) ((-1 . -191)) ((5 . 12) (6 . 13) (178 . 372)) ((83 . -240) (82 . 
+    -240)) ((83 . -237) (82 . -237)) ((91 . -207) (82 . -207)) ((89 . 378)) ((
+    -1 . -188)) ((89 . 377)) ((-1 . -182)) ((-1 . -187)) ((-1 . -186))))
+
+(define rto-v
+  #(#f 180 174 174 174 174 173 173 173 173 173 173 173 173 173 173 172 172 
+    172 172 168 168 165 165 165 165 165 165 164 164 164 164 164 164 163 163 
+    162 162 162 162 161 161 161 160 160 160 159 159 159 159 159 158 158 158 
+    157 157 156 156 155 155 154 154 153 153 152 152 169 169 151 151 151 151 
+    151 151 151 151 151 151 151 175 175 127 103 103 149 167 167 167 167 167 
+    167 167 167 150 150 143 143 147 147 147 147 147 146 146 146 146 146 146 
+    146 146 140 140 140 140 140 140 140 140 140 140 140 140 140 140 140 140 
+    140 140 140 140 140 140 140 140 140 140 139 139 139 138 138 138 138 137 
+    137 137 137 137 137 134 134 133 133 133 133 132 130 130 130 130 129 129 
+    128 128 128 136 136 136 136 136 126 126 125 125 145 145 145 144 142 142 
+    123 123 123 123 123 123 123 123 123 123 123 123 123 124 124 124 124 122 
+    122 121 121 119 119 118 118 118 120 120 171 171 166 166 166 117 117 117 
+    117 117 117 117 117 117 117 117 117 117 117 117 117 117 117 117 117 117 
+    135 141 141 141 170 170 170 170 116 115 115 114 114 106 106 106 106 106 
+    106 106 113 113 113 112 112 105 105 104 104 111 111 110 110 110 109 109 
+    109 102 102 102 101 101 108 108 108 108 108 179 179 100 100 100 100 100 99
+    99 98 98 148 148 178 178 177 177 177 176 176 97 131 107))
+
+(define mtab
+  '((cpp-stmt . 1) ($chlit . 2) ($float . 3) ($fixed . 4) (cpp-ident . 5) (
+    $ident . 6) ($string . 7) ("return" . 8) ("break" . 9) ("continue" . 10) (
+    "goto" . 11) ("for" . 12) ("do" . 13) ("while" . 14) ("switch" . 15) (
+    "else" . 16) (then . 17) ("if" . 18) ("default" . 19) ("case" . 20) (
+    typename . 21) ("..." . 22) ("inline" . 23) ("restrict" . 24) ("volatile" 
+    . 25) ("const" . 26) ("enum" . 27) ("union" . 28) ("struct" . 29) (
+    "_Complex" . 30) ("double" . 31) ("float" . 32) ("char" . 33) ("unsigned" 
+    . 34) ("long" . 35) ("signed" . 36) ("int" . 37) (imp . 38) ("short" . 39)
+    ("_Bool" . 40) ("void" . 41) ("typedef" . 42) ("static" . 43) ("register"
+    . 44) ("extern" . 45) ("auto" . 46) (";" . 47) ("|=" . 48) ("^=" . 49) (
+    "&=" . 50) (">>=" . 51) ("<<=" . 52) ("%=" . 53) ("/=" . 54) ("*=" . 55) (
+    "-=" . 56) ("+=" . 57) ("=" . 58) (":" . 59) ("?" . 60) ("||" . 61) ("&&" 
+    . 62) ("|" . 63) ("^" . 64) ("!=" . 65) ("==" . 66) (">=" . 67) ("<=" . 68
+    ) (">" . 69) ("<" . 70) (">>" . 71) ("<<" . 72) ("%" . 73) ("/" . 74) ("!"
+    . 75) ("~" . 76) ("-" . 77) ("+" . 78) ("*" . 79) ("&" . 80) ("sizeof" . 
+    81) ("," . 82) ("}" . 83) ("{" . 84) ("--" . 85) ("++" . 86) ("->" . 87) (
+    "." . 88) ("]" . 89) ("[" . 90) (")" . 91) ("(" . 92) ($code-comm . 93) (
+    $lone-comm . 94) ($error . 95) ($end . 96)))
+
+;;; end tables
diff --git a/module/nyacc/lang/c99/mach.d/cppact.scm b/module/nyacc/lang/c99/mach.d/cppact.scm
new file mode 100644 (file)
index 0000000..6d31288
--- /dev/null
@@ -0,0 +1,110 @@
+;; ./mach.d/cppact.scm
+
+;; Copyright (C) 2015,2016 Matthew R. Wette
+;; 
+;; This software is covered by the GNU GENERAL PUBLIC LICENCE, Version 3,
+;; or any later version published by the Free Software Foundation.  See the
+;; file COPYING included with the this distribution.
+
+(define act-v
+  (vector
+   ;; $start => conditional-expression
+   (lambda ($1 . $rest) $1)
+   ;; conditional-expression => logical-or-expression
+   (lambda ($1 . $rest) $1)
+   ;; conditional-expression => logical-or-expression "?" logical-or-expres...
+   (lambda ($5 $4 $3 $2 $1 . $rest)
+     `(cond-expr ,$1 ,$3 ,$5))
+   ;; logical-or-expression => logical-and-expression
+   (lambda ($1 . $rest) $1)
+   ;; logical-or-expression => logical-or-expression "||" logical-and-expre...
+   (lambda ($3 $2 $1 . $rest) `(or ,$1 ,$3))
+   ;; logical-and-expression => bitwise-or-expression
+   (lambda ($1 . $rest) $1)
+   ;; logical-and-expression => logical-and-expression "&&" bitwise-or-expr...
+   (lambda ($3 $2 $1 . $rest) `(and ,$1 ,$3))
+   ;; bitwise-or-expression => bitwise-xor-expression
+   (lambda ($1 . $rest) $1)
+   ;; bitwise-or-expression => bitwise-or-expression "|" bitwise-xor-expres...
+   (lambda ($3 $2 $1 . $rest) `(bitwise-or ,$1 ,$3))
+   ;; bitwise-xor-expression => bitwise-and-expression
+   (lambda ($1 . $rest) $1)
+   ;; bitwise-xor-expression => bitwise-xor-expression "^" bitwise-and-expr...
+   (lambda ($3 $2 $1 . $rest)
+     `(bitwise-xor ,$1 ,$3))
+   ;; bitwise-and-expression => equality-expression
+   (lambda ($1 . $rest) $1)
+   ;; bitwise-and-expression => bitwise-and-expression "&" equality-expression
+   (lambda ($3 $2 $1 . $rest)
+     `(bitwise-and ,$1 ,$3))
+   ;; equality-expression => relational-expression
+   (lambda ($1 . $rest) $1)
+   ;; equality-expression => equality-expression "==" relational-expression
+   (lambda ($3 $2 $1 . $rest) `(equal ,$1 ,$3))
+   ;; equality-expression => equality-expression "!=" relational-expression
+   (lambda ($3 $2 $1 . $rest) `(noteq ,$1 ,$3))
+   ;; relational-expression => shift-expression
+   (lambda ($1 . $rest) $1)
+   ;; relational-expression => relational-expression "<" shift-expression
+   (lambda ($3 $2 $1 . $rest) `(lt ,$1 ,$3))
+   ;; relational-expression => relational-expression "<=" shift-expression
+   (lambda ($3 $2 $1 . $rest) `(le ,$1 ,$3))
+   ;; relational-expression => relational-expression ">" shift-expression
+   (lambda ($3 $2 $1 . $rest) `(gt ,$1 ,$3))
+   ;; relational-expression => relational-expression ">=" shift-expression
+   (lambda ($3 $2 $1 . $rest) `(ge ,$1 ,$3))
+   ;; shift-expression => additive-expression
+   (lambda ($1 . $rest) $1)
+   ;; shift-expression => shift-expression "<<" additive-expression
+   (lambda ($3 $2 $1 . $rest) `(lshift ,$1 ,$3))
+   ;; shift-expression => shift-expression ">>" additive-expression
+   (lambda ($3 $2 $1 . $rest) `(rshift ,$1 ,$3))
+   ;; additive-expression => multiplicative-expression
+   (lambda ($1 . $rest) $1)
+   ;; additive-expression => additive-expression "+" multiplicative-expression
+   (lambda ($3 $2 $1 . $rest) `(add ,$1 ,$3))
+   ;; additive-expression => additive-expression "-" multiplicative-expression
+   (lambda ($3 $2 $1 . $rest) `(sub ,$1 ,$3))
+   ;; multiplicative-expression => unary-expression
+   (lambda ($1 . $rest) $1)
+   ;; multiplicative-expression => multiplicative-expression "*" unary-expr...
+   (lambda ($3 $2 $1 . $rest) `(mul ,$1 ,$3))
+   ;; multiplicative-expression => multiplicative-expression "/" unary-expr...
+   (lambda ($3 $2 $1 . $rest) `(div ,$1 ,$3))
+   ;; multiplicative-expression => multiplicative-expression "%" unary-expr...
+   (lambda ($3 $2 $1 . $rest) `(mod ,$1 ,$3))
+   ;; unary-expression => postfix-expression
+   (lambda ($1 . $rest) $1)
+   ;; unary-expression => "-" unary-expression
+   (lambda ($2 $1 . $rest) `(neg ,$2))
+   ;; unary-expression => "+" unary-expression
+   (lambda ($2 $1 . $rest) `(pos ,$2))
+   ;; unary-expression => "!" unary-expression
+   (lambda ($2 $1 . $rest) `(not ,$2))
+   ;; unary-expression => "~" unary-expression
+   (lambda ($2 $1 . $rest) `(bitwise-not ,$2))
+   ;; unary-expression => "++" unary-expression
+   (lambda ($2 $1 . $rest) `(pre-inc ,$2))
+   ;; unary-expression => "--" unary-expression
+   (lambda ($2 $1 . $rest) `(pre-dec ,$2))
+   ;; postfix-expression => primary-expression
+   (lambda ($1 . $rest) $1)
+   ;; postfix-expression => postfix-expression "++"
+   (lambda ($2 $1 . $rest) `(post-inc ,$1))
+   ;; postfix-expression => postfix-expression "--"
+   (lambda ($2 $1 . $rest) `(post-dec ,$1))
+   ;; primary-expression => '$fixed
+   (lambda ($1 . $rest) `(fixed ,$1))
+   ;; primary-expression => '$chlit
+   (lambda ($1 . $rest) `(char ,$1))
+   ;; primary-expression => "defined" "(" '$ident ")"
+   (lambda ($4 $3 $2 $1 . $rest) `(defined ,$3))
+   ;; primary-expression => "(" expression-list ")"
+   (lambda ($3 $2 $1 . $rest) $2)
+   ;; expression-list => conditional-expression
+   (lambda ($1 . $rest) $1)
+   ;; expression-list => expression-list "," conditional-expression
+   (lambda ($3 $2 $1 . $rest) $3)
+   ))
+
+;;; end tables
diff --git a/module/nyacc/lang/c99/mach.d/cpptab.scm b/module/nyacc/lang/c99/mach.d/cpptab.scm
new file mode 100644 (file)
index 0000000..d814304
--- /dev/null
@@ -0,0 +1,106 @@
+;; ./mach.d/cpptab.scm
+
+;; Copyright (C) 2015,2016 Matthew R. Wette
+;; 
+;; This software is covered by the GNU GENERAL PUBLIC LICENCE, Version 3,
+;; or any later version published by the Free Software Foundation.  See the
+;; file COPYING included with the this distribution.
+
+(define len-v
+  #(1 1 5 1 3 1 3 1 3 1 3 1 3 1 3 3 1 3 3 3 3 1 3 3 1 3 3 1 3 3 3 1 2 2 2 2 
+    2 2 1 2 2 1 1 4 3 1 3))
+
+(define pat-v
+  #(((4 . 1) (5 . 2) (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 
+    . 9) (16 . 10) (15 . 11) (38 . 12) (39 . 13) (40 . 14) (41 . 15) (42 . 16)
+    (43 . 17) (44 . 18) (45 . 19) (46 . 20) (47 . 21) (48 . 22) (49 . 23) (50
+    . 24)) ((4 . 1) (5 . 2) (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8)
+    (11 . 9) (16 . 10) (15 . 11) (38 . 12) (39 . 13) (40 . 14) (41 . 15) (42 
+    . 16) (43 . 17) (44 . 18) (45 . 19) (46 . 20) (47 . 21) (48 . 22) (49 . 23
+    ) (50 . 53) (36 . 54)) ((4 . 52)) ((-1 . -42)) ((-1 . -41)) ((-1 . -38)) (
+    (4 . 1) (5 . 2) (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9)
+    (16 . 10) (15 . 11) (38 . 12) (39 . 51)) ((4 . 1) (5 . 2) (6 . 3) (7 . 4)
+    (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 11) (38 . 12) 
+    (39 . 50)) ((4 . 1) (5 . 2) (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 
+    . 8) (11 . 9) (16 . 10) (15 . 11) (38 . 12) (39 . 49)) ((4 . 1) (5 . 2) (6
+    . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 
+    11) (38 . 12) (39 . 48)) ((4 . 1) (5 . 2) (6 . 3) (7 . 4) (37 . 5) (8 . 6)
+    (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 11) (38 . 12) (39 . 47)) ((4 . 
+    1) (5 . 2) (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 
+    . 10) (15 . 11) (38 . 12) (39 . 46)) ((9 . 44) (8 . 45) (-1 . -31)) ((-1 
+    . -27)) ((14 . 41) (13 . 42) (12 . 43) (-1 . -24)) ((16 . 39) (15 . 40) (
+    -1 . -21)) ((18 . 37) (17 . 38) (-1 . -16)) ((22 . 33) (21 . 34) (20 . 35)
+    (19 . 36) (-1 . -13)) ((24 . 31) (23 . 32) (-1 . -11)) ((25 . 30) (-1 . 
+    -9)) ((26 . 29) (-1 . -7)) ((27 . 28) (-1 . -5)) ((28 . 27) (-1 . -3)) ((
+    31 . 25) (29 . 26) (2 . -1) (1 . -1) (35 . -1)) ((35 . 0)) ((4 . 1) (5 . 2
+    ) (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15
+    . 11) (38 . 12) (39 . 13) (40 . 14) (41 . 15) (42 . 16) (43 . 17) (44 . 
+    18) (45 . 19) (46 . 20) (47 . 21) (48 . 22) (49 . 76)) ((4 . 1) (5 . 2) (6
+    . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 
+    11) (38 . 12) (39 . 13) (40 . 14) (41 . 15) (42 . 16) (43 . 17) (44 . 18) 
+    (45 . 19) (46 . 20) (47 . 21) (48 . 75)) ((4 . 1) (5 . 2) (6 . 3) (7 . 4) 
+    (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 11) (38 . 12) (
+    39 . 13) (40 . 14) (41 . 15) (42 . 16) (43 . 17) (44 . 18) (45 . 19) (46 
+    . 20) (47 . 74)) ((4 . 1) (5 . 2) (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7)
+    (10 . 8) (11 . 9) (16 . 10) (15 . 11) (38 . 12) (39 . 13) (40 . 14) (41 
+    . 15) (42 . 16) (43 . 17) (44 . 18) (45 . 19) (46 . 73)) ((4 . 1) (5 . 2) 
+    (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 
+    . 11) (38 . 12) (39 . 13) (40 . 14) (41 . 15) (42 . 16) (43 . 17) (44 . 18
+    ) (45 . 72)) ((4 . 1) (5 . 2) (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10
+    . 8) (11 . 9) (16 . 10) (15 . 11) (38 . 12) (39 . 13) (40 . 14) (41 . 15)
+    (42 . 16) (43 . 17) (44 . 71)) ((4 . 1) (5 . 2) (6 . 3) (7 . 4) (37 . 5) 
+    (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 11) (38 . 12) (39 . 13) 
+    (40 . 14) (41 . 15) (42 . 16) (43 . 70)) ((4 . 1) (5 . 2) (6 . 3) (7 . 4) 
+    (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 11) (38 . 12) (
+    39 . 13) (40 . 14) (41 . 15) (42 . 16) (43 . 69)) ((4 . 1) (5 . 2) (6 . 3)
+    (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 11) (
+    38 . 12) (39 . 13) (40 . 14) (41 . 15) (42 . 68)) ((4 . 1) (5 . 2) (6 . 3)
+    (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 11) (
+    38 . 12) (39 . 13) (40 . 14) (41 . 15) (42 . 67)) ((4 . 1) (5 . 2) (6 . 3)
+    (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 11) (
+    38 . 12) (39 . 13) (40 . 14) (41 . 15) (42 . 66)) ((4 . 1) (5 . 2) (6 . 3)
+    (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 11) (
+    38 . 12) (39 . 13) (40 . 14) (41 . 15) (42 . 65)) ((4 . 1) (5 . 2) (6 . 3)
+    (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 11) (
+    38 . 12) (39 . 13) (40 . 14) (41 . 64)) ((4 . 1) (5 . 2) (6 . 3) (7 . 4) (
+    37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 11) (38 . 12) (
+    39 . 13) (40 . 14) (41 . 63)) ((4 . 1) (5 . 2) (6 . 3) (7 . 4) (37 . 5) (8
+    . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 11) (38 . 12) (39 . 13) (
+    40 . 62)) ((4 . 1) (5 . 2) (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 
+    8) (11 . 9) (16 . 10) (15 . 11) (38 . 12) (39 . 13) (40 . 61)) ((4 . 1) (5
+    . 2) (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10)
+    (15 . 11) (38 . 12) (39 . 60)) ((4 . 1) (5 . 2) (6 . 3) (7 . 4) (37 . 5) 
+    (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 10) (15 . 11) (38 . 12) (39 . 59))
+    ((4 . 1) (5 . 2) (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 
+    9) (16 . 10) (15 . 11) (38 . 12) (39 . 58)) ((-1 . -39)) ((-1 . -40)) ((-1
+    . -32)) ((-1 . -33)) ((-1 . -34)) ((-1 . -35)) ((-1 . -36)) ((-1 . -37)) 
+    ((3 . 57)) ((2 . -45) (1 . -45)) ((2 . 55) (1 . 56)) ((-1 . -44)) ((4 . 1)
+    (5 . 2) (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 
+    10) (15 . 11) (38 . 12) (39 . 13) (40 . 14) (41 . 15) (42 . 16) (43 . 17) 
+    (44 . 18) (45 . 19) (46 . 20) (47 . 21) (48 . 22) (49 . 23) (50 . 79)) ((2
+    . 78)) ((-1 . -30)) ((-1 . -29)) ((-1 . -28)) ((14 . 41) (13 . 42) (12 . 
+    43) (-1 . -26)) ((14 . 41) (13 . 42) (12 . 43) (-1 . -25)) ((16 . 39) (15 
+    . 40) (-1 . -23)) ((16 . 39) (15 . 40) (-1 . -22)) ((18 . 37) (17 . 38) (
+    -1 . -20)) ((18 . 37) (17 . 38) (-1 . -19)) ((18 . 37) (17 . 38) (-1 . -18
+    )) ((18 . 37) (17 . 38) (-1 . -17)) ((22 . 33) (21 . 34) (20 . 35) (19 . 
+    36) (-1 . -15)) ((22 . 33) (21 . 34) (20 . 35) (19 . 36) (-1 . -14)) ((24 
+    . 31) (23 . 32) (-1 . -12)) ((25 . 30) (-1 . -10)) ((26 . 29) (-1 . -8)) (
+    (27 . 28) (-1 . -6)) ((28 . 27) (-1 . -4)) ((30 . 77) (29 . 26)) ((4 . 1) 
+    (5 . 2) (6 . 3) (7 . 4) (37 . 5) (8 . 6) (9 . 7) (10 . 8) (11 . 9) (16 . 
+    10) (15 . 11) (38 . 12) (39 . 13) (40 . 14) (41 . 15) (42 . 16) (43 . 17) 
+    (44 . 18) (45 . 19) (46 . 20) (47 . 21) (48 . 22) (49 . 23) (50 . 80)) ((
+    -1 . -43)) ((2 . -46) (1 . -46)) ((2 . -2) (1 . -2) (35 . -2))))
+
+(define rto-v
+  #(#f 50 50 49 49 48 48 47 47 46 46 45 45 44 44 44 43 43 43 43 43 42 42 42 
+    41 41 41 40 40 40 40 39 39 39 39 39 39 39 38 38 38 37 37 37 37 36 36))
+
+(define mtab
+  '(("," . 1) (")" . 2) ($ident . 3) ("(" . 4) ("defined" . 5) ($chlit . 6) 
+    ($fixed . 7) ("--" . 8) ("++" . 9) ("~" . 10) ("!" . 11) ("%" . 12) ("/" 
+    . 13) ("*" . 14) ("-" . 15) ("+" . 16) (">>" . 17) ("<<" . 18) (">=" . 19)
+    (">" . 20) ("<=" . 21) ("<" . 22) ("!=" . 23) ("==" . 24) ("&" . 25) ("^"
+    . 26) ("|" . 27) ("&&" . 28) ("||" . 29) (":" . 30) ("?" . 31) (
+    $code-comm . 32) ($lone-comm . 33) ($error . 34) ($end . 35)))
+
+;;; end tables
diff --git a/module/nyacc/lang/c99/mach.scm b/module/nyacc/lang/c99/mach.scm
new file mode 100644 (file)
index 0000000..e76be7d
--- /dev/null
@@ -0,0 +1,763 @@
+;;; lang/c99/mach.scm
+;;;
+;;; Copyright (C) 2015,2016 Matthew R. Wette
+;;;
+;;; This program is free software: you can redistribute it and/or modify
+;;; it under the terms of the GNU General Public License as published by 
+;;; the Free Software Foundation, either version 3 of the License, or 
+;;; (at your option) any later version.
+;;;
+;;; This program is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of 
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;; C parser generator: based on ISO-C99; with comments and CPP statements
+
+(define-module (nyacc lang c99 mach)
+  #:export (c99-spec c99-mach dev-parse-c dev-parse-c99
+           gen-c99-files gen-c99x-files)
+  #:use-module (nyacc lang c99 cpp)
+  #:use-module (nyacc lang util)
+  #:use-module (nyacc lalr)
+  #:use-module (nyacc parse)
+  #:use-module (nyacc lex)
+  #:use-module (nyacc util)
+  #:use-module ((srfi srfi-9) #:select (define-record-type))
+  #:use-module ((srfi srfi-43) #:select (vector-map))
+  #:use-module ((sxml xpath) #:select (sxpath))
+  )
+
+;; @item c99-spec
+;; This variable is the specification a-list for the hacked ISO C99 language.
+;; Run this through @code{make-lalr-machine} to get an a-list for the
+;; automaton.  The grammar is modified to parse CPP statements and comments.
+;; The output of the end parser will be a SXML tree (w/o the @code{*TOP*} node.
+(define c99-spec
+  (lalr-spec
+   (notice lang-crn-lic)
+   (prec< 'then "else")               ; "then/else" SR-conflict resolution
+   (prec< 'imp                ; "implied type" SR-conflict resolution
+         "char" "short" "int" "long"
+         "float" "double" "_Complex")
+   (start translation-unit-proxy)
+   (grammar
+
+    (translation-unit-proxy (translation-unit ($$ (tl->list $1))))
+
+    ;; expressions
+    (primary-expression                        ; S 6.5.1
+     (identifier ($$ `(p-expr ,$1)))
+     (constant ($$ `(p-expr ,$1)))
+     (string-literal ($$ `(p-expr ,(tl->list $1))))
+     ("(" expression ")" ($$ $2))
+     )
+
+    (postfix-expression                        ; S 6.5.2
+     (primary-expression)
+     (postfix-expression "[" expression "]" ($$ `(array-ref ,$3 ,$1)))
+     (postfix-expression "(" argument-expression-list ")"
+                        ($$ `(fctn-call ,$1 ,(tl->list $3))))
+     (postfix-expression "(" ")" ($$ `(fctn-call ,$1 (expr-list))))
+     (postfix-expression "." identifier ($$ `(d-sel ,$3 ,$1)))
+     (postfix-expression "->" identifier ($$ `(i-sel ,$3 ,$1)))
+     (postfix-expression "++" ($$ `(post-inc ,$1)))
+     (postfix-expression "--" ($$ `(post-dec ,$1)))
+     ("(" type-name ")" "{" initializer-list "}"
+      ($$ `(comp-lit ,$2 ,(tl->list $5))))
+     ("(" type-name ")" "{" initializer-list "," "}"
+      ($$ `(comp-lit ,$2 ,(tl->list $5))))
+     )
+
+    (argument-expression-list
+     (assignment-expression ($$ (make-tl 'expr-list $1)))
+     (argument-expression-list "," assignment-expression ($$ (tl-append $1 $3)))
+     ;; The following is a modification to deal with using abstract declarations
+     ;; as arguments to CPP macros (e.g., see offsetof in <stddef.h>).
+     (arg-expr-hack ($$ (make-tl 'expr-list $1)))
+     (argument-expression-list "," arg-expr-hack ($$ (tl-append $1 $3)))
+     )
+    (arg-expr-hack
+     (declaration-specifiers
+      abstract-declarator ($$ `(param-decl ,(tl->list $1) $2)))
+     (declaration-specifiers ($$ `(param-decl ,(tl->list $1)))))
+
+    (unary-expression
+     (postfix-expression)              ; S 6.5.3
+     ("++" unary-expression ($$ `(pre-inc ,$2)))
+     ("--" unary-expression ($$ `(pre-dec ,$2)))
+     (unary-operator cast-expression ($$ (list $1 $2)))
+     ("sizeof" unary-expression ($$ `(sizeof-expr ,$2)))
+     ("sizeof" "(" type-name ")" ($$ `(sizeof-type ,$3)))
+     )
+    (unary-operator ("&" ($$ 'ref-to)) ("*" ($$ 'de-ref))
+                   ("+" ($$ 'pos)) ("-" ($$ 'neg))
+                   ("~" ($$ 'bitwise-not)) ("!" ($$ 'not)))
+
+    (cast-expression                   ; S 6.5.4
+     (unary-expression)
+     ("(" type-name ")" cast-expression ($$ `(cast ,$2 ,$4)))
+     )
+
+    (multiplicative-expression         ; S 6.5.5
+     (cast-expression)
+     (multiplicative-expression "*" cast-expression ($$ `(mul ,$1 ,$3)))
+     (multiplicative-expression "/" cast-expression ($$ `(div ,$1 ,$3)))
+     (multiplicative-expression "%" cast-expression ($$ `(mod ,$1 ,$3)))
+     )
+
+    (additive-expression               ; S 6.5.6
+     (multiplicative-expression)
+     (additive-expression "+" multiplicative-expression ($$ `(add ,$1 ,$3)))
+     (additive-expression "-" multiplicative-expression ($$ `(sub ,$1 ,$3)))
+     )
+
+    (shift-expression                  ; S 6.5.7
+     (additive-expression)
+     (shift-expression "<<" additive-expression ($$ `(lshift ,$1 ,$3)))
+     (shift-expression ">>" additive-expression ($$ `(rshift ,$1 ,$3)))
+     )
+
+    (relational-expression             ; S 6.5.8
+     (shift-expression)
+     (relational-expression "<" shift-expression ($$ `(lt ,$1 ,$3)))
+     (relational-expression ">" shift-expression ($$ `(gt ,$1 ,$3)))
+     (relational-expression "<=" shift-expression ($$ `(le ,$1 ,$3)))
+     (relational-expression ">=" shift-expression ($$ `(ge ,$1 ,$3)))
+     )
+    
+    (equality-expression               ; S 6.5.9
+     (relational-expression)
+     (equality-expression "==" relational-expression ($$ `(eq ,$1 ,$3)))
+     (equality-expression "!=" relational-expression ($$ `(ne ,$1 ,$3)))
+     )
+
+    ;; called AND-expression
+    (bitwise-and-expression            ; S 6.5.10
+     (equality-expression)
+     (bitwise-and-expression "&" equality-expression
+                            ($$ `(bitwise-and ,$1 ,$3)))
+     )
+
+    ;; called exclusive-OR-expression
+    (bitwise-xor-expression            ; S 6.5.11
+     (bitwise-and-expression)
+     (bitwise-xor-expression "^" bitwise-and-expression
+                            ($$ `(bitwise-xor ,$1 ,$3)))
+     )
+
+    ;; called inclusive-OR-expression
+    (bitwise-or-expression             ; S 6.5.12
+     (bitwise-xor-expression)
+     (bitwise-or-expression "|" bitwise-xor-expression
+                           ($$ `(bitwise-or ,$1 ,$3)))
+     )
+
+    (logical-and-expression            ; S 6.5.13
+     (bitwise-or-expression)
+     (logical-and-expression "&&" bitwise-or-expression
+                            ($$ `(and ,$1 ,$3)))
+     )
+
+    (logical-or-expression             ; 6.5.14
+     (logical-and-expression)
+     (logical-or-expression "||" logical-and-expression
+