From b21727a3fe3912511d60a24247a4baaf3544a0db Mon Sep 17 00:00:00 2001
From: Aleksey Chichenkov <a.chichenkov@initi.ru>
Date: Mon, 28 Jan 2019 15:08:59 +0300
Subject: [PATCH] first commit

---
 README.md                   |   84 +
 documentation/lemon.html    |  987 +++++++
 examples/calculator-c.y     |   45 +
 examples/calculator-js.js   |  917 ++++++
 examples/calculator-js.out  |  102 +
 examples/calculator-js.y    |   74 +
 lemon-src/lemon-js          |  Bin 0 -> 86608 bytes
 lemon-src/lemon-js.c        | 5442 +++++++++++++++++++++++++++++++++++
 lemon-src/lemon.c           | 5436 ++++++++++++++++++++++++++++++++++
 lemon-src/lempar.js         |  775 +++++
 main.js                     |   54 +
 package-lock.json           |  223 ++
 package.json                |   14 +
 parsers/filters/lexer.js    | 1922 +++++++++++++
 parsers/filters/parser.js   | 1152 ++++++++
 parsers/filters/parser.out  |  155 +
 parsers/filters/parser.y    |  152 +
 process.js                  |  370 +++
 tests/out_test_and.json     |  153 +
 tests/out_tree_address.json |   69 +
 20 files changed, 18126 insertions(+)
 create mode 100644 README.md
 create mode 100644 documentation/lemon.html
 create mode 100644 examples/calculator-c.y
 create mode 100644 examples/calculator-js.js
 create mode 100644 examples/calculator-js.out
 create mode 100644 examples/calculator-js.y
 create mode 100755 lemon-src/lemon-js
 create mode 100644 lemon-src/lemon-js.c
 create mode 100644 lemon-src/lemon.c
 create mode 100644 lemon-src/lempar.js
 create mode 100644 main.js
 create mode 100644 package-lock.json
 create mode 100644 package.json
 create mode 100644 parsers/filters/lexer.js
 create mode 100644 parsers/filters/parser.js
 create mode 100644 parsers/filters/parser.out
 create mode 100644 parsers/filters/parser.y
 create mode 100644 process.js
 create mode 100644 tests/out_test_and.json
 create mode 100644 tests/out_tree_address.json

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..d687c88
--- /dev/null
+++ b/README.md
@@ -0,0 +1,84 @@
+# LEMON.JS - LALR(1) Parser Generator for JavaScript
+
+Lemon.JS is an LALR(1) parser generator for JavaScript based on Lemon parser generator for C included in SQLite package distribution.
+
+## Parser Code Base
+
+Files `lemon.c`, `lempar.c`, `lemon.html` are extracted from SQLite v3.17.0. Original parser generator code is slightly fixed to produce JavaScript compatible statements. Parser template translated from C to JavaScript. Source comments mostly not touched to keep it easy diff against original file.
+
+Both original C version and patched JS version are included for side by side comparison for reference.
+
+## Installation
+
+Compile lenon-js.c with any C compiler and place in anywhere with lempar.js side by side.
+
+## Compilation
+
+Prerequisites: C compiler, for example GCC.
+
+```bash
+gcc -o lemon-js -O2 lemon-js.c
+```
+
+## Usage
+
+```bash
+lemon-js <filename>.y
+```
+
+See http://www.hwaci.com/sw/lemon/lemon.html for more details.
+
+## Special Directives
+
+See lemon.html for additional documentation.
+
+- %name - Set parser class name (default is "Parse")
+- %include - Include code in the beginning of file (usefull for imports)
+- %code - Include code in the end of file (usefull for exports or main code)
+- %token_destructor - Define code which will be executed on token destruction.
+- %default_destructor
+- %token_prefix - Define token name prefix.
+- %syntax_error - Define custom error handler for syntax erorrs.
+- %parse_accept - Define handler for all accepted tokens.
+- %parse_failure - Define handler for parse errors.
+- %stack_overflow - Define handler for stack overflow.
+- %extra_argument - **NOT SUPPORTED**
+- %token_type - **NOT SUPPORTED**
+- %default_type - **NOT SUPPORTED**
+- %stack_size - Set default stack size.
+- %start_symbol
+- %left - Set left associative tokens.
+- %right - Set right associative tokens.
+- %nonassoc - Set non associative tokens.
+- %destructor - Define custom parser destructor.
+- %type - **NOT SUPPORTED**
+- %fallback - Define fallback logic for tokens.
+- %wildcard - Define WILDCARD token.
+- %token_class - **NOT SUPPORTED**
+
+Notes:
+
+- some expressions, for example, regular expression `/\*/` could break lemon parser in `%code` or `%include` sections.
+- the best place to put something like `module.exports = ParserName;` or `export default ParserName;` is in `%code` section.
+
+## TODO
+
+- add some tests for different options
+- document variables
+- YYNOERRORRECOVERY ?
+- YYERRORSYMBOL ?
+- rename methods, variables, get rid of YY prefixes?
+- enable asserts, could be usefull for testing
+
+## Alternative Lexers
+
+- https://github.com/tantaman/lexed.js
+- https://github.com/aaditmshah/lexer
+- https://github.com/YuhangGe/jslex
+
+## Alternative Parsers
+
+- https://github.com/sormy/flex-js
+- http://jscc.brobston.com
+- http://zaach.github.io/jison/
+- https://pegjs.org
diff --git a/documentation/lemon.html b/documentation/lemon.html
new file mode 100644
index 0000000..114526f
--- /dev/null
+++ b/documentation/lemon.html
@@ -0,0 +1,987 @@
+<html>
+<head>
+<title>The Lemon Parser Generator</title>
+</head>
+<body bgcolor=white>
+<h1 align=center>The Lemon Parser Generator</h1>
+
+<p>Lemon is an LALR(1) parser generator for C.
+It does the same job as "bison" and "yacc".
+But lemon is not a bison or yacc clone.  Lemon
+uses a different grammar syntax which is designed to
+reduce the number of coding errors.  Lemon also uses a
+parsing engine that is faster than yacc and
+bison and which is both reentrant and threadsafe.
+(Update: Since the previous sentence was written, bison
+has also been updated so that it too can generate a
+reentrant and threadsafe parser.)
+Lemon also implements features that can be used
+to eliminate resource leaks, making is suitable for use
+in long-running programs such as graphical user interfaces
+or embedded controllers.</p>
+
+<p>This document is an introduction to the Lemon
+parser generator.</p>
+
+<h2>Theory of Operation</h2>
+
+<p>The main goal of Lemon is to translate a context free grammar (CFG)
+for a particular language into C code that implements a parser for
+that language.
+The program has two inputs:
+<ul>
+<li>The grammar specification.
+<li>A parser template file.
+</ul>
+Typically, only the grammar specification is supplied by the programmer.
+Lemon comes with a default parser template which works fine for most
+applications.  But the user is free to substitute a different parser
+template if desired.</p>
+
+<p>Depending on command-line options, Lemon will generate between
+one and three files of outputs.
+<ul>
+<li>C code to implement the parser.
+<li>A header file defining an integer ID for each terminal symbol.
+<li>An information file that describes the states of the generated parser
+    automaton.
+</ul>
+By default, all three of these output files are generated.
+The header file is suppressed if the "-m" command-line option is
+used and the report file is omitted when "-q" is selected.</p>
+
+<p>The grammar specification file uses a ".y" suffix, by convention.
+In the examples used in this document, we'll assume the name of the
+grammar file is "gram.y".  A typical use of Lemon would be the
+following command:
+<pre>
+   lemon gram.y
+</pre>
+This command will generate three output files named "gram.c",
+"gram.h" and "gram.out".
+The first is C code to implement the parser.  The second
+is the header file that defines numerical values for all
+terminal symbols, and the last is the report that explains
+the states used by the parser automaton.</p>
+
+<h3>Command Line Options</h3>
+
+<p>The behavior of Lemon can be modified using command-line options.
+You can obtain a list of the available command-line options together
+with a brief explanation of what each does by typing
+<pre>
+   lemon -?
+</pre>
+As of this writing, the following command-line options are supported:
+<ul>
+<li><b>-b</b>
+Show only the basis for each parser state in the report file.
+<li><b>-c</b>
+Do not compress the generated action tables.
+<li><b>-D<i>name</i></b>
+Define C preprocessor macro <i>name</i>.  This macro is useable by
+"%ifdef" lines in the grammar file.
+<li><b>-g</b>
+Do not generate a parser.  Instead write the input grammar to standard
+output with all comments, actions, and other extraneous text removed.
+<li><b>-l</b>
+Omit "#line" directives in the generated parser C code.
+<li><b>-m</b>
+Cause the output C source code to be compatible with the "makeheaders"
+program. 
+<li><b>-p</b>
+Display all conflicts that are resolved by 
+<a href='#precrules'>precedence rules</a>.
+<li><b>-q</b>
+Suppress generation of the report file.
+<li><b>-r</b>
+Do not sort or renumber the parser states as part of optimization.
+<li><b>-s</b>
+Show parser statistics before existing.
+<li><b>-T<i>file</i></b>
+Use <i>file</i> as the template for the generated C-code parser implementation.
+<li><b>-x</b>
+Print the Lemon version number.
+</ul>
+
+<h3>The Parser Interface</h3>
+
+<p>Lemon doesn't generate a complete, working program.  It only generates
+a few subroutines that implement a parser.  This section describes
+the interface to those subroutines.  It is up to the programmer to
+call these subroutines in an appropriate way in order to produce a
+complete system.</p>
+
+<p>Before a program begins using a Lemon-generated parser, the program
+must first create the parser.
+A new parser is created as follows:
+<pre>
+   void *pParser = ParseAlloc( malloc );
+</pre>
+The ParseAlloc() routine allocates and initializes a new parser and
+returns a pointer to it.
+The actual data structure used to represent a parser is opaque &mdash;
+its internal structure is not visible or usable by the calling routine.
+For this reason, the ParseAlloc() routine returns a pointer to void
+rather than a pointer to some particular structure.
+The sole argument to the ParseAlloc() routine is a pointer to the
+subroutine used to allocate memory.  Typically this means malloc().</p>
+
+<p>After a program is finished using a parser, it can reclaim all
+memory allocated by that parser by calling
+<pre>
+   ParseFree(pParser, free);
+</pre>
+The first argument is the same pointer returned by ParseAlloc().  The
+second argument is a pointer to the function used to release bulk
+memory back to the system.</p>
+
+<p>After a parser has been allocated using ParseAlloc(), the programmer
+must supply the parser with a sequence of tokens (terminal symbols) to
+be parsed.  This is accomplished by calling the following function
+once for each token:
+<pre>
+   Parse(pParser, hTokenID, sTokenData, pArg);
+</pre>
+The first argument to the Parse() routine is the pointer returned by
+ParseAlloc().
+The second argument is a small positive integer that tells the parse the
+type of the next token in the data stream.
+There is one token type for each terminal symbol in the grammar.
+The gram.h file generated by Lemon contains #define statements that
+map symbolic terminal symbol names into appropriate integer values.
+A value of 0 for the second argument is a special flag to the
+parser to indicate that the end of input has been reached.
+The third argument is the value of the given token.  By default,
+the type of the third argument is integer, but the grammar will
+usually redefine this type to be some kind of structure.
+Typically the second argument will be a broad category of tokens
+such as "identifier" or "number" and the third argument will
+be the name of the identifier or the value of the number.</p>
+
+<p>The Parse() function may have either three or four arguments,
+depending on the grammar.  If the grammar specification file requests
+it (via the <a href='#extraarg'><tt>extra_argument</tt> directive</a>),
+the Parse() function will have a fourth parameter that can be
+of any type chosen by the programmer.  The parser doesn't do anything
+with this argument except to pass it through to action routines.
+This is a convenient mechanism for passing state information down
+to the action routines without having to use global variables.</p>
+
+<p>A typical use of a Lemon parser might look something like the
+following:
+<pre>
+   01 ParseTree *ParseFile(const char *zFilename){
+   02    Tokenizer *pTokenizer;
+   03    void *pParser;
+   04    Token sToken;
+   05    int hTokenId;
+   06    ParserState sState;
+   07
+   08    pTokenizer = TokenizerCreate(zFilename);
+   09    pParser = ParseAlloc( malloc );
+   10    InitParserState(&sState);
+   11    while( GetNextToken(pTokenizer, &hTokenId, &sToken) ){
+   12       Parse(pParser, hTokenId, sToken, &sState);
+   13    }
+   14    Parse(pParser, 0, sToken, &sState);
+   15    ParseFree(pParser, free );
+   16    TokenizerFree(pTokenizer);
+   17    return sState.treeRoot;
+   18 }
+</pre>
+This example shows a user-written routine that parses a file of
+text and returns a pointer to the parse tree.
+(All error-handling code is omitted from this example to keep it
+simple.)
+We assume the existence of some kind of tokenizer which is created
+using TokenizerCreate() on line 8 and deleted by TokenizerFree()
+on line 16.  The GetNextToken() function on line 11 retrieves the
+next token from the input file and puts its type in the 
+integer variable hTokenId.  The sToken variable is assumed to be
+some kind of structure that contains details about each token,
+such as its complete text, what line it occurs on, etc. </p>
+
+<p>This example also assumes the existence of structure of type
+ParserState that holds state information about a particular parse.
+An instance of such a structure is created on line 6 and initialized
+on line 10.  A pointer to this structure is passed into the Parse()
+routine as the optional 4th argument.
+The action routine specified by the grammar for the parser can use
+the ParserState structure to hold whatever information is useful and
+appropriate.  In the example, we note that the treeRoot field of
+the ParserState structure is left pointing to the root of the parse
+tree.</p>
+
+<p>The core of this example as it relates to Lemon is as follows:
+<pre>
+   ParseFile(){
+      pParser = ParseAlloc( malloc );
+      while( GetNextToken(pTokenizer,&hTokenId, &sToken) ){
+         Parse(pParser, hTokenId, sToken);
+      }
+      Parse(pParser, 0, sToken);
+      ParseFree(pParser, free );
+   }
+</pre>
+Basically, what a program has to do to use a Lemon-generated parser
+is first create the parser, then send it lots of tokens obtained by
+tokenizing an input source.  When the end of input is reached, the
+Parse() routine should be called one last time with a token type
+of 0.  This step is necessary to inform the parser that the end of
+input has been reached.  Finally, we reclaim memory used by the
+parser by calling ParseFree().</p>
+
+<p>There is one other interface routine that should be mentioned
+before we move on.
+The ParseTrace() function can be used to generate debugging output
+from the parser.  A prototype for this routine is as follows:
+<pre>
+   ParseTrace(FILE *stream, char *zPrefix);
+</pre>
+After this routine is called, a short (one-line) message is written
+to the designated output stream every time the parser changes states
+or calls an action routine.  Each such message is prefaced using
+the text given by zPrefix.  This debugging output can be turned off
+by calling ParseTrace() again with a first argument of NULL (0).</p>
+
+<h3>Differences With YACC and BISON</h3>
+
+<p>Programmers who have previously used the yacc or bison parser
+generator will notice several important differences between yacc and/or
+bison and Lemon.
+<ul>
+<li>In yacc and bison, the parser calls the tokenizer.  In Lemon,
+    the tokenizer calls the parser.
+<li>Lemon uses no global variables.  Yacc and bison use global variables
+    to pass information between the tokenizer and parser.
+<li>Lemon allows multiple parsers to be running simultaneously.  Yacc
+    and bison do not.
+</ul>
+These differences may cause some initial confusion for programmers
+with prior yacc and bison experience.
+But after years of experience using Lemon, I firmly
+believe that the Lemon way of doing things is better.</p>
+
+<p><i>Updated as of 2016-02-16:</i>
+The text above was written in the 1990s.
+We are told that Bison has lately been enhanced to support the
+tokenizer-calls-parser paradigm used by Lemon, and to obviate the
+need for global variables.</p>
+
+<h2>Input File Syntax</h2>
+
+<p>The main purpose of the grammar specification file for Lemon is
+to define the grammar for the parser.  But the input file also
+specifies additional information Lemon requires to do its job.
+Most of the work in using Lemon is in writing an appropriate
+grammar file.</p>
+
+<p>The grammar file for lemon is, for the most part, free format.
+It does not have sections or divisions like yacc or bison.  Any
+declaration can occur at any point in the file.
+Lemon ignores whitespace (except where it is needed to separate
+tokens) and it honors the same commenting conventions as C and C++.</p>
+
+<h3>Terminals and Nonterminals</h3>
+
+<p>A terminal symbol (token) is any string of alphanumeric
+and/or underscore characters
+that begins with an upper case letter.
+A terminal can contain lowercase letters after the first character,
+but the usual convention is to make terminals all upper case.
+A nonterminal, on the other hand, is any string of alphanumeric
+and underscore characters than begins with a lower case letter.
+Again, the usual convention is to make nonterminals use all lower
+case letters.</p>
+
+<p>In Lemon, terminal and nonterminal symbols do not need to 
+be declared or identified in a separate section of the grammar file.
+Lemon is able to generate a list of all terminals and nonterminals
+by examining the grammar rules, and it can always distinguish a
+terminal from a nonterminal by checking the case of the first
+character of the name.</p>
+
+<p>Yacc and bison allow terminal symbols to have either alphanumeric
+names or to be individual characters included in single quotes, like
+this: ')' or '$'.  Lemon does not allow this alternative form for
+terminal symbols.  With Lemon, all symbols, terminals and nonterminals,
+must have alphanumeric names.</p>
+
+<h3>Grammar Rules</h3>
+
+<p>The main component of a Lemon grammar file is a sequence of grammar
+rules.
+Each grammar rule consists of a nonterminal symbol followed by
+the special symbol "::=" and then a list of terminals and/or nonterminals.
+The rule is terminated by a period.
+The list of terminals and nonterminals on the right-hand side of the
+rule can be empty.
+Rules can occur in any order, except that the left-hand side of the
+first rule is assumed to be the start symbol for the grammar (unless
+specified otherwise using the <tt>%start</tt> directive described below.)
+A typical sequence of grammar rules might look something like this:
+<pre>
+  expr ::= expr PLUS expr.
+  expr ::= expr TIMES expr.
+  expr ::= LPAREN expr RPAREN.
+  expr ::= VALUE.
+</pre>
+</p>
+
+<p>There is one non-terminal in this example, "expr", and five
+terminal symbols or tokens: "PLUS", "TIMES", "LPAREN",
+"RPAREN" and "VALUE".</p>
+
+<p>Like yacc and bison, Lemon allows the grammar to specify a block
+of C code that will be executed whenever a grammar rule is reduced
+by the parser.
+In Lemon, this action is specified by putting the C code (contained
+within curly braces <tt>{...}</tt>) immediately after the
+period that closes the rule.
+For example:
+<pre>
+  expr ::= expr PLUS expr.   { printf("Doing an addition...\n"); }
+</pre>
+</p>
+
+<p>In order to be useful, grammar actions must normally be linked to
+their associated grammar rules.
+In yacc and bison, this is accomplished by embedding a "$$" in the
+action to stand for the value of the left-hand side of the rule and
+symbols "$1", "$2", and so forth to stand for the value of
+the terminal or nonterminal at position 1, 2 and so forth on the
+right-hand side of the rule.
+This idea is very powerful, but it is also very error-prone.  The
+single most common source of errors in a yacc or bison grammar is
+to miscount the number of symbols on the right-hand side of a grammar
+rule and say "$7" when you really mean "$8".</p>
+
+<p>Lemon avoids the need to count grammar symbols by assigning symbolic
+names to each symbol in a grammar rule and then using those symbolic
+names in the action.
+In yacc or bison, one would write this:
+<pre>
+  expr -> expr PLUS expr  { $$ = $1 + $3; };
+</pre>
+But in Lemon, the same rule becomes the following:
+<pre>
+  expr(A) ::= expr(B) PLUS expr(C).  { A = B+C; }
+</pre>
+In the Lemon rule, any symbol in parentheses after a grammar rule
+symbol becomes a place holder for that symbol in the grammar rule.
+This place holder can then be used in the associated C action to
+stand for the value of that symbol.<p>
+
+<p>The Lemon notation for linking a grammar rule with its reduce
+action is superior to yacc/bison on several counts.
+First, as mentioned above, the Lemon method avoids the need to
+count grammar symbols.
+Secondly, if a terminal or nonterminal in a Lemon grammar rule
+includes a linking symbol in parentheses but that linking symbol
+is not actually used in the reduce action, then an error message
+is generated.
+For example, the rule
+<pre>
+  expr(A) ::= expr(B) PLUS expr(C).  { A = B; }
+</pre>
+will generate an error because the linking symbol "C" is used
+in the grammar rule but not in the reduce action.</p>
+
+<p>The Lemon notation for linking grammar rules to reduce actions
+also facilitates the use of destructors for reclaiming memory
+allocated by the values of terminals and nonterminals on the
+right-hand side of a rule.</p>
+
+<a name='precrules'></a>
+<h3>Precedence Rules</h3>
+
+<p>Lemon resolves parsing ambiguities in exactly the same way as
+yacc and bison.  A shift-reduce conflict is resolved in favor
+of the shift, and a reduce-reduce conflict is resolved by reducing
+whichever rule comes first in the grammar file.</p>
+
+<p>Just like in
+yacc and bison, Lemon allows a measure of control 
+over the resolution of paring conflicts using precedence rules.
+A precedence value can be assigned to any terminal symbol
+using the 
+<a href='#pleft'>%left</a>,
+<a href='#pright'>%right</a> or
+<a href='#pnonassoc'>%nonassoc</a> directives.  Terminal symbols
+mentioned in earlier directives have a lower precedence that
+terminal symbols mentioned in later directives.  For example:</p>
+
+<p><pre>
+   %left AND.
+   %left OR.
+   %nonassoc EQ NE GT GE LT LE.
+   %left PLUS MINUS.
+   %left TIMES DIVIDE MOD.
+   %right EXP NOT.
+</pre></p>
+
+<p>In the preceding sequence of directives, the AND operator is
+defined to have the lowest precedence.  The OR operator is one
+precedence level higher.  And so forth.  Hence, the grammar would
+attempt to group the ambiguous expression
+<pre>
+     a AND b OR c
+</pre>
+like this
+<pre>
+     a AND (b OR c).
+</pre>
+The associativity (left, right or nonassoc) is used to determine
+the grouping when the precedence is the same.  AND is left-associative
+in our example, so
+<pre>
+     a AND b AND c
+</pre>
+is parsed like this
+<pre>
+     (a AND b) AND c.
+</pre>
+The EXP operator is right-associative, though, so
+<pre>
+     a EXP b EXP c
+</pre>
+is parsed like this
+<pre>
+     a EXP (b EXP c).
+</pre>
+The nonassoc precedence is used for non-associative operators.
+So
+<pre>
+     a EQ b EQ c
+</pre>
+is an error.</p>
+
+<p>The precedence of non-terminals is transferred to rules as follows:
+The precedence of a grammar rule is equal to the precedence of the
+left-most terminal symbol in the rule for which a precedence is
+defined.  This is normally what you want, but in those cases where
+you want to precedence of a grammar rule to be something different,
+you can specify an alternative precedence symbol by putting the
+symbol in square braces after the period at the end of the rule and
+before any C-code.  For example:</p>
+
+<p><pre>
+   expr = MINUS expr.  [NOT]
+</pre></p>
+
+<p>This rule has a precedence equal to that of the NOT symbol, not the
+MINUS symbol as would have been the case by default.</p>
+
+<p>With the knowledge of how precedence is assigned to terminal
+symbols and individual
+grammar rules, we can now explain precisely how parsing conflicts
+are resolved in Lemon.  Shift-reduce conflicts are resolved
+as follows:
+<ul>
+<li> If either the token to be shifted or the rule to be reduced
+     lacks precedence information, then resolve in favor of the
+     shift, but report a parsing conflict.
+<li> If the precedence of the token to be shifted is greater than
+     the precedence of the rule to reduce, then resolve in favor
+     of the shift.  No parsing conflict is reported.
+<li> If the precedence of the token it be shifted is less than the
+     precedence of the rule to reduce, then resolve in favor of the
+     reduce action.  No parsing conflict is reported.
+<li> If the precedences are the same and the shift token is
+     right-associative, then resolve in favor of the shift.
+     No parsing conflict is reported.
+<li> If the precedences are the same the shift token is
+     left-associative, then resolve in favor of the reduce.
+     No parsing conflict is reported.
+<li> Otherwise, resolve the conflict by doing the shift and
+     report the parsing conflict.
+</ul>
+Reduce-reduce conflicts are resolved this way:
+<ul>
+<li> If either reduce rule 
+     lacks precedence information, then resolve in favor of the
+     rule that appears first in the grammar and report a parsing
+     conflict.
+<li> If both rules have precedence and the precedence is different
+     then resolve the dispute in favor of the rule with the highest
+     precedence and do not report a conflict.
+<li> Otherwise, resolve the conflict by reducing by the rule that
+     appears first in the grammar and report a parsing conflict.
+</ul>
+
+<h3>Special Directives</h3>
+
+<p>The input grammar to Lemon consists of grammar rules and special
+directives.  We've described all the grammar rules, so now we'll
+talk about the special directives.</p>
+
+<p>Directives in lemon can occur in any order.  You can put them before
+the grammar rules, or after the grammar rules, or in the mist of the
+grammar rules.  It doesn't matter.  The relative order of
+directives used to assign precedence to terminals is important, but
+other than that, the order of directives in Lemon is arbitrary.</p>
+
+<p>Lemon supports the following special directives:
+<ul>
+<li><tt>%code</tt>
+<li><tt>%default_destructor</tt>
+<li><tt>%default_type</tt>
+<li><tt>%destructor</tt>
+<li><tt>%endif</tt>
+<li><tt>%extra_argument</tt>
+<li><tt>%fallback</tt>
+<li><tt>%ifdef</tt>
+<li><tt>%ifndef</tt>
+<li><tt>%include</tt>
+<li><tt>%left</tt>
+<li><tt>%name</tt>
+<li><tt>%nonassoc</tt>
+<li><tt>%parse_accept</tt>
+<li><tt>%parse_failure </tt>
+<li><tt>%right</tt>
+<li><tt>%stack_overflow</tt>
+<li><tt>%stack_size</tt>
+<li><tt>%start_symbol</tt>
+<li><tt>%syntax_error</tt>
+<li><tt>%token_class</tt>
+<li><tt>%token_destructor</tt>
+<li><tt>%token_prefix</tt>
+<li><tt>%token_type</tt>
+<li><tt>%type</tt>
+<li><tt>%wildcard</tt>
+</ul>
+Each of these directives will be described separately in the
+following sections:</p>
+
+<a name='pcode'></a>
+<h4>The <tt>%code</tt> directive</h4>
+
+<p>The %code directive is used to specify addition C code that
+is added to the end of the main output file.  This is similar to
+the <a href='#pinclude'>%include</a> directive except that %include
+is inserted at the beginning of the main output file.</p>
+
+<p>%code is typically used to include some action routines or perhaps
+a tokenizer or even the "main()" function 
+as part of the output file.</p>
+
+<a name='default_destructor'></a>
+<h4>The <tt>%default_destructor</tt> directive</h4>
+
+<p>The %default_destructor directive specifies a destructor to 
+use for non-terminals that do not have their own destructor
+specified by a separate %destructor directive.  See the documentation
+on the <a name='#destructor'>%destructor</a> directive below for
+additional information.</p>
+
+<p>In some grammers, many different non-terminal symbols have the
+same datatype and hence the same destructor.  This directive is
+a convenience way to specify the same destructor for all those
+non-terminals using a single statement.</p>
+
+<a name='default_type'></a>
+<h4>The <tt>%default_type</tt> directive</h4>
+
+<p>The %default_type directive specifies the datatype of non-terminal
+symbols that do no have their own datatype defined using a separate
+<a href='#ptype'>%type</a> directive.  
+</p>
+
+<a name='destructor'></a>
+<h4>The <tt>%destructor</tt> directive</h4>
+
+<p>The %destructor directive is used to specify a destructor for
+a non-terminal symbol.
+(See also the <a href='#token_destructor'>%token_destructor</a>
+directive which is used to specify a destructor for terminal symbols.)</p>
+
+<p>A non-terminal's destructor is called to dispose of the
+non-terminal's value whenever the non-terminal is popped from
+the stack.  This includes all of the following circumstances:
+<ul>
+<li> When a rule reduces and the value of a non-terminal on
+     the right-hand side is not linked to C code.
+<li> When the stack is popped during error processing.
+<li> When the ParseFree() function runs.
+</ul>
+The destructor can do whatever it wants with the value of
+the non-terminal, but its design is to deallocate memory
+or other resources held by that non-terminal.</p>
+
+<p>Consider an example:
+<pre>
+   %type nt {void*}
+   %destructor nt { free($$); }
+   nt(A) ::= ID NUM.   { A = malloc( 100 ); }
+</pre>
+This example is a bit contrived but it serves to illustrate how
+destructors work.  The example shows a non-terminal named
+"nt" that holds values of type "void*".  When the rule for
+an "nt" reduces, it sets the value of the non-terminal to
+space obtained from malloc().  Later, when the nt non-terminal
+is popped from the stack, the destructor will fire and call
+free() on this malloced space, thus avoiding a memory leak.
+(Note that the symbol "$$" in the destructor code is replaced
+by the value of the non-terminal.)</p>
+
+<p>It is important to note that the value of a non-terminal is passed
+to the destructor whenever the non-terminal is removed from the
+stack, unless the non-terminal is used in a C-code action.  If
+the non-terminal is used by C-code, then it is assumed that the
+C-code will take care of destroying it.
+More commonly, the value is used to build some
+larger structure and we don't want to destroy it, which is why
+the destructor is not called in this circumstance.</p>
+
+<p>Destructors help avoid memory leaks by automatically freeing
+allocated objects when they go out of scope.
+To do the same using yacc or bison is much more difficult.</p>
+
+<a name="extraarg"></a>
+<h4>The <tt>%extra_argument</tt> directive</h4>
+
+The %extra_argument directive instructs Lemon to add a 4th parameter
+to the parameter list of the Parse() function it generates.  Lemon
+doesn't do anything itself with this extra argument, but it does
+make the argument available to C-code action routines, destructors,
+and so forth.  For example, if the grammar file contains:</p>
+
+<p><pre>
+    %extra_argument { MyStruct *pAbc }
+</pre></p>
+
+<p>Then the Parse() function generated will have an 4th parameter
+of type "MyStruct*" and all action routines will have access to
+a variable named "pAbc" that is the value of the 4th parameter
+in the most recent call to Parse().</p>
+
+<a name='pfallback'></a>
+<h4>The <tt>%fallback</tt> directive</h4>
+
+<p>The %fallback directive specifies an alternative meaning for one
+or more tokens.  The alternative meaning is tried if the original token
+would have generated a syntax error.
+
+<p>The %fallback directive was added to support robust parsing of SQL
+syntax in <a href="https://www.sqlite.org/">SQLite</a>.
+The SQL language contains a large assortment of keywords, each of which
+appears as a different token to the language parser.  SQL contains so
+many keywords, that it can be difficult for programmers to keep up with
+them all.  Programmers will, therefore, sometimes mistakenly use an
+obscure language keyword for an identifier.  The %fallback directive
+provides a mechanism to tell the parser:  "If you are unable to parse
+this keyword, try treating it as an identifier instead."
+
+<p>The syntax of %fallback is as follows:
+
+<blockquote>
+<tt>%fallback</tt>  <i>ID</i> <i>TOKEN...</i> <b>.</b>
+</blockquote>
+
+<p>In words, the %fallback directive is followed by a list of token names
+terminated by a period.  The first token name is the fallback token - the
+token to which all the other tokens fall back to.  The second and subsequent
+arguments are tokens which fall back to the token identified by the first
+argument.
+
+<a name='pifdef'></a>
+<h4>The <tt>%ifdef</tt>, <tt>%ifndef</tt>, and <tt>%endif</tt> directives.</h4>
+
+<p>The %ifdef, %ifndef, and %endif directives are similar to
+#ifdef, #ifndef, and #endif in the C-preprocessor, just not as general.
+Each of these directives must begin at the left margin.  No whitespace
+is allowed between the "%" and the directive name.
+
+<p>Grammar text in between "%ifdef MACRO" and the next nested "%endif" is
+ignored unless the "-DMACRO" command-line option is used.  Grammar text
+betwen "%ifndef MACRO" and the next nested "%endif" is included except when
+the "-DMACRO" command-line option is used.
+
+<p>Note that the argument to %ifdef and %ifndef must be a single 
+preprocessor symbol name, not a general expression.  There is no "%else"
+directive.
+
+
+<a name='pinclude'></a>
+<h4>The <tt>%include</tt> directive</h4>
+
+<p>The %include directive specifies C code that is included at the
+top of the generated parser.  You can include any text you want --
+the Lemon parser generator copies it blindly.  If you have multiple
+%include directives in your grammar file, their values are concatenated
+so that all %include code ultimately appears near the top of the
+generated parser, in the same order as it appeared in the grammer.</p>
+
+<p>The %include directive is very handy for getting some extra #include
+preprocessor statements at the beginning of the generated parser.
+For example:</p>
+
+<p><pre>
+   %include {#include &lt;unistd.h&gt;}
+</pre></p>
+
+<p>This might be needed, for example, if some of the C actions in the
+grammar call functions that are prototyed in unistd.h.</p>
+
+<a name='pleft'></a>
+<h4>The <tt>%left</tt> directive</h4>
+
+The %left directive is used (along with the <a href='#pright'>%right</a> and
+<a href='#pnonassoc'>%nonassoc</a> directives) to declare precedences of 
+terminal symbols.  Every terminal symbol whose name appears after
+a %left directive but before the next period (".") is
+given the same left-associative precedence value.  Subsequent
+%left directives have higher precedence.  For example:</p>
+
+<p><pre>
+   %left AND.
+   %left OR.
+   %nonassoc EQ NE GT GE LT LE.
+   %left PLUS MINUS.
+   %left TIMES DIVIDE MOD.
+   %right EXP NOT.
+</pre></p>
+
+<p>Note the period that terminates each %left, %right or %nonassoc
+directive.</p>
+
+<p>LALR(1) grammars can get into a situation where they require
+a large amount of stack space if you make heavy use or right-associative
+operators.  For this reason, it is recommended that you use %left
+rather than %right whenever possible.</p>
+
+<a name='pname'></a>
+<h4>The <tt>%name</tt> directive</h4>
+
+<p>By default, the functions generated by Lemon all begin with the
+five-character string "Parse".  You can change this string to something
+different using the %name directive.  For instance:</p>
+
+<p><pre>
+   %name Abcde
+</pre></p>
+
+<p>Putting this directive in the grammar file will cause Lemon to generate
+functions named
+<ul>
+<li> AbcdeAlloc(),
+<li> AbcdeFree(),
+<li> AbcdeTrace(), and
+<li> Abcde().
+</ul>
+The %name directive allows you to generator two or more different
+parsers and link them all into the same executable.
+</p>
+
+<a name='pnonassoc'></a>
+<h4>The <tt>%nonassoc</tt> directive</h4>
+
+<p>This directive is used to assign non-associative precedence to
+one or more terminal symbols.  See the section on 
+<a href='#precrules'>precedence rules</a>
+or on the <a href='#pleft'>%left</a> directive for additional information.</p>
+
+<a name='parse_accept'></a>
+<h4>The <tt>%parse_accept</tt> directive</h4>
+
+<p>The %parse_accept directive specifies a block of C code that is
+executed whenever the parser accepts its input string.  To "accept"
+an input string means that the parser was able to process all tokens
+without error.</p>
+
+<p>For example:</p>
+
+<p><pre>
+   %parse_accept {
+      printf("parsing complete!\n");
+   }
+</pre></p>
+
+<a name='parse_failure'></a>
+<h4>The <tt>%parse_failure</tt> directive</h4>
+
+<p>The %parse_failure directive specifies a block of C code that
+is executed whenever the parser fails complete.  This code is not
+executed until the parser has tried and failed to resolve an input
+error using is usual error recovery strategy.  The routine is
+only invoked when parsing is unable to continue.</p>
+
+<p><pre>
+   %parse_failure {
+     fprintf(stderr,"Giving up.  Parser is hopelessly lost...\n");
+   }
+</pre></p>
+
+<a name='pright'></a>
+<h4>The <tt>%right</tt> directive</h4>
+
+<p>This directive is used to assign right-associative precedence to
+one or more terminal symbols.  See the section on 
+<a href='#precrules'>precedence rules</a>
+or on the <a href='#pleft'>%left</a> directive for additional information.</p>
+
+<a name='stack_overflow'></a>
+<h4>The <tt>%stack_overflow</tt> directive</h4>
+
+<p>The %stack_overflow directive specifies a block of C code that
+is executed if the parser's internal stack ever overflows.  Typically
+this just prints an error message.  After a stack overflow, the parser
+will be unable to continue and must be reset.</p>
+
+<p><pre>
+   %stack_overflow {
+     fprintf(stderr,"Giving up.  Parser stack overflow\n");
+   }
+</pre></p>
+
+<p>You can help prevent parser stack overflows by avoiding the use
+of right recursion and right-precedence operators in your grammar.
+Use left recursion and and left-precedence operators instead, to
+encourage rules to reduce sooner and keep the stack size down.
+For example, do rules like this:
+<pre>
+   list ::= list element.      // left-recursion.  Good!
+   list ::= .
+</pre>
+Not like this:
+<pre>
+   list ::= element list.      // right-recursion.  Bad!
+   list ::= .
+</pre>
+
+<a name='stack_size'></a>
+<h4>The <tt>%stack_size</tt> directive</h4>
+
+<p>If stack overflow is a problem and you can't resolve the trouble
+by using left-recursion, then you might want to increase the size
+of the parser's stack using this directive.  Put an positive integer
+after the %stack_size directive and Lemon will generate a parse
+with a stack of the requested size.  The default value is 100.</p>
+
+<p><pre>
+   %stack_size 2000
+</pre></p>
+
+<a name='start_symbol'></a>
+<h4>The <tt>%start_symbol</tt> directive</h4>
+
+<p>By default, the start-symbol for the grammar that Lemon generates
+is the first non-terminal that appears in the grammar file.  But you
+can choose a different start-symbol using the %start_symbol directive.</p>
+
+<p><pre>
+   %start_symbol  prog
+</pre></p>
+
+<a name='token_destructor'></a>
+<h4>The <tt>%token_destructor</tt> directive</h4>
+
+<p>The %destructor directive assigns a destructor to a non-terminal
+symbol.  (See the description of the %destructor directive above.)
+This directive does the same thing for all terminal symbols.</p>
+
+<p>Unlike non-terminal symbols which may each have a different data type
+for their values, terminals all use the same data type (defined by
+the %token_type directive) and so they use a common destructor.  Other
+than that, the token destructor works just like the non-terminal
+destructors.</p>
+
+<a name='token_prefix'></a>
+<h4>The <tt>%token_prefix</tt> directive</h4>
+
+<p>Lemon generates #defines that assign small integer constants
+to each terminal symbol in the grammar.  If desired, Lemon will
+add a prefix specified by this directive
+to each of the #defines it generates.
+So if the default output of Lemon looked like this:
+<pre>
+    #define AND              1
+    #define MINUS            2
+    #define OR               3
+    #define PLUS             4
+</pre>
+You can insert a statement into the grammar like this:
+<pre>
+    %token_prefix    TOKEN_
+</pre>
+to cause Lemon to produce these symbols instead:
+<pre>
+    #define TOKEN_AND        1
+    #define TOKEN_MINUS      2
+    #define TOKEN_OR         3
+    #define TOKEN_PLUS       4
+</pre>
+
+<a name='token_type'></a><a name='ptype'></a>
+<h4>The <tt>%token_type</tt> and <tt>%type</tt> directives</h4>
+
+<p>These directives are used to specify the data types for values
+on the parser's stack associated with terminal and non-terminal
+symbols.  The values of all terminal symbols must be of the same
+type.  This turns out to be the same data type as the 3rd parameter
+to the Parse() function generated by Lemon.  Typically, you will
+make the value of a terminal symbol by a pointer to some kind of
+token structure.  Like this:</p>
+
+<p><pre>
+   %token_type    {Token*}
+</pre></p>
+
+<p>If the data type of terminals is not specified, the default value
+is "void*".</p>
+
+<p>Non-terminal symbols can each have their own data types.  Typically
+the data type  of a non-terminal is a pointer to the root of a parse-tree
+structure that contains all information about that non-terminal.
+For example:</p>
+
+<p><pre>
+   %type   expr  {Expr*}
+</pre></p>
+
+<p>Each entry on the parser's stack is actually a union containing
+instances of all data types for every non-terminal and terminal symbol.
+Lemon will automatically use the correct element of this union depending
+on what the corresponding non-terminal or terminal symbol is.  But
+the grammar designer should keep in mind that the size of the union
+will be the size of its largest element.  So if you have a single
+non-terminal whose data type requires 1K of storage, then your 100
+entry parser stack will require 100K of heap space.  If you are willing
+and able to pay that price, fine.  You just need to know.</p>
+
+<a name='pwildcard'></a>
+<h4>The <tt>%wildcard</tt> directive</h4>
+
+<p>The %wildcard directive is followed by a single token name and a
+period.  This directive specifies that the identified token should 
+match any input token.
+
+<p>When the generated parser has the choice of matching an input against
+the wildcard token and some other token, the other token is always used.
+The wildcard token is only matched if there are no other alternatives.
+
+<h3>Error Processing</h3>
+
+<p>After extensive experimentation over several years, it has been
+discovered that the error recovery strategy used by yacc is about
+as good as it gets.  And so that is what Lemon uses.</p>
+
+<p>When a Lemon-generated parser encounters a syntax error, it
+first invokes the code specified by the %syntax_error directive, if
+any.  It then enters its error recovery strategy.  The error recovery
+strategy is to begin popping the parsers stack until it enters a
+state where it is permitted to shift a special non-terminal symbol
+named "error".  It then shifts this non-terminal and continues
+parsing.  But the %syntax_error routine will not be called again
+until at least three new tokens have been successfully shifted.</p>
+
+<p>If the parser pops its stack until the stack is empty, and it still
+is unable to shift the error symbol, then the %parse_failed routine
+is invoked and the parser resets itself to its start state, ready
+to begin parsing a new file.  This is what will happen at the very
+first syntax error, of course, if there are no instances of the 
+"error" non-terminal in your grammar.</p>
+
+</body>
+</html>
diff --git a/examples/calculator-c.y b/examples/calculator-c.y
new file mode 100644
index 0000000..60d7dd9
--- /dev/null
+++ b/examples/calculator-c.y
@@ -0,0 +1,45 @@
+%token_type {int}
+
+%left PLUS MINUS.
+%left DIVIDE TIMES.
+
+%include {
+  #include <stdio.h>
+  #include <stdlib.h>
+  #include <assert.h>
+  #include "calculator-c.h"
+}
+
+%code {
+  int main()
+  {
+    void* pParser = ParseAlloc(malloc);
+    ParseTrace(stderr, "> ");
+    Parse(pParser, INTEGER, 1);
+    Parse(pParser, PLUS, 0);
+    Parse(pParser, INTEGER, 2);
+    Parse(pParser, TIMES, 0);
+    Parse(pParser, INTEGER, 10);
+    Parse(pParser, DIVIDE, 0);
+    Parse(pParser, INTEGER, 2);
+    Parse(pParser, 0, 0);
+    ParseFree(pParser, free);
+  }
+}
+
+%syntax_error {
+  fprintf(stderr, "Syntax error\n");
+}
+
+program ::= expr(A). { printf("Result=%d\n", A); }
+expr(A) ::= expr(B) MINUS expr(C). { A = B - C; }
+expr(A) ::= expr(B) PLUS expr(C). { A = B + C; }
+expr(A) ::= expr(B) TIMES  expr(C). { A = B * C; }
+expr(A) ::= expr(B) DIVIDE expr(C). {
+  if (C != 0) {
+    A = B / C;
+  } else {
+    fprintf(stderr, "Divide by zero\n");
+  }
+}
+expr(A) ::= INTEGER(B). { A = B; }
diff --git a/examples/calculator-js.js b/examples/calculator-js.js
new file mode 100644
index 0000000..110cde4
--- /dev/null
+++ b/examples/calculator-js.js
@@ -0,0 +1,917 @@
+/*
+** 2000-05-29
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+** Based on SQLite distribution v3.17.0
+** Adopted for JavaScript by Artem Butusov <art.sormy@gmail.com>
+**
+*************************************************************************
+** Driver template for the LEMON parser generator.
+**
+** The "lemon" program processes an LALR(1) input grammar file, then uses
+** this template to construct a parser.  The "lemon" program inserts text
+** at each "%%" line.  Also, any "P-a-r-s-e" identifer prefix (without the
+** interstitial "-" characters) contained in this template is changed into
+** the value of the %name directive from the grammar.  Otherwise, the content
+** of this template is copied straight through into the generate parser
+** source file.
+**
+** The following is the concatenation of all %include directives from the
+** input grammar file:
+*/
+/************ Begin %include sections from the grammar ************************/
+// line 8 "examples/calculator-js.y"
+
+  // include something
+// line 33 "examples/calculator-js.js"
+/**************** End of %include directives **********************************/
+function Parser() {
+/* These constants specify the various numeric values for terminal symbols
+** in a format understandable to "makeheaders".
+***************** Begin makeheaders token definitions *************************/
+this.TOKEN_PLUS                           =  1;
+this.TOKEN_MINUS                          =  2;
+this.TOKEN_DIVIDE                         =  3;
+this.TOKEN_TIMES                          =  4;
+this.TOKEN_INTEGER                        =  5;
+/**************** End makeheaders token definitions ***************************/
+
+/* The next sections is a series of control #defines.
+** various aspects of the generated parser.
+**    YYNOCODE           is a number of type YYCODETYPE that is not used for
+**                       any terminal or nonterminal symbol.
+**    YYFALLBACK         If defined, this indicates that one or more tokens
+**                       (also known as: "terminal symbols") have fall-back
+**                       values which should be used if the original symbol
+**                       would not parse.  This permits keywords to sometimes
+**                       be used as identifiers, for example.
+**    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
+**                       zero the stack is dynamically sized using realloc()
+**    YYERRORSYMBOL      is the code number of the error symbol.  If not
+**                       defined, then do no error processing.
+**    YYNSTATE           the combined number of states.
+**    YYNRULE            the number of rules in the grammar
+**    YY_MAX_SHIFT       Maximum value for shift actions
+**    YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
+**    YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
+**    YY_MIN_REDUCE      Maximum value for reduce actions
+**    YY_ERROR_ACTION    The yy_action[] code for syntax error
+**    YY_ACCEPT_ACTION   The yy_action[] code for accept
+**    YY_NO_ACTION       The yy_action[] code for no-op
+*/
+/************* Begin control #defines *****************************************/
+this.YYNOCODE = 10;
+this.YYSTACKDEPTH = 100;
+this.YYFALLBACK = false;
+this.YYNSTATE            = 8;
+this.YYNRULE             = 6;
+this.YY_MAX_SHIFT        = 7;
+this.YY_MIN_SHIFTREDUCE  = 11;
+this.YY_MAX_SHIFTREDUCE  = 16;
+this.YY_MIN_REDUCE       = 17;
+this.YY_MAX_REDUCE       = 22;
+this.YY_ERROR_ACTION     = 23;
+this.YY_ACCEPT_ACTION    = 24;
+this.YY_NO_ACTION        = 25;
+/************* End control #defines *******************************************/
+
+/* Define the yytestcase() macro to be a no-op if is not already defined
+** otherwise.
+**
+** Applications can choose to define yytestcase() in the %include section
+** to a macro that can assist in verifying code coverage.  For production
+** code the yytestcase() macro should be turned off.  But it is useful
+** for testing.
+*/
+if (!this.yytestcase) {
+  this.yytestcase = function () {};
+}
+
+
+/* Next are the tables used to determine what action to take based on the
+** current state and lookahead token.  These tables are used to implement
+** functions that take a state number and lookahead value and return an
+** action integer.
+**
+** Suppose the action integer is N.  Then the action is determined as
+** follows
+**
+**   0 <= N <= YY_MAX_SHIFT             Shift N.  That is, push the lookahead
+**                                      token onto the stack and goto state N.
+**
+**   N between YY_MIN_SHIFTREDUCE       Shift to an arbitrary state then
+**     and YY_MAX_SHIFTREDUCE           reduce by rule N-YY_MIN_SHIFTREDUCE.
+**
+**   N between YY_MIN_REDUCE            Reduce by rule N-YY_MIN_REDUCE
+**     and YY_MAX_REDUCE
+**
+**   N == YY_ERROR_ACTION               A syntax error has occurred.
+**
+**   N == YY_ACCEPT_ACTION              The parser accepts its input.
+**
+**   N == YY_NO_ACTION                  No such action.  Denotes unused
+**                                      slots in the yy_action[] table.
+**
+** The action table is constructed as a single large table named yy_action[].
+** Given state S and lookahead X, the action is computed as either:
+**
+**    (A)   N = yy_action[ yy_shift_ofst[S] + X ]
+**    (B)   N = yy_default[S]
+**
+** The (A) formula is preferred.  The B formula is used instead if:
+**    (1)  The yy_shift_ofst[S]+X value is out of range, or
+**    (2)  yy_lookahead[yy_shift_ofst[S]+X] is not equal to X, or
+**    (3)  yy_shift_ofst[S] equal YY_SHIFT_USE_DFLT.
+** (Implementation note: YY_SHIFT_USE_DFLT is chosen so that
+** YY_SHIFT_USE_DFLT+X will be out of range for all possible lookaheads X.
+** Hence only tests (1) and (2) need to be evaluated.)
+**
+** The formulas above are for computing the action when the lookahead is
+** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
+** a reduce action) then the yy_reduce_ofst[] array is used in place of
+** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
+** YY_SHIFT_USE_DFLT.
+**
+** The following are the tables generated in this section:
+**
+**  yy_action[]        A single table containing all actions.
+**  yy_lookahead[]     A table containing the lookahead for each entry in
+**                     yy_action.  Used to detect hash collisions.
+**  yy_shift_ofst[]    For each state, the offset into yy_action for
+**                     shifting terminals.
+**  yy_reduce_ofst[]   For each state, the offset into yy_action for
+**                     shifting non-terminals after a reduce.
+**  yy_default[]       Default action for each state.
+**
+*********** Begin parsing tables **********************************************/
+this.yy_action = [
+ /*     0 */    17,    3,    4,    1,    2,   24,    5,    1,    2,   15,
+ /*    10 */    16,   14,   19,   19,    6,    7,
+];
+this.yy_lookahead = [
+ /*     0 */     0,    1,    2,    3,    4,    7,    8,    3,    4,    8,
+ /*    10 */     5,    8,    9,    9,    8,    8,
+];
+this.YY_SHIFT_USE_DFLT = 16;
+this.YY_SHIFT_COUNT    = 7;
+this.YY_SHIFT_MIN      = 0;
+this.YY_SHIFT_MAX      = 5;
+this.yy_shift_ofst = [
+ /*     0 */     5,    5,    5,    5,    5,    0,    4,    4,
+];
+this.YY_REDUCE_USE_DFLT = -3;
+this.YY_REDUCE_COUNT = 4;
+this.YY_REDUCE_MIN   = -2;
+this.YY_REDUCE_MAX   = 7;
+this.yy_reduce_ofst = [
+ /*     0 */    -2,    1,    3,    6,    7,
+];
+this.yy_default = [
+ /*     0 */    23,   23,   23,   23,   23,   23,   19,   18,
+];
+/********** End of lemon-generated parsing tables *****************************/
+
+/* The next table maps tokens (terminal symbols) into fallback tokens.
+** If a construct like the following:
+**
+**      %fallback ID X Y Z.
+**
+** appears in the grammar, then ID becomes a fallback token for X, Y,
+** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
+** but it does not parse, the type of the token is changed to ID and
+** the parse is retried before an error is thrown.
+**
+** This feature can be used, for example, to cause some keywords in a language
+** to revert to identifiers if they keyword does not apply in the context where
+** it appears.
+*/
+this.yyFallback = [
+];
+
+/* The following structure represents a single element of the
+** parser's stack.  Information stored includes:
+**
+**   +  The state number for the parser at this level of the stack.
+**
+**   +  The value of the token stored at this level of the stack.
+**      (In other words, the "major" token.)
+**
+**   +  The semantic value stored at this level of the stack.  This is
+**      the information used by the action routines in the grammar.
+**      It is sometimes called the "minor" token.
+**
+** After the "shift" half of a SHIFTREDUCE action, the stateno field
+** actually contains the reduce action for the second half of the
+** SHIFTREDUCE.
+*/
+//{
+//  stateno,  /* The state-number, or reduce action in SHIFTREDUCE */
+//  major,    /* The major token value.  This is the code
+//            ** number for the token at this stack level */
+//  minor,    /* The user-supplied minor token value.  This
+//            ** is the value of the token  */
+//}
+
+/* The state of the parser is completely contained in an instance of
+** the following structure */
+this.yyhwm = 0;               /* High-water mark of the stack */
+this.yyerrcnt = -1;           /* Shifts left before out of the error */
+this.yystack = null;          /* The parser's stack */
+this.yyidx = -1;              /* Stack index of current element in the stack */
+
+this.yyTraceCallback = null;
+this.yyTracePrompt = "";
+
+/*
+** Turn parser tracing on by giving a stream to which to write the trace
+** and a prompt to preface each trace message.  Tracing is turned off
+** by making either argument NULL
+**
+** Inputs:
+** <ul>
+** <li> A callback to which trace output should be written.
+**      If NULL, then tracing is turned off.
+** <li> A prefix string written at the beginning of every
+**      line of trace output. Default is "".
+** </ul>
+**
+** Outputs:
+** None.
+*/
+this.setTraceCallback = function (callback, prompt) {
+  this.yyTraceCallback = callback;
+  this.yyTracePrompt = prompt || "";
+}
+
+this.trace = function (message) {
+  this.yyTraceCallback(this.yyTracePrompt + message + "\n");
+}
+
+/* For tracing shifts, the names of all terminals and nonterminals
+** are required.  The following table supplies these names */
+this.yyTokenName = [
+  "$",             "PLUS",          "MINUS",         "DIVIDE",      
+  "TIMES",         "INTEGER",       "error",         "program",     
+  "expr",        
+];
+
+/* For tracing reduce actions, the names of all rules are required.
+*/
+this.yyRuleName = [
+ /*   0 */ "program ::= expr",
+ /*   1 */ "expr ::= expr MINUS expr",
+ /*   2 */ "expr ::= expr PLUS expr",
+ /*   3 */ "expr ::= expr TIMES expr",
+ /*   4 */ "expr ::= expr DIVIDE expr",
+ /*   5 */ "expr ::= INTEGER",
+];
+/*
+** Try to increase the size of the parser stack.  Return the number
+** of errors.  Return 0 on success.
+*/
+this.yyGrowStack = function () {
+  // fix me: yystksz*2 + 100
+  this.yystack.push({
+    stateno: undefined,
+    major: undefined,
+    minor: undefined
+  });
+}
+
+/* Initialize a new parser that has already been allocated.
+*/
+this.init = function () {
+  this.yyhwm = 0;
+  this.yyerrcnt = -1;
+  this.yyidx = 0;
+  if (this.YYSTACKDEPTH <= 0) {
+    this.yystack = [];
+    this.yyGrowStack();
+  } else {
+    this.yystack = new Array(this.YYSTACKDEPTH);
+    for (var i = 0; i < this.YYSTACKDEPTH; i++) {
+      this.yystack[i] = {
+        stateno: undefined,
+        major: undefined,
+        minor: undefined
+      };
+    }
+  }
+  var yytos = this.yystack[0];
+  yytos.stateno = 0;
+  yytos.major = 0;
+}
+
+/* The following function deletes the "minor type" or semantic value
+** associated with a symbol.  The symbol can be either a terminal
+** or nonterminal. "yymajor" is the symbol code, and "yypminor" is
+** a pointer to the value to be deleted.  The code used to do the
+** deletions is derived from the %destructor and/or %token_destructor
+** directives of the input grammar.
+*/
+this.yy_destructor = function (
+  yymajor,  /* Type code for object to destroy */
+  yyminor   /* The object to be destroyed */
+) {
+  switch (yymajor) {
+    /* Here is inserted the actions which take place when a
+    ** terminal or non-terminal is destroyed.  This can happen
+    ** when the symbol is popped from the stack during a
+    ** reduce or during error processing or when a parser is
+    ** being destroyed before it is finished parsing.
+    **
+    ** Note: during a reduce, the only symbols destroyed are those
+    ** which appear on the RHS of the rule, but which are *not* used
+    ** inside the C code.
+    */
+/********* Begin destructor definitions ***************************************/
+/********* End destructor definitions *****************************************/
+    default:  break;   /* If no destructor action specified: do nothing */
+  }
+}
+
+/*
+** Pop the parser's stack once.
+**
+** If there is a destructor routine associated with the token which
+** is popped from the stack, then call it.
+*/
+this.yy_pop_parser_stack = function () {
+  // assert( pParser->yytos!=0 );
+  // assert( pParser->yytos > pParser->yystack );
+  var yytos = this.yystack[this.yyidx];
+
+  if (this.yyTraceCallback) {
+    this.trace("Popping " + this.yyTokenName[yytos.major]);
+  }
+  this.yy_destructor(yytos.major, yytos.minor);
+
+  this.yyidx--;
+}
+
+/*
+** Clear all secondary memory allocations from the parser
+*/
+this.finalize = function () {
+  while (this.yyidx > 0) {
+    this.yy_pop_parser_stack();
+  }
+  this.yystack = null;
+}
+
+/*
+** Return the peak depth of the stack for a parser.
+*/
+this.getStackPeak = function () {
+  return this.yyhwm;
+}
+
+/*
+** Find the appropriate action for a parser given the terminal
+** look-ahead token iLookAhead.
+*/
+this.yy_find_shift_action = function (
+  iLookAhead     /* The look-ahead token */
+) {
+  var yytos = this.yystack[this.yyidx];
+  var stateno = yytos.stateno;
+
+  if (stateno >= this.YY_MIN_REDUCE) {
+    return stateno;
+  }
+
+  // assert( stateno <= YY_SHIFT_COUNT );
+
+  do {
+    var i = this.yy_shift_ofst[stateno];
+    // assert( iLookAhead!=YYNOCODE );
+    i += iLookAhead;
+    if (i < 0 || i >= this.yy_action.length || this.yy_lookahead[i] != iLookAhead) {
+      if (this.YYFALLBACK) {
+        var iFallback;  /* Fallback token */
+        if ((iLookAhead < this.yyFallback.length)
+          && (iFallback = this.yyFallback[iLookAhead]) != 0
+        ) {
+          if (this.yyTraceCallback) {
+            this.trace("FALLBACK " + this.yyTokenName[iLookAhead] + " => " + this.yyTokenName[iFallback]);
+          }
+        }
+        // assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
+        iLookAhead = iFallback;
+        continue;
+      }
+
+      if (this.YYWILDCARD) {
+        var j = i - iLookAhead + this.YYWILDCARD;
+        var cond1 = (this.YY_SHIFT_MIN + this.YYWILDCARD) < 0 ? j >= 0 : true;
+        var cond2 = (this.YY_SHIFT_MAX + this.YYWILDCARD) >= this.yy_action.length ? j < this.yy_action.length : true;
+        if (cond1 && cond2 && this.yy_lookahead[j] == this.YYWILDCARD && iLookAhead > 0) {
+          if (this.yyTraceCallback) {
+            this.trace("WILDCARD " + this.yyTokenName[iLookAhead] + " => " + this.yyTokenName[this.YYWILDCARD]);
+          }
+          return this.yy_action[j];
+        }
+      }
+
+      return this.yy_default[stateno];
+    } else {
+      return this.yy_action[i];
+    }
+  } while (true);
+}
+
+/*
+** Find the appropriate action for a parser given the non-terminal
+** look-ahead token iLookAhead.
+*/
+this.yy_find_reduce_action = function (
+  stateno,       /* Current state number */
+  iLookAhead     /* The look-ahead token */
+) {
+  if (this.YYERRORSYMBOL) {
+    if (stateno > this.YY_REDUCE_COUNT) {
+      return this.yy_default[stateno];
+    }
+  } else {
+    // assert( stateno<=YY_REDUCE_COUNT );
+  }
+
+  var i = this.yy_reduce_ofst[stateno];
+  // assert( i!=YY_REDUCE_USE_DFLT );
+  // assert( iLookAhead!=YYNOCODE );
+  i += iLookAhead;
+
+  if (this.YYERRORSYMBOL) {
+    if (i < 0 || i >= this.yy_action.length || this.yy_lookahead[i] != iLookAhead) {
+      return this.yy_default[stateno];
+    }
+  } else {
+    // assert( i>=0 && i<YY_ACTTAB_COUNT );
+    // assert( yy_lookahead[i]==iLookAhead );
+  }
+
+  return this.yy_action[i];
+}
+
+/*
+** The following routine is called if the stack overflows.
+*/
+this.yyStackOverflow = function () {
+  if (this.yyTraceCallback) {
+    this.trace("Stack Overflow!");
+  }
+
+  while (this.yyidx > 0) {
+    this.yy_pop_parser_stack();
+  }
+  /* Here code is inserted which will execute if the parser
+  ** stack every overflows */
+/******** Begin %stack_overflow code ******************************************/
+/******** End %stack_overflow code ********************************************/
+}
+
+/*
+** Print tracing information for a SHIFT action
+*/
+this.yyTraceShift = function (yyNewState) {
+  if (this.yyTraceCallback) {
+    var yytos = this.yystack[this.yyidx];
+    if (yyNewState < this.YYNSTATE) {
+      this.trace("Shift '" + this.yyTokenName[yytos.major] + "', go to state " + yyNewState);
+    } else {
+      this.trace("Shift '" + this.yyTokenName[yytos.major] + "'");
+    }
+  }
+}
+
+/*
+** Perform a shift action.
+*/
+this.yy_shift = function (
+  yyNewState,    /* The new state to shift in */
+  yyMajor,       /* The major token to shift in */
+  yyMinor        /* The minor token to shift in */
+) {
+  this.yyidx++;
+
+  if (this.yyidx > this.yyhwm) {
+    this.yyhwm++;
+    // assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
+  }
+
+  if (this.YYSTACKDEPTH > 0) {
+    if (this.yyidx >= this.YYSTACKDEPTH) {
+      this.yyidx--;
+      this.yyStackOverflow();
+      return;
+    }
+  } else {
+    if (this.yyidx >= this.yystack.length) {
+      this.yyGrowStack();
+    }
+  }
+
+  if (yyNewState > this.YY_MAX_SHIFT) {
+    yyNewState += this.YY_MIN_REDUCE - this.YY_MIN_SHIFTREDUCE;
+  }
+
+  var yytos = this.yystack[this.yyidx];
+  yytos.stateno = yyNewState;
+  yytos.major = yyMajor;
+  yytos.minor = yyMinor;
+
+  this.yyTraceShift(yyNewState);
+}
+
+/* The following table contains information about every rule that
+** is used during the reduce.
+*/
+//{
+//  lhs,      /* Symbol on the left-hand side of the rule */
+//  nrhs,     /* Number of right-hand side symbols in the rule */
+//}
+this.yyRuleInfo = [
+  { lhs: 7, nrhs: 1 },
+  { lhs: 8, nrhs: 3 },
+  { lhs: 8, nrhs: 3 },
+  { lhs: 8, nrhs: 3 },
+  { lhs: 8, nrhs: 3 },
+  { lhs: 8, nrhs: 1 },
+];
+
+/*
+** Perform a reduce action and the shift that must immediately
+** follow the reduce.
+*/
+this.yy_reduce = function (
+  yyruleno        /* Number of the rule by which to reduce */
+){
+  var yymsp = this.yystack[this.yyidx]; /* The top of the parser's stack */
+
+  if (yyruleno < this.yyRuleName.length) {
+    var yysize = this.yyRuleInfo[yyruleno].nrhs;
+    var ruleName = this.yyRuleName[yyruleno];
+    var newStateNo = this.yystack[this.yyidx - yysize].stateno;
+    if (this.yyTraceCallback) {
+      this.trace("Reduce [" + ruleName + "], go to state " + newStateNo + ".");
+    }
+  }
+
+  /* Check that the stack is large enough to grow by a single entry
+  ** if the RHS of the rule is empty.  This ensures that there is room
+  ** enough on the stack to push the LHS value */
+  if (this.yyRuleInfo[yyruleno].nrhs == 0) {
+    if (this.yyidx > this.yyhwm) {
+      this.yyhwm++;
+      // assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
+    }
+    if (this.YYSTACKDEPTH > 0) {
+      if (this.yyidx >= this.YYSTACKDEPTH - 1) {
+        this.yyStackOverflow();
+        return;
+      }
+    } else {
+      if (this.yyidx >= this.yystack.length - 1) {
+        this.yyGrowStack();
+        yymsp = this.yystack[this.yyidx];
+      }
+    }
+  }
+
+  var yylhsminor;
+  switch (yyruleno) {
+  /* Beginning here are the reduction cases.  A typical example
+  ** follows:
+  **   case 0:
+  **  #line <lineno> <grammarfile>
+  **     { ... }           // User supplied code
+  **  #line <lineno> <thisfile>
+  **     break;
+  */
+/********** Begin reduce actions **********************************************/
+      case 0: /* program ::= expr */
+// line 63 "examples/calculator-js.y"
+{ console.log("Result=" + this.yystack[this.yyidx + 0].minor); }
+// line 602 "examples/calculator-js.js"
+        break;
+      case 1: /* expr ::= expr MINUS expr */
+// line 64 "examples/calculator-js.y"
+{ yylhsminor = this.yystack[this.yyidx + -2].minor - this.yystack[this.yyidx + 0].minor; }
+// line 607 "examples/calculator-js.js"
+  this.yystack[this.yyidx + -2].minor = yylhsminor;
+        break;
+      case 2: /* expr ::= expr PLUS expr */
+// line 65 "examples/calculator-js.y"
+{ yylhsminor = this.yystack[this.yyidx + -2].minor + this.yystack[this.yyidx + 0].minor; }
+// line 613 "examples/calculator-js.js"
+  this.yystack[this.yyidx + -2].minor = yylhsminor;
+        break;
+      case 3: /* expr ::= expr TIMES expr */
+// line 66 "examples/calculator-js.y"
+{ yylhsminor = this.yystack[this.yyidx + -2].minor * this.yystack[this.yyidx + 0].minor; }
+// line 619 "examples/calculator-js.js"
+  this.yystack[this.yyidx + -2].minor = yylhsminor;
+        break;
+      case 4: /* expr ::= expr DIVIDE expr */
+// line 67 "examples/calculator-js.y"
+{
+  if (this.yystack[this.yyidx + 0].minor != 0) {
+    yylhsminor = this.yystack[this.yyidx + -2].minor / this.yystack[this.yyidx + 0].minor;
+  } else {
+    throw new Error("Divide by zero");
+  }
+}
+// line 631 "examples/calculator-js.js"
+  this.yystack[this.yyidx + -2].minor = yylhsminor;
+        break;
+      case 5: /* expr ::= INTEGER */
+// line 74 "examples/calculator-js.y"
+{ yylhsminor = this.yystack[this.yyidx + 0].minor; }
+// line 637 "examples/calculator-js.js"
+  this.yystack[this.yyidx + 0].minor = yylhsminor;
+        break;
+      default:
+        break;
+/********** End reduce actions ************************************************/
+  };
+  // assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
+
+  var yygoto = this.yyRuleInfo[yyruleno].lhs;    /* The next state */
+  var yysize = this.yyRuleInfo[yyruleno].nrhs;   /* Amount to pop the stack */
+  var yyact = this.yy_find_reduce_action(   /* The next action */
+    this.yystack[this.yyidx - yysize].stateno,
+    yygoto
+  );
+  if (yyact <= this.YY_MAX_SHIFTREDUCE) {
+    if (yyact > this.YY_MAX_SHIFT) {
+      yyact += this.YY_MIN_REDUCE - this.YY_MIN_SHIFTREDUCE;
+    }
+    this.yyidx -= yysize - 1;
+    yymsp = this.yystack[this.yyidx];
+    yymsp.stateno = yyact;
+    yymsp.major = yygoto;
+    this.yyTraceShift(yyact);
+  } else {
+    // assert( yyact == YY_ACCEPT_ACTION );
+    this.yyidx -= yysize;
+    this.yy_accept();
+  }
+}
+
+/*
+** The following code executes when the parse fails
+*/
+this.yy_parse_failed = function () {
+  if (this.yyTraceCallback) {
+    this.trace("Fail!");
+  }
+  while (this.yyidx > 0) {
+    this.yy_pop_parser_stack();
+  }
+  /* Here code is inserted which will be executed whenever the
+  ** parser fails */
+/************ Begin %parse_failure code ***************************************/
+/************ End %parse_failure code *****************************************/
+}
+
+/*
+** The following code executes when a syntax error first occurs.
+*/
+this.yy_syntax_error = function (
+  yymajor,        /* The major type of the error token */
+  yyminor         /* The minor type of the error token */
+) {
+  var TOKEN = yyminor;
+/************ Begin %syntax_error code ****************************************/
+// line 59 "examples/calculator-js.y"
+
+  console.log("Syntax error");
+// line 696 "examples/calculator-js.js"
+/************ End %syntax_error code ******************************************/
+}
+
+/*
+** The following is executed when the parser accepts
+*/
+this.yy_accept = function () {
+  if (this.yyTraceCallback) {
+    this.trace("Accept!");
+  }
+  if (!this.YYNOERRORRECOVERY) {
+    this.yyerrcnt = -1;
+  }
+  // assert( yypParser->yytos==yypParser->yystack );
+  /* Here code is inserted which will be executed whenever the
+  ** parser accepts */
+/*********** Begin %parse_accept code *****************************************/
+/*********** End %parse_accept code *******************************************/
+}
+
+/* The main parser program.
+** The first argument is a pointer to a structure obtained from
+** "ParserAlloc" which describes the current state of the parser.
+** The second argument is the major token number.  The third is
+** the minor token.  The fourth optional argument is whatever the
+** user wants (and specified in the grammar) and is available for
+** use by the action routines.
+**
+** Inputs:
+** <ul>
+** <li> A pointer to the parser (an opaque structure.)
+** <li> The major token number.
+** <li> The minor token number.
+** <li> An option argument of a grammar-specified type.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+this.parse = function (
+  yymajor,                  /* The major token code number */
+  yyminor                   /* The value for the token */
+) {
+  var yyact;            /* The parser action. */
+  var yyendofinput;     /* True if we are at the end of input */
+  var yyerrorhit = 0;   /* True if yymajor has invoked an error */
+
+  //assert( yypParser->yytos!=0 );
+
+  if (yymajor === undefined || yymajor === null) {
+    yymajor = 0;
+  }
+
+  yyendofinput = yymajor == 0;
+
+  if (this.yyTraceCallback) {
+    this.trace("Input '" + this.yyTokenName[yymajor] + "'");
+  }
+
+  do {
+    yyact = this.yy_find_shift_action(yymajor);
+    if (yyact <= this.YY_MAX_SHIFTREDUCE) { // check me?
+      this.yy_shift(yyact, yymajor, yyminor);
+      if (!this.YYNOERRORRECOVERY) {
+        this.yyerrcnt--;
+      }
+      yymajor = this.YYNOCODE;
+    } else if (yyact <= this.YY_MAX_REDUCE) { // check me?
+      this.yy_reduce(yyact - this.YY_MIN_REDUCE); // check me?
+    } else {
+      // assert( yyact == YY_ERROR_ACTION );
+      if (this.yyTraceCallback) {
+        this.trace("Syntax Error!");
+      }
+      if (this.YYERRORSYMBOL) {
+        /* A syntax error has occurred.
+        ** The response to an error depends upon whether or not the
+        ** grammar defines an error token "ERROR".
+        **
+        ** This is what we do if the grammar does define ERROR:
+        **
+        **  * Call the %syntax_error function.
+        **
+        **  * Begin popping the stack until we enter a state where
+        **    it is legal to shift the error symbol, then shift
+        **    the error symbol.
+        **
+        **  * Set the error count to three.
+        **
+        **  * Begin accepting and shifting new tokens.  No new error
+        **    processing will occur until three tokens have been
+        **    shifted successfully.
+        **
+        */
+        if (this.yyerrcnt < 0) {
+          this.yy_syntax_error(yymajor, yyminor);
+        }
+        var yymx = this.yystack[this.yyidx].major;
+        if (yymx == this.YYERRORSYMBOL || yyerrorhit) {
+          if (this.yyTraceCallback) {
+            this.trace("Discard input token " + this.yyTokenName[yymajor]);
+          }
+          this.yy_destructor(yymajor, yyminor);
+          yymajor = this.YYNOCODE;
+        } else {
+          while (this.yyidx >= 0
+              && yymx != this.YYERRORSYMBOL
+              && (yyact = this.yy_find_reduce_action(
+                          this.yystack[this.yyidx].stateno,
+                          this.YYERRORSYMBOL)) >= this.YY_MIN_REDUCE // check me?
+          ) {
+            this.yy_pop_parser_stack();
+          }
+          if (this.yyidx < 0 || yymajor == 0) {
+            this.yy_destructor(yymajor, yyminor);
+            this.yy_parse_failed();
+            if (!this.YYNOERRORRECOVERY) {
+              this.yyerrcnt = -1;
+            }
+            yymajor = this.YYNOCODE;
+          } else if (yymx != this.YYERRORSYMBOL) {
+            this.yy_shift(yyact, this.YYERRORSYMBOL, yyminor); // check me?
+          }
+        }
+        this.yyerrcnt = 3;
+        yyerrorhit = 1;
+      } else if (this.YYNOERRORRECOVERY) {
+        /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
+        ** do any kind of error recovery.  Instead, simply invoke the syntax
+        ** error routine and continue going as if nothing had happened.
+        **
+        ** Applications can set this macro (for example inside %include) if
+        ** they intend to abandon the parse upon the first syntax error seen.
+        */
+        this.yy_syntax_error(yymajor, yyminor);
+        this.yy_destructor(yymajor, yyminor);
+        yymajor = this.YYNOCODE;
+      } else {  /* YYERRORSYMBOL is not defined */
+        /* This is what we do if the grammar does not define ERROR:
+        **
+        **  * Report an error message, and throw away the input token.
+        **
+        **  * If the input token is $, then fail the parse.
+        **
+        ** As before, subsequent error messages are suppressed until
+        ** three input tokens have been successfully shifted.
+        */
+        if (this.yyerrcnt <= 0) {
+          this.yy_syntax_error(yymajor, yyminor);
+        }
+        this.yyerrcnt = 3;
+        this.yy_destructor(yymajor, yyminor);
+        if (yyendofinput) {
+          this.yy_parse_failed();
+          if (!this.YYNOERRORRECOVERY) {
+            this.yyerrcnt = -1;
+          }
+        }
+        yymajor = this.YYNOCODE;
+      }
+    }
+  } while (yymajor != this.YYNOCODE && this.yyidx > 0);
+
+  if (this.yyTraceCallback) {
+    var remainingTokens = [];
+    for (var i = 1; i <= this.yyidx; i++) {
+      remainingTokens.push(this.yyTokenName[this.yystack[i].major]);
+    }
+    this.trace("Return. Stack=[" + remainingTokens.join(" ") + "]");
+  }
+}
+
+this.init();
+
+} // function Parser()
+// line 12 "examples/calculator-js.y"
+
+  var Lexer = require('../lexer/lexer');
+
+  var parser = new Parser();
+
+  parser.setTraceCallback(function (value) {
+    process.stdout.write(value);
+  }, '> ');
+
+  var lexer = new Lexer();
+
+  lexer.addRule(/\d+/, function (value) {
+    return { major: parser.TOKEN_INTEGER, minor: parseInt(value, 10) };
+  });
+  lexer.addRule('+', function (value) {
+    return { major: parser.TOKEN_PLUS, minor: null };
+  });
+  lexer.addRule('-', function (value) {
+    return { major: parser.TOKEN_MINUS, minor: null };
+  });
+  lexer.addRule('/', function (value) {
+    return { major: parser.TOKEN_DIVIDE, minor: null };
+  });
+  lexer.addRule('*', function (value) {
+    return { major: parser.TOKEN_TIMES, minor: null };
+  });
+  lexer.addRule(/\s+/, function () {});
+
+  var data = '';
+
+  process.stdin.on('data', function (chunk) {
+    data += chunk;
+  });
+
+  process.stdin.on('end', function () {
+    var token;
+
+    lexer.setInput(data);
+
+    while (token = lexer.lex()) {
+      parser.parse(token.major, token.minor);
+    }
+
+    parser.parse();
+  });
+// line 918 "examples/calculator-js.js"
diff --git a/examples/calculator-js.out b/examples/calculator-js.out
new file mode 100644
index 0000000..ef48d8f
--- /dev/null
+++ b/examples/calculator-js.out
@@ -0,0 +1,102 @@
+State 0:
+          program ::= * expr
+          expr ::= * expr MINUS expr
+          expr ::= * expr PLUS expr
+          expr ::= * expr TIMES expr
+          expr ::= * expr DIVIDE expr
+          expr ::= * INTEGER
+
+                       INTEGER shift-reduce 5      expr ::= INTEGER
+                       program accept
+                          expr shift        5      
+
+State 1:
+          expr ::= * expr MINUS expr
+          expr ::= * expr PLUS expr
+          expr ::= * expr TIMES expr
+          expr ::= * expr DIVIDE expr
+          expr ::= expr DIVIDE * expr
+          expr ::= * INTEGER
+
+                       INTEGER shift-reduce 5      expr ::= INTEGER
+                          expr shift-reduce 4      expr ::= expr DIVIDE expr
+
+State 2:
+          expr ::= * expr MINUS expr
+          expr ::= * expr PLUS expr
+          expr ::= * expr TIMES expr
+          expr ::= expr TIMES * expr
+          expr ::= * expr DIVIDE expr
+          expr ::= * INTEGER
+
+                       INTEGER shift-reduce 5      expr ::= INTEGER
+                          expr shift-reduce 3      expr ::= expr TIMES expr
+
+State 3:
+          expr ::= * expr MINUS expr
+          expr ::= * expr PLUS expr
+          expr ::= expr PLUS * expr
+          expr ::= * expr TIMES expr
+          expr ::= * expr DIVIDE expr
+          expr ::= * INTEGER
+
+                       INTEGER shift-reduce 5      expr ::= INTEGER
+                          expr shift        6      
+
+State 4:
+          expr ::= * expr MINUS expr
+          expr ::= expr MINUS * expr
+          expr ::= * expr PLUS expr
+          expr ::= * expr TIMES expr
+          expr ::= * expr DIVIDE expr
+          expr ::= * INTEGER
+
+                       INTEGER shift-reduce 5      expr ::= INTEGER
+                          expr shift        7      
+
+State 5:
+      (0) program ::= expr *
+          expr ::= expr * MINUS expr
+          expr ::= expr * PLUS expr
+          expr ::= expr * TIMES expr
+          expr ::= expr * DIVIDE expr
+
+                             $ reduce       0      program ::= expr
+                          PLUS shift        3      
+                         MINUS shift        4      
+                        DIVIDE shift        1      
+                         TIMES shift        2      
+
+State 6:
+          expr ::= expr * MINUS expr
+          expr ::= expr * PLUS expr
+      (2) expr ::= expr PLUS expr *
+          expr ::= expr * TIMES expr
+          expr ::= expr * DIVIDE expr
+
+                        DIVIDE shift        1      
+                         TIMES shift        2      
+                     {default} reduce       2      expr ::= expr PLUS expr
+
+State 7:
+          expr ::= expr * MINUS expr
+      (1) expr ::= expr MINUS expr *
+          expr ::= expr * PLUS expr
+          expr ::= expr * TIMES expr
+          expr ::= expr * DIVIDE expr
+
+                        DIVIDE shift        1      
+                         TIMES shift        2      
+                     {default} reduce       1      expr ::= expr MINUS expr
+
+----------------------------------------------------
+Symbols:
+    0: $:
+    1: PLUS
+    2: MINUS
+    3: DIVIDE
+    4: TIMES
+    5: INTEGER
+    6: error:
+    7: program: INTEGER
+    8: expr: INTEGER
diff --git a/examples/calculator-js.y b/examples/calculator-js.y
new file mode 100644
index 0000000..a49217f
--- /dev/null
+++ b/examples/calculator-js.y
@@ -0,0 +1,74 @@
+%name Parser
+
+%token_prefix TOKEN_
+
+%left PLUS MINUS.
+%left DIVIDE TIMES.
+
+%include {
+  // include something
+}
+
+%code {
+  var Lexer = require('../lexer/lexer');
+
+  var parser = new Parser();
+
+  parser.setTraceCallback(function (value) {
+    process.stdout.write(value);
+  }, '> ');
+
+  var lexer = new Lexer();
+
+  lexer.addRule(/\d+/, function (value) {
+    return { major: parser.TOKEN_INTEGER, minor: parseInt(value, 10) };
+  });
+  lexer.addRule('+', function (value) {
+    return { major: parser.TOKEN_PLUS, minor: null };
+  });
+  lexer.addRule('-', function (value) {
+    return { major: parser.TOKEN_MINUS, minor: null };
+  });
+  lexer.addRule('/', function (value) {
+    return { major: parser.TOKEN_DIVIDE, minor: null };
+  });
+  lexer.addRule('*', function (value) {
+    return { major: parser.TOKEN_TIMES, minor: null };
+  });
+  lexer.addRule(/\s+/, function () {});
+
+  var data = '';
+
+  process.stdin.on('data', function (chunk) {
+    data += chunk;
+  });
+
+  process.stdin.on('end', function () {
+    var token;
+
+    lexer.setInput(data);
+
+    while (token = lexer.lex()) {
+      parser.parse(token.major, token.minor);
+    }
+
+    parser.parse();
+  });
+}
+
+%syntax_error {
+  console.log("Syntax error");
+}
+
+program ::= expr(A). { console.log("Result=" + A); }
+expr(A) ::= expr(B) MINUS expr(C). { A = B - C; }
+expr(A) ::= expr(B) PLUS expr(C). { A = B + C; }
+expr(A) ::= expr(B) TIMES expr(C). { A = B * C; }
+expr(A) ::= expr(B) DIVIDE expr(C). {
+  if (C != 0) {
+    A = B / C;
+  } else {
+    throw new Error("Divide by zero");
+  }
+}
+expr(A) ::= INTEGER(B). { A = B; }
diff --git a/lemon-src/lemon-js b/lemon-src/lemon-js
new file mode 100755
index 0000000000000000000000000000000000000000..72d006f3977aca03e6873975c5874157022d5bd4
GIT binary patch
literal 86608
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
V1Rus?^Ma^khEOnJ`2GNx005DtetG}^

literal 0
HcmV?d00001

diff --git a/lemon-src/lemon-js.c b/lemon-src/lemon-js.c
new file mode 100644
index 0000000..4cdfeb7
--- /dev/null
+++ b/lemon-src/lemon-js.c
@@ -0,0 +1,5442 @@
+/*
+** This file contains all sources (including headers) to the LEMON
+** LALR(1) parser generator.  The sources have been combined into a
+** single file to make it easy to include LEMON in the source tree
+** and Makefile of another program.
+**
+** The author of this program disclaims copyright.
+**
+** Based on SQLite distribution v3.17.0
+** Adopted for JavaScript by Artem Butusov <art.sormy@gmail.com>
+*/
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#define ISSPACE(X) isspace((unsigned char)(X))
+#define ISDIGIT(X) isdigit((unsigned char)(X))
+#define ISALNUM(X) isalnum((unsigned char)(X))
+#define ISALPHA(X) isalpha((unsigned char)(X))
+#define ISUPPER(X) isupper((unsigned char)(X))
+#define ISLOWER(X) islower((unsigned char)(X))
+
+
+#ifndef __WIN32__
+#   if defined(_WIN32) || defined(WIN32)
+#       define __WIN32__
+#   endif
+#endif
+
+#ifdef __WIN32__
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern int access(const char *path, int mode);
+#ifdef __cplusplus
+}
+#endif
+#else
+#include <unistd.h>
+#endif
+
+/* #define PRIVATE static */
+#define PRIVATE
+
+#ifdef TEST
+#define MAXRHS 5       /* Set low to exercise exception code */
+#else
+#define MAXRHS 1000
+#endif
+
+static int showPrecedenceConflict = 0;
+static char *msort(char*,char**,int(*)(const char*,const char*));
+
+/*
+** Compilers are getting increasingly pedantic about type conversions
+** as C evolves ever closer to Ada....  To work around the latest problems
+** we have to define the following variant of strlen().
+*/
+#define lemonStrlen(X)   ((int)strlen(X))
+
+/*
+** Compilers are starting to complain about the use of sprintf() and strcpy(),
+** saying they are unsafe.  So we define our own versions of those routines too.
+**
+** There are three routines here:  lemon_sprintf(), lemon_vsprintf(), and
+** lemon_addtext(). The first two are replacements for sprintf() and vsprintf().
+** The third is a helper routine for vsnprintf() that adds texts to the end of a
+** buffer, making sure the buffer is always zero-terminated.
+**
+** The string formatter is a minimal subset of stdlib sprintf() supporting only
+** a few simply conversions:
+**
+**   %d
+**   %s
+**   %.*s
+**
+*/
+static void lemon_addtext(
+  char *zBuf,           /* The buffer to which text is added */
+  int *pnUsed,          /* Slots of the buffer used so far */
+  const char *zIn,      /* Text to add */
+  int nIn,              /* Bytes of text to add.  -1 to use strlen() */
+  int iWidth            /* Field width.  Negative to left justify */
+){
+  if( nIn<0 ) for(nIn=0; zIn[nIn]; nIn++){}
+  while( iWidth>nIn ){ zBuf[(*pnUsed)++] = ' '; iWidth--; }
+  if( nIn==0 ) return;
+  memcpy(&zBuf[*pnUsed], zIn, nIn);
+  *pnUsed += nIn;
+  while( (-iWidth)>nIn ){ zBuf[(*pnUsed)++] = ' '; iWidth++; }
+  zBuf[*pnUsed] = 0;
+}
+static int lemon_vsprintf(char *str, const char *zFormat, va_list ap){
+  int i, j, k, c;
+  int nUsed = 0;
+  const char *z;
+  char zTemp[50];
+  str[0] = 0;
+  for(i=j=0; (c = zFormat[i])!=0; i++){
+    if( c=='%' ){
+      int iWidth = 0;
+      lemon_addtext(str, &nUsed, &zFormat[j], i-j, 0);
+      c = zFormat[++i];
+      if( ISDIGIT(c) || (c=='-' && ISDIGIT(zFormat[i+1])) ){
+        if( c=='-' ) i++;
+        while( ISDIGIT(zFormat[i]) ) iWidth = iWidth*10 + zFormat[i++] - '0';
+        if( c=='-' ) iWidth = -iWidth;
+        c = zFormat[i];
+      }
+      if( c=='d' ){
+        int v = va_arg(ap, int);
+        if( v<0 ){
+          lemon_addtext(str, &nUsed, "-", 1, iWidth);
+          v = -v;
+        }else if( v==0 ){
+          lemon_addtext(str, &nUsed, "0", 1, iWidth);
+        }
+        k = 0;
+        while( v>0 ){
+          k++;
+          zTemp[sizeof(zTemp)-k] = (v%10) + '0';
+          v /= 10;
+        }
+        lemon_addtext(str, &nUsed, &zTemp[sizeof(zTemp)-k], k, iWidth);
+      }else if( c=='s' ){
+        z = va_arg(ap, const char*);
+        lemon_addtext(str, &nUsed, z, -1, iWidth);
+      }else if( c=='.' && memcmp(&zFormat[i], ".*s", 3)==0 ){
+        i += 2;
+        k = va_arg(ap, int);
+        z = va_arg(ap, const char*);
+        lemon_addtext(str, &nUsed, z, k, iWidth);
+      }else if( c=='%' ){
+        lemon_addtext(str, &nUsed, "%", 1, 0);
+      }else{
+        fprintf(stderr, "illegal format\n");
+        exit(1);
+      }
+      j = i+1;
+    }
+  }
+  lemon_addtext(str, &nUsed, &zFormat[j], i-j, 0);
+  return nUsed;
+}
+static int lemon_sprintf(char *str, const char *format, ...){
+  va_list ap;
+  int rc;
+  va_start(ap, format);
+  rc = lemon_vsprintf(str, format, ap);
+  va_end(ap);
+  return rc;
+}
+static void lemon_strcpy(char *dest, const char *src){
+  while( (*(dest++) = *(src++))!=0 ){}
+}
+static void lemon_strcat(char *dest, const char *src){
+  while( *dest ) dest++;
+  lemon_strcpy(dest, src);
+}
+
+
+/* a few forward declarations... */
+struct rule;
+struct lemon;
+struct action;
+
+static struct action *Action_new(void);
+static struct action *Action_sort(struct action *);
+
+/********** From the file "build.h" ************************************/
+void FindRulePrecedences();
+void FindFirstSets();
+void FindStates();
+void FindLinks();
+void FindFollowSets();
+void FindActions();
+
+/********* From the file "configlist.h" *********************************/
+void Configlist_init(void);
+struct config *Configlist_add(struct rule *, int);
+struct config *Configlist_addbasis(struct rule *, int);
+void Configlist_closure(struct lemon *);
+void Configlist_sort(void);
+void Configlist_sortbasis(void);
+struct config *Configlist_return(void);
+struct config *Configlist_basis(void);
+void Configlist_eat(struct config *);
+void Configlist_reset(void);
+
+/********* From the file "error.h" ***************************************/
+void ErrorMsg(const char *, int,const char *, ...);
+
+/****** From the file "option.h" ******************************************/
+enum option_type { OPT_FLAG=1,  OPT_INT,  OPT_DBL,  OPT_STR,
+         OPT_FFLAG, OPT_FINT, OPT_FDBL, OPT_FSTR};
+struct s_options {
+  enum option_type type;
+  const char *label;
+  char *arg;
+  const char *message;
+};
+int    OptInit(char**,struct s_options*,FILE*);
+int    OptNArgs(void);
+char  *OptArg(int);
+void   OptErr(int);
+void   OptPrint(void);
+
+/******** From the file "parse.h" *****************************************/
+void Parse(struct lemon *lemp);
+
+/********* From the file "plink.h" ***************************************/
+struct plink *Plink_new(void);
+void Plink_add(struct plink **, struct config *);
+void Plink_copy(struct plink **, struct plink *);
+void Plink_delete(struct plink *);
+
+/********** From the file "report.h" *************************************/
+void Reprint(struct lemon *);
+void ReportOutput(struct lemon *);
+void ReportTable(struct lemon *, int);
+void ReportHeader(struct lemon *);
+void CompressTables(struct lemon *);
+void ResortStates(struct lemon *);
+
+/********** From the file "set.h" ****************************************/
+void  SetSize(int);             /* All sets will be of size N */
+char *SetNew(void);               /* A new set for element 0..N */
+void  SetFree(char*);             /* Deallocate a set */
+int SetAdd(char*,int);            /* Add element to a set */
+int SetUnion(char *,char *);    /* A <- A U B, thru element N */
+#define SetFind(X,Y) (X[Y])       /* True if Y is in set X */
+
+/********** From the file "struct.h" *************************************/
+/*
+** Principal data structures for the LEMON parser generator.
+*/
+
+typedef enum {LEMON_FALSE=0, LEMON_TRUE} Boolean;
+
+/* Symbols (terminals and nonterminals) of the grammar are stored
+** in the following: */
+enum symbol_type {
+  TERMINAL,
+  NONTERMINAL,
+  MULTITERMINAL
+};
+enum e_assoc {
+    LEFT,
+    RIGHT,
+    NONE,
+    UNK
+};
+struct symbol {
+  const char *name;        /* Name of the symbol */
+  int index;               /* Index number for this symbol */
+  enum symbol_type type;   /* Symbols are all either TERMINALS or NTs */
+  struct rule *rule;       /* Linked list of rules of this (if an NT) */
+  struct symbol *fallback; /* fallback token in case this token doesn't parse */
+  int prec;                /* Precedence if defined (-1 otherwise) */
+  enum e_assoc assoc;      /* Associativity if precedence is defined */
+  char *firstset;          /* First-set for all rules of this symbol */
+  Boolean lambda;          /* True if NT and can generate an empty string */
+  int useCnt;              /* Number of times used */
+  char *destructor;        /* Code which executes whenever this symbol is
+                           ** popped from the stack during error processing */
+  int destLineno;          /* Line number for start of destructor.  Set to
+                           ** -1 for duplicate destructors. */
+  char *datatype;          /* The data type of information held by this
+                           ** object. Only used if type==NONTERMINAL */
+  int dtnum;               /* The data type number.  In the parser, the value
+                           ** stack is a union.  The .yy%d element of this
+                           ** union is the correct data type for this object */
+  /* The following fields are used by MULTITERMINALs only */
+  int nsubsym;             /* Number of constituent symbols in the MULTI */
+  struct symbol **subsym;  /* Array of constituent symbols */
+};
+
+/* Each production rule in the grammar is stored in the following
+** structure.  */
+struct rule {
+  struct symbol *lhs;      /* Left-hand side of the rule */
+  const char *lhsalias;    /* Alias for the LHS (NULL if none) */
+  int lhsStart;            /* True if left-hand side is the start symbol */
+  int ruleline;            /* Line number for the rule */
+  int nrhs;                /* Number of RHS symbols */
+  struct symbol **rhs;     /* The RHS symbols */
+  const char **rhsalias;   /* An alias for each RHS symbol (NULL if none) */
+  int line;                /* Line number at which code begins */
+  const char *code;        /* The code executed when this rule is reduced */
+  const char *codePrefix;  /* Setup code before code[] above */
+  const char *codeSuffix;  /* Breakdown code after code[] above */
+  int noCode;              /* True if this rule has no associated C code */
+  int codeEmitted;         /* True if the code has been emitted already */
+  struct symbol *precsym;  /* Precedence symbol for this rule */
+  int index;               /* An index number for this rule */
+  int iRule;               /* Rule number as used in the generated tables */
+  Boolean canReduce;       /* True if this rule is ever reduced */
+  Boolean doesReduce;      /* Reduce actions occur after optimization */
+  struct rule *nextlhs;    /* Next rule with the same LHS */
+  struct rule *next;       /* Next rule in the global list */
+};
+
+/* A configuration is a production rule of the grammar together with
+** a mark (dot) showing how much of that rule has been processed so far.
+** Configurations also contain a follow-set which is a list of terminal
+** symbols which are allowed to immediately follow the end of the rule.
+** Every configuration is recorded as an instance of the following: */
+enum cfgstatus {
+  COMPLETE,
+  INCOMPLETE
+};
+struct config {
+  struct rule *rp;         /* The rule upon which the configuration is based */
+  int dot;                 /* The parse point */
+  char *fws;               /* Follow-set for this configuration only */
+  struct plink *fplp;      /* Follow-set forward propagation links */
+  struct plink *bplp;      /* Follow-set backwards propagation links */
+  struct state *stp;       /* Pointer to state which contains this */
+  enum cfgstatus status;   /* used during followset and shift computations */
+  struct config *next;     /* Next configuration in the state */
+  struct config *bp;       /* The next basis configuration */
+};
+
+enum e_action {
+  SHIFT,
+  ACCEPT,
+  REDUCE,
+  ERROR,
+  SSCONFLICT,              /* A shift/shift conflict */
+  SRCONFLICT,              /* Was a reduce, but part of a conflict */
+  RRCONFLICT,              /* Was a reduce, but part of a conflict */
+  SH_RESOLVED,             /* Was a shift.  Precedence resolved conflict */
+  RD_RESOLVED,             /* Was reduce.  Precedence resolved conflict */
+  NOT_USED,                /* Deleted by compression */
+  SHIFTREDUCE              /* Shift first, then reduce */
+};
+
+/* Every shift or reduce operation is stored as one of the following */
+struct action {
+  struct symbol *sp;       /* The look-ahead symbol */
+  enum e_action type;
+  union {
+    struct state *stp;     /* The new state, if a shift */
+    struct rule *rp;       /* The rule, if a reduce */
+  } x;
+  struct symbol *spOpt;    /* SHIFTREDUCE optimization to this symbol */
+  struct action *next;     /* Next action for this state */
+  struct action *collide;  /* Next action with the same hash */
+};
+
+/* Each state of the generated parser's finite state machine
+** is encoded as an instance of the following structure. */
+struct state {
+  struct config *bp;       /* The basis configurations for this state */
+  struct config *cfp;      /* All configurations in this set */
+  int statenum;            /* Sequential number for this state */
+  struct action *ap;       /* List of actions for this state */
+  int nTknAct, nNtAct;     /* Number of actions on terminals and nonterminals */
+  int iTknOfst, iNtOfst;   /* yy_action[] offset for terminals and nonterms */
+  int iDfltReduce;         /* Default action is to REDUCE by this rule */
+  struct rule *pDfltReduce;/* The default REDUCE rule. */
+  int autoReduce;          /* True if this is an auto-reduce state */
+};
+#define NO_OFFSET (-2147483647)
+
+/* A followset propagation link indicates that the contents of one
+** configuration followset should be propagated to another whenever
+** the first changes. */
+struct plink {
+  struct config *cfp;      /* The configuration to which linked */
+  struct plink *next;      /* The next propagate link */
+};
+
+/* The state vector for the entire parser generator is recorded as
+** follows.  (LEMON uses no global variables and makes little use of
+** static variables.  Fields in the following structure can be thought
+** of as begin global variables in the program.) */
+struct lemon {
+  struct state **sorted;   /* Table of states sorted by state number */
+  struct rule *rule;       /* List of all rules */
+  struct rule *startRule;  /* First rule */
+  int nstate;              /* Number of states */
+  int nxstate;             /* nstate with tail degenerate states removed */
+  int nrule;               /* Number of rules */
+  int nsymbol;             /* Number of terminal and nonterminal symbols */
+  int nterminal;           /* Number of terminal symbols */
+  struct symbol **symbols; /* Sorted array of pointers to symbols */
+  int errorcnt;            /* Number of errors */
+  struct symbol *errsym;   /* The error symbol */
+  struct symbol *wildcard; /* Token that matches anything */
+  char *name;              /* Name of the generated parser */
+  char *arg;               /* Declaration of the 3th argument to parser */
+  char *tokentype;         /* Type of terminal symbols in the parser stack */
+  char *vartype;           /* The default type of non-terminal symbols */
+  char *start;             /* Name of the start symbol for the grammar */
+  char *stacksize;         /* Size of the parser stack */
+  char *include;           /* Code to put at the start of the C file */
+  char *error;             /* Code to execute when an error is seen */
+  char *overflow;          /* Code to execute on a stack overflow */
+  char *failure;           /* Code to execute on parser failure */
+  char *accept;            /* Code to execute when the parser excepts */
+  char *extracode;         /* Code appended to the generated file */
+  char *tokendest;         /* Code to execute to destroy token data */
+  char *vardest;           /* Code for the default non-terminal destructor */
+  char *filename;          /* Name of the input file */
+  char *outname;           /* Name of the current output file */
+  char *tokenprefix;       /* A prefix added to token names in the .h file */
+  int nconflict;           /* Number of parsing conflicts */
+  int nactiontab;          /* Number of entries in the yy_action[] table */
+  int tablesize;           /* Total table size of all tables in bytes */
+  int basisflag;           /* Print only basis configurations */
+  int has_fallback;        /* True if any %fallback is seen in the grammar */
+  int nolinenosflag;       /* True if #line statements should not be printed */
+  char *argv0;             /* Name of the program */
+};
+
+#define MemoryCheck(X) if((X)==0){ \
+  extern void memory_error(); \
+  memory_error(); \
+}
+
+/**************** From the file "table.h" *********************************/
+/*
+** All code in this file has been automatically generated
+** from a specification in the file
+**              "table.q"
+** by the associative array code building program "aagen".
+** Do not edit this file!  Instead, edit the specification
+** file, then rerun aagen.
+*/
+/*
+** Code for processing tables in the LEMON parser generator.
+*/
+/* Routines for handling a strings */
+
+const char *Strsafe(const char *);
+
+void Strsafe_init(void);
+int Strsafe_insert(const char *);
+const char *Strsafe_find(const char *);
+
+/* Routines for handling symbols of the grammar */
+
+struct symbol *Symbol_new(const char *);
+int Symbolcmpp(const void *, const void *);
+void Symbol_init(void);
+int Symbol_insert(struct symbol *, const char *);
+struct symbol *Symbol_find(const char *);
+struct symbol *Symbol_Nth(int);
+int Symbol_count(void);
+struct symbol **Symbol_arrayof(void);
+
+/* Routines to manage the state table */
+
+int Configcmp(const char *, const char *);
+struct state *State_new(void);
+void State_init(void);
+int State_insert(struct state *, struct config *);
+struct state *State_find(struct config *);
+struct state **State_arrayof(/*  */);
+
+/* Routines used for efficiency in Configlist_add */
+
+void Configtable_init(void);
+int Configtable_insert(struct config *);
+struct config *Configtable_find(struct config *);
+void Configtable_clear(int(*)(struct config *));
+
+/****************** From the file "action.c" *******************************/
+/*
+** Routines processing parser actions in the LEMON parser generator.
+*/
+
+/* Allocate a new parser action */
+static struct action *Action_new(void){
+  static struct action *freelist = 0;
+  struct action *newaction;
+
+  if( freelist==0 ){
+    int i;
+    int amt = 100;
+    freelist = (struct action *)calloc(amt, sizeof(struct action));
+    if( freelist==0 ){
+      fprintf(stderr,"Unable to allocate memory for a new parser action.");
+      exit(1);
+    }
+    for(i=0; i<amt-1; i++) freelist[i].next = &freelist[i+1];
+    freelist[amt-1].next = 0;
+  }
+  newaction = freelist;
+  freelist = freelist->next;
+  return newaction;
+}
+
+/* Compare two actions for sorting purposes.  Return negative, zero, or
+** positive if the first action is less than, equal to, or greater than
+** the first
+*/
+static int actioncmp(
+  struct action *ap1,
+  struct action *ap2
+){
+  int rc;
+  rc = ap1->sp->index - ap2->sp->index;
+  if( rc==0 ){
+    rc = (int)ap1->type - (int)ap2->type;
+  }
+  if( rc==0 && (ap1->type==REDUCE || ap1->type==SHIFTREDUCE) ){
+    rc = ap1->x.rp->index - ap2->x.rp->index;
+  }
+  if( rc==0 ){
+    rc = (int) (ap2 - ap1);
+  }
+  return rc;
+}
+
+/* Sort parser actions */
+static struct action *Action_sort(
+  struct action *ap
+){
+  ap = (struct action *)msort((char *)ap,(char **)&ap->next,
+                              (int(*)(const char*,const char*))actioncmp);
+  return ap;
+}
+
+void Action_add(
+  struct action **app,
+  enum e_action type,
+  struct symbol *sp,
+  char *arg
+){
+  struct action *newaction;
+  newaction = Action_new();
+  newaction->next = *app;
+  *app = newaction;
+  newaction->type = type;
+  newaction->sp = sp;
+  newaction->spOpt = 0;
+  if( type==SHIFT ){
+    newaction->x.stp = (struct state *)arg;
+  }else{
+    newaction->x.rp = (struct rule *)arg;
+  }
+}
+/********************** New code to implement the "acttab" module ***********/
+/*
+** This module implements routines use to construct the yy_action[] table.
+*/
+
+/*
+** The state of the yy_action table under construction is an instance of
+** the following structure.
+**
+** The yy_action table maps the pair (state_number, lookahead) into an
+** action_number.  The table is an array of integers pairs.  The state_number
+** determines an initial offset into the yy_action array.  The lookahead
+** value is then added to this initial offset to get an index X into the
+** yy_action array. If the aAction[X].lookahead equals the value of the
+** of the lookahead input, then the value of the action_number output is
+** aAction[X].action.  If the lookaheads do not match then the
+** default action for the state_number is returned.
+**
+** All actions associated with a single state_number are first entered
+** into aLookahead[] using multiple calls to acttab_action().  Then the
+** actions for that single state_number are placed into the aAction[]
+** array with a single call to acttab_insert().  The acttab_insert() call
+** also resets the aLookahead[] array in preparation for the next
+** state number.
+*/
+struct lookahead_action {
+  int lookahead;             /* Value of the lookahead token */
+  int action;                /* Action to take on the given lookahead */
+};
+typedef struct acttab acttab;
+struct acttab {
+  int nAction;                 /* Number of used slots in aAction[] */
+  int nActionAlloc;            /* Slots allocated for aAction[] */
+  struct lookahead_action
+    *aAction,                  /* The yy_action[] table under construction */
+    *aLookahead;               /* A single new transaction set */
+  int mnLookahead;             /* Minimum aLookahead[].lookahead */
+  int mnAction;                /* Action associated with mnLookahead */
+  int mxLookahead;             /* Maximum aLookahead[].lookahead */
+  int nLookahead;              /* Used slots in aLookahead[] */
+  int nLookaheadAlloc;         /* Slots allocated in aLookahead[] */
+};
+
+/* Return the number of entries in the yy_action table */
+#define acttab_size(X) ((X)->nAction)
+
+/* The value for the N-th entry in yy_action */
+#define acttab_yyaction(X,N)  ((X)->aAction[N].action)
+
+/* The value for the N-th entry in yy_lookahead */
+#define acttab_yylookahead(X,N)  ((X)->aAction[N].lookahead)
+
+/* Free all memory associated with the given acttab */
+void acttab_free(acttab *p){
+  free( p->aAction );
+  free( p->aLookahead );
+  free( p );
+}
+
+/* Allocate a new acttab structure */
+acttab *acttab_alloc(void){
+  acttab *p = (acttab *) calloc( 1, sizeof(*p) );
+  if( p==0 ){
+    fprintf(stderr,"Unable to allocate memory for a new acttab.");
+    exit(1);
+  }
+  memset(p, 0, sizeof(*p));
+  return p;
+}
+
+/* Add a new action to the current transaction set.
+**
+** This routine is called once for each lookahead for a particular
+** state.
+*/
+void acttab_action(acttab *p, int lookahead, int action){
+  if( p->nLookahead>=p->nLookaheadAlloc ){
+    p->nLookaheadAlloc += 25;
+    p->aLookahead = (struct lookahead_action *) realloc( p->aLookahead,
+                             sizeof(p->aLookahead[0])*p->nLookaheadAlloc );
+    if( p->aLookahead==0 ){
+      fprintf(stderr,"malloc failed\n");
+      exit(1);
+    }
+  }
+  if( p->nLookahead==0 ){
+    p->mxLookahead = lookahead;
+    p->mnLookahead = lookahead;
+    p->mnAction = action;
+  }else{
+    if( p->mxLookahead<lookahead ) p->mxLookahead = lookahead;
+    if( p->mnLookahead>lookahead ){
+      p->mnLookahead = lookahead;
+      p->mnAction = action;
+    }
+  }
+  p->aLookahead[p->nLookahead].lookahead = lookahead;
+  p->aLookahead[p->nLookahead].action = action;
+  p->nLookahead++;
+}
+
+/*
+** Add the transaction set built up with prior calls to acttab_action()
+** into the current action table.  Then reset the transaction set back
+** to an empty set in preparation for a new round of acttab_action() calls.
+**
+** Return the offset into the action table of the new transaction.
+*/
+int acttab_insert(acttab *p){
+  int i, j, k, n;
+  assert( p->nLookahead>0 );
+
+  /* Make sure we have enough space to hold the expanded action table
+  ** in the worst case.  The worst case occurs if the transaction set
+  ** must be appended to the current action table
+  */
+  n = p->mxLookahead + 1;
+  if( p->nAction + n >= p->nActionAlloc ){
+    int oldAlloc = p->nActionAlloc;
+    p->nActionAlloc = p->nAction + n + p->nActionAlloc + 20;
+    p->aAction = (struct lookahead_action *) realloc( p->aAction,
+                          sizeof(p->aAction[0])*p->nActionAlloc);
+    if( p->aAction==0 ){
+      fprintf(stderr,"malloc failed\n");
+      exit(1);
+    }
+    for(i=oldAlloc; i<p->nActionAlloc; i++){
+      p->aAction[i].lookahead = -1;
+      p->aAction[i].action = -1;
+    }
+  }
+
+  /* Scan the existing action table looking for an offset that is a
+  ** duplicate of the current transaction set.  Fall out of the loop
+  ** if and when the duplicate is found.
+  **
+  ** i is the index in p->aAction[] where p->mnLookahead is inserted.
+  */
+  for(i=p->nAction-1; i>=0; i--){
+    if( p->aAction[i].lookahead==p->mnLookahead ){
+      /* All lookaheads and actions in the aLookahead[] transaction
+      ** must match against the candidate aAction[i] entry. */
+      if( p->aAction[i].action!=p->mnAction ) continue;
+      for(j=0; j<p->nLookahead; j++){
+        k = p->aLookahead[j].lookahead - p->mnLookahead + i;
+        if( k<0 || k>=p->nAction ) break;
+        if( p->aLookahead[j].lookahead!=p->aAction[k].lookahead ) break;
+        if( p->aLookahead[j].action!=p->aAction[k].action ) break;
+      }
+      if( j<p->nLookahead ) continue;
+
+      /* No possible lookahead value that is not in the aLookahead[]
+      ** transaction is allowed to match aAction[i] */
+      n = 0;
+      for(j=0; j<p->nAction; j++){
+        if( p->aAction[j].lookahead<0 ) continue;
+        if( p->aAction[j].lookahead==j+p->mnLookahead-i ) n++;
+      }
+      if( n==p->nLookahead ){
+        break;  /* An exact match is found at offset i */
+      }
+    }
+  }
+
+  /* If no existing offsets exactly match the current transaction, find an
+  ** an empty offset in the aAction[] table in which we can add the
+  ** aLookahead[] transaction.
+  */
+  if( i<0 ){
+    /* Look for holes in the aAction[] table that fit the current
+    ** aLookahead[] transaction.  Leave i set to the offset of the hole.
+    ** If no holes are found, i is left at p->nAction, which means the
+    ** transaction will be appended. */
+    for(i=0; i<p->nActionAlloc - p->mxLookahead; i++){
+      if( p->aAction[i].lookahead<0 ){
+        for(j=0; j<p->nLookahead; j++){
+          k = p->aLookahead[j].lookahead - p->mnLookahead + i;
+          if( k<0 ) break;
+          if( p->aAction[k].lookahead>=0 ) break;
+        }
+        if( j<p->nLookahead ) continue;
+        for(j=0; j<p->nAction; j++){
+          if( p->aAction[j].lookahead==j+p->mnLookahead-i ) break;
+        }
+        if( j==p->nAction ){
+          break;  /* Fits in empty slots */
+        }
+      }
+    }
+  }
+  /* Insert transaction set at index i. */
+  for(j=0; j<p->nLookahead; j++){
+    k = p->aLookahead[j].lookahead - p->mnLookahead + i;
+    p->aAction[k] = p->aLookahead[j];
+    if( k>=p->nAction ) p->nAction = k+1;
+  }
+  p->nLookahead = 0;
+
+  /* Return the offset that is added to the lookahead in order to get the
+  ** index into yy_action of the action */
+  return i - p->mnLookahead;
+}
+
+/********************** From the file "build.c" *****************************/
+/*
+** Routines to construction the finite state machine for the LEMON
+** parser generator.
+*/
+
+/* Find a precedence symbol of every rule in the grammar.
+**
+** Those rules which have a precedence symbol coded in the input
+** grammar using the "[symbol]" construct will already have the
+** rp->precsym field filled.  Other rules take as their precedence
+** symbol the first RHS symbol with a defined precedence.  If there
+** are not RHS symbols with a defined precedence, the precedence
+** symbol field is left blank.
+*/
+void FindRulePrecedences(struct lemon *xp)
+{
+  struct rule *rp;
+  for(rp=xp->rule; rp; rp=rp->next){
+    if( rp->precsym==0 ){
+      int i, j;
+      for(i=0; i<rp->nrhs && rp->precsym==0; i++){
+        struct symbol *sp = rp->rhs[i];
+        if( sp->type==MULTITERMINAL ){
+          for(j=0; j<sp->nsubsym; j++){
+            if( sp->subsym[j]->prec>=0 ){
+              rp->precsym = sp->subsym[j];
+              break;
+            }
+          }
+        }else if( sp->prec>=0 ){
+          rp->precsym = rp->rhs[i];
+        }
+      }
+    }
+  }
+  return;
+}
+
+/* Find all nonterminals which will generate the empty string.
+** Then go back and compute the first sets of every nonterminal.
+** The first set is the set of all terminal symbols which can begin
+** a string generated by that nonterminal.
+*/
+void FindFirstSets(struct lemon *lemp)
+{
+  int i, j;
+  struct rule *rp;
+  int progress;
+
+  for(i=0; i<lemp->nsymbol; i++){
+    lemp->symbols[i]->lambda = LEMON_FALSE;
+  }
+  for(i=lemp->nterminal; i<lemp->nsymbol; i++){
+    lemp->symbols[i]->firstset = SetNew();
+  }
+
+  /* First compute all lambdas */
+  do{
+    progress = 0;
+    for(rp=lemp->rule; rp; rp=rp->next){
+      if( rp->lhs->lambda ) continue;
+      for(i=0; i<rp->nrhs; i++){
+        struct symbol *sp = rp->rhs[i];
+        assert( sp->type==NONTERMINAL || sp->lambda==LEMON_FALSE );
+        if( sp->lambda==LEMON_FALSE ) break;
+      }
+      if( i==rp->nrhs ){
+        rp->lhs->lambda = LEMON_TRUE;
+        progress = 1;
+      }
+    }
+  }while( progress );
+
+  /* Now compute all first sets */
+  do{
+    struct symbol *s1, *s2;
+    progress = 0;
+    for(rp=lemp->rule; rp; rp=rp->next){
+      s1 = rp->lhs;
+      for(i=0; i<rp->nrhs; i++){
+        s2 = rp->rhs[i];
+        if( s2->type==TERMINAL ){
+          progress += SetAdd(s1->firstset,s2->index);
+          break;
+        }else if( s2->type==MULTITERMINAL ){
+          for(j=0; j<s2->nsubsym; j++){
+            progress += SetAdd(s1->firstset,s2->subsym[j]->index);
+          }
+          break;
+        }else if( s1==s2 ){
+          if( s1->lambda==LEMON_FALSE ) break;
+        }else{
+          progress += SetUnion(s1->firstset,s2->firstset);
+          if( s2->lambda==LEMON_FALSE ) break;
+        }
+      }
+    }
+  }while( progress );
+  return;
+}
+
+/* Compute all LR(0) states for the grammar.  Links
+** are added to between some states so that the LR(1) follow sets
+** can be computed later.
+*/
+PRIVATE struct state *getstate(struct lemon *);  /* forward reference */
+void FindStates(struct lemon *lemp)
+{
+  struct symbol *sp;
+  struct rule *rp;
+
+  Configlist_init();
+
+  /* Find the start symbol */
+  if( lemp->start ){
+    sp = Symbol_find(lemp->start);
+    if( sp==0 ){
+      ErrorMsg(lemp->filename,0,
+"The specified start symbol \"%s\" is not \
+in a nonterminal of the grammar.  \"%s\" will be used as the start \
+symbol instead.",lemp->start,lemp->startRule->lhs->name);
+      lemp->errorcnt++;
+      sp = lemp->startRule->lhs;
+    }
+  }else{
+    sp = lemp->startRule->lhs;
+  }
+
+  /* Make sure the start symbol doesn't occur on the right-hand side of
+  ** any rule.  Report an error if it does.  (YACC would generate a new
+  ** start symbol in this case.) */
+  for(rp=lemp->rule; rp; rp=rp->next){
+    int i;
+    for(i=0; i<rp->nrhs; i++){
+      if( rp->rhs[i]==sp ){   /* FIX ME:  Deal with multiterminals */
+        ErrorMsg(lemp->filename,0,
+"The start symbol \"%s\" occurs on the \
+right-hand side of a rule. This will result in a parser which \
+does not work properly.",sp->name);
+        lemp->errorcnt++;
+      }
+    }
+  }
+
+  /* The basis configuration set for the first state
+  ** is all rules which have the start symbol as their
+  ** left-hand side */
+  for(rp=sp->rule; rp; rp=rp->nextlhs){
+    struct config *newcfp;
+    rp->lhsStart = 1;
+    newcfp = Configlist_addbasis(rp,0);
+    SetAdd(newcfp->fws,0);
+  }
+
+  /* Compute the first state.  All other states will be
+  ** computed automatically during the computation of the first one.
+  ** The returned pointer to the first state is not used. */
+  (void)getstate(lemp);
+  return;
+}
+
+/* Return a pointer to a state which is described by the configuration
+** list which has been built from calls to Configlist_add.
+*/
+PRIVATE void buildshifts(struct lemon *, struct state *); /* Forwd ref */
+PRIVATE struct state *getstate(struct lemon *lemp)
+{
+  struct config *cfp, *bp;
+  struct state *stp;
+
+  /* Extract the sorted basis of the new state.  The basis was constructed
+  ** by prior calls to "Configlist_addbasis()". */
+  Configlist_sortbasis();
+  bp = Configlist_basis();
+
+  /* Get a state with the same basis */
+  stp = State_find(bp);
+  if( stp ){
+    /* A state with the same basis already exists!  Copy all the follow-set
+    ** propagation links from the state under construction into the
+    ** preexisting state, then return a pointer to the preexisting state */
+    struct config *x, *y;
+    for(x=bp, y=stp->bp; x && y; x=x->bp, y=y->bp){
+      Plink_copy(&y->bplp,x->bplp);
+      Plink_delete(x->fplp);
+      x->fplp = x->bplp = 0;
+    }
+    cfp = Configlist_return();
+    Configlist_eat(cfp);
+  }else{
+    /* This really is a new state.  Construct all the details */
+    Configlist_closure(lemp);    /* Compute the configuration closure */
+    Configlist_sort();           /* Sort the configuration closure */
+    cfp = Configlist_return();   /* Get a pointer to the config list */
+    stp = State_new();           /* A new state structure */
+    MemoryCheck(stp);
+    stp->bp = bp;                /* Remember the configuration basis */
+    stp->cfp = cfp;              /* Remember the configuration closure */
+    stp->statenum = lemp->nstate++; /* Every state gets a sequence number */
+    stp->ap = 0;                 /* No actions, yet. */
+    State_insert(stp,stp->bp);   /* Add to the state table */
+    buildshifts(lemp,stp);       /* Recursively compute successor states */
+  }
+  return stp;
+}
+
+/*
+** Return true if two symbols are the same.
+*/
+int same_symbol(struct symbol *a, struct symbol *b)
+{
+  int i;
+  if( a==b ) return 1;
+  if( a->type!=MULTITERMINAL ) return 0;
+  if( b->type!=MULTITERMINAL ) return 0;
+  if( a->nsubsym!=b->nsubsym ) return 0;
+  for(i=0; i<a->nsubsym; i++){
+    if( a->subsym[i]!=b->subsym[i] ) return 0;
+  }
+  return 1;
+}
+
+/* Construct all successor states to the given state.  A "successor"
+** state is any state which can be reached by a shift action.
+*/
+PRIVATE void buildshifts(struct lemon *lemp, struct state *stp)
+{
+  struct config *cfp;  /* For looping thru the config closure of "stp" */
+  struct config *bcfp; /* For the inner loop on config closure of "stp" */
+  struct config *newcfg;  /* */
+  struct symbol *sp;   /* Symbol following the dot in configuration "cfp" */
+  struct symbol *bsp;  /* Symbol following the dot in configuration "bcfp" */
+  struct state *newstp; /* A pointer to a successor state */
+
+  /* Each configuration becomes complete after it contibutes to a successor
+  ** state.  Initially, all configurations are incomplete */
+  for(cfp=stp->cfp; cfp; cfp=cfp->next) cfp->status = INCOMPLETE;
+
+  /* Loop through all configurations of the state "stp" */
+  for(cfp=stp->cfp; cfp; cfp=cfp->next){
+    if( cfp->status==COMPLETE ) continue;    /* Already used by inner loop */
+    if( cfp->dot>=cfp->rp->nrhs ) continue;  /* Can't shift this config */
+    Configlist_reset();                      /* Reset the new config set */
+    sp = cfp->rp->rhs[cfp->dot];             /* Symbol after the dot */
+
+    /* For every configuration in the state "stp" which has the symbol "sp"
+    ** following its dot, add the same configuration to the basis set under
+    ** construction but with the dot shifted one symbol to the right. */
+    for(bcfp=cfp; bcfp; bcfp=bcfp->next){
+      if( bcfp->status==COMPLETE ) continue;    /* Already used */
+      if( bcfp->dot>=bcfp->rp->nrhs ) continue; /* Can't shift this one */
+      bsp = bcfp->rp->rhs[bcfp->dot];           /* Get symbol after dot */
+      if( !same_symbol(bsp,sp) ) continue;      /* Must be same as for "cfp" */
+      bcfp->status = COMPLETE;                  /* Mark this config as used */
+      newcfg = Configlist_addbasis(bcfp->rp,bcfp->dot+1);
+      Plink_add(&newcfg->bplp,bcfp);
+    }
+
+    /* Get a pointer to the state described by the basis configuration set
+    ** constructed in the preceding loop */
+    newstp = getstate(lemp);
+
+    /* The state "newstp" is reached from the state "stp" by a shift action
+    ** on the symbol "sp" */
+    if( sp->type==MULTITERMINAL ){
+      int i;
+      for(i=0; i<sp->nsubsym; i++){
+        Action_add(&stp->ap,SHIFT,sp->subsym[i],(char*)newstp);
+      }
+    }else{
+      Action_add(&stp->ap,SHIFT,sp,(char *)newstp);
+    }
+  }
+}
+
+/*
+** Construct the propagation links
+*/
+void FindLinks(struct lemon *lemp)
+{
+  int i;
+  struct config *cfp, *other;
+  struct state *stp;
+  struct plink *plp;
+
+  /* Housekeeping detail:
+  ** Add to every propagate link a pointer back to the state to
+  ** which the link is attached. */
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    for(cfp=stp->cfp; cfp; cfp=cfp->next){
+      cfp->stp = stp;
+    }
+  }
+
+  /* Convert all backlinks into forward links.  Only the forward
+  ** links are used in the follow-set computation. */
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    for(cfp=stp->cfp; cfp; cfp=cfp->next){
+      for(plp=cfp->bplp; plp; plp=plp->next){
+        other = plp->cfp;
+        Plink_add(&other->fplp,cfp);
+      }
+    }
+  }
+}
+
+/* Compute all followsets.
+**
+** A followset is the set of all symbols which can come immediately
+** after a configuration.
+*/
+void FindFollowSets(struct lemon *lemp)
+{
+  int i;
+  struct config *cfp;
+  struct plink *plp;
+  int progress;
+  int change;
+
+  for(i=0; i<lemp->nstate; i++){
+    for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){
+      cfp->status = INCOMPLETE;
+    }
+  }
+
+  do{
+    progress = 0;
+    for(i=0; i<lemp->nstate; i++){
+      for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){
+        if( cfp->status==COMPLETE ) continue;
+        for(plp=cfp->fplp; plp; plp=plp->next){
+          change = SetUnion(plp->cfp->fws,cfp->fws);
+          if( change ){
+            plp->cfp->status = INCOMPLETE;
+            progress = 1;
+          }
+        }
+        cfp->status = COMPLETE;
+      }
+    }
+  }while( progress );
+}
+
+static int resolve_conflict(struct action *,struct action *);
+
+/* Compute the reduce actions, and resolve conflicts.
+*/
+void FindActions(struct lemon *lemp)
+{
+  int i,j;
+  struct config *cfp;
+  struct state *stp;
+  struct symbol *sp;
+  struct rule *rp;
+
+  /* Add all of the reduce actions
+  ** A reduce action is added for each element of the followset of
+  ** a configuration which has its dot at the extreme right.
+  */
+  for(i=0; i<lemp->nstate; i++){   /* Loop over all states */
+    stp = lemp->sorted[i];
+    for(cfp=stp->cfp; cfp; cfp=cfp->next){  /* Loop over all configurations */
+      if( cfp->rp->nrhs==cfp->dot ){        /* Is dot at extreme right? */
+        for(j=0; j<lemp->nterminal; j++){
+          if( SetFind(cfp->fws,j) ){
+            /* Add a reduce action to the state "stp" which will reduce by the
+            ** rule "cfp->rp" if the lookahead symbol is "lemp->symbols[j]" */
+            Action_add(&stp->ap,REDUCE,lemp->symbols[j],(char *)cfp->rp);
+          }
+        }
+      }
+    }
+  }
+
+  /* Add the accepting token */
+  if( lemp->start ){
+    sp = Symbol_find(lemp->start);
+    if( sp==0 ) sp = lemp->startRule->lhs;
+  }else{
+    sp = lemp->startRule->lhs;
+  }
+  /* Add to the first state (which is always the starting state of the
+  ** finite state machine) an action to ACCEPT if the lookahead is the
+  ** start nonterminal.  */
+  Action_add(&lemp->sorted[0]->ap,ACCEPT,sp,0);
+
+  /* Resolve conflicts */
+  for(i=0; i<lemp->nstate; i++){
+    struct action *ap, *nap;
+    stp = lemp->sorted[i];
+    /* assert( stp->ap ); */
+    stp->ap = Action_sort(stp->ap);
+    for(ap=stp->ap; ap && ap->next; ap=ap->next){
+      for(nap=ap->next; nap && nap->sp==ap->sp; nap=nap->next){
+         /* The two actions "ap" and "nap" have the same lookahead.
+         ** Figure out which one should be used */
+         lemp->nconflict += resolve_conflict(ap,nap);
+      }
+    }
+  }
+
+  /* Report an error for each rule that can never be reduced. */
+  for(rp=lemp->rule; rp; rp=rp->next) rp->canReduce = LEMON_FALSE;
+  for(i=0; i<lemp->nstate; i++){
+    struct action *ap;
+    for(ap=lemp->sorted[i]->ap; ap; ap=ap->next){
+      if( ap->type==REDUCE ) ap->x.rp->canReduce = LEMON_TRUE;
+    }
+  }
+  for(rp=lemp->rule; rp; rp=rp->next){
+    if( rp->canReduce ) continue;
+    ErrorMsg(lemp->filename,rp->ruleline,"This rule can not be reduced.\n");
+    lemp->errorcnt++;
+  }
+}
+
+/* Resolve a conflict between the two given actions.  If the
+** conflict can't be resolved, return non-zero.
+**
+** NO LONGER TRUE:
+**   To resolve a conflict, first look to see if either action
+**   is on an error rule.  In that case, take the action which
+**   is not associated with the error rule.  If neither or both
+**   actions are associated with an error rule, then try to
+**   use precedence to resolve the conflict.
+**
+** If either action is a SHIFT, then it must be apx.  This
+** function won't work if apx->type==REDUCE and apy->type==SHIFT.
+*/
+static int resolve_conflict(
+  struct action *apx,
+  struct action *apy
+){
+  struct symbol *spx, *spy;
+  int errcnt = 0;
+  assert( apx->sp==apy->sp );  /* Otherwise there would be no conflict */
+  if( apx->type==SHIFT && apy->type==SHIFT ){
+    apy->type = SSCONFLICT;
+    errcnt++;
+  }
+  if( apx->type==SHIFT && apy->type==REDUCE ){
+    spx = apx->sp;
+    spy = apy->x.rp->precsym;
+    if( spy==0 || spx->prec<0 || spy->prec<0 ){
+      /* Not enough precedence information. */
+      apy->type = SRCONFLICT;
+      errcnt++;
+    }else if( spx->prec>spy->prec ){    /* higher precedence wins */
+      apy->type = RD_RESOLVED;
+    }else if( spx->prec<spy->prec ){
+      apx->type = SH_RESOLVED;
+    }else if( spx->prec==spy->prec && spx->assoc==RIGHT ){ /* Use operator */
+      apy->type = RD_RESOLVED;                             /* associativity */
+    }else if( spx->prec==spy->prec && spx->assoc==LEFT ){  /* to break tie */
+      apx->type = SH_RESOLVED;
+    }else{
+      assert( spx->prec==spy->prec && spx->assoc==NONE );
+      apx->type = ERROR;
+    }
+  }else if( apx->type==REDUCE && apy->type==REDUCE ){
+    spx = apx->x.rp->precsym;
+    spy = apy->x.rp->precsym;
+    if( spx==0 || spy==0 || spx->prec<0 ||
+    spy->prec<0 || spx->prec==spy->prec ){
+      apy->type = RRCONFLICT;
+      errcnt++;
+    }else if( spx->prec>spy->prec ){
+      apy->type = RD_RESOLVED;
+    }else if( spx->prec<spy->prec ){
+      apx->type = RD_RESOLVED;
+    }
+  }else{
+    assert(
+      apx->type==SH_RESOLVED ||
+      apx->type==RD_RESOLVED ||
+      apx->type==SSCONFLICT ||
+      apx->type==SRCONFLICT ||
+      apx->type==RRCONFLICT ||
+      apy->type==SH_RESOLVED ||
+      apy->type==RD_RESOLVED ||
+      apy->type==SSCONFLICT ||
+      apy->type==SRCONFLICT ||
+      apy->type==RRCONFLICT
+    );
+    /* The REDUCE/SHIFT case cannot happen because SHIFTs come before
+    ** REDUCEs on the list.  If we reach this point it must be because
+    ** the parser conflict had already been resolved. */
+  }
+  return errcnt;
+}
+/********************* From the file "configlist.c" *************************/
+/*
+** Routines to processing a configuration list and building a state
+** in the LEMON parser generator.
+*/
+
+static struct config *freelist = 0;      /* List of free configurations */
+static struct config *current = 0;       /* Top of list of configurations */
+static struct config **currentend = 0;   /* Last on list of configs */
+static struct config *basis = 0;         /* Top of list of basis configs */
+static struct config **basisend = 0;     /* End of list of basis configs */
+
+/* Return a pointer to a new configuration */
+PRIVATE struct config *newconfig(){
+  struct config *newcfg;
+  if( freelist==0 ){
+    int i;
+    int amt = 3;
+    freelist = (struct config *)calloc( amt, sizeof(struct config) );
+    if( freelist==0 ){
+      fprintf(stderr,"Unable to allocate memory for a new configuration.");
+      exit(1);
+    }
+    for(i=0; i<amt-1; i++) freelist[i].next = &freelist[i+1];
+    freelist[amt-1].next = 0;
+  }
+  newcfg = freelist;
+  freelist = freelist->next;
+  return newcfg;
+}
+
+/* The configuration "old" is no longer used */
+PRIVATE void deleteconfig(struct config *old)
+{
+  old->next = freelist;
+  freelist = old;
+}
+
+/* Initialized the configuration list builder */
+void Configlist_init(){
+  current = 0;
+  currentend = &current;
+  basis = 0;
+  basisend = &basis;
+  Configtable_init();
+  return;
+}
+
+/* Initialized the configuration list builder */
+void Configlist_reset(){
+  current = 0;
+  currentend = &current;
+  basis = 0;
+  basisend = &basis;
+  Configtable_clear(0);
+  return;
+}
+
+/* Add another configuration to the configuration list */
+struct config *Configlist_add(
+  struct rule *rp,    /* The rule */
+  int dot             /* Index into the RHS of the rule where the dot goes */
+){
+  struct config *cfp, model;
+
+  assert( currentend!=0 );
+  model.rp = rp;
+  model.dot = dot;
+  cfp = Configtable_find(&model);
+  if( cfp==0 ){
+    cfp = newconfig();
+    cfp->rp = rp;
+    cfp->dot = dot;
+    cfp->fws = SetNew();
+    cfp->stp = 0;
+    cfp->fplp = cfp->bplp = 0;
+    cfp->next = 0;
+    cfp->bp = 0;
+    *currentend = cfp;
+    currentend = &cfp->next;
+    Configtable_insert(cfp);
+  }
+  return cfp;
+}
+
+/* Add a basis configuration to the configuration list */
+struct config *Configlist_addbasis(struct rule *rp, int dot)
+{
+  struct config *cfp, model;
+
+  assert( basisend!=0 );
+  assert( currentend!=0 );
+  model.rp = rp;
+  model.dot = dot;
+  cfp = Configtable_find(&model);
+  if( cfp==0 ){
+    cfp = newconfig();
+    cfp->rp = rp;
+    cfp->dot = dot;
+    cfp->fws = SetNew();
+    cfp->stp = 0;
+    cfp->fplp = cfp->bplp = 0;
+    cfp->next = 0;
+    cfp->bp = 0;
+    *currentend = cfp;
+    currentend = &cfp->next;
+    *basisend = cfp;
+    basisend = &cfp->bp;
+    Configtable_insert(cfp);
+  }
+  return cfp;
+}
+
+/* Compute the closure of the configuration list */
+void Configlist_closure(struct lemon *lemp)
+{
+  struct config *cfp, *newcfp;
+  struct rule *rp, *newrp;
+  struct symbol *sp, *xsp;
+  int i, dot;
+
+  assert( currentend!=0 );
+  for(cfp=current; cfp; cfp=cfp->next){
+    rp = cfp->rp;
+    dot = cfp->dot;
+    if( dot>=rp->nrhs ) continue;
+    sp = rp->rhs[dot];
+    if( sp->type==NONTERMINAL ){
+      if( sp->rule==0 && sp!=lemp->errsym ){
+        ErrorMsg(lemp->filename,rp->line,"Nonterminal \"%s\" has no rules.",
+          sp->name);
+        lemp->errorcnt++;
+      }
+      for(newrp=sp->rule; newrp; newrp=newrp->nextlhs){
+        newcfp = Configlist_add(newrp,0);
+        for(i=dot+1; i<rp->nrhs; i++){
+          xsp = rp->rhs[i];
+          if( xsp->type==TERMINAL ){
+            SetAdd(newcfp->fws,xsp->index);
+            break;
+          }else if( xsp->type==MULTITERMINAL ){
+            int k;
+            for(k=0; k<xsp->nsubsym; k++){
+              SetAdd(newcfp->fws, xsp->subsym[k]->index);
+            }
+            break;
+          }else{
+            SetUnion(newcfp->fws,xsp->firstset);
+            if( xsp->lambda==LEMON_FALSE ) break;
+          }
+        }
+        if( i==rp->nrhs ) Plink_add(&cfp->fplp,newcfp);
+      }
+    }
+  }
+  return;
+}
+
+/* Sort the configuration list */
+void Configlist_sort(){
+  current = (struct config*)msort((char*)current,(char**)&(current->next),
+                                  Configcmp);
+  currentend = 0;
+  return;
+}
+
+/* Sort the basis configuration list */
+void Configlist_sortbasis(){
+  basis = (struct config*)msort((char*)current,(char**)&(current->bp),
+                                Configcmp);
+  basisend = 0;
+  return;
+}
+
+/* Return a pointer to the head of the configuration list and
+** reset the list */
+struct config *Configlist_return(){
+  struct config *old;
+  old = current;
+  current = 0;
+  currentend = 0;
+  return old;
+}
+
+/* Return a pointer to the head of the configuration list and
+** reset the list */
+struct config *Configlist_basis(){
+  struct config *old;
+  old = basis;
+  basis = 0;
+  basisend = 0;
+  return old;
+}
+
+/* Free all elements of the given configuration list */
+void Configlist_eat(struct config *cfp)
+{
+  struct config *nextcfp;
+  for(; cfp; cfp=nextcfp){
+    nextcfp = cfp->next;
+    assert( cfp->fplp==0 );
+    assert( cfp->bplp==0 );
+    if( cfp->fws ) SetFree(cfp->fws);
+    deleteconfig(cfp);
+  }
+  return;
+}
+/***************** From the file "error.c" *********************************/
+/*
+** Code for printing error message.
+*/
+
+void ErrorMsg(const char *filename, int lineno, const char *format, ...){
+  va_list ap;
+  fprintf(stderr, "%s:%d: ", filename, lineno);
+  va_start(ap, format);
+  vfprintf(stderr,format,ap);
+  va_end(ap);
+  fprintf(stderr, "\n");
+}
+/**************** From the file "main.c" ************************************/
+/*
+** Main program file for the LEMON parser generator.
+*/
+
+/* Report an out-of-memory condition and abort.  This function
+** is used mostly by the "MemoryCheck" macro in struct.h
+*/
+void memory_error(){
+  fprintf(stderr,"Out of memory.  Aborting...\n");
+  exit(1);
+}
+
+static int nDefine = 0;      /* Number of -D options on the command line */
+static char **azDefine = 0;  /* Name of the -D macros */
+
+/* This routine is called with the argument to each -D command-line option.
+** Add the macro defined to the azDefine array.
+*/
+static void handle_D_option(char *z){
+  char **paz;
+  nDefine++;
+  azDefine = (char **) realloc(azDefine, sizeof(azDefine[0])*nDefine);
+  if( azDefine==0 ){
+    fprintf(stderr,"out of memory\n");
+    exit(1);
+  }
+  paz = &azDefine[nDefine-1];
+  *paz = (char *) malloc( lemonStrlen(z)+1 );
+  if( *paz==0 ){
+    fprintf(stderr,"out of memory\n");
+    exit(1);
+  }
+  lemon_strcpy(*paz, z);
+  for(z=*paz; *z && *z!='='; z++){}
+  *z = 0;
+}
+
+static char *user_templatename = NULL;
+static void handle_T_option(char *z){
+  user_templatename = (char *) malloc( lemonStrlen(z)+1 );
+  if( user_templatename==0 ){
+    memory_error();
+  }
+  lemon_strcpy(user_templatename, z);
+}
+
+/* Merge together to lists of rules ordered by rule.iRule */
+static struct rule *Rule_merge(struct rule *pA, struct rule *pB){
+  struct rule *pFirst = 0;
+  struct rule **ppPrev = &pFirst;
+  while( pA && pB ){
+    if( pA->iRule<pB->iRule ){
+      *ppPrev = pA;
+      ppPrev = &pA->next;
+      pA = pA->next;
+    }else{
+      *ppPrev = pB;
+      ppPrev = &pB->next;
+      pB = pB->next;
+    }
+  }
+  if( pA ){
+    *ppPrev = pA;
+  }else{
+    *ppPrev = pB;
+  }
+  return pFirst;
+}
+
+/*
+** Sort a list of rules in order of increasing iRule value
+*/
+static struct rule *Rule_sort(struct rule *rp){
+  int i;
+  struct rule *pNext;
+  struct rule *x[32];
+  memset(x, 0, sizeof(x));
+  while( rp ){
+    pNext = rp->next;
+    rp->next = 0;
+    for(i=0; i<sizeof(x)/sizeof(x[0]) && x[i]; i++){
+      rp = Rule_merge(x[i], rp);
+      x[i] = 0;
+    }
+    x[i] = rp;
+    rp = pNext;
+  }
+  rp = 0;
+  for(i=0; i<sizeof(x)/sizeof(x[0]); i++){
+    rp = Rule_merge(x[i], rp);
+  }
+  return rp;
+}
+
+/* forward reference */
+static const char *minimum_size_type(int lwr, int upr, int *pnByte);
+
+/* Print a single line of the "Parser Stats" output
+*/
+static void stats_line(const char *zLabel, int iValue){
+  int nLabel = lemonStrlen(zLabel);
+  printf("  %s%.*s %5d\n", zLabel,
+         35-nLabel, "................................",
+         iValue);
+}
+
+/* The main program.  Parse the command line and do it... */
+int main(int argc, char **argv)
+{
+  static int version = 0;
+  static int rpflag = 0;
+  static int basisflag = 0;
+  static int compress = 0;
+  static int quiet = 0;
+  static int statistics = 0;
+  static int mhflag = 0;
+  static int nolinenosflag = 0;
+  static int noResort = 0;
+  static struct s_options options[] = {
+    {OPT_FLAG, "b", (char*)&basisflag, "Print only the basis in report."},
+    {OPT_FLAG, "c", (char*)&compress, "Don't compress the action table."},
+    //{OPT_FSTR, "D", (char*)handle_D_option, "Define an %ifdef macro."},
+    //{OPT_FSTR, "f", 0, "Ignored.  (Placeholder for -f compiler options.)"},
+    {OPT_FLAG, "g", (char*)&rpflag, "Print grammar without actions."},
+    //{OPT_FSTR, "I", 0, "Ignored.  (Placeholder for '-I' compiler options.)"},
+    //{OPT_FLAG, "m", (char*)&mhflag, "Output a makeheaders compatible file."},
+    {OPT_FLAG, "l", (char*)&nolinenosflag, "Do not print \"// line ...\" statements."},
+    //{OPT_FSTR, "O", 0, "Ignored.  (Placeholder for '-O' compiler options.)"},
+    {OPT_FLAG, "p", (char*)&showPrecedenceConflict,
+                    "Show conflicts resolved by precedence rules"},
+    {OPT_FLAG, "q", (char*)&quiet, "(Quiet) Don't print the report file."},
+    {OPT_FLAG, "r", (char*)&noResort, "Do not sort or renumber states"},
+    {OPT_FLAG, "s", (char*)&statistics,
+                                   "Print parser stats to standard output."},
+    {OPT_FLAG, "x", (char*)&version, "Print the version number."},
+    {OPT_FSTR, "T", (char*)handle_T_option, "Specify a template file."},
+    //{OPT_FSTR, "W", 0, "Ignored.  (Placeholder for '-W' compiler options.)"},
+    {OPT_FLAG,0,0,0}
+  };
+  int i;
+  int exitcode;
+  struct lemon lem;
+  struct rule *rp;
+
+  OptInit(argv,options,stderr);
+  if( version ){
+     printf("Lemon version 1.0\n");
+     exit(0);
+  }
+  if( OptNArgs()!=1 ){
+    fprintf(stderr,"Exactly one filename argument is required.\n");
+    exit(1);
+  }
+  memset(&lem, 0, sizeof(lem));
+  lem.errorcnt = 0;
+
+  /* Initialize the machine */
+  Strsafe_init();
+  Symbol_init();
+  State_init();
+  lem.argv0 = argv[0];
+  lem.filename = OptArg(0);
+  lem.basisflag = basisflag;
+  lem.nolinenosflag = nolinenosflag;
+  Symbol_new("$");
+  lem.errsym = Symbol_new("error");
+  lem.errsym->useCnt = 0;
+
+  /* Parse the input file */
+  Parse(&lem);
+  if( lem.errorcnt ) exit(lem.errorcnt);
+  if( lem.nrule==0 ){
+    fprintf(stderr,"Empty grammar.\n");
+    exit(1);
+  }
+
+  /* Count and index the symbols of the grammar */
+  Symbol_new("{default}");
+  lem.nsymbol = Symbol_count();
+  lem.symbols = Symbol_arrayof();
+  for(i=0; i<lem.nsymbol; i++) lem.symbols[i]->index = i;
+  qsort(lem.symbols,lem.nsymbol,sizeof(struct symbol*), Symbolcmpp);
+  for(i=0; i<lem.nsymbol; i++) lem.symbols[i]->index = i;
+  while( lem.symbols[i-1]->type==MULTITERMINAL ){ i--; }
+  assert( strcmp(lem.symbols[i-1]->name,"{default}")==0 );
+  lem.nsymbol = i - 1;
+  for(i=1; ISUPPER(lem.symbols[i]->name[0]); i++);
+  lem.nterminal = i;
+
+  /* Assign sequential rule numbers.  Start with 0.  Put rules that have no
+  ** reduce action C-code associated with them last, so that the switch()
+  ** statement that selects reduction actions will have a smaller jump table.
+  */
+  for(i=0, rp=lem.rule; rp; rp=rp->next){
+    rp->iRule = rp->code ? i++ : -1;
+  }
+  for(rp=lem.rule; rp; rp=rp->next){
+    if( rp->iRule<0 ) rp->iRule = i++;
+  }
+  lem.startRule = lem.rule;
+  lem.rule = Rule_sort(lem.rule);
+
+  /* Generate a reprint of the grammar, if requested on the command line */
+  if( rpflag ){
+    Reprint(&lem);
+  }else{
+    /* Initialize the size for all follow and first sets */
+    SetSize(lem.nterminal+1);
+
+    /* Find the precedence for every production rule (that has one) */
+    FindRulePrecedences(&lem);
+
+    /* Compute the lambda-nonterminals and the first-sets for every
+    ** nonterminal */
+    FindFirstSets(&lem);
+
+    /* Compute all LR(0) states.  Also record follow-set propagation
+    ** links so that the follow-set can be computed later */
+    lem.nstate = 0;
+    FindStates(&lem);
+    lem.sorted = State_arrayof();
+
+    /* Tie up loose ends on the propagation links */
+    FindLinks(&lem);
+
+    /* Compute the follow set of every reducible configuration */
+    FindFollowSets(&lem);
+
+    /* Compute the action tables */
+    FindActions(&lem);
+
+    /* Compress the action tables */
+    if( compress==0 ) CompressTables(&lem);
+
+    /* Reorder and renumber the states so that states with fewer choices
+    ** occur at the end.  This is an optimization that helps make the
+    ** generated parser tables smaller. */
+    if( noResort==0 ) ResortStates(&lem);
+
+    /* Generate a report of the parser generated.  (the "y.output" file) */
+    if( !quiet ) ReportOutput(&lem);
+
+    /* Generate the source code for the parser */
+    ReportTable(&lem, mhflag);
+
+    /* Produce a header file for use by the scanner.  (This step is
+    ** omitted if the "-m" option is used because makeheaders will
+    ** generate the file for us.) */
+    //if( !mhflag ) ReportHeader(&lem);
+  }
+  if( statistics ){
+    printf("Parser statistics:\n");
+    stats_line("terminal symbols", lem.nterminal);
+    stats_line("non-terminal symbols", lem.nsymbol - lem.nterminal);
+    stats_line("total symbols", lem.nsymbol);
+    stats_line("rules", lem.nrule);
+    stats_line("states", lem.nxstate);
+    stats_line("conflicts", lem.nconflict);
+    stats_line("action table entries", lem.nactiontab);
+    stats_line("total table size (bytes)", lem.tablesize);
+  }
+  if( lem.nconflict > 0 ){
+    fprintf(stderr,"%d parsing conflicts.\n",lem.nconflict);
+  }
+
+  /* return 0 on success, 1 on failure. */
+  exitcode = ((lem.errorcnt > 0) || (lem.nconflict > 0)) ? 1 : 0;
+  exit(exitcode);
+  return (exitcode);
+}
+/******************** From the file "msort.c" *******************************/
+/*
+** A generic merge-sort program.
+**
+** USAGE:
+** Let "ptr" be a pointer to some structure which is at the head of
+** a null-terminated list.  Then to sort the list call:
+**
+**     ptr = msort(ptr,&(ptr->next),cmpfnc);
+**
+** In the above, "cmpfnc" is a pointer to a function which compares
+** two instances of the structure and returns an integer, as in
+** strcmp.  The second argument is a pointer to the pointer to the
+** second element of the linked list.  This address is used to compute
+** the offset to the "next" field within the structure.  The offset to
+** the "next" field must be constant for all structures in the list.
+**
+** The function returns a new pointer which is the head of the list
+** after sorting.
+**
+** ALGORITHM:
+** Merge-sort.
+*/
+
+/*
+** Return a pointer to the next structure in the linked list.
+*/
+#define NEXT(A) (*(char**)(((char*)A)+offset))
+
+/*
+** Inputs:
+**   a:       A sorted, null-terminated linked list.  (May be null).
+**   b:       A sorted, null-terminated linked list.  (May be null).
+**   cmp:     A pointer to the comparison function.
+**   offset:  Offset in the structure to the "next" field.
+**
+** Return Value:
+**   A pointer to the head of a sorted list containing the elements
+**   of both a and b.
+**
+** Side effects:
+**   The "next" pointers for elements in the lists a and b are
+**   changed.
+*/
+static char *merge(
+  char *a,
+  char *b,
+  int (*cmp)(const char*,const char*),
+  int offset
+){
+  char *ptr, *head;
+
+  if( a==0 ){
+    head = b;
+  }else if( b==0 ){
+    head = a;
+  }else{
+    if( (*cmp)(a,b)<=0 ){
+      ptr = a;
+      a = NEXT(a);
+    }else{
+      ptr = b;
+      b = NEXT(b);
+    }
+    head = ptr;
+    while( a && b ){
+      if( (*cmp)(a,b)<=0 ){
+        NEXT(ptr) = a;
+        ptr = a;
+        a = NEXT(a);
+      }else{
+        NEXT(ptr) = b;
+        ptr = b;
+        b = NEXT(b);
+      }
+    }
+    if( a ) NEXT(ptr) = a;
+    else    NEXT(ptr) = b;
+  }
+  return head;
+}
+
+/*
+** Inputs:
+**   list:      Pointer to a singly-linked list of structures.
+**   next:      Pointer to pointer to the second element of the list.
+**   cmp:       A comparison function.
+**
+** Return Value:
+**   A pointer to the head of a sorted list containing the elements
+**   orginally in list.
+**
+** Side effects:
+**   The "next" pointers for elements in list are changed.
+*/
+#define LISTSIZE 30
+static char *msort(
+  char *list,
+  char **next,
+  int (*cmp)(const char*,const char*)
+){
+  unsigned long offset;
+  char *ep;
+  char *set[LISTSIZE];
+  int i;
+  offset = (unsigned long)((char*)next - (char*)list);
+  for(i=0; i<LISTSIZE; i++) set[i] = 0;
+  while( list ){
+    ep = list;
+    list = NEXT(list);
+    NEXT(ep) = 0;
+    for(i=0; i<LISTSIZE-1 && set[i]!=0; i++){
+      ep = merge(ep,set[i],cmp,offset);
+      set[i] = 0;
+    }
+    set[i] = ep;
+  }
+  ep = 0;
+  for(i=0; i<LISTSIZE; i++) if( set[i] ) ep = merge(set[i],ep,cmp,offset);
+  return ep;
+}
+/************************ From the file "option.c" **************************/
+static char **argv;
+static struct s_options *op;
+static FILE *errstream;
+
+#define ISOPT(X) ((X)[0]=='-'||(X)[0]=='+'||strchr((X),'=')!=0)
+
+/*
+** Print the command line with a carrot pointing to the k-th character
+** of the n-th field.
+*/
+static void errline(int n, int k, FILE *err)
+{
+  int spcnt, i;
+  if( argv[0] ) fprintf(err,"%s",argv[0]);
+  spcnt = lemonStrlen(argv[0]) + 1;
+  for(i=1; i<n && argv[i]; i++){
+    fprintf(err," %s",argv[i]);
+    spcnt += lemonStrlen(argv[i])+1;
+  }
+  spcnt += k;
+  for(; argv[i]; i++) fprintf(err," %s",argv[i]);
+  if( spcnt<20 ){
+    fprintf(err,"\n%*s^-- here\n",spcnt,"");
+  }else{
+    fprintf(err,"\n%*shere --^\n",spcnt-7,"");
+  }
+}
+
+/*
+** Return the index of the N-th non-switch argument.  Return -1
+** if N is out of range.
+*/
+static int argindex(int n)
+{
+  int i;
+  int dashdash = 0;
+  if( argv!=0 && *argv!=0 ){
+    for(i=1; argv[i]; i++){
+      if( dashdash || !ISOPT(argv[i]) ){
+        if( n==0 ) return i;
+        n--;
+      }
+      if( strcmp(argv[i],"--")==0 ) dashdash = 1;
+    }
+  }
+  return -1;
+}
+
+static char emsg[] = "Command line syntax error: ";
+
+/*
+** Process a flag command line argument.
+*/
+static int handleflags(int i, FILE *err)
+{
+  int v;
+  int errcnt = 0;
+  int j;
+  for(j=0; op[j].label; j++){
+    if( strncmp(&argv[i][1],op[j].label,lemonStrlen(op[j].label))==0 ) break;
+  }
+  v = argv[i][0]=='-' ? 1 : 0;
+  if( op[j].label==0 ){
+    if( err ){
+      fprintf(err,"%sundefined option.\n",emsg);
+      errline(i,1,err);
+    }
+    errcnt++;
+  }else if( op[j].arg==0 ){
+    /* Ignore this option */
+  }else if( op[j].type==OPT_FLAG ){
+    *((int*)op[j].arg) = v;
+  }else if( op[j].type==OPT_FFLAG ){
+    (*(void(*)(int))(op[j].arg))(v);
+  }else if( op[j].type==OPT_FSTR ){
+    (*(void(*)(char *))(op[j].arg))(&argv[i][2]);
+  }else{
+    if( err ){
+      fprintf(err,"%smissing argument on switch.\n",emsg);
+      errline(i,1,err);
+    }
+    errcnt++;
+  }
+  return errcnt;
+}
+
+/*
+** Process a command line switch which has an argument.
+*/
+static int handleswitch(int i, FILE *err)
+{
+  int lv = 0;
+  double dv = 0.0;
+  char *sv = 0, *end;
+  char *cp;
+  int j;
+  int errcnt = 0;
+  cp = strchr(argv[i],'=');
+  assert( cp!=0 );
+  *cp = 0;
+  for(j=0; op[j].label; j++){
+    if( strcmp(argv[i],op[j].label)==0 ) break;
+  }
+  *cp = '=';
+  if( op[j].label==0 ){
+    if( err ){
+      fprintf(err,"%sundefined option.\n",emsg);
+      errline(i,0,err);
+    }
+    errcnt++;
+  }else{
+    cp++;
+    switch( op[j].type ){
+      case OPT_FLAG:
+      case OPT_FFLAG:
+        if( err ){
+          fprintf(err,"%soption requires an argument.\n",emsg);
+          errline(i,0,err);
+        }
+        errcnt++;
+        break;
+      case OPT_DBL:
+      case OPT_FDBL:
+        dv = strtod(cp,&end);
+        if( *end ){
+          if( err ){
+            fprintf(err,
+               "%sillegal character in floating-point argument.\n",emsg);
+            errline(i,(int)((char*)end-(char*)argv[i]),err);
+          }
+          errcnt++;
+        }
+        break;
+      case OPT_INT:
+      case OPT_FINT:
+        lv = strtol(cp,&end,0);
+        if( *end ){
+          if( err ){
+            fprintf(err,"%sillegal character in integer argument.\n",emsg);
+            errline(i,(int)((char*)end-(char*)argv[i]),err);
+          }
+          errcnt++;
+        }
+        break;
+      case OPT_STR:
+      case OPT_FSTR:
+        sv = cp;
+        break;
+    }
+    switch( op[j].type ){
+      case OPT_FLAG:
+      case OPT_FFLAG:
+        break;
+      case OPT_DBL:
+        *(double*)(op[j].arg) = dv;
+        break;
+      case OPT_FDBL:
+        (*(void(*)(double))(op[j].arg))(dv);
+        break;
+      case OPT_INT:
+        *(int*)(op[j].arg) = lv;
+        break;
+      case OPT_FINT:
+        (*(void(*)(int))(op[j].arg))((int)lv);
+        break;
+      case OPT_STR:
+        *(char**)(op[j].arg) = sv;
+        break;
+      case OPT_FSTR:
+        (*(void(*)(char *))(op[j].arg))(sv);
+        break;
+    }
+  }
+  return errcnt;
+}
+
+int OptInit(char **a, struct s_options *o, FILE *err)
+{
+  int errcnt = 0;
+  argv = a;
+  op = o;
+  errstream = err;
+  if( argv && *argv && op ){
+    int i;
+    for(i=1; argv[i]; i++){
+      if( argv[i][0]=='+' || argv[i][0]=='-' ){
+        errcnt += handleflags(i,err);
+      }else if( strchr(argv[i],'=') ){
+        errcnt += handleswitch(i,err);
+      }
+    }
+  }
+  if( errcnt>0 ){
+    fprintf(err,"Valid command line options for \"%s\" are:\n",*a);
+    OptPrint();
+    exit(1);
+  }
+  return 0;
+}
+
+int OptNArgs(){
+  int cnt = 0;
+  int dashdash = 0;
+  int i;
+  if( argv!=0 && argv[0]!=0 ){
+    for(i=1; argv[i]; i++){
+      if( dashdash || !ISOPT(argv[i]) ) cnt++;
+      if( strcmp(argv[i],"--")==0 ) dashdash = 1;
+    }
+  }
+  return cnt;
+}
+
+char *OptArg(int n)
+{
+  int i;
+  i = argindex(n);
+  return i>=0 ? argv[i] : 0;
+}
+
+void OptErr(int n)
+{
+  int i;
+  i = argindex(n);
+  if( i>=0 ) errline(i,0,errstream);
+}
+
+void OptPrint(){
+  int i;
+  int max, len;
+  max = 0;
+  for(i=0; op[i].label; i++){
+    len = lemonStrlen(op[i].label) + 1;
+    switch( op[i].type ){
+      case OPT_FLAG:
+      case OPT_FFLAG:
+        break;
+      case OPT_INT:
+      case OPT_FINT:
+        len += 9;       /* length of "<integer>" */
+        break;
+      case OPT_DBL:
+      case OPT_FDBL:
+        len += 6;       /* length of "<real>" */
+        break;
+      case OPT_STR:
+      case OPT_FSTR:
+        len += 8;       /* length of "<string>" */
+        break;
+    }
+    if( len>max ) max = len;
+  }
+  for(i=0; op[i].label; i++){
+    switch( op[i].type ){
+      case OPT_FLAG:
+      case OPT_FFLAG:
+        fprintf(errstream,"  -%-*s  %s\n",max,op[i].label,op[i].message);
+        break;
+      case OPT_INT:
+      case OPT_FINT:
+        fprintf(errstream,"  -%s<integer>%*s  %s\n",op[i].label,
+          (int)(max-lemonStrlen(op[i].label)-9),"",op[i].message);
+        break;
+      case OPT_DBL:
+      case OPT_FDBL:
+        fprintf(errstream,"  -%s<real>%*s  %s\n",op[i].label,
+          (int)(max-lemonStrlen(op[i].label)-6),"",op[i].message);
+        break;
+      case OPT_STR:
+      case OPT_FSTR:
+        fprintf(errstream,"  -%s<string>%*s  %s\n",op[i].label,
+          (int)(max-lemonStrlen(op[i].label)-8),"",op[i].message);
+        break;
+    }
+  }
+}
+/*********************** From the file "parse.c" ****************************/
+/*
+** Input file parser for the LEMON parser generator.
+*/
+
+/* The state of the parser */
+enum e_state {
+  INITIALIZE,
+  WAITING_FOR_DECL_OR_RULE,
+  WAITING_FOR_DECL_KEYWORD,
+  WAITING_FOR_DECL_ARG,
+  WAITING_FOR_PRECEDENCE_SYMBOL,
+  WAITING_FOR_ARROW,
+  IN_RHS,
+  LHS_ALIAS_1,
+  LHS_ALIAS_2,
+  LHS_ALIAS_3,
+  RHS_ALIAS_1,
+  RHS_ALIAS_2,
+  PRECEDENCE_MARK_1,
+  PRECEDENCE_MARK_2,
+  RESYNC_AFTER_RULE_ERROR,
+  RESYNC_AFTER_DECL_ERROR,
+  WAITING_FOR_DESTRUCTOR_SYMBOL,
+  WAITING_FOR_DATATYPE_SYMBOL,
+  WAITING_FOR_FALLBACK_ID,
+  WAITING_FOR_WILDCARD_ID,
+  WAITING_FOR_CLASS_ID,
+  WAITING_FOR_CLASS_TOKEN
+};
+struct pstate {
+  char *filename;       /* Name of the input file */
+  int tokenlineno;      /* Linenumber at which current token starts */
+  int errorcnt;         /* Number of errors so far */
+  char *tokenstart;     /* Text of current token */
+  struct lemon *gp;     /* Global state vector */
+  enum e_state state;        /* The state of the parser */
+  struct symbol *fallback;   /* The fallback token */
+  struct symbol *tkclass;    /* Token class symbol */
+  struct symbol *lhs;        /* Left-hand side of current rule */
+  const char *lhsalias;      /* Alias for the LHS */
+  int nrhs;                  /* Number of right-hand side symbols seen */
+  struct symbol *rhs[MAXRHS];  /* RHS symbols */
+  const char *alias[MAXRHS]; /* Aliases for each RHS symbol (or NULL) */
+  struct rule *prevrule;     /* Previous rule parsed */
+  const char *declkeyword;   /* Keyword of a declaration */
+  char **declargslot;        /* Where the declaration argument should be put */
+  int insertLineMacro;       /* Add #line before declaration insert */
+  int *decllinenoslot;       /* Where to write declaration line number */
+  enum e_assoc declassoc;    /* Assign this association to decl arguments */
+  int preccounter;           /* Assign this precedence to decl arguments */
+  struct rule *firstrule;    /* Pointer to first rule in the grammar */
+  struct rule *lastrule;     /* Pointer to the most recently parsed rule */
+};
+
+/* Parse a single token */
+static void parseonetoken(struct pstate *psp)
+{
+  const char *x;
+  x = Strsafe(psp->tokenstart);     /* Save the token permanently */
+#if 0
+  printf("%s:%d: Token=[%s] state=%d\n",psp->filename,psp->tokenlineno,
+    x,psp->state);
+#endif
+  switch( psp->state ){
+    case INITIALIZE:
+      psp->prevrule = 0;
+      psp->preccounter = 0;
+      psp->firstrule = psp->lastrule = 0;
+      psp->gp->nrule = 0;
+      /* Fall thru to next case */
+    case WAITING_FOR_DECL_OR_RULE:
+      if( x[0]=='%' ){
+        psp->state = WAITING_FOR_DECL_KEYWORD;
+      }else if( ISLOWER(x[0]) ){
+        psp->lhs = Symbol_new(x);
+        psp->nrhs = 0;
+        psp->lhsalias = 0;
+        psp->state = WAITING_FOR_ARROW;
+      }else if( x[0]=='{' ){
+        if( psp->prevrule==0 ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+"There is no prior rule upon which to attach the code \
+fragment which begins on this line.");
+          psp->errorcnt++;
+        }else if( psp->prevrule->code!=0 ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+"Code fragment beginning on this line is not the first \
+to follow the previous rule.");
+          psp->errorcnt++;
+        }else{
+          psp->prevrule->line = psp->tokenlineno;
+          psp->prevrule->code = &x[1];
+          psp->prevrule->noCode = 0;
+        }
+      }else if( x[0]=='[' ){
+        psp->state = PRECEDENCE_MARK_1;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Token \"%s\" should be either \"%%\" or a nonterminal name.",
+          x);
+        psp->errorcnt++;
+      }
+      break;
+    case PRECEDENCE_MARK_1:
+      if( !ISUPPER(x[0]) ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "The precedence symbol must be a terminal.");
+        psp->errorcnt++;
+      }else if( psp->prevrule==0 ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "There is no prior rule to assign precedence \"[%s]\".",x);
+        psp->errorcnt++;
+      }else if( psp->prevrule->precsym!=0 ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+"Precedence mark on this line is not the first \
+to follow the previous rule.");
+        psp->errorcnt++;
+      }else{
+        psp->prevrule->precsym = Symbol_new(x);
+      }
+      psp->state = PRECEDENCE_MARK_2;
+      break;
+    case PRECEDENCE_MARK_2:
+      if( x[0]!=']' ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Missing \"]\" on precedence mark.");
+        psp->errorcnt++;
+      }
+      psp->state = WAITING_FOR_DECL_OR_RULE;
+      break;
+    case WAITING_FOR_ARROW:
+      if( x[0]==':' && x[1]==':' && x[2]=='=' ){
+        psp->state = IN_RHS;
+      }else if( x[0]=='(' ){
+        psp->state = LHS_ALIAS_1;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Expected to see a \":\" following the LHS symbol \"%s\".",
+          psp->lhs->name);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case LHS_ALIAS_1:
+      if( ISALPHA(x[0]) ){
+        psp->lhsalias = x;
+        psp->state = LHS_ALIAS_2;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "\"%s\" is not a valid alias for the LHS \"%s\"\n",
+          x,psp->lhs->name);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case LHS_ALIAS_2:
+      if( x[0]==')' ){
+        psp->state = LHS_ALIAS_3;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Missing \")\" following LHS alias name \"%s\".",psp->lhsalias);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case LHS_ALIAS_3:
+      if( x[0]==':' && x[1]==':' && x[2]=='=' ){
+        psp->state = IN_RHS;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Missing \"->\" following: \"%s(%s)\".",
+           psp->lhs->name,psp->lhsalias);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case IN_RHS:
+      if( x[0]=='.' ){
+        struct rule *rp;
+        rp = (struct rule *)calloc( sizeof(struct rule) +
+             sizeof(struct symbol*)*psp->nrhs + sizeof(char*)*psp->nrhs, 1);
+        if( rp==0 ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Can't allocate enough memory for this rule.");
+          psp->errorcnt++;
+          psp->prevrule = 0;
+        }else{
+          int i;
+          rp->ruleline = psp->tokenlineno;
+          rp->rhs = (struct symbol**)&rp[1];
+          rp->rhsalias = (const char**)&(rp->rhs[psp->nrhs]);
+          for(i=0; i<psp->nrhs; i++){
+            rp->rhs[i] = psp->rhs[i];
+            rp->rhsalias[i] = psp->alias[i];
+          }
+          rp->lhs = psp->lhs;
+          rp->lhsalias = psp->lhsalias;
+          rp->nrhs = psp->nrhs;
+          rp->code = 0;
+          rp->noCode = 1;
+          rp->precsym = 0;
+          rp->index = psp->gp->nrule++;
+          rp->nextlhs = rp->lhs->rule;
+          rp->lhs->rule = rp;
+          rp->next = 0;
+          if( psp->firstrule==0 ){
+            psp->firstrule = psp->lastrule = rp;
+          }else{
+            psp->lastrule->next = rp;
+            psp->lastrule = rp;
+          }
+          psp->prevrule = rp;
+        }
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( ISALPHA(x[0]) ){
+        if( psp->nrhs>=MAXRHS ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Too many symbols on RHS of rule beginning at \"%s\".",
+            x);
+          psp->errorcnt++;
+          psp->state = RESYNC_AFTER_RULE_ERROR;
+        }else{
+          psp->rhs[psp->nrhs] = Symbol_new(x);
+          psp->alias[psp->nrhs] = 0;
+          psp->nrhs++;
+        }
+      }else if( (x[0]=='|' || x[0]=='/') && psp->nrhs>0 ){
+        struct symbol *msp = psp->rhs[psp->nrhs-1];
+        if( msp->type!=MULTITERMINAL ){
+          struct symbol *origsp = msp;
+          msp = (struct symbol *) calloc(1,sizeof(*msp));
+          memset(msp, 0, sizeof(*msp));
+          msp->type = MULTITERMINAL;
+          msp->nsubsym = 1;
+          msp->subsym = (struct symbol **) calloc(1,sizeof(struct symbol*));
+          msp->subsym[0] = origsp;
+          msp->name = origsp->name;
+          psp->rhs[psp->nrhs-1] = msp;
+        }
+        msp->nsubsym++;
+        msp->subsym = (struct symbol **) realloc(msp->subsym,
+          sizeof(struct symbol*)*msp->nsubsym);
+        msp->subsym[msp->nsubsym-1] = Symbol_new(&x[1]);
+        if( ISLOWER(x[1]) || ISLOWER(msp->subsym[0]->name[0]) ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Cannot form a compound containing a non-terminal");
+          psp->errorcnt++;
+        }
+      }else if( x[0]=='(' && psp->nrhs>0 ){
+        psp->state = RHS_ALIAS_1;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Illegal character on RHS of rule: \"%s\".",x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case RHS_ALIAS_1:
+      if( ISALPHA(x[0]) ){
+        psp->alias[psp->nrhs-1] = x;
+        psp->state = RHS_ALIAS_2;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "\"%s\" is not a valid alias for the RHS symbol \"%s\"\n",
+          x,psp->rhs[psp->nrhs-1]->name);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case RHS_ALIAS_2:
+      if( x[0]==')' ){
+        psp->state = IN_RHS;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Missing \")\" following LHS alias name \"%s\".",psp->lhsalias);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case WAITING_FOR_DECL_KEYWORD:
+      if( ISALPHA(x[0]) ){
+        psp->declkeyword = x;
+        psp->declargslot = 0;
+        psp->decllinenoslot = 0;
+        psp->insertLineMacro = 1;
+        psp->state = WAITING_FOR_DECL_ARG;
+        if( strcmp(x,"name")==0 ){
+          psp->declargslot = &(psp->gp->name);
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"include")==0 ){
+          psp->declargslot = &(psp->gp->include);
+        }else if( strcmp(x,"code")==0 ){
+          psp->declargslot = &(psp->gp->extracode);
+        }else if( strcmp(x,"token_destructor")==0 ){
+          psp->declargslot = &psp->gp->tokendest;
+        }else if( strcmp(x,"default_destructor")==0 ){
+          psp->declargslot = &psp->gp->vardest;
+        }else if( strcmp(x,"token_prefix")==0 ){
+          psp->declargslot = &psp->gp->tokenprefix;
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"syntax_error")==0 ){
+          psp->declargslot = &(psp->gp->error);
+        }else if( strcmp(x,"parse_accept")==0 ){
+          psp->declargslot = &(psp->gp->accept);
+        }else if( strcmp(x,"parse_failure")==0 ){
+          psp->declargslot = &(psp->gp->failure);
+        }else if( strcmp(x,"stack_overflow")==0 ){
+          psp->declargslot = &(psp->gp->overflow);
+        }else if( strcmp(x,"extra_argument")==0 ){
+          psp->declargslot = &(psp->gp->arg);
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"token_type")==0 ){
+          psp->declargslot = &(psp->gp->tokentype);
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"default_type")==0 ){
+          psp->declargslot = &(psp->gp->vartype);
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"stack_size")==0 ){
+          psp->declargslot = &(psp->gp->stacksize);
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"start_symbol")==0 ){
+          psp->declargslot = &(psp->gp->start);
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"left")==0 ){
+          psp->preccounter++;
+          psp->declassoc = LEFT;
+          psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
+        }else if( strcmp(x,"right")==0 ){
+          psp->preccounter++;
+          psp->declassoc = RIGHT;
+          psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
+        }else if( strcmp(x,"nonassoc")==0 ){
+          psp->preccounter++;
+          psp->declassoc = NONE;
+          psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
+        }else if( strcmp(x,"destructor")==0 ){
+          psp->state = WAITING_FOR_DESTRUCTOR_SYMBOL;
+        }else if( strcmp(x,"type")==0 ){
+          psp->state = WAITING_FOR_DATATYPE_SYMBOL;
+        }else if( strcmp(x,"fallback")==0 ){
+          psp->fallback = 0;
+          psp->state = WAITING_FOR_FALLBACK_ID;
+        }else if( strcmp(x,"wildcard")==0 ){
+          psp->state = WAITING_FOR_WILDCARD_ID;
+        }else if( strcmp(x,"token_class")==0 ){
+          psp->state = WAITING_FOR_CLASS_ID;
+        }else{
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Unknown declaration keyword: \"%%%s\".",x);
+          psp->errorcnt++;
+          psp->state = RESYNC_AFTER_DECL_ERROR;
+        }
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Illegal declaration keyword: \"%s\".",x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }
+      break;
+    case WAITING_FOR_DESTRUCTOR_SYMBOL:
+      if( !ISALPHA(x[0]) ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Symbol name missing after %%destructor keyword");
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }else{
+        struct symbol *sp = Symbol_new(x);
+        psp->declargslot = &sp->destructor;
+        psp->decllinenoslot = &sp->destLineno;
+        psp->insertLineMacro = 1;
+        psp->state = WAITING_FOR_DECL_ARG;
+      }
+      break;
+    case WAITING_FOR_DATATYPE_SYMBOL:
+      if( !ISALPHA(x[0]) ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Symbol name missing after %%type keyword");
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }else{
+        struct symbol *sp = Symbol_find(x);
+        if((sp) && (sp->datatype)){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Symbol %%type \"%s\" already defined", x);
+          psp->errorcnt++;
+          psp->state = RESYNC_AFTER_DECL_ERROR;
+        }else{
+          if (!sp){
+            sp = Symbol_new(x);
+          }
+          psp->declargslot = &sp->datatype;
+          psp->insertLineMacro = 0;
+          psp->state = WAITING_FOR_DECL_ARG;
+        }
+      }
+      break;
+    case WAITING_FOR_PRECEDENCE_SYMBOL:
+      if( x[0]=='.' ){
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( ISUPPER(x[0]) ){
+        struct symbol *sp;
+        sp = Symbol_new(x);
+        if( sp->prec>=0 ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Symbol \"%s\" has already be given a precedence.",x);
+          psp->errorcnt++;
+        }else{
+          sp->prec = psp->preccounter;
+          sp->assoc = psp->declassoc;
+        }
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Can't assign a precedence to \"%s\".",x);
+        psp->errorcnt++;
+      }
+      break;
+    case WAITING_FOR_DECL_ARG:
+      if( x[0]=='{' || x[0]=='\"' || ISALNUM(x[0]) ){
+        const char *zOld, *zNew;
+        char *zBuf, *z;
+        int nOld, n, nLine = 0, nNew, nBack;
+        int addLineMacro;
+        char zLine[50];
+        zNew = x;
+        if( zNew[0]=='"' || zNew[0]=='{' ) zNew++;
+        nNew = lemonStrlen(zNew);
+        if( *psp->declargslot ){
+          zOld = *psp->declargslot;
+        }else{
+          zOld = "";
+        }
+        nOld = lemonStrlen(zOld);
+        n = nOld + nNew + 20;
+        addLineMacro = !psp->gp->nolinenosflag && psp->insertLineMacro &&
+                        (psp->decllinenoslot==0 || psp->decllinenoslot[0]!=0);
+        if( addLineMacro ){
+          for(z=psp->filename, nBack=0; *z; z++){
+            if( *z=='\\' ) nBack++;
+          }
+          lemon_sprintf(zLine, "// line %d ", psp->tokenlineno);
+          nLine = lemonStrlen(zLine);
+          n += nLine + lemonStrlen(psp->filename) + nBack;
+        }
+        *psp->declargslot = (char *) realloc(*psp->declargslot, n);
+        zBuf = *psp->declargslot + nOld;
+        if( addLineMacro ){
+          if( nOld && zBuf[-1]!='\n' ){
+            *(zBuf++) = '\n';
+          }
+          memcpy(zBuf, zLine, nLine);
+          zBuf += nLine;
+          *(zBuf++) = '"';
+          for(z=psp->filename; *z; z++){
+            if( *z=='\\' ){
+              *(zBuf++) = '\\';
+            }
+            *(zBuf++) = *z;
+          }
+          *(zBuf++) = '"';
+          *(zBuf++) = '\n';
+        }
+        if( psp->decllinenoslot && psp->decllinenoslot[0]==0 ){
+          psp->decllinenoslot[0] = psp->tokenlineno;
+        }
+        memcpy(zBuf, zNew, nNew);
+        zBuf += nNew;
+        *zBuf = 0;
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Illegal argument to %%%s: %s",psp->declkeyword,x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }
+      break;
+    case WAITING_FOR_FALLBACK_ID:
+      if( x[0]=='.' ){
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( !ISUPPER(x[0]) ){
+        ErrorMsg(psp->filename, psp->tokenlineno,
+          "%%fallback argument \"%s\" should be a token", x);
+        psp->errorcnt++;
+      }else{
+        struct symbol *sp = Symbol_new(x);
+        if( psp->fallback==0 ){
+          psp->fallback = sp;
+        }else if( sp->fallback ){
+          ErrorMsg(psp->filename, psp->tokenlineno,
+            "More than one fallback assigned to token %s", x);
+          psp->errorcnt++;
+        }else{
+          sp->fallback = psp->fallback;
+          psp->gp->has_fallback = 1;
+        }
+      }
+      break;
+    case WAITING_FOR_WILDCARD_ID:
+      if( x[0]=='.' ){
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( !ISUPPER(x[0]) ){
+        ErrorMsg(psp->filename, psp->tokenlineno,
+          "%%wildcard argument \"%s\" should be a token", x);
+        psp->errorcnt++;
+      }else{
+        struct symbol *sp = Symbol_new(x);
+        if( psp->gp->wildcard==0 ){
+          psp->gp->wildcard = sp;
+        }else{
+          ErrorMsg(psp->filename, psp->tokenlineno,
+            "Extra wildcard to token: %s", x);
+          psp->errorcnt++;
+        }
+      }
+      break;
+    case WAITING_FOR_CLASS_ID:
+      if( !ISLOWER(x[0]) ){
+        ErrorMsg(psp->filename, psp->tokenlineno,
+          "%%token_class must be followed by an identifier: ", x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+     }else if( Symbol_find(x) ){
+        ErrorMsg(psp->filename, psp->tokenlineno,
+          "Symbol \"%s\" already used", x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }else{
+        psp->tkclass = Symbol_new(x);
+        psp->tkclass->type = MULTITERMINAL;
+        psp->state = WAITING_FOR_CLASS_TOKEN;
+      }
+      break;
+    case WAITING_FOR_CLASS_TOKEN:
+      if( x[0]=='.' ){
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( ISUPPER(x[0]) || ((x[0]=='|' || x[0]=='/') && ISUPPER(x[1])) ){
+        struct symbol *msp = psp->tkclass;
+        msp->nsubsym++;
+        msp->subsym = (struct symbol **) realloc(msp->subsym,
+          sizeof(struct symbol*)*msp->nsubsym);
+        if( !ISUPPER(x[0]) ) x++;
+        msp->subsym[msp->nsubsym-1] = Symbol_new(x);
+      }else{
+        ErrorMsg(psp->filename, psp->tokenlineno,
+          "%%token_class argument \"%s\" should be a token", x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }
+      break;
+    case RESYNC_AFTER_RULE_ERROR:
+/*      if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE;
+**      break; */
+    case RESYNC_AFTER_DECL_ERROR:
+      if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE;
+      if( x[0]=='%' ) psp->state = WAITING_FOR_DECL_KEYWORD;
+      break;
+  }
+}
+
+/* Run the preprocessor over the input file text.  The global variables
+** azDefine[0] through azDefine[nDefine-1] contains the names of all defined
+** macros.  This routine looks for "%ifdef" and "%ifndef" and "%endif" and
+** comments them out.  Text in between is also commented out as appropriate.
+*/
+static void preprocess_input(char *z){
+  int i, j, k, n;
+  int exclude = 0;
+  int start = 0;
+  int lineno = 1;
+  int start_lineno = 1;
+  for(i=0; z[i]; i++){
+    if( z[i]=='\n' ) lineno++;
+    if( z[i]!='%' || (i>0 && z[i-1]!='\n') ) continue;
+    if( strncmp(&z[i],"%endif",6)==0 && ISSPACE(z[i+6]) ){
+      if( exclude ){
+        exclude--;
+        if( exclude==0 ){
+          for(j=start; j<i; j++) if( z[j]!='\n' ) z[j] = ' ';
+        }
+      }
+      for(j=i; z[j] && z[j]!='\n'; j++) z[j] = ' ';
+    }else if( (strncmp(&z[i],"%ifdef",6)==0 && ISSPACE(z[i+6]))
+          || (strncmp(&z[i],"%ifndef",7)==0 && ISSPACE(z[i+7])) ){
+      if( exclude ){
+        exclude++;
+      }else{
+        for(j=i+7; ISSPACE(z[j]); j++){}
+        for(n=0; z[j+n] && !ISSPACE(z[j+n]); n++){}
+        exclude = 1;
+        for(k=0; k<nDefine; k++){
+          if( strncmp(azDefine[k],&z[j],n)==0 && lemonStrlen(azDefine[k])==n ){
+            exclude = 0;
+            break;
+          }
+        }
+        if( z[i+3]=='n' ) exclude = !exclude;
+        if( exclude ){
+          start = i;
+          start_lineno = lineno;
+        }
+      }
+      for(j=i; z[j] && z[j]!='\n'; j++) z[j] = ' ';
+    }
+  }
+  if( exclude ){
+    fprintf(stderr,"unterminated %%ifdef starting on line %d\n", start_lineno);
+    exit(1);
+  }
+}
+
+/* In spite of its name, this function is really a scanner.  It read
+** in the entire input file (all at once) then tokenizes it.  Each
+** token is passed to the function "parseonetoken" which builds all
+** the appropriate data structures in the global state vector "gp".
+*/
+void Parse(struct lemon *gp)
+{
+  struct pstate ps;
+  FILE *fp;
+  char *filebuf;
+  unsigned int filesize;
+  int lineno;
+  int c;
+  char *cp, *nextcp;
+  int startline = 0;
+
+  memset(&ps, '\0', sizeof(ps));
+  ps.gp = gp;
+  ps.filename = gp->filename;
+  ps.errorcnt = 0;
+  ps.state = INITIALIZE;
+
+  /* Begin by reading the input file */
+  fp = fopen(ps.filename,"rb");
+  if( fp==0 ){
+    ErrorMsg(ps.filename,0,"Can't open this file for reading.");
+    gp->errorcnt++;
+    return;
+  }
+  fseek(fp,0,2);
+  filesize = ftell(fp);
+  rewind(fp);
+  filebuf = (char *)malloc( filesize+1 );
+  if( filesize>100000000 || filebuf==0 ){
+    ErrorMsg(ps.filename,0,"Input file too large.");
+    gp->errorcnt++;
+    fclose(fp);
+    return;
+  }
+  if( fread(filebuf,1,filesize,fp)!=filesize ){
+    ErrorMsg(ps.filename,0,"Can't read in all %d bytes of this file.",
+      filesize);
+    free(filebuf);
+    gp->errorcnt++;
+    fclose(fp);
+    return;
+  }
+  fclose(fp);
+  filebuf[filesize] = 0;
+
+  /* Make an initial pass through the file to handle %ifdef and %ifndef */
+  preprocess_input(filebuf);
+
+  /* Now scan the text of the input file */
+  lineno = 1;
+  for(cp=filebuf; (c= *cp)!=0; ){
+    if( c=='\n' ) lineno++;              /* Keep track of the line number */
+    if( ISSPACE(c) ){ cp++; continue; }  /* Skip all white space */
+    if( c=='/' && cp[1]=='/' ){          /* Skip C++ style comments */
+      cp+=2;
+      while( (c= *cp)!=0 && c!='\n' ) cp++;
+      continue;
+    }
+    if( c=='/' && cp[1]=='*' ){          /* Skip C style comments */
+      cp+=2;
+      while( (c= *cp)!=0 && (c!='/' || cp[-1]!='*') ){
+        if( c=='\n' ) lineno++;
+        cp++;
+      }
+      if( c ) cp++;
+      continue;
+    }
+    ps.tokenstart = cp;                /* Mark the beginning of the token */
+    ps.tokenlineno = lineno;           /* Linenumber on which token begins */
+    if( c=='\"' ){                     /* String literals */
+      cp++;
+      while( (c= *cp)!=0 && c!='\"' ){
+        if( c=='\n' ) lineno++;
+        cp++;
+      }
+      if( c==0 ){
+        ErrorMsg(ps.filename,startline,
+"String starting on this line is not terminated before the end of the file.");
+        ps.errorcnt++;
+        nextcp = cp;
+      }else{
+        nextcp = cp+1;
+      }
+    }else if( c=='{' ){               /* A block of C code */
+      int level;
+      cp++;
+      for(level=1; (c= *cp)!=0 && (level>1 || c!='}'); cp++){
+        if( c=='\n' ) lineno++;
+        else if( c=='{' ) level++;
+        else if( c=='}' ) level--;
+        else if( c=='/' && cp[1]=='*' ){  /* Skip comments */
+          int prevc;
+          cp = &cp[2];
+          prevc = 0;
+          while( (c= *cp)!=0 && (c!='/' || prevc!='*') ){
+            if( c=='\n' ) lineno++;
+            prevc = c;
+            cp++;
+          }
+        }else if( c=='/' && cp[1]=='/' ){  /* Skip C++ style comments too */
+          cp = &cp[2];
+          while( (c= *cp)!=0 && c!='\n' ) cp++;
+          if( c ) lineno++;
+        }else if( c=='\'' || c=='\"' ){    /* String a character literals */
+          int startchar, prevc;
+          startchar = c;
+          prevc = 0;
+          for(cp++; (c= *cp)!=0 && (c!=startchar || prevc=='\\'); cp++){
+            if( c=='\n' ) lineno++;
+            if( prevc=='\\' ) prevc = 0;
+            else              prevc = c;
+          }
+        }
+      }
+      if( c==0 ){
+        ErrorMsg(ps.filename,ps.tokenlineno,
+"C code starting on this line is not terminated before the end of the file.");
+        ps.errorcnt++;
+        nextcp = cp;
+      }else{
+        nextcp = cp+1;
+      }
+    }else if( ISALNUM(c) ){          /* Identifiers */
+      while( (c= *cp)!=0 && (ISALNUM(c) || c=='_') ) cp++;
+      nextcp = cp;
+    }else if( c==':' && cp[1]==':' && cp[2]=='=' ){ /* The operator "::=" */
+      cp += 3;
+      nextcp = cp;
+    }else if( (c=='/' || c=='|') && ISALPHA(cp[1]) ){
+      cp += 2;
+      while( (c = *cp)!=0 && (ISALNUM(c) || c=='_') ) cp++;
+      nextcp = cp;
+    }else{                          /* All other (one character) operators */
+      cp++;
+      nextcp = cp;
+    }
+    c = *cp;
+    *cp = 0;                        /* Null terminate the token */
+    parseonetoken(&ps);             /* Parse the token */
+    *cp = (char)c;                  /* Restore the buffer */
+    cp = nextcp;
+  }
+  free(filebuf);                    /* Release the buffer after parsing */
+  gp->rule = ps.firstrule;
+  gp->errorcnt = ps.errorcnt;
+}
+/*************************** From the file "plink.c" *********************/
+/*
+** Routines processing configuration follow-set propagation links
+** in the LEMON parser generator.
+*/
+static struct plink *plink_freelist = 0;
+
+/* Allocate a new plink */
+struct plink *Plink_new(){
+  struct plink *newlink;
+
+  if( plink_freelist==0 ){
+    int i;
+    int amt = 100;
+    plink_freelist = (struct plink *)calloc( amt, sizeof(struct plink) );
+    if( plink_freelist==0 ){
+      fprintf(stderr,
+      "Unable to allocate memory for a new follow-set propagation link.\n");
+      exit(1);
+    }
+    for(i=0; i<amt-1; i++) plink_freelist[i].next = &plink_freelist[i+1];
+    plink_freelist[amt-1].next = 0;
+  }
+  newlink = plink_freelist;
+  plink_freelist = plink_freelist->next;
+  return newlink;
+}
+
+/* Add a plink to a plink list */
+void Plink_add(struct plink **plpp, struct config *cfp)
+{
+  struct plink *newlink;
+  newlink = Plink_new();
+  newlink->next = *plpp;
+  *plpp = newlink;
+  newlink->cfp = cfp;
+}
+
+/* Transfer every plink on the list "from" to the list "to" */
+void Plink_copy(struct plink **to, struct plink *from)
+{
+  struct plink *nextpl;
+  while( from ){
+    nextpl = from->next;
+    from->next = *to;
+    *to = from;
+    from = nextpl;
+  }
+}
+
+/* Delete every plink on the list */
+void Plink_delete(struct plink *plp)
+{
+  struct plink *nextpl;
+
+  while( plp ){
+    nextpl = plp->next;
+    plp->next = plink_freelist;
+    plink_freelist = plp;
+    plp = nextpl;
+  }
+}
+/*********************** From the file "report.c" **************************/
+/*
+** Procedures for generating reports and tables in the LEMON parser generator.
+*/
+
+/* Generate a filename with the given suffix.  Space to hold the
+** name comes from malloc() and must be freed by the calling
+** function.
+*/
+PRIVATE char *file_makename(struct lemon *lemp, const char *suffix)
+{
+  char *name;
+  char *cp;
+
+  name = (char*)malloc( lemonStrlen(lemp->filename) + lemonStrlen(suffix) + 5 );
+  if( name==0 ){
+    fprintf(stderr,"Can't allocate space for a filename.\n");
+    exit(1);
+  }
+  lemon_strcpy(name,lemp->filename);
+  cp = strrchr(name,'.');
+  if( cp ) *cp = 0;
+  lemon_strcat(name,suffix);
+  return name;
+}
+
+/* Open a file with a name based on the name of the input file,
+** but with a different (specified) suffix, and return a pointer
+** to the stream */
+PRIVATE FILE *file_open(
+  struct lemon *lemp,
+  const char *suffix,
+  const char *mode
+){
+  FILE *fp;
+
+  if( lemp->outname ) free(lemp->outname);
+  lemp->outname = file_makename(lemp, suffix);
+  fp = fopen(lemp->outname,mode);
+  if( fp==0 && *mode=='w' ){
+    fprintf(stderr,"Can't open file \"%s\".\n",lemp->outname);
+    lemp->errorcnt++;
+    return 0;
+  }
+  return fp;
+}
+
+/* Duplicate the input file without comments and without actions
+** on rules */
+void Reprint(struct lemon *lemp)
+{
+  struct rule *rp;
+  struct symbol *sp;
+  int i, j, maxlen, len, ncolumns, skip;
+  printf("// Reprint of input file \"%s\".\n// Symbols:\n",lemp->filename);
+  maxlen = 10;
+  for(i=0; i<lemp->nsymbol; i++){
+    sp = lemp->symbols[i];
+    len = lemonStrlen(sp->name);
+    if( len>maxlen ) maxlen = len;
+  }
+  ncolumns = 76/(maxlen+5);
+  if( ncolumns<1 ) ncolumns = 1;
+  skip = (lemp->nsymbol + ncolumns - 1)/ncolumns;
+  for(i=0; i<skip; i++){
+    printf("//");
+    for(j=i; j<lemp->nsymbol; j+=skip){
+      sp = lemp->symbols[j];
+      assert( sp->index==j );
+      printf(" %3d %-*.*s",j,maxlen,maxlen,sp->name);
+    }
+    printf("\n");
+  }
+  for(rp=lemp->rule; rp; rp=rp->next){
+    printf("%s",rp->lhs->name);
+    /*    if( rp->lhsalias ) printf("(%s)",rp->lhsalias); */
+    printf(" ::=");
+    for(i=0; i<rp->nrhs; i++){
+      sp = rp->rhs[i];
+      if( sp->type==MULTITERMINAL ){
+        printf(" %s", sp->subsym[0]->name);
+        for(j=1; j<sp->nsubsym; j++){
+          printf("|%s", sp->subsym[j]->name);
+        }
+      }else{
+        printf(" %s", sp->name);
+      }
+      /* if( rp->rhsalias[i] ) printf("(%s)",rp->rhsalias[i]); */
+    }
+    printf(".");
+    if( rp->precsym ) printf(" [%s]",rp->precsym->name);
+    /* if( rp->code ) printf("\n    %s",rp->code); */
+    printf("\n");
+  }
+}
+
+/* Print a single rule.
+*/
+void RulePrint(FILE *fp, struct rule *rp, int iCursor){
+  struct symbol *sp;
+  int i, j;
+  fprintf(fp,"%s ::=",rp->lhs->name);
+  for(i=0; i<=rp->nrhs; i++){
+    if( i==iCursor ) fprintf(fp," *");
+    if( i==rp->nrhs ) break;
+    sp = rp->rhs[i];
+    if( sp->type==MULTITERMINAL ){
+      fprintf(fp," %s", sp->subsym[0]->name);
+      for(j=1; j<sp->nsubsym; j++){
+        fprintf(fp,"|%s",sp->subsym[j]->name);
+      }
+    }else{
+      fprintf(fp," %s", sp->name);
+    }
+  }
+}
+
+/* Print the rule for a configuration.
+*/
+void ConfigPrint(FILE *fp, struct config *cfp){
+  RulePrint(fp, cfp->rp, cfp->dot);
+}
+
+/* #define TEST */
+#if 0
+/* Print a set */
+PRIVATE void SetPrint(out,set,lemp)
+FILE *out;
+char *set;
+struct lemon *lemp;
+{
+  int i;
+  char *spacer;
+  spacer = "";
+  fprintf(out,"%12s[","");
+  for(i=0; i<lemp->nterminal; i++){
+    if( SetFind(set,i) ){
+      fprintf(out,"%s%s",spacer,lemp->symbols[i]->name);
+      spacer = " ";
+    }
+  }
+  fprintf(out,"]\n");
+}
+
+/* Print a plink chain */
+PRIVATE void PlinkPrint(out,plp,tag)
+FILE *out;
+struct plink *plp;
+char *tag;
+{
+  while( plp ){
+    fprintf(out,"%12s%s (state %2d) ","",tag,plp->cfp->stp->statenum);
+    ConfigPrint(out,plp->cfp);
+    fprintf(out,"\n");
+    plp = plp->next;
+  }
+}
+#endif
+
+/* Print an action to the given file descriptor.  Return FALSE if
+** nothing was actually printed.
+*/
+int PrintAction(
+  struct action *ap,          /* The action to print */
+  FILE *fp,                   /* Print the action here */
+  int indent                  /* Indent by this amount */
+){
+  int result = 1;
+  switch( ap->type ){
+    case SHIFT: {
+      struct state *stp = ap->x.stp;
+      fprintf(fp,"%*s shift        %-7d",indent,ap->sp->name,stp->statenum);
+      break;
+    }
+    case REDUCE: {
+      struct rule *rp = ap->x.rp;
+      fprintf(fp,"%*s reduce       %-7d",indent,ap->sp->name,rp->iRule);
+      RulePrint(fp, rp, -1);
+      break;
+    }
+    case SHIFTREDUCE: {
+      struct rule *rp = ap->x.rp;
+      fprintf(fp,"%*s shift-reduce %-7d",indent,ap->sp->name,rp->iRule);
+      RulePrint(fp, rp, -1);
+      break;
+    }
+    case ACCEPT:
+      fprintf(fp,"%*s accept",indent,ap->sp->name);
+      break;
+    case ERROR:
+      fprintf(fp,"%*s error",indent,ap->sp->name);
+      break;
+    case SRCONFLICT:
+    case RRCONFLICT:
+      fprintf(fp,"%*s reduce       %-7d ** Parsing conflict **",
+        indent,ap->sp->name,ap->x.rp->iRule);
+      break;
+    case SSCONFLICT:
+      fprintf(fp,"%*s shift        %-7d ** Parsing conflict **",
+        indent,ap->sp->name,ap->x.stp->statenum);
+      break;
+    case SH_RESOLVED:
+      if( showPrecedenceConflict ){
+        fprintf(fp,"%*s shift        %-7d -- dropped by precedence",
+                indent,ap->sp->name,ap->x.stp->statenum);
+      }else{
+        result = 0;
+      }
+      break;
+    case RD_RESOLVED:
+      if( showPrecedenceConflict ){
+        fprintf(fp,"%*s reduce %-7d -- dropped by precedence",
+                indent,ap->sp->name,ap->x.rp->iRule);
+      }else{
+        result = 0;
+      }
+      break;
+    case NOT_USED:
+      result = 0;
+      break;
+  }
+  if( result && ap->spOpt ){
+    fprintf(fp,"  /* because %s==%s */", ap->sp->name, ap->spOpt->name);
+  }
+  return result;
+}
+
+/* Generate the "*.out" log file */
+void ReportOutput(struct lemon *lemp)
+{
+  int i;
+  struct state *stp;
+  struct config *cfp;
+  struct action *ap;
+  FILE *fp;
+
+  fp = file_open(lemp,".out","wb");
+  if( fp==0 ) return;
+  for(i=0; i<lemp->nxstate; i++){
+    stp = lemp->sorted[i];
+    fprintf(fp,"State %d:\n",stp->statenum);
+    if( lemp->basisflag ) cfp=stp->bp;
+    else                  cfp=stp->cfp;
+    while( cfp ){
+      char buf[20];
+      if( cfp->dot==cfp->rp->nrhs ){
+        lemon_sprintf(buf,"(%d)",cfp->rp->iRule);
+        fprintf(fp,"    %5s ",buf);
+      }else{
+        fprintf(fp,"          ");
+      }
+      ConfigPrint(fp,cfp);
+      fprintf(fp,"\n");
+#if 0
+      SetPrint(fp,cfp->fws,lemp);
+      PlinkPrint(fp,cfp->fplp,"To  ");
+      PlinkPrint(fp,cfp->bplp,"From");
+#endif
+      if( lemp->basisflag ) cfp=cfp->bp;
+      else                  cfp=cfp->next;
+    }
+    fprintf(fp,"\n");
+    for(ap=stp->ap; ap; ap=ap->next){
+      if( PrintAction(ap,fp,30) ) fprintf(fp,"\n");
+    }
+    fprintf(fp,"\n");
+  }
+  fprintf(fp, "----------------------------------------------------\n");
+  fprintf(fp, "Symbols:\n");
+  for(i=0; i<lemp->nsymbol; i++){
+    int j;
+    struct symbol *sp;
+
+    sp = lemp->symbols[i];
+    fprintf(fp, "  %3d: %s", i, sp->name);
+    if( sp->type==NONTERMINAL ){
+      fprintf(fp, ":");
+      if( sp->lambda ){
+        fprintf(fp, " <lambda>");
+      }
+      for(j=0; j<lemp->nterminal; j++){
+        if( sp->firstset && SetFind(sp->firstset, j) ){
+          fprintf(fp, " %s", lemp->symbols[j]->name);
+        }
+      }
+    }
+    fprintf(fp, "\n");
+  }
+  fclose(fp);
+  return;
+}
+
+/* Search for the file "name" which is in the same directory as
+** the exacutable */
+PRIVATE char *pathsearch(char *argv0, char *name, int modemask)
+{
+  const char *pathlist;
+  char *pathbufptr;
+  char *pathbuf;
+  char *path,*cp;
+  char c;
+
+#ifdef __WIN32__
+  cp = strrchr(argv0,'\\');
+#else
+  cp = strrchr(argv0,'/');
+#endif
+  if( cp ){
+    c = *cp;
+    *cp = 0;
+    path = (char *)malloc( lemonStrlen(argv0) + lemonStrlen(name) + 2 );
+    if( path ) lemon_sprintf(path,"%s/%s",argv0,name);
+    *cp = c;
+  }else{
+    pathlist = getenv("PATH");
+    if( pathlist==0 ) pathlist = ".:/bin:/usr/bin";
+    pathbuf = (char *) malloc( lemonStrlen(pathlist) + 1 );
+    path = (char *)malloc( lemonStrlen(pathlist)+lemonStrlen(name)+2 );
+    if( (pathbuf != 0) && (path!=0) ){
+      pathbufptr = pathbuf;
+      lemon_strcpy(pathbuf, pathlist);
+      while( *pathbuf ){
+        cp = strchr(pathbuf,':');
+        if( cp==0 ) cp = &pathbuf[lemonStrlen(pathbuf)];
+        c = *cp;
+        *cp = 0;
+        lemon_sprintf(path,"%s/%s",pathbuf,name);
+        *cp = c;
+        if( c==0 ) pathbuf[0] = 0;
+        else pathbuf = &cp[1];
+        if( access(path,modemask)==0 ) break;
+      }
+      free(pathbufptr);
+    }
+  }
+  return path;
+}
+
+/* Given an action, compute the integer value for that action
+** which is to be put in the action table of the generated machine.
+** Return negative if no action should be generated.
+*/
+PRIVATE int compute_action(struct lemon *lemp, struct action *ap)
+{
+  int act;
+  switch( ap->type ){
+    case SHIFT:  act = ap->x.stp->statenum;                        break;
+    case SHIFTREDUCE: act = ap->x.rp->iRule + lemp->nstate;        break;
+    case REDUCE: act = ap->x.rp->iRule + lemp->nstate+lemp->nrule; break;
+    case ERROR:  act = lemp->nstate + lemp->nrule*2;               break;
+    case ACCEPT: act = lemp->nstate + lemp->nrule*2 + 1;           break;
+    default:     act = -1; break;
+  }
+  return act;
+}
+
+#define LINESIZE 1000
+/* The next cluster of routines are for reading the template file
+** and writing the results to the generated parser */
+/* The first function transfers data from "in" to "out" until
+** a line is seen which begins with "%%".  The line number is
+** tracked.
+**
+** if name!=0, then any word that begin with "Parse" is changed to
+** begin with *name instead.
+*/
+PRIVATE void tplt_xfer(char *name, FILE *in, FILE *out, int *lineno)
+{
+  int i, iStart;
+  char line[LINESIZE];
+  while( fgets(line,LINESIZE,in) && (line[0]!='%' || line[1]!='%') ){
+    (*lineno)++;
+    iStart = 0;
+    if( name ){
+      for(i=0; line[i]; i++){
+        if( line[i]=='P' && strncmp(&line[i],"Parse",5)==0
+          && (i==0 || !ISALPHA(line[i-1]))
+        ){
+          if( i>iStart ) fprintf(out,"%.*s",i-iStart,&line[iStart]);
+          fprintf(out,"%s",name);
+          i += 4;
+          iStart = i+1;
+        }
+      }
+    }
+    fprintf(out,"%s",&line[iStart]);
+  }
+}
+
+/* The next function finds the template file and opens it, returning
+** a pointer to the opened file. */
+PRIVATE FILE *tplt_open(struct lemon *lemp)
+{
+  static char templatename[] = "lempar.js";
+  char buf[1000];
+  FILE *in;
+  char *tpltname;
+  char *cp;
+
+  /* first, see if user specified a template filename on the command line. */
+  if (user_templatename != 0) {
+    if( access(user_templatename,004)==-1 ){
+      fprintf(stderr,"Can't find the parser driver template file \"%s\".\n",
+        user_templatename);
+      lemp->errorcnt++;
+      return 0;
+    }
+    in = fopen(user_templatename,"rb");
+    if( in==0 ){
+      fprintf(stderr,"Can't open the template file \"%s\".\n",
+              user_templatename);
+      lemp->errorcnt++;
+      return 0;
+    }
+    return in;
+  }
+
+  cp = strrchr(lemp->filename,'.');
+  if( cp ){
+    lemon_sprintf(buf,"%.*s.lt",(int)(cp-lemp->filename),lemp->filename);
+  }else{
+    lemon_sprintf(buf,"%s.lt",lemp->filename);
+  }
+  if( access(buf,004)==0 ){
+    tpltname = buf;
+  }else if( access(templatename,004)==0 ){
+    tpltname = templatename;
+  }else{
+    tpltname = pathsearch(lemp->argv0,templatename,0);
+  }
+  if( tpltname==0 ){
+    fprintf(stderr,"Can't find the parser driver template file \"%s\".\n",
+    templatename);
+    lemp->errorcnt++;
+    return 0;
+  }
+  in = fopen(tpltname,"rb");
+  if( in==0 ){
+    fprintf(stderr,"Can't open the template file \"%s\".\n",templatename);
+    lemp->errorcnt++;
+    return 0;
+  }
+  return in;
+}
+
+/* Print a #line directive line to the output file. */
+PRIVATE void tplt_linedir(FILE *out, int lineno, char *filename)
+{
+  fprintf(out,"// line %d \"",lineno);
+  while( *filename ){
+    if( *filename == '\\' ) putc('\\',out);
+    putc(*filename,out);
+    filename++;
+  }
+  fprintf(out,"\"\n");
+}
+
+/* Print a string to the file and keep the linenumber up to date */
+PRIVATE void tplt_print(FILE *out, struct lemon *lemp, char *str, int *lineno)
+{
+  if( str==0 ) return;
+  while( *str ){
+    putc(*str,out);
+    if( *str=='\n' ) (*lineno)++;
+    str++;
+  }
+  if( str[-1]!='\n' ){
+    putc('\n',out);
+    (*lineno)++;
+  }
+  if (!lemp->nolinenosflag) {
+    (*lineno)++; tplt_linedir(out,*lineno,lemp->outname);
+  }
+  return;
+}
+
+/*
+** The following routine emits code for the destructor for the
+** symbol sp
+*/
+void emit_destructor_code(
+  FILE *out,
+  struct symbol *sp,
+  struct lemon *lemp,
+  int *lineno
+){
+ char *cp = 0;
+
+ if( sp->type==TERMINAL ){
+   cp = lemp->tokendest;
+   if( cp==0 ) return;
+   fprintf(out,"{\n"); (*lineno)++;
+ }else if( sp->destructor ){
+   cp = sp->destructor;
+   fprintf(out,"{\n"); (*lineno)++;
+   if( !lemp->nolinenosflag ){
+     (*lineno)++;
+     tplt_linedir(out,sp->destLineno,lemp->filename);
+   }
+ }else if( lemp->vardest ){
+   cp = lemp->vardest;
+   if( cp==0 ) return;
+   fprintf(out,"{\n"); (*lineno)++;
+ }else{
+   assert( 0 );  /* Cannot happen */
+ }
+ for(; *cp; cp++){
+   if( *cp=='$' && cp[1]=='$' ){
+     fprintf(out,"(yypminor->yy%d)",sp->dtnum);
+     cp++;
+     continue;
+   }
+   if( *cp=='\n' ) (*lineno)++;
+   fputc(*cp,out);
+ }
+ fprintf(out,"\n"); (*lineno)++;
+ if (!lemp->nolinenosflag) {
+   (*lineno)++; tplt_linedir(out,*lineno,lemp->outname);
+ }
+ fprintf(out,"}\n"); (*lineno)++;
+ return;
+}
+
+/*
+** Return TRUE (non-zero) if the given symbol has a destructor.
+*/
+int has_destructor(struct symbol *sp, struct lemon *lemp)
+{
+  int ret;
+  if( sp->type==TERMINAL ){
+    ret = lemp->tokendest!=0;
+  }else{
+    ret = lemp->vardest!=0 || sp->destructor!=0;
+  }
+  return ret;
+}
+
+/*
+** Append text to a dynamically allocated string.  If zText is 0 then
+** reset the string to be empty again.  Always return the complete text
+** of the string (which is overwritten with each call).
+**
+** n bytes of zText are stored.  If n==0 then all of zText up to the first
+** \000 terminator is stored.  zText can contain up to two instances of
+** %d.  The values of p1 and p2 are written into the first and second
+** %d.
+**
+** If n==-1, then the previous character is overwritten.
+*/
+PRIVATE char *append_str(const char *zText, int n, int p1, int p2){
+  static char empty[1] = { 0 };
+  static char *z = 0;
+  static int alloced = 0;
+  static int used = 0;
+  int c;
+  char zInt[40];
+  if( zText==0 ){
+    if( used==0 && z!=0 ) z[0] = 0;
+    used = 0;
+    return z;
+  }
+  if( n<=0 ){
+    if( n<0 ){
+      used += n;
+      assert( used>=0 );
+    }
+    n = lemonStrlen(zText);
+  }
+  if( (int) (n+sizeof(zInt)*2+used) >= alloced ){
+    alloced = n + sizeof(zInt)*2 + used + 200;
+    z = (char *) realloc(z,  alloced);
+  }
+  if( z==0 ) return empty;
+  while( n-- > 0 ){
+    c = *(zText++);
+    if( c=='%' && n>0 && zText[0]=='d' ){
+      lemon_sprintf(zInt, "%d", p1);
+      p1 = p2;
+      lemon_strcpy(&z[used], zInt);
+      used += lemonStrlen(&z[used]);
+      zText++;
+      n--;
+    }else{
+      z[used++] = (char)c;
+    }
+  }
+  z[used] = 0;
+  return z;
+}
+
+/*
+** Write and transform the rp->code string so that symbols are expanded.
+** Populate the rp->codePrefix and rp->codeSuffix strings, as appropriate.
+**
+** Return 1 if the expanded code requires that "yylhsminor" local variable
+** to be defined.
+*/
+PRIVATE int translate_code(struct lemon *lemp, struct rule *rp){
+  char *cp, *xp;
+  int i;
+  int rc = 0;            /* True if yylhsminor is used */
+  int dontUseRhs0 = 0;   /* If true, use of left-most RHS label is illegal */
+  const char *zSkip = 0; /* The zOvwrt comment within rp->code, or NULL */
+  char lhsused = 0;      /* True if the LHS element has been used */
+  char lhsdirect;        /* True if LHS writes directly into stack */
+  char used[MAXRHS];     /* True for each RHS element which is used */
+  char zLhs[50];         /* Convert the LHS symbol into this string */
+  char zOvwrt[900];      /* Comment that to allow LHS to overwrite RHS */
+
+  for(i=0; i<rp->nrhs; i++) used[i] = 0;
+  lhsused = 0;
+
+  if( rp->code==0 ){
+    static char newlinestr[2] = { '\n', '\0' };
+    rp->code = newlinestr;
+    rp->line = rp->ruleline;
+    rp->noCode = 1;
+  }else{
+    rp->noCode = 0;
+  }
+
+
+  if( rp->nrhs==0 ){
+    /* If there are no RHS symbols, then writing directly to the LHS is ok */
+    lhsdirect = 1;
+  }else if( rp->rhsalias[0]==0 ){
+    /* The left-most RHS symbol has no value.  LHS direct is ok.  But
+    ** we have to call the distructor on the RHS symbol first. */
+    lhsdirect = 1;
+    if( has_destructor(rp->rhs[0],lemp) ){
+      append_str(0,0,0,0);
+      append_str("  this.yy_destructor(%d, this.yystack[this.yyidx + %d].minor);\n", 0,
+                 rp->rhs[0]->index,1-rp->nrhs);
+      rp->codePrefix = Strsafe(append_str(0,0,0,0));
+      rp->noCode = 0;
+    }
+  }else if( rp->lhsalias==0 ){
+    /* There is no LHS value symbol. */
+    lhsdirect = 1;
+  }else if( strcmp(rp->lhsalias,rp->rhsalias[0])==0 ){
+    /* The LHS symbol and the left-most RHS symbol are the same, so
+    ** direct writing is allowed */
+    lhsdirect = 1;
+    lhsused = 1;
+    used[0] = 1;
+    if( rp->lhs->dtnum!=rp->rhs[0]->dtnum ){
+      ErrorMsg(lemp->filename,rp->ruleline,
+        "%s(%s) and %s(%s) share the same label but have "
+        "different datatypes.",
+        rp->lhs->name, rp->lhsalias, rp->rhs[0]->name, rp->rhsalias[0]);
+      lemp->errorcnt++;
+    }
+  }else{
+    lemon_sprintf(zOvwrt, "/*%s-overwrites-%s*/",
+                  rp->lhsalias, rp->rhsalias[0]);
+    zSkip = strstr(rp->code, zOvwrt);
+    if( zSkip!=0 ){
+      /* The code contains a special comment that indicates that it is safe
+      ** for the LHS label to overwrite left-most RHS label. */
+      lhsdirect = 1;
+    }else{
+      lhsdirect = 0;
+    }
+  }
+  if( lhsdirect ){
+    sprintf(zLhs, "this.yystack[this.yyidx + %d].minor",1-rp->nrhs/*,rp->lhs->dtnum*/);
+  }else{
+    rc = 1;
+    sprintf(zLhs, "yylhsminor"/*,rp->lhs->dtnum*/);
+  }
+
+  append_str(0,0,0,0);
+
+  /* This const cast is wrong but harmless, if we're careful. */
+  for(cp=(char *)rp->code; *cp; cp++){
+    if( cp==zSkip ){
+      append_str(zOvwrt,0,0,0);
+      cp += lemonStrlen(zOvwrt)-1;
+      dontUseRhs0 = 1;
+      continue;
+    }
+    if( ISALPHA(*cp) && (cp==rp->code || (!ISALNUM(cp[-1]) && cp[-1]!='_')) ){
+      char saved;
+      for(xp= &cp[1]; ISALNUM(*xp) || *xp=='_'; xp++);
+      saved = *xp;
+      *xp = 0;
+      if( rp->lhsalias && strcmp(cp,rp->lhsalias)==0 ){
+        append_str(zLhs,0,0,0);
+        cp = xp;
+        lhsused = 1;
+      }else{
+        for(i=0; i<rp->nrhs; i++){
+          if( rp->rhsalias[i] && strcmp(cp,rp->rhsalias[i])==0 ){
+            if( i==0 && dontUseRhs0 ){
+              ErrorMsg(lemp->filename,rp->ruleline,
+                 "Label %s used after '%s'.",
+                 rp->rhsalias[0], zOvwrt);
+              lemp->errorcnt++;
+            }else if( cp!=rp->code && cp[-1]=='@' ){
+              /* If the argument is of the form @X then substituted
+              ** the token number of X, not the value of X */
+              append_str("this.yystack[this.yyidx + %d].major",-1,i-rp->nrhs+1,0);
+            }else{
+              struct symbol *sp = rp->rhs[i];
+              int dtnum;
+              if( sp->type==MULTITERMINAL ){
+                dtnum = sp->subsym[0]->dtnum;
+              }else{
+                dtnum = sp->dtnum;
+              }
+              append_str("this.yystack[this.yyidx + %d].minor",0,i-rp->nrhs+1, dtnum);
+            }
+            cp = xp;
+            used[i] = 1;
+            break;
+          }
+        }
+      }
+      *xp = saved;
+    }
+    append_str(cp, 1, 0, 0);
+  } /* End loop */
+
+  /* Main code generation completed */
+  cp = append_str(0,0,0,0);
+  if( cp && cp[0] ) rp->code = Strsafe(cp);
+  append_str(0,0,0,0);
+
+  /* Check to make sure the LHS has been used */
+  if( rp->lhsalias && !lhsused ){
+    ErrorMsg(lemp->filename,rp->ruleline,
+      "Label \"%s\" for \"%s(%s)\" is never used.",
+        rp->lhsalias,rp->lhs->name,rp->lhsalias);
+    lemp->errorcnt++;
+  }
+
+  /* Generate destructor code for RHS minor values which are not referenced.
+  ** Generate error messages for unused labels and duplicate labels.
+  */
+  for(i=0; i<rp->nrhs; i++){
+    if( rp->rhsalias[i] ){
+      if( i>0 ){
+        int j;
+        if( rp->lhsalias && strcmp(rp->lhsalias,rp->rhsalias[i])==0 ){
+          ErrorMsg(lemp->filename,rp->ruleline,
+            "%s(%s) has the same label as the LHS but is not the left-most "
+            "symbol on the RHS.",
+            rp->rhs[i]->name, rp->rhsalias);
+          lemp->errorcnt++;
+        }
+        for(j=0; j<i; j++){
+          if( rp->rhsalias[j] && strcmp(rp->rhsalias[j],rp->rhsalias[i])==0 ){
+            ErrorMsg(lemp->filename,rp->ruleline,
+              "Label %s used for multiple symbols on the RHS of a rule.",
+              rp->rhsalias[i]);
+            lemp->errorcnt++;
+            break;
+          }
+        }
+      }
+      if( !used[i] ){
+        ErrorMsg(lemp->filename,rp->ruleline,
+          "Label %s for \"%s(%s)\" is never used.",
+          rp->rhsalias[i],rp->rhs[i]->name,rp->rhsalias[i]);
+        lemp->errorcnt++;
+      }
+    }else if( i>0 && has_destructor(rp->rhs[i],lemp) ){
+      append_str("  this.yy_destructor(%d, this.yystack[this.yyidx + %d].minor);\n", 0,
+         rp->rhs[i]->index,i-rp->nrhs+1);
+    }
+  }
+
+  /* If unable to write LHS values directly into the stack, write the
+  ** saved LHS value now. */
+  if( lhsdirect==0 ){
+    append_str("  this.yystack[this.yyidx + %d].minor = ", 0, 1-rp->nrhs, rp->lhs->dtnum);
+    append_str(zLhs, 0, 0, 0);
+    append_str(";\n", 0, 0, 0);
+  }
+
+  /* Suffix code generation complete */
+  cp = append_str(0,0,0,0);
+  if( cp && cp[0] ){
+    rp->codeSuffix = Strsafe(cp);
+    rp->noCode = 0;
+  }
+
+  return rc;
+}
+
+/*
+** Generate code which executes when the rule "rp" is reduced.  Write
+** the code to "out".  Make sure lineno stays up-to-date.
+*/
+PRIVATE void emit_code(
+  FILE *out,
+  struct rule *rp,
+  struct lemon *lemp,
+  int *lineno
+){
+ const char *cp;
+
+ /* Setup code prior to the #line directive */
+ if( rp->codePrefix && rp->codePrefix[0] ){
+   fprintf(out, "{%s", rp->codePrefix);
+   for(cp=rp->codePrefix; *cp; cp++){ if( *cp=='\n' ) (*lineno)++; }
+ }
+
+ /* Generate code to do the reduce action */
+ if( rp->code ){
+   if( !lemp->nolinenosflag ){
+     (*lineno)++;
+     tplt_linedir(out,rp->line,lemp->filename);
+   }
+   fprintf(out,"{%s",rp->code);
+   for(cp=rp->code; *cp; cp++){ if( *cp=='\n' ) (*lineno)++; }
+   fprintf(out,"}\n"); (*lineno)++;
+   if( !lemp->nolinenosflag ){
+     (*lineno)++;
+     tplt_linedir(out,*lineno,lemp->outname);
+   }
+ }
+
+ /* Generate breakdown code that occurs after the #line directive */
+ if( rp->codeSuffix && rp->codeSuffix[0] ){
+   fprintf(out, "%s", rp->codeSuffix);
+   for(cp=rp->codeSuffix; *cp; cp++){ if( *cp=='\n' ) (*lineno)++; }
+ }
+
+ if( rp->codePrefix ){
+   fprintf(out, "}\n"); (*lineno)++;
+ }
+
+ return;
+}
+
+/*
+** Print the definition of the union used for the parser's data stack.
+** This union contains fields for every possible data type for tokens
+** and nonterminals.  In the process of computing and printing this
+** union, also set the ".dtnum" field of every terminal and nonterminal
+** symbol.
+*/
+void print_stack_union(
+  FILE *out,                  /* The output stream */
+  struct lemon *lemp,         /* The main info structure for this parser */
+  int *plineno,               /* Pointer to the line number */
+  int mhflag                  /* True if generating makeheaders output */
+){
+  int lineno = *plineno;    /* The line number of the output */
+  char **types;             /* A hash table of datatypes */
+  int arraysize;            /* Size of the "types" array */
+  int maxdtlength;          /* Maximum length of any ".datatype" field. */
+  char *stddt;              /* Standardized name for a datatype */
+  int i,j;                  /* Loop counters */
+  unsigned hash;            /* For hashing the name of a type */
+  const char *name;         /* Name of the parser */
+
+  /* Allocate and initialize types[] and allocate stddt[] */
+  arraysize = lemp->nsymbol * 2;
+  types = (char**)calloc( arraysize, sizeof(char*) );
+  if( types==0 ){
+    fprintf(stderr,"Out of memory.\n");
+    exit(1);
+  }
+  for(i=0; i<arraysize; i++) types[i] = 0;
+  maxdtlength = 0;
+  if( lemp->vartype ){
+    maxdtlength = lemonStrlen(lemp->vartype);
+  }
+  for(i=0; i<lemp->nsymbol; i++){
+    int len;
+    struct symbol *sp = lemp->symbols[i];
+    if( sp->datatype==0 ) continue;
+    len = lemonStrlen(sp->datatype);
+    if( len>maxdtlength ) maxdtlength = len;
+  }
+  stddt = (char*)malloc( maxdtlength*2 + 1 );
+  if( stddt==0 ){
+    fprintf(stderr,"Out of memory.\n");
+    exit(1);
+  }
+
+  /* Build a hash table of datatypes. The ".dtnum" field of each symbol
+  ** is filled in with the hash index plus 1.  A ".dtnum" value of 0 is
+  ** used for terminal symbols.  If there is no %default_type defined then
+  ** 0 is also used as the .dtnum value for nonterminals which do not specify
+  ** a datatype using the %type directive.
+  */
+  for(i=0; i<lemp->nsymbol; i++){
+    struct symbol *sp = lemp->symbols[i];
+    char *cp;
+    if( sp==lemp->errsym ){
+      sp->dtnum = arraysize+1;
+      continue;
+    }
+    if( sp->type!=NONTERMINAL || (sp->datatype==0 && lemp->vartype==0) ){
+      sp->dtnum = 0;
+      continue;
+    }
+    cp = sp->datatype;
+    if( cp==0 ) cp = lemp->vartype;
+    j = 0;
+    while( ISSPACE(*cp) ) cp++;
+    while( *cp ) stddt[j++] = *cp++;
+    while( j>0 && ISSPACE(stddt[j-1]) ) j--;
+    stddt[j] = 0;
+    if( lemp->tokentype && strcmp(stddt, lemp->tokentype)==0 ){
+      sp->dtnum = 0;
+      continue;
+    }
+    hash = 0;
+    for(j=0; stddt[j]; j++){
+      hash = hash*53 + stddt[j];
+    }
+    hash = (hash & 0x7fffffff)%arraysize;
+    while( types[hash] ){
+      if( strcmp(types[hash],stddt)==0 ){
+        sp->dtnum = hash + 1;
+        break;
+      }
+      hash++;
+      if( hash>=(unsigned)arraysize ) hash = 0;
+    }
+    if( types[hash]==0 ){
+      sp->dtnum = hash + 1;
+      types[hash] = (char*)malloc( lemonStrlen(stddt)+1 );
+      if( types[hash]==0 ){
+        fprintf(stderr,"Out of memory.\n");
+        exit(1);
+      }
+      lemon_strcpy(types[hash],stddt);
+    }
+  }
+
+  /* Print out the definition of YYTOKENTYPE and YYMINORTYPE */
+  /*
+  name = lemp->name ? lemp->name : "Parse";
+  lineno = *plineno;
+  if( mhflag ){ fprintf(out,"#if INTERFACE\n"); lineno++; }
+  fprintf(out,"#define %sTOKENTYPE %s\n",name,
+    lemp->tokentype?lemp->tokentype:"void*");  lineno++;
+  if( mhflag ){ fprintf(out,"#endif\n"); lineno++; }
+  fprintf(out,"typedef union {\n"); lineno++;
+  fprintf(out,"  int yyinit;\n"); lineno++;
+  fprintf(out,"  %sTOKENTYPE yy0;\n",name); lineno++;
+  for(i=0; i<arraysize; i++){
+    if( types[i]==0 ) continue;
+    fprintf(out,"  %s yy%d;\n",types[i],i+1); lineno++;
+    free(types[i]);
+  }
+  if( lemp->errsym->useCnt ){
+    fprintf(out,"  int yy%d;\n",lemp->errsym->dtnum); lineno++;
+  }
+  free(stddt);
+  free(types);
+  fprintf(out,"} YYMINORTYPE;\n"); lineno++;
+  *plineno = lineno;
+  */
+}
+
+/*
+** Return the name of a C datatype able to represent values between
+** lwr and upr, inclusive.  If pnByte!=NULL then also write the sizeof
+** for that type (1, 2, or 4) into *pnByte.
+*/
+static const char *minimum_size_type(int lwr, int upr, int *pnByte){
+  const char *zType = "int";
+  int nByte = 4;
+  if( lwr>=0 ){
+    if( upr<=255 ){
+      zType = "unsigned char";
+      nByte = 1;
+    }else if( upr<65535 ){
+      zType = "unsigned short int";
+      nByte = 2;
+    }else{
+      zType = "unsigned int";
+      nByte = 4;
+    }
+  }else if( lwr>=-127 && upr<=127 ){
+    zType = "signed char";
+    nByte = 1;
+  }else if( lwr>=-32767 && upr<32767 ){
+    zType = "short";
+    nByte = 2;
+  }
+  if( pnByte ) *pnByte = nByte;
+  return zType;
+}
+
+/*
+** Each state contains a set of token transaction and a set of
+** nonterminal transactions.  Each of these sets makes an instance
+** of the following structure.  An array of these structures is used
+** to order the creation of entries in the yy_action[] table.
+*/
+struct axset {
+  struct state *stp;   /* A pointer to a state */
+  int isTkn;           /* True to use tokens.  False for non-terminals */
+  int nAction;         /* Number of actions */
+  int iOrder;          /* Original order of action sets */
+};
+
+/*
+** Compare to axset structures for sorting purposes
+*/
+static int axset_compare(const void *a, const void *b){
+  struct axset *p1 = (struct axset*)a;
+  struct axset *p2 = (struct axset*)b;
+  int c;
+  c = p2->nAction - p1->nAction;
+  if( c==0 ){
+    c = p1->iOrder - p2->iOrder;
+  }
+  assert( c!=0 || p1==p2 );
+  return c;
+}
+
+/*
+** Write text on "out" that describes the rule "rp".
+*/
+static void writeRuleText(FILE *out, struct rule *rp){
+  int j;
+  fprintf(out,"%s ::=", rp->lhs->name);
+  for(j=0; j<rp->nrhs; j++){
+    struct symbol *sp = rp->rhs[j];
+    if( sp->type!=MULTITERMINAL ){
+      fprintf(out," %s", sp->name);
+    }else{
+      int k;
+      fprintf(out," %s", sp->subsym[0]->name);
+      for(k=1; k<sp->nsubsym; k++){
+        fprintf(out,"|%s",sp->subsym[k]->name);
+      }
+    }
+  }
+}
+
+
+/* Generate C source code for the parser */
+void ReportTable(
+  struct lemon *lemp,
+  int mhflag     /* Output in makeheaders format if true */
+){
+  FILE *out, *in;
+  char line[LINESIZE];
+  int  lineno;
+  struct state *stp;
+  struct action *ap;
+  struct rule *rp;
+  struct acttab *pActtab;
+  int i, j, n, sz;
+  int szActionType;     /* sizeof(YYACTIONTYPE) */
+  int szCodeType;       /* sizeof(YYCODETYPE)   */
+  const char *name;
+  int mnTknOfst, mxTknOfst;
+  int mnNtOfst, mxNtOfst;
+  struct axset *ax;
+
+  in = tplt_open(lemp);
+  if( in==0 ) return;
+  out = file_open(lemp,".js","wb");
+  if( out==0 ){
+    fclose(in);
+    return;
+  }
+  lineno = 1;
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate the include code, if any */
+  tplt_print(out,lemp,lemp->include,&lineno);
+  /*
+  if( mhflag ){
+    char *incName = file_makename(lemp, ".h");
+    fprintf(out,"#include \"%s\"\n", incName); lineno++;
+    free(incName);
+  }
+  */
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate #defines for all tokens */
+  //if( mhflag ){
+    const char *prefix;
+    //fprintf(out,"#if INTERFACE\n"); lineno++;
+    if( lemp->tokenprefix ) prefix = lemp->tokenprefix;
+    else                    prefix = "";
+    for(i=1; i<lemp->nterminal; i++){
+      fprintf(out,"this.%s%-30s = %2d;\n",prefix,lemp->symbols[i]->name,i);
+      lineno++;
+    }
+    //fprintf(out,"#endif\n"); lineno++;
+  //}
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate the defines */
+  //fprintf(out,"#define YYCODETYPE %s\n",
+  //  minimum_size_type(0, lemp->nsymbol+1, &szCodeType)); lineno++;
+  fprintf(out,"this.YYNOCODE = %d;\n",lemp->nsymbol+1);  lineno++;
+  //fprintf(out,"#define YYACTIONTYPE %s\n",
+  //  minimum_size_type(0,lemp->nstate+lemp->nrule*2+5,&szActionType)); lineno++;
+  if( lemp->wildcard ){
+    fprintf(out,"this.YYWILDCARD = %d;\n",
+       lemp->wildcard->index); lineno++;
+  }
+  print_stack_union(out,lemp,&lineno,mhflag);
+  //fprintf(out, "#ifndef YYSTACKDEPTH\n"); lineno++;
+  if( lemp->stacksize ){
+    fprintf(out,"this.YYSTACKDEPTH = %s;\n",lemp->stacksize);  lineno++;
+  }else{
+    fprintf(out,"this.YYSTACKDEPTH = 100;\n");  lineno++;
+  }
+  //fprintf(out, "#endif\n"); lineno++;
+  /*
+  if( mhflag ){
+    fprintf(out,"#if INTERFACE\n"); lineno++;
+  }
+  name = lemp->name ? lemp->name : "Parse";
+  if( lemp->arg && lemp->arg[0] ){
+    i = lemonStrlen(lemp->arg);
+    while( i>=1 && ISSPACE(lemp->arg[i-1]) ) i--;
+    while( i>=1 && (ISALNUM(lemp->arg[i-1]) || lemp->arg[i-1]=='_') ) i--;
+    fprintf(out,"#define %sARG_SDECL %s;\n",name,lemp->arg);  lineno++;
+    fprintf(out,"#define %sARG_PDECL ,%s\n",name,lemp->arg);  lineno++;
+    fprintf(out,"#define %sARG_FETCH %s = yypParser->%s\n",
+                 name,lemp->arg,&lemp->arg[i]);  lineno++;
+    fprintf(out,"#define %sARG_STORE yypParser->%s = %s\n",
+                 name,&lemp->arg[i],&lemp->arg[i]);  lineno++;
+  }else{
+    fprintf(out,"#define %sARG_SDECL\n",name);  lineno++;
+    fprintf(out,"#define %sARG_PDECL\n",name);  lineno++;
+    fprintf(out,"#define %sARG_FETCH\n",name); lineno++;
+    fprintf(out,"#define %sARG_STORE\n",name); lineno++;
+  }
+  if( mhflag ){
+    fprintf(out,"#endif\n"); lineno++;
+  }
+  */
+  if( lemp->errsym->useCnt ){
+    fprintf(out,"this.YYERRORSYMBOL = %d;\n",lemp->errsym->index); lineno++;
+    // fprintf(out,"#define YYERRSYMDT yy%d\n",lemp->errsym->dtnum); lineno++;
+  }
+  fprintf(out,"this.YYFALLBACK = %s;\n", lemp->has_fallback ? "true" : "false");  lineno++;
+
+  /* Compute the action table, but do not output it yet.  The action
+  ** table must be computed before generating the YYNSTATE macro because
+  ** we need to know how many states can be eliminated.
+  */
+  ax = (struct axset *) calloc(lemp->nxstate*2, sizeof(ax[0]));
+  if( ax==0 ){
+    fprintf(stderr,"malloc failed\n");
+    exit(1);
+  }
+  for(i=0; i<lemp->nxstate; i++){
+    stp = lemp->sorted[i];
+    ax[i*2].stp = stp;
+    ax[i*2].isTkn = 1;
+    ax[i*2].nAction = stp->nTknAct;
+    ax[i*2+1].stp = stp;
+    ax[i*2+1].isTkn = 0;
+    ax[i*2+1].nAction = stp->nNtAct;
+  }
+  mxTknOfst = mnTknOfst = 0;
+  mxNtOfst = mnNtOfst = 0;
+  /* In an effort to minimize the action table size, use the heuristic
+  ** of placing the largest action sets first */
+  for(i=0; i<lemp->nxstate*2; i++) ax[i].iOrder = i;
+  qsort(ax, lemp->nxstate*2, sizeof(ax[0]), axset_compare);
+  pActtab = acttab_alloc();
+  for(i=0; i<lemp->nxstate*2 && ax[i].nAction>0; i++){
+    stp = ax[i].stp;
+    if( ax[i].isTkn ){
+      for(ap=stp->ap; ap; ap=ap->next){
+        int action;
+        if( ap->sp->index>=lemp->nterminal ) continue;
+        action = compute_action(lemp, ap);
+        if( action<0 ) continue;
+        acttab_action(pActtab, ap->sp->index, action);
+      }
+      stp->iTknOfst = acttab_insert(pActtab);
+      if( stp->iTknOfst<mnTknOfst ) mnTknOfst = stp->iTknOfst;
+      if( stp->iTknOfst>mxTknOfst ) mxTknOfst = stp->iTknOfst;
+    }else{
+      for(ap=stp->ap; ap; ap=ap->next){
+        int action;
+        if( ap->sp->index<lemp->nterminal ) continue;
+        if( ap->sp->index==lemp->nsymbol ) continue;
+        action = compute_action(lemp, ap);
+        if( action<0 ) continue;
+        acttab_action(pActtab, ap->sp->index, action);
+      }
+      stp->iNtOfst = acttab_insert(pActtab);
+      if( stp->iNtOfst<mnNtOfst ) mnNtOfst = stp->iNtOfst;
+      if( stp->iNtOfst>mxNtOfst ) mxNtOfst = stp->iNtOfst;
+    }
+#if 0  /* Uncomment for a trace of how the yy_action[] table fills out */
+    { int jj, nn;
+      for(jj=nn=0; jj<pActtab->nAction; jj++){
+        if( pActtab->aAction[jj].action<0 ) nn++;
+      }
+      printf("%4d: State %3d %s n: %2d size: %5d freespace: %d\n",
+             i, stp->statenum, ax[i].isTkn ? "Token" : "Var  ",
+             ax[i].nAction, pActtab->nAction, nn);
+    }
+#endif
+  }
+  free(ax);
+
+  /* Mark rules that are actually used for reduce actions after all
+  ** optimizations have been applied
+  */
+  for(rp=lemp->rule; rp; rp=rp->next) rp->doesReduce = LEMON_FALSE;
+  for(i=0; i<lemp->nxstate; i++){
+    for(ap=lemp->sorted[i]->ap; ap; ap=ap->next){
+      if( ap->type==REDUCE || ap->type==SHIFTREDUCE ){
+        ap->x.rp->doesReduce = i;
+      }
+    }
+  }
+
+  /* Finish rendering the constants now that the action table has
+  ** been computed */
+  fprintf(out,"this.YYNSTATE            = %d;\n",lemp->nxstate);  lineno++;
+  fprintf(out,"this.YYNRULE             = %d;\n",lemp->nrule);  lineno++;
+  fprintf(out,"this.YY_MAX_SHIFT        = %d;\n",lemp->nxstate-1); lineno++;
+  fprintf(out,"this.YY_MIN_SHIFTREDUCE  = %d;\n",lemp->nstate); lineno++;
+  i = lemp->nstate + lemp->nrule;
+  fprintf(out,"this.YY_MAX_SHIFTREDUCE  = %d;\n", i-1); lineno++;
+  fprintf(out,"this.YY_MIN_REDUCE       = %d;\n", i); lineno++;
+  i = lemp->nstate + lemp->nrule*2;
+  fprintf(out,"this.YY_MAX_REDUCE       = %d;\n", i-1); lineno++;
+  fprintf(out,"this.YY_ERROR_ACTION     = %d;\n", i); lineno++;
+  fprintf(out,"this.YY_ACCEPT_ACTION    = %d;\n", i+1); lineno++;
+  fprintf(out,"this.YY_NO_ACTION        = %d;\n", i+2); lineno++;
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Now output the action table and its associates:
+  **
+  **  yy_action[]        A single table containing all actions.
+  **  yy_lookahead[]     A table containing the lookahead for each entry in
+  **                     yy_action.  Used to detect hash collisions.
+  **  yy_shift_ofst[]    For each state, the offset into yy_action for
+  **                     shifting terminals.
+  **  yy_reduce_ofst[]   For each state, the offset into yy_action for
+  **                     shifting non-terminals after a reduce.
+  **  yy_default[]       Default action for each state.
+  */
+
+  /* Output the yy_action table */
+  lemp->nactiontab = n = acttab_size(pActtab);
+  lemp->tablesize += n*szActionType;
+  fprintf(out,"this.yy_action = [\n"); lineno++;
+  for(i=j=0; i<n; i++){
+    int action = acttab_yyaction(pActtab, i);
+    if( action<0 ) action = lemp->nstate + lemp->nrule + 2;
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", action);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "];\n"); lineno++;
+
+  /* Output the yy_lookahead table */
+  lemp->tablesize += n*szCodeType;
+  fprintf(out,"this.yy_lookahead = [\n"); lineno++;
+  for(i=j=0; i<n; i++){
+    int la = acttab_yylookahead(pActtab, i);
+    if( la<0 ) la = lemp->nsymbol;
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", la);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "];\n"); lineno++;
+
+  /* Output the yy_shift_ofst[] table */
+  n = lemp->nxstate;
+  while( n>0 && lemp->sorted[n-1]->iTknOfst==NO_OFFSET ) n--;
+  fprintf(out, "this.YY_SHIFT_USE_DFLT = %d;\n", lemp->nactiontab); lineno++;
+  fprintf(out, "this.YY_SHIFT_COUNT    = %d;\n", n-1); lineno++;
+  fprintf(out, "this.YY_SHIFT_MIN      = %d;\n", mnTknOfst); lineno++;
+  fprintf(out, "this.YY_SHIFT_MAX      = %d;\n", mxTknOfst); lineno++;
+  fprintf(out, "this.yy_shift_ofst = [\n"/*,
+       minimum_size_type(mnTknOfst, lemp->nterminal+lemp->nactiontab, &sz)*/);
+       lineno++;
+  lemp->tablesize += n*sz;
+  for(i=j=0; i<n; i++){
+    int ofst;
+    stp = lemp->sorted[i];
+    ofst = stp->iTknOfst;
+    if( ofst==NO_OFFSET ) ofst = lemp->nactiontab;
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", ofst);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "];\n"); lineno++;
+
+  /* Output the yy_reduce_ofst[] table */
+  fprintf(out, "this.YY_REDUCE_USE_DFLT = %d;\n", mnNtOfst-1); lineno++;
+  n = lemp->nxstate;
+  while( n>0 && lemp->sorted[n-1]->iNtOfst==NO_OFFSET ) n--;
+  fprintf(out, "this.YY_REDUCE_COUNT = %d;\n", n-1); lineno++;
+  fprintf(out, "this.YY_REDUCE_MIN   = %d;\n", mnNtOfst); lineno++;
+  fprintf(out, "this.YY_REDUCE_MAX   = %d;\n", mxNtOfst); lineno++;
+  fprintf(out, "this.yy_reduce_ofst = [\n"/*,
+          minimum_size_type(mnNtOfst-1, mxNtOfst, &sz)*/); lineno++;
+  lemp->tablesize += n*sz;
+  for(i=j=0; i<n; i++){
+    int ofst;
+    stp = lemp->sorted[i];
+    ofst = stp->iNtOfst;
+    if( ofst==NO_OFFSET ) ofst = mnNtOfst - 1;
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", ofst);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "];\n"); lineno++;
+
+  /* Output the default action table */
+  fprintf(out, "this.yy_default = [\n"); lineno++;
+  n = lemp->nxstate;
+  lemp->tablesize += n*szActionType;
+  for(i=j=0; i<n; i++){
+    stp = lemp->sorted[i];
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", stp->iDfltReduce+lemp->nstate+lemp->nrule);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "];\n"); lineno++;
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate the table of fallback tokens.
+  */
+  if( lemp->has_fallback ){
+    int mx = lemp->nterminal - 1;
+    while( mx>0 && lemp->symbols[mx]->fallback==0 ){ mx--; }
+    lemp->tablesize += (mx+1)*szCodeType;
+    for(i=0; i<=mx; i++){
+      struct symbol *p = lemp->symbols[i];
+      if( p->fallback==0 ){
+        fprintf(out, "    0,  /* %10s => nothing */\n", p->name);
+      }else{
+        fprintf(out, "  %3d,  /* %10s => %s */\n", p->fallback->index,
+          p->name, p->fallback->name);
+      }
+      lineno++;
+    }
+  }
+  tplt_xfer(lemp->name, in, out, &lineno);
+
+  /* Generate a table containing the symbolic name of every symbol
+  */
+  for(i=0; i<lemp->nsymbol; i++){
+    lemon_sprintf(line,"\"%s\",",lemp->symbols[i]->name);
+    fprintf(out,"  %-15s",line);
+    if( (i&3)==3 ){ fprintf(out,"\n"); lineno++; }
+  }
+  if( (i&3)!=0 ){ fprintf(out,"\n"); lineno++; }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate a table containing a text string that describes every
+  ** rule in the rule set of the grammar.  This information is used
+  ** when tracing REDUCE actions.
+  */
+  for(i=0, rp=lemp->rule; rp; rp=rp->next, i++){
+    assert( rp->iRule==i );
+    fprintf(out," /* %3d */ \"", i);
+    writeRuleText(out, rp);
+    fprintf(out,"\",\n"); lineno++;
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes every time a symbol is popped from
+  ** the stack while processing errors or while destroying the parser.
+  ** (In other words, generate the %destructor actions)
+  */
+  if( lemp->tokendest ){
+    int once = 1;
+    for(i=0; i<lemp->nsymbol; i++){
+      struct symbol *sp = lemp->symbols[i];
+      if( sp==0 || sp->type!=TERMINAL ) continue;
+      if( once ){
+        fprintf(out, "      /* TERMINAL Destructor */\n"); lineno++;
+        once = 0;
+      }
+      fprintf(out,"    case %d: /* %s */\n", sp->index, sp->name); lineno++;
+    }
+    for(i=0; i<lemp->nsymbol && lemp->symbols[i]->type!=TERMINAL; i++);
+    if( i<lemp->nsymbol ){
+      emit_destructor_code(out,lemp->symbols[i],lemp,&lineno);
+      fprintf(out,"      break;\n"); lineno++;
+    }
+  }
+  if( lemp->vardest ){
+    struct symbol *dflt_sp = 0;
+    int once = 1;
+    for(i=0; i<lemp->nsymbol; i++){
+      struct symbol *sp = lemp->symbols[i];
+      if( sp==0 || sp->type==TERMINAL ||
+          sp->index<=0 || sp->destructor!=0 ) continue;
+      if( once ){
+        fprintf(out, "      /* Default NON-TERMINAL Destructor */\n"); lineno++;
+        once = 0;
+      }
+      fprintf(out,"    case %d: /* %s */\n", sp->index, sp->name); lineno++;
+      dflt_sp = sp;
+    }
+    if( dflt_sp!=0 ){
+      emit_destructor_code(out,dflt_sp,lemp,&lineno);
+    }
+    fprintf(out,"      break;\n"); lineno++;
+  }
+  for(i=0; i<lemp->nsymbol; i++){
+    struct symbol *sp = lemp->symbols[i];
+    if( sp==0 || sp->type==TERMINAL || sp->destructor==0 ) continue;
+    if( sp->destLineno<0 ) continue;  /* Already emitted */
+    fprintf(out,"    case %d: /* %s */\n", sp->index, sp->name); lineno++;
+
+    /* Combine duplicate destructors into a single case */
+    for(j=i+1; j<lemp->nsymbol; j++){
+      struct symbol *sp2 = lemp->symbols[j];
+      if( sp2 && sp2->type!=TERMINAL && sp2->destructor
+          && sp2->dtnum==sp->dtnum
+          && strcmp(sp->destructor,sp2->destructor)==0 ){
+         fprintf(out,"    case %d: /* %s */\n",
+                 sp2->index, sp2->name); lineno++;
+         sp2->destLineno = -1;  /* Avoid emitting this destructor again */
+      }
+    }
+
+    emit_destructor_code(out,lemp->symbols[i],lemp,&lineno);
+    fprintf(out,"      break;\n"); lineno++;
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes whenever the parser stack overflows */
+  tplt_print(out,lemp,lemp->overflow,&lineno);
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate the table of rule information
+  **
+  ** Note: This code depends on the fact that rules are number
+  ** sequentually beginning with 0.
+  */
+  for(rp=lemp->rule; rp; rp=rp->next){
+    fprintf(out,"  { lhs: %d, nrhs: %d },\n",rp->lhs->index,rp->nrhs); lineno++;
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which execution during each REDUCE action */
+  i = 0;
+  for(rp=lemp->rule; rp; rp=rp->next){
+    i += translate_code(lemp, rp);
+  }
+  //if( i ){
+  //  fprintf(out,"        var yylhsminor;\n"); lineno++;
+  //}
+  /* First output rules other than the default: rule */
+  for(rp=lemp->rule; rp; rp=rp->next){
+    struct rule *rp2;               /* Other rules with the same action */
+    if( rp->codeEmitted ) continue;
+    if( rp->noCode ){
+      /* No C code actions, so this will be part of the "default:" rule */
+      continue;
+    }
+    fprintf(out,"      case %d: /* ", rp->iRule);
+    writeRuleText(out, rp);
+    fprintf(out, " */\n"); lineno++;
+    for(rp2=rp->next; rp2; rp2=rp2->next){
+      if( rp2->code==rp->code && rp2->codePrefix==rp->codePrefix
+             && rp2->codeSuffix==rp->codeSuffix ){
+        fprintf(out,"      case %d: /* ", rp2->iRule);
+        writeRuleText(out, rp2);
+        fprintf(out," */ this.yytestcase(yyruleno==%d);\n", rp2->iRule); lineno++;
+        rp2->codeEmitted = 1;
+      }
+    }
+    emit_code(out,rp,lemp,&lineno);
+    fprintf(out,"        break;\n"); lineno++;
+    rp->codeEmitted = 1;
+  }
+  /* Finally, output the default: rule.  We choose as the default: all
+  ** empty actions. */
+  fprintf(out,"      default:\n"); lineno++;
+  for(rp=lemp->rule; rp; rp=rp->next){
+    if( rp->codeEmitted ) continue;
+    assert( rp->noCode );
+    fprintf(out,"      /* (%d) ", rp->iRule);
+    writeRuleText(out, rp);
+    if( rp->doesReduce ){
+      fprintf(out, " */ this.yytestcase(yyruleno==%d);\n", rp->iRule); lineno++;
+    }else{
+      fprintf(out, " (OPTIMIZED OUT) */ assert(yyruleno!=%d);\n",
+              rp->iRule); lineno++;
+    }
+  }
+  fprintf(out,"        break;\n"); lineno++;
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes if a parse fails */
+  tplt_print(out,lemp,lemp->failure,&lineno);
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes when a syntax error occurs */
+  tplt_print(out,lemp,lemp->error,&lineno);
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes when the parser accepts its input */
+  tplt_print(out,lemp,lemp->accept,&lineno);
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Append any addition code the user desires */
+  tplt_print(out,lemp,lemp->extracode,&lineno);
+
+  fclose(in);
+  fclose(out);
+  return;
+}
+
+/* Generate a header file for the parser */
+void ReportHeader(struct lemon *lemp)
+{
+  FILE *out, *in;
+  const char *prefix;
+  char line[LINESIZE];
+  char pattern[LINESIZE];
+  int i;
+
+  if( lemp->tokenprefix ) prefix = lemp->tokenprefix;
+  else                    prefix = "";
+  in = file_open(lemp,".h","rb");
+  if( in ){
+    int nextChar;
+    for(i=1; i<lemp->nterminal && fgets(line,LINESIZE,in); i++){
+      lemon_sprintf(pattern,"#define %s%-30s %3d\n",
+                    prefix,lemp->symbols[i]->name,i);
+      if( strcmp(line,pattern) ) break;
+    }
+    nextChar = fgetc(in);
+    fclose(in);
+    if( i==lemp->nterminal && nextChar==EOF ){
+      /* No change in the file.  Don't rewrite it. */
+      return;
+    }
+  }
+  out = file_open(lemp,".h","wb");
+  if( out ){
+    for(i=1; i<lemp->nterminal; i++){
+      fprintf(out,"#define %s%-30s %3d\n",prefix,lemp->symbols[i]->name,i);
+    }
+    fclose(out);
+  }
+  return;
+}
+
+/* Reduce the size of the action tables, if possible, by making use
+** of defaults.
+**
+** In this version, we take the most frequent REDUCE action and make
+** it the default.  Except, there is no default if the wildcard token
+** is a possible look-ahead.
+*/
+void CompressTables(struct lemon *lemp)
+{
+  struct state *stp;
+  struct action *ap, *ap2, *nextap;
+  struct rule *rp, *rp2, *rbest;
+  int nbest, n;
+  int i;
+  int usesWildcard;
+
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    nbest = 0;
+    rbest = 0;
+    usesWildcard = 0;
+
+    for(ap=stp->ap; ap; ap=ap->next){
+      if( ap->type==SHIFT && ap->sp==lemp->wildcard ){
+        usesWildcard = 1;
+      }
+      if( ap->type!=REDUCE ) continue;
+      rp = ap->x.rp;
+      if( rp->lhsStart ) continue;
+      if( rp==rbest ) continue;
+      n = 1;
+      for(ap2=ap->next; ap2; ap2=ap2->next){
+        if( ap2->type!=REDUCE ) continue;
+        rp2 = ap2->x.rp;
+        if( rp2==rbest ) continue;
+        if( rp2==rp ) n++;
+      }
+      if( n>nbest ){
+        nbest = n;
+        rbest = rp;
+      }
+    }
+
+    /* Do not make a default if the number of rules to default
+    ** is not at least 1 or if the wildcard token is a possible
+    ** lookahead.
+    */
+    if( nbest<1 || usesWildcard ) continue;
+
+
+    /* Combine matching REDUCE actions into a single default */
+    for(ap=stp->ap; ap; ap=ap->next){
+      if( ap->type==REDUCE && ap->x.rp==rbest ) break;
+    }
+    assert( ap );
+    ap->sp = Symbol_new("{default}");
+    for(ap=ap->next; ap; ap=ap->next){
+      if( ap->type==REDUCE && ap->x.rp==rbest ) ap->type = NOT_USED;
+    }
+    stp->ap = Action_sort(stp->ap);
+
+    for(ap=stp->ap; ap; ap=ap->next){
+      if( ap->type==SHIFT ) break;
+      if( ap->type==REDUCE && ap->x.rp!=rbest ) break;
+    }
+    if( ap==0 ){
+      stp->autoReduce = 1;
+      stp->pDfltReduce = rbest;
+    }
+  }
+
+  /* Make a second pass over all states and actions.  Convert
+  ** every action that is a SHIFT to an autoReduce state into
+  ** a SHIFTREDUCE action.
+  */
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    for(ap=stp->ap; ap; ap=ap->next){
+      struct state *pNextState;
+      if( ap->type!=SHIFT ) continue;
+      pNextState = ap->x.stp;
+      if( pNextState->autoReduce && pNextState->pDfltReduce!=0 ){
+        ap->type = SHIFTREDUCE;
+        ap->x.rp = pNextState->pDfltReduce;
+      }
+    }
+  }
+
+  /* If a SHIFTREDUCE action specifies a rule that has a single RHS term
+  ** (meaning that the SHIFTREDUCE will land back in the state where it
+  ** started) and if there is no C-code associated with the reduce action,
+  ** then we can go ahead and convert the action to be the same as the
+  ** action for the RHS of the rule.
+  */
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    for(ap=stp->ap; ap; ap=nextap){
+      nextap = ap->next;
+      if( ap->type!=SHIFTREDUCE ) continue;
+      rp = ap->x.rp;
+      if( rp->noCode==0 ) continue;
+      if( rp->nrhs!=1 ) continue;
+#if 1
+      /* Only apply this optimization to non-terminals.  It would be OK to
+      ** apply it to terminal symbols too, but that makes the parser tables
+      ** larger. */
+      if( ap->sp->index<lemp->nterminal ) continue;
+#endif
+      /* If we reach this point, it means the optimization can be applied */
+      nextap = ap;
+      for(ap2=stp->ap; ap2 && (ap2==ap || ap2->sp!=rp->lhs); ap2=ap2->next){}
+      assert( ap2!=0 );
+      ap->spOpt = ap2->sp;
+      ap->type = ap2->type;
+      ap->x = ap2->x;
+    }
+  }
+}
+
+
+/*
+** Compare two states for sorting purposes.  The smaller state is the
+** one with the most non-terminal actions.  If they have the same number
+** of non-terminal actions, then the smaller is the one with the most
+** token actions.
+*/
+static int stateResortCompare(const void *a, const void *b){
+  const struct state *pA = *(const struct state**)a;
+  const struct state *pB = *(const struct state**)b;
+  int n;
+
+  n = pB->nNtAct - pA->nNtAct;
+  if( n==0 ){
+    n = pB->nTknAct - pA->nTknAct;
+    if( n==0 ){
+      n = pB->statenum - pA->statenum;
+    }
+  }
+  assert( n!=0 );
+  return n;
+}
+
+
+/*
+** Renumber and resort states so that states with fewer choices
+** occur at the end.  Except, keep state 0 as the first state.
+*/
+void ResortStates(struct lemon *lemp)
+{
+  int i;
+  struct state *stp;
+  struct action *ap;
+
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    stp->nTknAct = stp->nNtAct = 0;
+    stp->iDfltReduce = lemp->nrule;  /* Init dflt action to "syntax error" */
+    stp->iTknOfst = NO_OFFSET;
+    stp->iNtOfst = NO_OFFSET;
+    for(ap=stp->ap; ap; ap=ap->next){
+      int iAction = compute_action(lemp,ap);
+      if( iAction>=0 ){
+        if( ap->sp->index<lemp->nterminal ){
+          stp->nTknAct++;
+        }else if( ap->sp->index<lemp->nsymbol ){
+          stp->nNtAct++;
+        }else{
+          assert( stp->autoReduce==0 || stp->pDfltReduce==ap->x.rp );
+          stp->iDfltReduce = iAction - lemp->nstate - lemp->nrule;
+        }
+      }
+    }
+  }
+  qsort(&lemp->sorted[1], lemp->nstate-1, sizeof(lemp->sorted[0]),
+        stateResortCompare);
+  for(i=0; i<lemp->nstate; i++){
+    lemp->sorted[i]->statenum = i;
+  }
+  lemp->nxstate = lemp->nstate;
+  while( lemp->nxstate>1 && lemp->sorted[lemp->nxstate-1]->autoReduce ){
+    lemp->nxstate--;
+  }
+}
+
+
+/***************** From the file "set.c" ************************************/
+/*
+** Set manipulation routines for the LEMON parser generator.
+*/
+
+static int size = 0;
+
+/* Set the set size */
+void SetSize(int n)
+{
+  size = n+1;
+}
+
+/* Allocate a new set */
+char *SetNew(){
+  char *s;
+  s = (char*)calloc( size, 1);
+  if( s==0 ){
+    extern void memory_error();
+    memory_error();
+  }
+  return s;
+}
+
+/* Deallocate a set */
+void SetFree(char *s)
+{
+  free(s);
+}
+
+/* Add a new element to the set.  Return TRUE if the element was added
+** and FALSE if it was already there. */
+int SetAdd(char *s, int e)
+{
+  int rv;
+  assert( e>=0 && e<size );
+  rv = s[e];
+  s[e] = 1;
+  return !rv;
+}
+
+/* Add every element of s2 to s1.  Return TRUE if s1 changes. */
+int SetUnion(char *s1, char *s2)
+{
+  int i, progress;
+  progress = 0;
+  for(i=0; i<size; i++){
+    if( s2[i]==0 ) continue;
+    if( s1[i]==0 ){
+      progress = 1;
+      s1[i] = 1;
+    }
+  }
+  return progress;
+}
+/********************** From the file "table.c" ****************************/
+/*
+** All code in this file has been automatically generated
+** from a specification in the file
+**              "table.q"
+** by the associative array code building program "aagen".
+** Do not edit this file!  Instead, edit the specification
+** file, then rerun aagen.
+*/
+/*
+** Code for processing tables in the LEMON parser generator.
+*/
+
+PRIVATE unsigned strhash(const char *x)
+{
+  unsigned h = 0;
+  while( *x ) h = h*13 + *(x++);
+  return h;
+}
+
+/* Works like strdup, sort of.  Save a string in malloced memory, but
+** keep strings in a table so that the same string is not in more
+** than one place.
+*/
+const char *Strsafe(const char *y)
+{
+  const char *z;
+  char *cpy;
+
+  if( y==0 ) return 0;
+  z = Strsafe_find(y);
+  if( z==0 && (cpy=(char *)malloc( lemonStrlen(y)+1 ))!=0 ){
+    lemon_strcpy(cpy,y);
+    z = cpy;
+    Strsafe_insert(z);
+  }
+  MemoryCheck(z);
+  return z;
+}
+
+/* There is one instance of the following structure for each
+** associative array of type "x1".
+*/
+struct s_x1 {
+  int size;               /* The number of available slots. */
+                          /*   Must be a power of 2 greater than or */
+                          /*   equal to 1 */
+  int count;              /* Number of currently slots filled */
+  struct s_x1node *tbl;  /* The data stored here */
+  struct s_x1node **ht;  /* Hash table for lookups */
+};
+
+/* There is one instance of this structure for every data element
+** in an associative array of type "x1".
+*/
+typedef struct s_x1node {
+  const char *data;        /* The data */
+  struct s_x1node *next;   /* Next entry with the same hash */
+  struct s_x1node **from;  /* Previous link */
+} x1node;
+
+/* There is only one instance of the array, which is the following */
+static struct s_x1 *x1a;
+
+/* Allocate a new associative array */
+void Strsafe_init(){
+  if( x1a ) return;
+  x1a = (struct s_x1*)malloc( sizeof(struct s_x1) );
+  if( x1a ){
+    x1a->size = 1024;
+    x1a->count = 0;
+    x1a->tbl = (x1node*)calloc(1024, sizeof(x1node) + sizeof(x1node*));
+    if( x1a->tbl==0 ){
+      free(x1a);
+      x1a = 0;
+    }else{
+      int i;
+      x1a->ht = (x1node**)&(x1a->tbl[1024]);
+      for(i=0; i<1024; i++) x1a->ht[i] = 0;
+    }
+  }
+}
+/* Insert a new record into the array.  Return TRUE if successful.
+** Prior data with the same key is NOT overwritten */
+int Strsafe_insert(const char *data)
+{
+  x1node *np;
+  unsigned h;
+  unsigned ph;
+
+  if( x1a==0 ) return 0;
+  ph = strhash(data);
+  h = ph & (x1a->size-1);
+  np = x1a->ht[h];
+  while( np ){
+    if( strcmp(np->data,data)==0 ){
+      /* An existing entry with the same key is found. */
+      /* Fail because overwrite is not allows. */
+      return 0;
+    }
+    np = np->next;
+  }
+  if( x1a->count>=x1a->size ){
+    /* Need to make the hash table bigger */
+    int i,arrSize;
+    struct s_x1 array;
+    array.size = arrSize = x1a->size*2;
+    array.count = x1a->count;
+    array.tbl = (x1node*)calloc(arrSize, sizeof(x1node) + sizeof(x1node*));
+    if( array.tbl==0 ) return 0;  /* Fail due to malloc failure */
+    array.ht = (x1node**)&(array.tbl[arrSize]);
+    for(i=0; i<arrSize; i++) array.ht[i] = 0;
+    for(i=0; i<x1a->count; i++){
+      x1node *oldnp, *newnp;
+      oldnp = &(x1a->tbl[i]);
+      h = strhash(oldnp->data) & (arrSize-1);
+      newnp = &(array.tbl[i]);
+      if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
+      newnp->next = array.ht[h];
+      newnp->data = oldnp->data;
+      newnp->from = &(array.ht[h]);
+      array.ht[h] = newnp;
+    }
+    free(x1a->tbl);
+    *x1a = array;
+  }
+  /* Insert the new data */
+  h = ph & (x1a->size-1);
+  np = &(x1a->tbl[x1a->count++]);
+  np->data = data;
+  if( x1a->ht[h] ) x1a->ht[h]->from = &(np->next);
+  np->next = x1a->ht[h];
+  x1a->ht[h] = np;
+  np->from = &(x1a->ht[h]);
+  return 1;
+}
+
+/* Return a pointer to data assigned to the given key.  Return NULL
+** if no such key. */
+const char *Strsafe_find(const char *key)
+{
+  unsigned h;
+  x1node *np;
+
+  if( x1a==0 ) return 0;
+  h = strhash(key) & (x1a->size-1);
+  np = x1a->ht[h];
+  while( np ){
+    if( strcmp(np->data,key)==0 ) break;
+    np = np->next;
+  }
+  return np ? np->data : 0;
+}
+
+/* Return a pointer to the (terminal or nonterminal) symbol "x".
+** Create a new symbol if this is the first time "x" has been seen.
+*/
+struct symbol *Symbol_new(const char *x)
+{
+  struct symbol *sp;
+
+  sp = Symbol_find(x);
+  if( sp==0 ){
+    sp = (struct symbol *)calloc(1, sizeof(struct symbol) );
+    MemoryCheck(sp);
+    sp->name = Strsafe(x);
+    sp->type = ISUPPER(*x) ? TERMINAL : NONTERMINAL;
+    sp->rule = 0;
+    sp->fallback = 0;
+    sp->prec = -1;
+    sp->assoc = UNK;
+    sp->firstset = 0;
+    sp->lambda = LEMON_FALSE;
+    sp->destructor = 0;
+    sp->destLineno = 0;
+    sp->datatype = 0;
+    sp->useCnt = 0;
+    Symbol_insert(sp,sp->name);
+  }
+  sp->useCnt++;
+  return sp;
+}
+
+/* Compare two symbols for sorting purposes.  Return negative,
+** zero, or positive if a is less then, equal to, or greater
+** than b.
+**
+** Symbols that begin with upper case letters (terminals or tokens)
+** must sort before symbols that begin with lower case letters
+** (non-terminals).  And MULTITERMINAL symbols (created using the
+** %token_class directive) must sort at the very end. Other than
+** that, the order does not matter.
+**
+** We find experimentally that leaving the symbols in their original
+** order (the order they appeared in the grammar file) gives the
+** smallest parser tables in SQLite.
+*/
+int Symbolcmpp(const void *_a, const void *_b)
+{
+  const struct symbol *a = *(const struct symbol **) _a;
+  const struct symbol *b = *(const struct symbol **) _b;
+  int i1 = a->type==MULTITERMINAL ? 3 : a->name[0]>'Z' ? 2 : 1;
+  int i2 = b->type==MULTITERMINAL ? 3 : b->name[0]>'Z' ? 2 : 1;
+  return i1==i2 ? a->index - b->index : i1 - i2;
+}
+
+/* There is one instance of the following structure for each
+** associative array of type "x2".
+*/
+struct s_x2 {
+  int size;               /* The number of available slots. */
+                          /*   Must be a power of 2 greater than or */
+                          /*   equal to 1 */
+  int count;              /* Number of currently slots filled */
+  struct s_x2node *tbl;  /* The data stored here */
+  struct s_x2node **ht;  /* Hash table for lookups */
+};
+
+/* There is one instance of this structure for every data element
+** in an associative array of type "x2".
+*/
+typedef struct s_x2node {
+  struct symbol *data;     /* The data */
+  const char *key;         /* The key */
+  struct s_x2node *next;   /* Next entry with the same hash */
+  struct s_x2node **from;  /* Previous link */
+} x2node;
+
+/* There is only one instance of the array, which is the following */
+static struct s_x2 *x2a;
+
+/* Allocate a new associative array */
+void Symbol_init(){
+  if( x2a ) return;
+  x2a = (struct s_x2*)malloc( sizeof(struct s_x2) );
+  if( x2a ){
+    x2a->size = 128;
+    x2a->count = 0;
+    x2a->tbl = (x2node*)calloc(128, sizeof(x2node) + sizeof(x2node*));
+    if( x2a->tbl==0 ){
+      free(x2a);
+      x2a = 0;
+    }else{
+      int i;
+      x2a->ht = (x2node**)&(x2a->tbl[128]);
+      for(i=0; i<128; i++) x2a->ht[i] = 0;
+    }
+  }
+}
+/* Insert a new record into the array.  Return TRUE if successful.
+** Prior data with the same key is NOT overwritten */
+int Symbol_insert(struct symbol *data, const char *key)
+{
+  x2node *np;
+  unsigned h;
+  unsigned ph;
+
+  if( x2a==0 ) return 0;
+  ph = strhash(key);
+  h = ph & (x2a->size-1);
+  np = x2a->ht[h];
+  while( np ){
+    if( strcmp(np->key,key)==0 ){
+      /* An existing entry with the same key is found. */
+      /* Fail because overwrite is not allows. */
+      return 0;
+    }
+    np = np->next;
+  }
+  if( x2a->count>=x2a->size ){
+    /* Need to make the hash table bigger */
+    int i,arrSize;
+    struct s_x2 array;
+    array.size = arrSize = x2a->size*2;
+    array.count = x2a->count;
+    array.tbl = (x2node*)calloc(arrSize, sizeof(x2node) + sizeof(x2node*));
+    if( array.tbl==0 ) return 0;  /* Fail due to malloc failure */
+    array.ht = (x2node**)&(array.tbl[arrSize]);
+    for(i=0; i<arrSize; i++) array.ht[i] = 0;
+    for(i=0; i<x2a->count; i++){
+      x2node *oldnp, *newnp;
+      oldnp = &(x2a->tbl[i]);
+      h = strhash(oldnp->key) & (arrSize-1);
+      newnp = &(array.tbl[i]);
+      if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
+      newnp->next = array.ht[h];
+      newnp->key = oldnp->key;
+      newnp->data = oldnp->data;
+      newnp->from = &(array.ht[h]);
+      array.ht[h] = newnp;
+    }
+    free(x2a->tbl);
+    *x2a = array;
+  }
+  /* Insert the new data */
+  h = ph & (x2a->size-1);
+  np = &(x2a->tbl[x2a->count++]);
+  np->key = key;
+  np->data = data;
+  if( x2a->ht[h] ) x2a->ht[h]->from = &(np->next);
+  np->next = x2a->ht[h];
+  x2a->ht[h] = np;
+  np->from = &(x2a->ht[h]);
+  return 1;
+}
+
+/* Return a pointer to data assigned to the given key.  Return NULL
+** if no such key. */
+struct symbol *Symbol_find(const char *key)
+{
+  unsigned h;
+  x2node *np;
+
+  if( x2a==0 ) return 0;
+  h = strhash(key) & (x2a->size-1);
+  np = x2a->ht[h];
+  while( np ){
+    if( strcmp(np->key,key)==0 ) break;
+    np = np->next;
+  }
+  return np ? np->data : 0;
+}
+
+/* Return the n-th data.  Return NULL if n is out of range. */
+struct symbol *Symbol_Nth(int n)
+{
+  struct symbol *data;
+  if( x2a && n>0 && n<=x2a->count ){
+    data = x2a->tbl[n-1].data;
+  }else{
+    data = 0;
+  }
+  return data;
+}
+
+/* Return the size of the array */
+int Symbol_count()
+{
+  return x2a ? x2a->count : 0;
+}
+
+/* Return an array of pointers to all data in the table.
+** The array is obtained from malloc.  Return NULL if memory allocation
+** problems, or if the array is empty. */
+struct symbol **Symbol_arrayof()
+{
+  struct symbol **array;
+  int i,arrSize;
+  if( x2a==0 ) return 0;
+  arrSize = x2a->count;
+  array = (struct symbol **)calloc(arrSize, sizeof(struct symbol *));
+  if( array ){
+    for(i=0; i<arrSize; i++) array[i] = x2a->tbl[i].data;
+  }
+  return array;
+}
+
+/* Compare two configurations */
+int Configcmp(const char *_a,const char *_b)
+{
+  const struct config *a = (struct config *) _a;
+  const struct config *b = (struct config *) _b;
+  int x;
+  x = a->rp->index - b->rp->index;
+  if( x==0 ) x = a->dot - b->dot;
+  return x;
+}
+
+/* Compare two states */
+PRIVATE int statecmp(struct config *a, struct config *b)
+{
+  int rc;
+  for(rc=0; rc==0 && a && b;  a=a->bp, b=b->bp){
+    rc = a->rp->index - b->rp->index;
+    if( rc==0 ) rc = a->dot - b->dot;
+  }
+  if( rc==0 ){
+    if( a ) rc = 1;
+    if( b ) rc = -1;
+  }
+  return rc;
+}
+
+/* Hash a state */
+PRIVATE unsigned statehash(struct config *a)
+{
+  unsigned h=0;
+  while( a ){
+    h = h*571 + a->rp->index*37 + a->dot;
+    a = a->bp;
+  }
+  return h;
+}
+
+/* Allocate a new state structure */
+struct state *State_new()
+{
+  struct state *newstate;
+  newstate = (struct state *)calloc(1, sizeof(struct state) );
+  MemoryCheck(newstate);
+  return newstate;
+}
+
+/* There is one instance of the following structure for each
+** associative array of type "x3".
+*/
+struct s_x3 {
+  int size;               /* The number of available slots. */
+                          /*   Must be a power of 2 greater than or */
+                          /*   equal to 1 */
+  int count;              /* Number of currently slots filled */
+  struct s_x3node *tbl;  /* The data stored here */
+  struct s_x3node **ht;  /* Hash table for lookups */
+};
+
+/* There is one instance of this structure for every data element
+** in an associative array of type "x3".
+*/
+typedef struct s_x3node {
+  struct state *data;                  /* The data */
+  struct config *key;                   /* The key */
+  struct s_x3node *next;   /* Next entry with the same hash */
+  struct s_x3node **from;  /* Previous link */
+} x3node;
+
+/* There is only one instance of the array, which is the following */
+static struct s_x3 *x3a;
+
+/* Allocate a new associative array */
+void State_init(){
+  if( x3a ) return;
+  x3a = (struct s_x3*)malloc( sizeof(struct s_x3) );
+  if( x3a ){
+    x3a->size = 128;
+    x3a->count = 0;
+    x3a->tbl = (x3node*)calloc(128, sizeof(x3node) + sizeof(x3node*));
+    if( x3a->tbl==0 ){
+      free(x3a);
+      x3a = 0;
+    }else{
+      int i;
+      x3a->ht = (x3node**)&(x3a->tbl[128]);
+      for(i=0; i<128; i++) x3a->ht[i] = 0;
+    }
+  }
+}
+/* Insert a new record into the array.  Return TRUE if successful.
+** Prior data with the same key is NOT overwritten */
+int State_insert(struct state *data, struct config *key)
+{
+  x3node *np;
+  unsigned h;
+  unsigned ph;
+
+  if( x3a==0 ) return 0;
+  ph = statehash(key);
+  h = ph & (x3a->size-1);
+  np = x3a->ht[h];
+  while( np ){
+    if( statecmp(np->key,key)==0 ){
+      /* An existing entry with the same key is found. */
+      /* Fail because overwrite is not allows. */
+      return 0;
+    }
+    np = np->next;
+  }
+  if( x3a->count>=x3a->size ){
+    /* Need to make the hash table bigger */
+    int i,arrSize;
+    struct s_x3 array;
+    array.size = arrSize = x3a->size*2;
+    array.count = x3a->count;
+    array.tbl = (x3node*)calloc(arrSize, sizeof(x3node) + sizeof(x3node*));
+    if( array.tbl==0 ) return 0;  /* Fail due to malloc failure */
+    array.ht = (x3node**)&(array.tbl[arrSize]);
+    for(i=0; i<arrSize; i++) array.ht[i] = 0;
+    for(i=0; i<x3a->count; i++){
+      x3node *oldnp, *newnp;
+      oldnp = &(x3a->tbl[i]);
+      h = statehash(oldnp->key) & (arrSize-1);
+      newnp = &(array.tbl[i]);
+      if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
+      newnp->next = array.ht[h];
+      newnp->key = oldnp->key;
+      newnp->data = oldnp->data;
+      newnp->from = &(array.ht[h]);
+      array.ht[h] = newnp;
+    }
+    free(x3a->tbl);
+    *x3a = array;
+  }
+  /* Insert the new data */
+  h = ph & (x3a->size-1);
+  np = &(x3a->tbl[x3a->count++]);
+  np->key = key;
+  np->data = data;
+  if( x3a->ht[h] ) x3a->ht[h]->from = &(np->next);
+  np->next = x3a->ht[h];
+  x3a->ht[h] = np;
+  np->from = &(x3a->ht[h]);
+  return 1;
+}
+
+/* Return a pointer to data assigned to the given key.  Return NULL
+** if no such key. */
+struct state *State_find(struct config *key)
+{
+  unsigned h;
+  x3node *np;
+
+  if( x3a==0 ) return 0;
+  h = statehash(key) & (x3a->size-1);
+  np = x3a->ht[h];
+  while( np ){
+    if( statecmp(np->key,key)==0 ) break;
+    np = np->next;
+  }
+  return np ? np->data : 0;
+}
+
+/* Return an array of pointers to all data in the table.
+** The array is obtained from malloc.  Return NULL if memory allocation
+** problems, or if the array is empty. */
+struct state **State_arrayof()
+{
+  struct state **array;
+  int i,arrSize;
+  if( x3a==0 ) return 0;
+  arrSize = x3a->count;
+  array = (struct state **)calloc(arrSize, sizeof(struct state *));
+  if( array ){
+    for(i=0; i<arrSize; i++) array[i] = x3a->tbl[i].data;
+  }
+  return array;
+}
+
+/* Hash a configuration */
+PRIVATE unsigned confighash(struct config *a)
+{
+  unsigned h=0;
+  h = h*571 + a->rp->index*37 + a->dot;
+  return h;
+}
+
+/* There is one instance of the following structure for each
+** associative array of type "x4".
+*/
+struct s_x4 {
+  int size;               /* The number of available slots. */
+                          /*   Must be a power of 2 greater than or */
+                          /*   equal to 1 */
+  int count;              /* Number of currently slots filled */
+  struct s_x4node *tbl;  /* The data stored here */
+  struct s_x4node **ht;  /* Hash table for lookups */
+};
+
+/* There is one instance of this structure for every data element
+** in an associative array of type "x4".
+*/
+typedef struct s_x4node {
+  struct config *data;                  /* The data */
+  struct s_x4node *next;   /* Next entry with the same hash */
+  struct s_x4node **from;  /* Previous link */
+} x4node;
+
+/* There is only one instance of the array, which is the following */
+static struct s_x4 *x4a;
+
+/* Allocate a new associative array */
+void Configtable_init(){
+  if( x4a ) return;
+  x4a = (struct s_x4*)malloc( sizeof(struct s_x4) );
+  if( x4a ){
+    x4a->size = 64;
+    x4a->count = 0;
+    x4a->tbl = (x4node*)calloc(64, sizeof(x4node) + sizeof(x4node*));
+    if( x4a->tbl==0 ){
+      free(x4a);
+      x4a = 0;
+    }else{
+      int i;
+      x4a->ht = (x4node**)&(x4a->tbl[64]);
+      for(i=0; i<64; i++) x4a->ht[i] = 0;
+    }
+  }
+}
+/* Insert a new record into the array.  Return TRUE if successful.
+** Prior data with the same key is NOT overwritten */
+int Configtable_insert(struct config *data)
+{
+  x4node *np;
+  unsigned h;
+  unsigned ph;
+
+  if( x4a==0 ) return 0;
+  ph = confighash(data);
+  h = ph & (x4a->size-1);
+  np = x4a->ht[h];
+  while( np ){
+    if( Configcmp((const char *) np->data,(const char *) data)==0 ){
+      /* An existing entry with the same key is found. */
+      /* Fail because overwrite is not allows. */
+      return 0;
+    }
+    np = np->next;
+  }
+  if( x4a->count>=x4a->size ){
+    /* Need to make the hash table bigger */
+    int i,arrSize;
+    struct s_x4 array;
+    array.size = arrSize = x4a->size*2;
+    array.count = x4a->count;
+    array.tbl = (x4node*)calloc(arrSize, sizeof(x4node) + sizeof(x4node*));
+    if( array.tbl==0 ) return 0;  /* Fail due to malloc failure */
+    array.ht = (x4node**)&(array.tbl[arrSize]);
+    for(i=0; i<arrSize; i++) array.ht[i] = 0;
+    for(i=0; i<x4a->count; i++){
+      x4node *oldnp, *newnp;
+      oldnp = &(x4a->tbl[i]);
+      h = confighash(oldnp->data) & (arrSize-1);
+      newnp = &(array.tbl[i]);
+      if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
+      newnp->next = array.ht[h];
+      newnp->data = oldnp->data;
+      newnp->from = &(array.ht[h]);
+      array.ht[h] = newnp;
+    }
+    free(x4a->tbl);
+    *x4a = array;
+  }
+  /* Insert the new data */
+  h = ph & (x4a->size-1);
+  np = &(x4a->tbl[x4a->count++]);
+  np->data = data;
+  if( x4a->ht[h] ) x4a->ht[h]->from = &(np->next);
+  np->next = x4a->ht[h];
+  x4a->ht[h] = np;
+  np->from = &(x4a->ht[h]);
+  return 1;
+}
+
+/* Return a pointer to data assigned to the given key.  Return NULL
+** if no such key. */
+struct config *Configtable_find(struct config *key)
+{
+  int h;
+  x4node *np;
+
+  if( x4a==0 ) return 0;
+  h = confighash(key) & (x4a->size-1);
+  np = x4a->ht[h];
+  while( np ){
+    if( Configcmp((const char *) np->data,(const char *) key)==0 ) break;
+    np = np->next;
+  }
+  return np ? np->data : 0;
+}
+
+/* Remove all data from the table.  Pass each data to the function "f"
+** as it is removed.  ("f" may be null to avoid this step.) */
+void Configtable_clear(int(*f)(struct config *))
+{
+  int i;
+  if( x4a==0 || x4a->count==0 ) return;
+  if( f ) for(i=0; i<x4a->count; i++) (*f)(x4a->tbl[i].data);
+  for(i=0; i<x4a->size; i++) x4a->ht[i] = 0;
+  x4a->count = 0;
+  return;
+}
diff --git a/lemon-src/lemon.c b/lemon-src/lemon.c
new file mode 100644
index 0000000..aa0f4e3
--- /dev/null
+++ b/lemon-src/lemon.c
@@ -0,0 +1,5436 @@
+/*
+** This file contains all sources (including headers) to the LEMON
+** LALR(1) parser generator.  The sources have been combined into a
+** single file to make it easy to include LEMON in the source tree
+** and Makefile of another program.
+**
+** The author of this program disclaims copyright.
+*/
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#define ISSPACE(X) isspace((unsigned char)(X))
+#define ISDIGIT(X) isdigit((unsigned char)(X))
+#define ISALNUM(X) isalnum((unsigned char)(X))
+#define ISALPHA(X) isalpha((unsigned char)(X))
+#define ISUPPER(X) isupper((unsigned char)(X))
+#define ISLOWER(X) islower((unsigned char)(X))
+
+
+#ifndef __WIN32__
+#   if defined(_WIN32) || defined(WIN32)
+#       define __WIN32__
+#   endif
+#endif
+
+#ifdef __WIN32__
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern int access(const char *path, int mode);
+#ifdef __cplusplus
+}
+#endif
+#else
+#include <unistd.h>
+#endif
+
+/* #define PRIVATE static */
+#define PRIVATE
+
+#ifdef TEST
+#define MAXRHS 5       /* Set low to exercise exception code */
+#else
+#define MAXRHS 1000
+#endif
+
+static int showPrecedenceConflict = 0;
+static char *msort(char*,char**,int(*)(const char*,const char*));
+
+/*
+** Compilers are getting increasingly pedantic about type conversions
+** as C evolves ever closer to Ada....  To work around the latest problems
+** we have to define the following variant of strlen().
+*/
+#define lemonStrlen(X)   ((int)strlen(X))
+
+/*
+** Compilers are starting to complain about the use of sprintf() and strcpy(),
+** saying they are unsafe.  So we define our own versions of those routines too.
+**
+** There are three routines here:  lemon_sprintf(), lemon_vsprintf(), and
+** lemon_addtext(). The first two are replacements for sprintf() and vsprintf().
+** The third is a helper routine for vsnprintf() that adds texts to the end of a
+** buffer, making sure the buffer is always zero-terminated.
+**
+** The string formatter is a minimal subset of stdlib sprintf() supporting only
+** a few simply conversions:
+**
+**   %d
+**   %s
+**   %.*s
+**
+*/
+static void lemon_addtext(
+  char *zBuf,           /* The buffer to which text is added */
+  int *pnUsed,          /* Slots of the buffer used so far */
+  const char *zIn,      /* Text to add */
+  int nIn,              /* Bytes of text to add.  -1 to use strlen() */
+  int iWidth            /* Field width.  Negative to left justify */
+){
+  if( nIn<0 ) for(nIn=0; zIn[nIn]; nIn++){}
+  while( iWidth>nIn ){ zBuf[(*pnUsed)++] = ' '; iWidth--; }
+  if( nIn==0 ) return;
+  memcpy(&zBuf[*pnUsed], zIn, nIn);
+  *pnUsed += nIn;
+  while( (-iWidth)>nIn ){ zBuf[(*pnUsed)++] = ' '; iWidth++; }
+  zBuf[*pnUsed] = 0;
+}
+static int lemon_vsprintf(char *str, const char *zFormat, va_list ap){
+  int i, j, k, c;
+  int nUsed = 0;
+  const char *z;
+  char zTemp[50];
+  str[0] = 0;
+  for(i=j=0; (c = zFormat[i])!=0; i++){
+    if( c=='%' ){
+      int iWidth = 0;
+      lemon_addtext(str, &nUsed, &zFormat[j], i-j, 0);
+      c = zFormat[++i];
+      if( ISDIGIT(c) || (c=='-' && ISDIGIT(zFormat[i+1])) ){
+        if( c=='-' ) i++;
+        while( ISDIGIT(zFormat[i]) ) iWidth = iWidth*10 + zFormat[i++] - '0';
+        if( c=='-' ) iWidth = -iWidth;
+        c = zFormat[i];
+      }
+      if( c=='d' ){
+        int v = va_arg(ap, int);
+        if( v<0 ){
+          lemon_addtext(str, &nUsed, "-", 1, iWidth);
+          v = -v;
+        }else if( v==0 ){
+          lemon_addtext(str, &nUsed, "0", 1, iWidth);
+        }
+        k = 0;
+        while( v>0 ){
+          k++;
+          zTemp[sizeof(zTemp)-k] = (v%10) + '0';
+          v /= 10;
+        }
+        lemon_addtext(str, &nUsed, &zTemp[sizeof(zTemp)-k], k, iWidth);
+      }else if( c=='s' ){
+        z = va_arg(ap, const char*);
+        lemon_addtext(str, &nUsed, z, -1, iWidth);
+      }else if( c=='.' && memcmp(&zFormat[i], ".*s", 3)==0 ){
+        i += 2;
+        k = va_arg(ap, int);
+        z = va_arg(ap, const char*);
+        lemon_addtext(str, &nUsed, z, k, iWidth);
+      }else if( c=='%' ){
+        lemon_addtext(str, &nUsed, "%", 1, 0);
+      }else{
+        fprintf(stderr, "illegal format\n");
+        exit(1);
+      }
+      j = i+1;
+    }
+  }
+  lemon_addtext(str, &nUsed, &zFormat[j], i-j, 0);
+  return nUsed;
+}
+static int lemon_sprintf(char *str, const char *format, ...){
+  va_list ap;
+  int rc;
+  va_start(ap, format);
+  rc = lemon_vsprintf(str, format, ap);
+  va_end(ap);
+  return rc;
+}
+static void lemon_strcpy(char *dest, const char *src){
+  while( (*(dest++) = *(src++))!=0 ){}
+}
+static void lemon_strcat(char *dest, const char *src){
+  while( *dest ) dest++;
+  lemon_strcpy(dest, src);
+}
+
+
+/* a few forward declarations... */
+struct rule;
+struct lemon;
+struct action;
+
+static struct action *Action_new(void);
+static struct action *Action_sort(struct action *);
+
+/********** From the file "build.h" ************************************/
+void FindRulePrecedences();
+void FindFirstSets();
+void FindStates();
+void FindLinks();
+void FindFollowSets();
+void FindActions();
+
+/********* From the file "configlist.h" *********************************/
+void Configlist_init(void);
+struct config *Configlist_add(struct rule *, int);
+struct config *Configlist_addbasis(struct rule *, int);
+void Configlist_closure(struct lemon *);
+void Configlist_sort(void);
+void Configlist_sortbasis(void);
+struct config *Configlist_return(void);
+struct config *Configlist_basis(void);
+void Configlist_eat(struct config *);
+void Configlist_reset(void);
+
+/********* From the file "error.h" ***************************************/
+void ErrorMsg(const char *, int,const char *, ...);
+
+/****** From the file "option.h" ******************************************/
+enum option_type { OPT_FLAG=1,  OPT_INT,  OPT_DBL,  OPT_STR,
+         OPT_FFLAG, OPT_FINT, OPT_FDBL, OPT_FSTR};
+struct s_options {
+  enum option_type type;
+  const char *label;
+  char *arg;
+  const char *message;
+};
+int    OptInit(char**,struct s_options*,FILE*);
+int    OptNArgs(void);
+char  *OptArg(int);
+void   OptErr(int);
+void   OptPrint(void);
+
+/******** From the file "parse.h" *****************************************/
+void Parse(struct lemon *lemp);
+
+/********* From the file "plink.h" ***************************************/
+struct plink *Plink_new(void);
+void Plink_add(struct plink **, struct config *);
+void Plink_copy(struct plink **, struct plink *);
+void Plink_delete(struct plink *);
+
+/********** From the file "report.h" *************************************/
+void Reprint(struct lemon *);
+void ReportOutput(struct lemon *);
+void ReportTable(struct lemon *, int);
+void ReportHeader(struct lemon *);
+void CompressTables(struct lemon *);
+void ResortStates(struct lemon *);
+
+/********** From the file "set.h" ****************************************/
+void  SetSize(int);             /* All sets will be of size N */
+char *SetNew(void);               /* A new set for element 0..N */
+void  SetFree(char*);             /* Deallocate a set */
+int SetAdd(char*,int);            /* Add element to a set */
+int SetUnion(char *,char *);    /* A <- A U B, thru element N */
+#define SetFind(X,Y) (X[Y])       /* True if Y is in set X */
+
+/********** From the file "struct.h" *************************************/
+/*
+** Principal data structures for the LEMON parser generator.
+*/
+
+typedef enum {LEMON_FALSE=0, LEMON_TRUE} Boolean;
+
+/* Symbols (terminals and nonterminals) of the grammar are stored
+** in the following: */
+enum symbol_type {
+  TERMINAL,
+  NONTERMINAL,
+  MULTITERMINAL
+};
+enum e_assoc {
+    LEFT,
+    RIGHT,
+    NONE,
+    UNK
+};
+struct symbol {
+  const char *name;        /* Name of the symbol */
+  int index;               /* Index number for this symbol */
+  enum symbol_type type;   /* Symbols are all either TERMINALS or NTs */
+  struct rule *rule;       /* Linked list of rules of this (if an NT) */
+  struct symbol *fallback; /* fallback token in case this token doesn't parse */
+  int prec;                /* Precedence if defined (-1 otherwise) */
+  enum e_assoc assoc;      /* Associativity if precedence is defined */
+  char *firstset;          /* First-set for all rules of this symbol */
+  Boolean lambda;          /* True if NT and can generate an empty string */
+  int useCnt;              /* Number of times used */
+  char *destructor;        /* Code which executes whenever this symbol is
+                           ** popped from the stack during error processing */
+  int destLineno;          /* Line number for start of destructor.  Set to
+                           ** -1 for duplicate destructors. */
+  char *datatype;          /* The data type of information held by this
+                           ** object. Only used if type==NONTERMINAL */
+  int dtnum;               /* The data type number.  In the parser, the value
+                           ** stack is a union.  The .yy%d element of this
+                           ** union is the correct data type for this object */
+  /* The following fields are used by MULTITERMINALs only */
+  int nsubsym;             /* Number of constituent symbols in the MULTI */
+  struct symbol **subsym;  /* Array of constituent symbols */
+};
+
+/* Each production rule in the grammar is stored in the following
+** structure.  */
+struct rule {
+  struct symbol *lhs;      /* Left-hand side of the rule */
+  const char *lhsalias;    /* Alias for the LHS (NULL if none) */
+  int lhsStart;            /* True if left-hand side is the start symbol */
+  int ruleline;            /* Line number for the rule */
+  int nrhs;                /* Number of RHS symbols */
+  struct symbol **rhs;     /* The RHS symbols */
+  const char **rhsalias;   /* An alias for each RHS symbol (NULL if none) */
+  int line;                /* Line number at which code begins */
+  const char *code;        /* The code executed when this rule is reduced */
+  const char *codePrefix;  /* Setup code before code[] above */
+  const char *codeSuffix;  /* Breakdown code after code[] above */
+  int noCode;              /* True if this rule has no associated C code */
+  int codeEmitted;         /* True if the code has been emitted already */
+  struct symbol *precsym;  /* Precedence symbol for this rule */
+  int index;               /* An index number for this rule */
+  int iRule;               /* Rule number as used in the generated tables */
+  Boolean canReduce;       /* True if this rule is ever reduced */
+  Boolean doesReduce;      /* Reduce actions occur after optimization */
+  struct rule *nextlhs;    /* Next rule with the same LHS */
+  struct rule *next;       /* Next rule in the global list */
+};
+
+/* A configuration is a production rule of the grammar together with
+** a mark (dot) showing how much of that rule has been processed so far.
+** Configurations also contain a follow-set which is a list of terminal
+** symbols which are allowed to immediately follow the end of the rule.
+** Every configuration is recorded as an instance of the following: */
+enum cfgstatus {
+  COMPLETE,
+  INCOMPLETE
+};
+struct config {
+  struct rule *rp;         /* The rule upon which the configuration is based */
+  int dot;                 /* The parse point */
+  char *fws;               /* Follow-set for this configuration only */
+  struct plink *fplp;      /* Follow-set forward propagation links */
+  struct plink *bplp;      /* Follow-set backwards propagation links */
+  struct state *stp;       /* Pointer to state which contains this */
+  enum cfgstatus status;   /* used during followset and shift computations */
+  struct config *next;     /* Next configuration in the state */
+  struct config *bp;       /* The next basis configuration */
+};
+
+enum e_action {
+  SHIFT,
+  ACCEPT,
+  REDUCE,
+  ERROR,
+  SSCONFLICT,              /* A shift/shift conflict */
+  SRCONFLICT,              /* Was a reduce, but part of a conflict */
+  RRCONFLICT,              /* Was a reduce, but part of a conflict */
+  SH_RESOLVED,             /* Was a shift.  Precedence resolved conflict */
+  RD_RESOLVED,             /* Was reduce.  Precedence resolved conflict */
+  NOT_USED,                /* Deleted by compression */
+  SHIFTREDUCE              /* Shift first, then reduce */
+};
+
+/* Every shift or reduce operation is stored as one of the following */
+struct action {
+  struct symbol *sp;       /* The look-ahead symbol */
+  enum e_action type;
+  union {
+    struct state *stp;     /* The new state, if a shift */
+    struct rule *rp;       /* The rule, if a reduce */
+  } x;
+  struct symbol *spOpt;    /* SHIFTREDUCE optimization to this symbol */
+  struct action *next;     /* Next action for this state */
+  struct action *collide;  /* Next action with the same hash */
+};
+
+/* Each state of the generated parser's finite state machine
+** is encoded as an instance of the following structure. */
+struct state {
+  struct config *bp;       /* The basis configurations for this state */
+  struct config *cfp;      /* All configurations in this set */
+  int statenum;            /* Sequential number for this state */
+  struct action *ap;       /* List of actions for this state */
+  int nTknAct, nNtAct;     /* Number of actions on terminals and nonterminals */
+  int iTknOfst, iNtOfst;   /* yy_action[] offset for terminals and nonterms */
+  int iDfltReduce;         /* Default action is to REDUCE by this rule */
+  struct rule *pDfltReduce;/* The default REDUCE rule. */
+  int autoReduce;          /* True if this is an auto-reduce state */
+};
+#define NO_OFFSET (-2147483647)
+
+/* A followset propagation link indicates that the contents of one
+** configuration followset should be propagated to another whenever
+** the first changes. */
+struct plink {
+  struct config *cfp;      /* The configuration to which linked */
+  struct plink *next;      /* The next propagate link */
+};
+
+/* The state vector for the entire parser generator is recorded as
+** follows.  (LEMON uses no global variables and makes little use of
+** static variables.  Fields in the following structure can be thought
+** of as begin global variables in the program.) */
+struct lemon {
+  struct state **sorted;   /* Table of states sorted by state number */
+  struct rule *rule;       /* List of all rules */
+  struct rule *startRule;  /* First rule */
+  int nstate;              /* Number of states */
+  int nxstate;             /* nstate with tail degenerate states removed */
+  int nrule;               /* Number of rules */
+  int nsymbol;             /* Number of terminal and nonterminal symbols */
+  int nterminal;           /* Number of terminal symbols */
+  struct symbol **symbols; /* Sorted array of pointers to symbols */
+  int errorcnt;            /* Number of errors */
+  struct symbol *errsym;   /* The error symbol */
+  struct symbol *wildcard; /* Token that matches anything */
+  char *name;              /* Name of the generated parser */
+  char *arg;               /* Declaration of the 3th argument to parser */
+  char *tokentype;         /* Type of terminal symbols in the parser stack */
+  char *vartype;           /* The default type of non-terminal symbols */
+  char *start;             /* Name of the start symbol for the grammar */
+  char *stacksize;         /* Size of the parser stack */
+  char *include;           /* Code to put at the start of the C file */
+  char *error;             /* Code to execute when an error is seen */
+  char *overflow;          /* Code to execute on a stack overflow */
+  char *failure;           /* Code to execute on parser failure */
+  char *accept;            /* Code to execute when the parser excepts */
+  char *extracode;         /* Code appended to the generated file */
+  char *tokendest;         /* Code to execute to destroy token data */
+  char *vardest;           /* Code for the default non-terminal destructor */
+  char *filename;          /* Name of the input file */
+  char *outname;           /* Name of the current output file */
+  char *tokenprefix;       /* A prefix added to token names in the .h file */
+  int nconflict;           /* Number of parsing conflicts */
+  int nactiontab;          /* Number of entries in the yy_action[] table */
+  int tablesize;           /* Total table size of all tables in bytes */
+  int basisflag;           /* Print only basis configurations */
+  int has_fallback;        /* True if any %fallback is seen in the grammar */
+  int nolinenosflag;       /* True if #line statements should not be printed */
+  char *argv0;             /* Name of the program */
+};
+
+#define MemoryCheck(X) if((X)==0){ \
+  extern void memory_error(); \
+  memory_error(); \
+}
+
+/**************** From the file "table.h" *********************************/
+/*
+** All code in this file has been automatically generated
+** from a specification in the file
+**              "table.q"
+** by the associative array code building program "aagen".
+** Do not edit this file!  Instead, edit the specification
+** file, then rerun aagen.
+*/
+/*
+** Code for processing tables in the LEMON parser generator.
+*/
+/* Routines for handling a strings */
+
+const char *Strsafe(const char *);
+
+void Strsafe_init(void);
+int Strsafe_insert(const char *);
+const char *Strsafe_find(const char *);
+
+/* Routines for handling symbols of the grammar */
+
+struct symbol *Symbol_new(const char *);
+int Symbolcmpp(const void *, const void *);
+void Symbol_init(void);
+int Symbol_insert(struct symbol *, const char *);
+struct symbol *Symbol_find(const char *);
+struct symbol *Symbol_Nth(int);
+int Symbol_count(void);
+struct symbol **Symbol_arrayof(void);
+
+/* Routines to manage the state table */
+
+int Configcmp(const char *, const char *);
+struct state *State_new(void);
+void State_init(void);
+int State_insert(struct state *, struct config *);
+struct state *State_find(struct config *);
+struct state **State_arrayof(/*  */);
+
+/* Routines used for efficiency in Configlist_add */
+
+void Configtable_init(void);
+int Configtable_insert(struct config *);
+struct config *Configtable_find(struct config *);
+void Configtable_clear(int(*)(struct config *));
+
+/****************** From the file "action.c" *******************************/
+/*
+** Routines processing parser actions in the LEMON parser generator.
+*/
+
+/* Allocate a new parser action */
+static struct action *Action_new(void){
+  static struct action *freelist = 0;
+  struct action *newaction;
+
+  if( freelist==0 ){
+    int i;
+    int amt = 100;
+    freelist = (struct action *)calloc(amt, sizeof(struct action));
+    if( freelist==0 ){
+      fprintf(stderr,"Unable to allocate memory for a new parser action.");
+      exit(1);
+    }
+    for(i=0; i<amt-1; i++) freelist[i].next = &freelist[i+1];
+    freelist[amt-1].next = 0;
+  }
+  newaction = freelist;
+  freelist = freelist->next;
+  return newaction;
+}
+
+/* Compare two actions for sorting purposes.  Return negative, zero, or
+** positive if the first action is less than, equal to, or greater than
+** the first
+*/
+static int actioncmp(
+  struct action *ap1,
+  struct action *ap2
+){
+  int rc;
+  rc = ap1->sp->index - ap2->sp->index;
+  if( rc==0 ){
+    rc = (int)ap1->type - (int)ap2->type;
+  }
+  if( rc==0 && (ap1->type==REDUCE || ap1->type==SHIFTREDUCE) ){
+    rc = ap1->x.rp->index - ap2->x.rp->index;
+  }
+  if( rc==0 ){
+    rc = (int) (ap2 - ap1);
+  }
+  return rc;
+}
+
+/* Sort parser actions */
+static struct action *Action_sort(
+  struct action *ap
+){
+  ap = (struct action *)msort((char *)ap,(char **)&ap->next,
+                              (int(*)(const char*,const char*))actioncmp);
+  return ap;
+}
+
+void Action_add(
+  struct action **app,
+  enum e_action type,
+  struct symbol *sp,
+  char *arg
+){
+  struct action *newaction;
+  newaction = Action_new();
+  newaction->next = *app;
+  *app = newaction;
+  newaction->type = type;
+  newaction->sp = sp;
+  newaction->spOpt = 0;
+  if( type==SHIFT ){
+    newaction->x.stp = (struct state *)arg;
+  }else{
+    newaction->x.rp = (struct rule *)arg;
+  }
+}
+/********************** New code to implement the "acttab" module ***********/
+/*
+** This module implements routines use to construct the yy_action[] table.
+*/
+
+/*
+** The state of the yy_action table under construction is an instance of
+** the following structure.
+**
+** The yy_action table maps the pair (state_number, lookahead) into an
+** action_number.  The table is an array of integers pairs.  The state_number
+** determines an initial offset into the yy_action array.  The lookahead
+** value is then added to this initial offset to get an index X into the
+** yy_action array. If the aAction[X].lookahead equals the value of the
+** of the lookahead input, then the value of the action_number output is
+** aAction[X].action.  If the lookaheads do not match then the
+** default action for the state_number is returned.
+**
+** All actions associated with a single state_number are first entered
+** into aLookahead[] using multiple calls to acttab_action().  Then the 
+** actions for that single state_number are placed into the aAction[] 
+** array with a single call to acttab_insert().  The acttab_insert() call
+** also resets the aLookahead[] array in preparation for the next
+** state number.
+*/
+struct lookahead_action {
+  int lookahead;             /* Value of the lookahead token */
+  int action;                /* Action to take on the given lookahead */
+};
+typedef struct acttab acttab;
+struct acttab {
+  int nAction;                 /* Number of used slots in aAction[] */
+  int nActionAlloc;            /* Slots allocated for aAction[] */
+  struct lookahead_action
+    *aAction,                  /* The yy_action[] table under construction */
+    *aLookahead;               /* A single new transaction set */
+  int mnLookahead;             /* Minimum aLookahead[].lookahead */
+  int mnAction;                /* Action associated with mnLookahead */
+  int mxLookahead;             /* Maximum aLookahead[].lookahead */
+  int nLookahead;              /* Used slots in aLookahead[] */
+  int nLookaheadAlloc;         /* Slots allocated in aLookahead[] */
+};
+
+/* Return the number of entries in the yy_action table */
+#define acttab_size(X) ((X)->nAction)
+
+/* The value for the N-th entry in yy_action */
+#define acttab_yyaction(X,N)  ((X)->aAction[N].action)
+
+/* The value for the N-th entry in yy_lookahead */
+#define acttab_yylookahead(X,N)  ((X)->aAction[N].lookahead)
+
+/* Free all memory associated with the given acttab */
+void acttab_free(acttab *p){
+  free( p->aAction );
+  free( p->aLookahead );
+  free( p );
+}
+
+/* Allocate a new acttab structure */
+acttab *acttab_alloc(void){
+  acttab *p = (acttab *) calloc( 1, sizeof(*p) );
+  if( p==0 ){
+    fprintf(stderr,"Unable to allocate memory for a new acttab.");
+    exit(1);
+  }
+  memset(p, 0, sizeof(*p));
+  return p;
+}
+
+/* Add a new action to the current transaction set.  
+**
+** This routine is called once for each lookahead for a particular
+** state.
+*/
+void acttab_action(acttab *p, int lookahead, int action){
+  if( p->nLookahead>=p->nLookaheadAlloc ){
+    p->nLookaheadAlloc += 25;
+    p->aLookahead = (struct lookahead_action *) realloc( p->aLookahead,
+                             sizeof(p->aLookahead[0])*p->nLookaheadAlloc );
+    if( p->aLookahead==0 ){
+      fprintf(stderr,"malloc failed\n");
+      exit(1);
+    }
+  }
+  if( p->nLookahead==0 ){
+    p->mxLookahead = lookahead;
+    p->mnLookahead = lookahead;
+    p->mnAction = action;
+  }else{
+    if( p->mxLookahead<lookahead ) p->mxLookahead = lookahead;
+    if( p->mnLookahead>lookahead ){
+      p->mnLookahead = lookahead;
+      p->mnAction = action;
+    }
+  }
+  p->aLookahead[p->nLookahead].lookahead = lookahead;
+  p->aLookahead[p->nLookahead].action = action;
+  p->nLookahead++;
+}
+
+/*
+** Add the transaction set built up with prior calls to acttab_action()
+** into the current action table.  Then reset the transaction set back
+** to an empty set in preparation for a new round of acttab_action() calls.
+**
+** Return the offset into the action table of the new transaction.
+*/
+int acttab_insert(acttab *p){
+  int i, j, k, n;
+  assert( p->nLookahead>0 );
+
+  /* Make sure we have enough space to hold the expanded action table
+  ** in the worst case.  The worst case occurs if the transaction set
+  ** must be appended to the current action table
+  */
+  n = p->mxLookahead + 1;
+  if( p->nAction + n >= p->nActionAlloc ){
+    int oldAlloc = p->nActionAlloc;
+    p->nActionAlloc = p->nAction + n + p->nActionAlloc + 20;
+    p->aAction = (struct lookahead_action *) realloc( p->aAction,
+                          sizeof(p->aAction[0])*p->nActionAlloc);
+    if( p->aAction==0 ){
+      fprintf(stderr,"malloc failed\n");
+      exit(1);
+    }
+    for(i=oldAlloc; i<p->nActionAlloc; i++){
+      p->aAction[i].lookahead = -1;
+      p->aAction[i].action = -1;
+    }
+  }
+
+  /* Scan the existing action table looking for an offset that is a 
+  ** duplicate of the current transaction set.  Fall out of the loop
+  ** if and when the duplicate is found.
+  **
+  ** i is the index in p->aAction[] where p->mnLookahead is inserted.
+  */
+  for(i=p->nAction-1; i>=0; i--){
+    if( p->aAction[i].lookahead==p->mnLookahead ){
+      /* All lookaheads and actions in the aLookahead[] transaction
+      ** must match against the candidate aAction[i] entry. */
+      if( p->aAction[i].action!=p->mnAction ) continue;
+      for(j=0; j<p->nLookahead; j++){
+        k = p->aLookahead[j].lookahead - p->mnLookahead + i;
+        if( k<0 || k>=p->nAction ) break;
+        if( p->aLookahead[j].lookahead!=p->aAction[k].lookahead ) break;
+        if( p->aLookahead[j].action!=p->aAction[k].action ) break;
+      }
+      if( j<p->nLookahead ) continue;
+
+      /* No possible lookahead value that is not in the aLookahead[]
+      ** transaction is allowed to match aAction[i] */
+      n = 0;
+      for(j=0; j<p->nAction; j++){
+        if( p->aAction[j].lookahead<0 ) continue;
+        if( p->aAction[j].lookahead==j+p->mnLookahead-i ) n++;
+      }
+      if( n==p->nLookahead ){
+        break;  /* An exact match is found at offset i */
+      }
+    }
+  }
+
+  /* If no existing offsets exactly match the current transaction, find an
+  ** an empty offset in the aAction[] table in which we can add the
+  ** aLookahead[] transaction.
+  */
+  if( i<0 ){
+    /* Look for holes in the aAction[] table that fit the current
+    ** aLookahead[] transaction.  Leave i set to the offset of the hole.
+    ** If no holes are found, i is left at p->nAction, which means the
+    ** transaction will be appended. */
+    for(i=0; i<p->nActionAlloc - p->mxLookahead; i++){
+      if( p->aAction[i].lookahead<0 ){
+        for(j=0; j<p->nLookahead; j++){
+          k = p->aLookahead[j].lookahead - p->mnLookahead + i;
+          if( k<0 ) break;
+          if( p->aAction[k].lookahead>=0 ) break;
+        }
+        if( j<p->nLookahead ) continue;
+        for(j=0; j<p->nAction; j++){
+          if( p->aAction[j].lookahead==j+p->mnLookahead-i ) break;
+        }
+        if( j==p->nAction ){
+          break;  /* Fits in empty slots */
+        }
+      }
+    }
+  }
+  /* Insert transaction set at index i. */
+  for(j=0; j<p->nLookahead; j++){
+    k = p->aLookahead[j].lookahead - p->mnLookahead + i;
+    p->aAction[k] = p->aLookahead[j];
+    if( k>=p->nAction ) p->nAction = k+1;
+  }
+  p->nLookahead = 0;
+
+  /* Return the offset that is added to the lookahead in order to get the
+  ** index into yy_action of the action */
+  return i - p->mnLookahead;
+}
+
+/********************** From the file "build.c" *****************************/
+/*
+** Routines to construction the finite state machine for the LEMON
+** parser generator.
+*/
+
+/* Find a precedence symbol of every rule in the grammar.
+** 
+** Those rules which have a precedence symbol coded in the input
+** grammar using the "[symbol]" construct will already have the
+** rp->precsym field filled.  Other rules take as their precedence
+** symbol the first RHS symbol with a defined precedence.  If there
+** are not RHS symbols with a defined precedence, the precedence
+** symbol field is left blank.
+*/
+void FindRulePrecedences(struct lemon *xp)
+{
+  struct rule *rp;
+  for(rp=xp->rule; rp; rp=rp->next){
+    if( rp->precsym==0 ){
+      int i, j;
+      for(i=0; i<rp->nrhs && rp->precsym==0; i++){
+        struct symbol *sp = rp->rhs[i];
+        if( sp->type==MULTITERMINAL ){
+          for(j=0; j<sp->nsubsym; j++){
+            if( sp->subsym[j]->prec>=0 ){
+              rp->precsym = sp->subsym[j];
+              break;
+            }
+          }
+        }else if( sp->prec>=0 ){
+          rp->precsym = rp->rhs[i];
+        }
+      }
+    }
+  }
+  return;
+}
+
+/* Find all nonterminals which will generate the empty string.
+** Then go back and compute the first sets of every nonterminal.
+** The first set is the set of all terminal symbols which can begin
+** a string generated by that nonterminal.
+*/
+void FindFirstSets(struct lemon *lemp)
+{
+  int i, j;
+  struct rule *rp;
+  int progress;
+
+  for(i=0; i<lemp->nsymbol; i++){
+    lemp->symbols[i]->lambda = LEMON_FALSE;
+  }
+  for(i=lemp->nterminal; i<lemp->nsymbol; i++){
+    lemp->symbols[i]->firstset = SetNew();
+  }
+
+  /* First compute all lambdas */
+  do{
+    progress = 0;
+    for(rp=lemp->rule; rp; rp=rp->next){
+      if( rp->lhs->lambda ) continue;
+      for(i=0; i<rp->nrhs; i++){
+        struct symbol *sp = rp->rhs[i];
+        assert( sp->type==NONTERMINAL || sp->lambda==LEMON_FALSE );
+        if( sp->lambda==LEMON_FALSE ) break;
+      }
+      if( i==rp->nrhs ){
+        rp->lhs->lambda = LEMON_TRUE;
+        progress = 1;
+      }
+    }
+  }while( progress );
+
+  /* Now compute all first sets */
+  do{
+    struct symbol *s1, *s2;
+    progress = 0;
+    for(rp=lemp->rule; rp; rp=rp->next){
+      s1 = rp->lhs;
+      for(i=0; i<rp->nrhs; i++){
+        s2 = rp->rhs[i];
+        if( s2->type==TERMINAL ){
+          progress += SetAdd(s1->firstset,s2->index);
+          break;
+        }else if( s2->type==MULTITERMINAL ){
+          for(j=0; j<s2->nsubsym; j++){
+            progress += SetAdd(s1->firstset,s2->subsym[j]->index);
+          }
+          break;
+        }else if( s1==s2 ){
+          if( s1->lambda==LEMON_FALSE ) break;
+        }else{
+          progress += SetUnion(s1->firstset,s2->firstset);
+          if( s2->lambda==LEMON_FALSE ) break;
+        }
+      }
+    }
+  }while( progress );
+  return;
+}
+
+/* Compute all LR(0) states for the grammar.  Links
+** are added to between some states so that the LR(1) follow sets
+** can be computed later.
+*/
+PRIVATE struct state *getstate(struct lemon *);  /* forward reference */
+void FindStates(struct lemon *lemp)
+{
+  struct symbol *sp;
+  struct rule *rp;
+
+  Configlist_init();
+
+  /* Find the start symbol */
+  if( lemp->start ){
+    sp = Symbol_find(lemp->start);
+    if( sp==0 ){
+      ErrorMsg(lemp->filename,0,
+"The specified start symbol \"%s\" is not \
+in a nonterminal of the grammar.  \"%s\" will be used as the start \
+symbol instead.",lemp->start,lemp->startRule->lhs->name);
+      lemp->errorcnt++;
+      sp = lemp->startRule->lhs;
+    }
+  }else{
+    sp = lemp->startRule->lhs;
+  }
+
+  /* Make sure the start symbol doesn't occur on the right-hand side of
+  ** any rule.  Report an error if it does.  (YACC would generate a new
+  ** start symbol in this case.) */
+  for(rp=lemp->rule; rp; rp=rp->next){
+    int i;
+    for(i=0; i<rp->nrhs; i++){
+      if( rp->rhs[i]==sp ){   /* FIX ME:  Deal with multiterminals */
+        ErrorMsg(lemp->filename,0,
+"The start symbol \"%s\" occurs on the \
+right-hand side of a rule. This will result in a parser which \
+does not work properly.",sp->name);
+        lemp->errorcnt++;
+      }
+    }
+  }
+
+  /* The basis configuration set for the first state
+  ** is all rules which have the start symbol as their
+  ** left-hand side */
+  for(rp=sp->rule; rp; rp=rp->nextlhs){
+    struct config *newcfp;
+    rp->lhsStart = 1;
+    newcfp = Configlist_addbasis(rp,0);
+    SetAdd(newcfp->fws,0);
+  }
+
+  /* Compute the first state.  All other states will be
+  ** computed automatically during the computation of the first one.
+  ** The returned pointer to the first state is not used. */
+  (void)getstate(lemp);
+  return;
+}
+
+/* Return a pointer to a state which is described by the configuration
+** list which has been built from calls to Configlist_add.
+*/
+PRIVATE void buildshifts(struct lemon *, struct state *); /* Forwd ref */
+PRIVATE struct state *getstate(struct lemon *lemp)
+{
+  struct config *cfp, *bp;
+  struct state *stp;
+
+  /* Extract the sorted basis of the new state.  The basis was constructed
+  ** by prior calls to "Configlist_addbasis()". */
+  Configlist_sortbasis();
+  bp = Configlist_basis();
+
+  /* Get a state with the same basis */
+  stp = State_find(bp);
+  if( stp ){
+    /* A state with the same basis already exists!  Copy all the follow-set
+    ** propagation links from the state under construction into the
+    ** preexisting state, then return a pointer to the preexisting state */
+    struct config *x, *y;
+    for(x=bp, y=stp->bp; x && y; x=x->bp, y=y->bp){
+      Plink_copy(&y->bplp,x->bplp);
+      Plink_delete(x->fplp);
+      x->fplp = x->bplp = 0;
+    }
+    cfp = Configlist_return();
+    Configlist_eat(cfp);
+  }else{
+    /* This really is a new state.  Construct all the details */
+    Configlist_closure(lemp);    /* Compute the configuration closure */
+    Configlist_sort();           /* Sort the configuration closure */
+    cfp = Configlist_return();   /* Get a pointer to the config list */
+    stp = State_new();           /* A new state structure */
+    MemoryCheck(stp);
+    stp->bp = bp;                /* Remember the configuration basis */
+    stp->cfp = cfp;              /* Remember the configuration closure */
+    stp->statenum = lemp->nstate++; /* Every state gets a sequence number */
+    stp->ap = 0;                 /* No actions, yet. */
+    State_insert(stp,stp->bp);   /* Add to the state table */
+    buildshifts(lemp,stp);       /* Recursively compute successor states */
+  }
+  return stp;
+}
+
+/*
+** Return true if two symbols are the same.
+*/
+int same_symbol(struct symbol *a, struct symbol *b)
+{
+  int i;
+  if( a==b ) return 1;
+  if( a->type!=MULTITERMINAL ) return 0;
+  if( b->type!=MULTITERMINAL ) return 0;
+  if( a->nsubsym!=b->nsubsym ) return 0;
+  for(i=0; i<a->nsubsym; i++){
+    if( a->subsym[i]!=b->subsym[i] ) return 0;
+  }
+  return 1;
+}
+
+/* Construct all successor states to the given state.  A "successor"
+** state is any state which can be reached by a shift action.
+*/
+PRIVATE void buildshifts(struct lemon *lemp, struct state *stp)
+{
+  struct config *cfp;  /* For looping thru the config closure of "stp" */
+  struct config *bcfp; /* For the inner loop on config closure of "stp" */
+  struct config *newcfg;  /* */
+  struct symbol *sp;   /* Symbol following the dot in configuration "cfp" */
+  struct symbol *bsp;  /* Symbol following the dot in configuration "bcfp" */
+  struct state *newstp; /* A pointer to a successor state */
+
+  /* Each configuration becomes complete after it contibutes to a successor
+  ** state.  Initially, all configurations are incomplete */
+  for(cfp=stp->cfp; cfp; cfp=cfp->next) cfp->status = INCOMPLETE;
+
+  /* Loop through all configurations of the state "stp" */
+  for(cfp=stp->cfp; cfp; cfp=cfp->next){
+    if( cfp->status==COMPLETE ) continue;    /* Already used by inner loop */
+    if( cfp->dot>=cfp->rp->nrhs ) continue;  /* Can't shift this config */
+    Configlist_reset();                      /* Reset the new config set */
+    sp = cfp->rp->rhs[cfp->dot];             /* Symbol after the dot */
+
+    /* For every configuration in the state "stp" which has the symbol "sp"
+    ** following its dot, add the same configuration to the basis set under
+    ** construction but with the dot shifted one symbol to the right. */
+    for(bcfp=cfp; bcfp; bcfp=bcfp->next){
+      if( bcfp->status==COMPLETE ) continue;    /* Already used */
+      if( bcfp->dot>=bcfp->rp->nrhs ) continue; /* Can't shift this one */
+      bsp = bcfp->rp->rhs[bcfp->dot];           /* Get symbol after dot */
+      if( !same_symbol(bsp,sp) ) continue;      /* Must be same as for "cfp" */
+      bcfp->status = COMPLETE;                  /* Mark this config as used */
+      newcfg = Configlist_addbasis(bcfp->rp,bcfp->dot+1);
+      Plink_add(&newcfg->bplp,bcfp);
+    }
+
+    /* Get a pointer to the state described by the basis configuration set
+    ** constructed in the preceding loop */
+    newstp = getstate(lemp);
+
+    /* The state "newstp" is reached from the state "stp" by a shift action
+    ** on the symbol "sp" */
+    if( sp->type==MULTITERMINAL ){
+      int i;
+      for(i=0; i<sp->nsubsym; i++){
+        Action_add(&stp->ap,SHIFT,sp->subsym[i],(char*)newstp);
+      }
+    }else{
+      Action_add(&stp->ap,SHIFT,sp,(char *)newstp);
+    }
+  }
+}
+
+/*
+** Construct the propagation links
+*/
+void FindLinks(struct lemon *lemp)
+{
+  int i;
+  struct config *cfp, *other;
+  struct state *stp;
+  struct plink *plp;
+
+  /* Housekeeping detail:
+  ** Add to every propagate link a pointer back to the state to
+  ** which the link is attached. */
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    for(cfp=stp->cfp; cfp; cfp=cfp->next){
+      cfp->stp = stp;
+    }
+  }
+
+  /* Convert all backlinks into forward links.  Only the forward
+  ** links are used in the follow-set computation. */
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    for(cfp=stp->cfp; cfp; cfp=cfp->next){
+      for(plp=cfp->bplp; plp; plp=plp->next){
+        other = plp->cfp;
+        Plink_add(&other->fplp,cfp);
+      }
+    }
+  }
+}
+
+/* Compute all followsets.
+**
+** A followset is the set of all symbols which can come immediately
+** after a configuration.
+*/
+void FindFollowSets(struct lemon *lemp)
+{
+  int i;
+  struct config *cfp;
+  struct plink *plp;
+  int progress;
+  int change;
+
+  for(i=0; i<lemp->nstate; i++){
+    for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){
+      cfp->status = INCOMPLETE;
+    }
+  }
+  
+  do{
+    progress = 0;
+    for(i=0; i<lemp->nstate; i++){
+      for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){
+        if( cfp->status==COMPLETE ) continue;
+        for(plp=cfp->fplp; plp; plp=plp->next){
+          change = SetUnion(plp->cfp->fws,cfp->fws);
+          if( change ){
+            plp->cfp->status = INCOMPLETE;
+            progress = 1;
+          }
+        }
+        cfp->status = COMPLETE;
+      }
+    }
+  }while( progress );
+}
+
+static int resolve_conflict(struct action *,struct action *);
+
+/* Compute the reduce actions, and resolve conflicts.
+*/
+void FindActions(struct lemon *lemp)
+{
+  int i,j;
+  struct config *cfp;
+  struct state *stp;
+  struct symbol *sp;
+  struct rule *rp;
+
+  /* Add all of the reduce actions 
+  ** A reduce action is added for each element of the followset of
+  ** a configuration which has its dot at the extreme right.
+  */
+  for(i=0; i<lemp->nstate; i++){   /* Loop over all states */
+    stp = lemp->sorted[i];
+    for(cfp=stp->cfp; cfp; cfp=cfp->next){  /* Loop over all configurations */
+      if( cfp->rp->nrhs==cfp->dot ){        /* Is dot at extreme right? */
+        for(j=0; j<lemp->nterminal; j++){
+          if( SetFind(cfp->fws,j) ){
+            /* Add a reduce action to the state "stp" which will reduce by the
+            ** rule "cfp->rp" if the lookahead symbol is "lemp->symbols[j]" */
+            Action_add(&stp->ap,REDUCE,lemp->symbols[j],(char *)cfp->rp);
+          }
+        }
+      }
+    }
+  }
+
+  /* Add the accepting token */
+  if( lemp->start ){
+    sp = Symbol_find(lemp->start);
+    if( sp==0 ) sp = lemp->startRule->lhs;
+  }else{
+    sp = lemp->startRule->lhs;
+  }
+  /* Add to the first state (which is always the starting state of the
+  ** finite state machine) an action to ACCEPT if the lookahead is the
+  ** start nonterminal.  */
+  Action_add(&lemp->sorted[0]->ap,ACCEPT,sp,0);
+
+  /* Resolve conflicts */
+  for(i=0; i<lemp->nstate; i++){
+    struct action *ap, *nap;
+    stp = lemp->sorted[i];
+    /* assert( stp->ap ); */
+    stp->ap = Action_sort(stp->ap);
+    for(ap=stp->ap; ap && ap->next; ap=ap->next){
+      for(nap=ap->next; nap && nap->sp==ap->sp; nap=nap->next){
+         /* The two actions "ap" and "nap" have the same lookahead.
+         ** Figure out which one should be used */
+         lemp->nconflict += resolve_conflict(ap,nap);
+      }
+    }
+  }
+
+  /* Report an error for each rule that can never be reduced. */
+  for(rp=lemp->rule; rp; rp=rp->next) rp->canReduce = LEMON_FALSE;
+  for(i=0; i<lemp->nstate; i++){
+    struct action *ap;
+    for(ap=lemp->sorted[i]->ap; ap; ap=ap->next){
+      if( ap->type==REDUCE ) ap->x.rp->canReduce = LEMON_TRUE;
+    }
+  }
+  for(rp=lemp->rule; rp; rp=rp->next){
+    if( rp->canReduce ) continue;
+    ErrorMsg(lemp->filename,rp->ruleline,"This rule can not be reduced.\n");
+    lemp->errorcnt++;
+  }
+}
+
+/* Resolve a conflict between the two given actions.  If the
+** conflict can't be resolved, return non-zero.
+**
+** NO LONGER TRUE:
+**   To resolve a conflict, first look to see if either action
+**   is on an error rule.  In that case, take the action which
+**   is not associated with the error rule.  If neither or both
+**   actions are associated with an error rule, then try to
+**   use precedence to resolve the conflict.
+**
+** If either action is a SHIFT, then it must be apx.  This
+** function won't work if apx->type==REDUCE and apy->type==SHIFT.
+*/
+static int resolve_conflict(
+  struct action *apx,
+  struct action *apy
+){
+  struct symbol *spx, *spy;
+  int errcnt = 0;
+  assert( apx->sp==apy->sp );  /* Otherwise there would be no conflict */
+  if( apx->type==SHIFT && apy->type==SHIFT ){
+    apy->type = SSCONFLICT;
+    errcnt++;
+  }
+  if( apx->type==SHIFT && apy->type==REDUCE ){
+    spx = apx->sp;
+    spy = apy->x.rp->precsym;
+    if( spy==0 || spx->prec<0 || spy->prec<0 ){
+      /* Not enough precedence information. */
+      apy->type = SRCONFLICT;
+      errcnt++;
+    }else if( spx->prec>spy->prec ){    /* higher precedence wins */
+      apy->type = RD_RESOLVED;
+    }else if( spx->prec<spy->prec ){
+      apx->type = SH_RESOLVED;
+    }else if( spx->prec==spy->prec && spx->assoc==RIGHT ){ /* Use operator */
+      apy->type = RD_RESOLVED;                             /* associativity */
+    }else if( spx->prec==spy->prec && spx->assoc==LEFT ){  /* to break tie */
+      apx->type = SH_RESOLVED;
+    }else{
+      assert( spx->prec==spy->prec && spx->assoc==NONE );
+      apx->type = ERROR;
+    }
+  }else if( apx->type==REDUCE && apy->type==REDUCE ){
+    spx = apx->x.rp->precsym;
+    spy = apy->x.rp->precsym;
+    if( spx==0 || spy==0 || spx->prec<0 ||
+    spy->prec<0 || spx->prec==spy->prec ){
+      apy->type = RRCONFLICT;
+      errcnt++;
+    }else if( spx->prec>spy->prec ){
+      apy->type = RD_RESOLVED;
+    }else if( spx->prec<spy->prec ){
+      apx->type = RD_RESOLVED;
+    }
+  }else{
+    assert( 
+      apx->type==SH_RESOLVED ||
+      apx->type==RD_RESOLVED ||
+      apx->type==SSCONFLICT ||
+      apx->type==SRCONFLICT ||
+      apx->type==RRCONFLICT ||
+      apy->type==SH_RESOLVED ||
+      apy->type==RD_RESOLVED ||
+      apy->type==SSCONFLICT ||
+      apy->type==SRCONFLICT ||
+      apy->type==RRCONFLICT
+    );
+    /* The REDUCE/SHIFT case cannot happen because SHIFTs come before
+    ** REDUCEs on the list.  If we reach this point it must be because
+    ** the parser conflict had already been resolved. */
+  }
+  return errcnt;
+}
+/********************* From the file "configlist.c" *************************/
+/*
+** Routines to processing a configuration list and building a state
+** in the LEMON parser generator.
+*/
+
+static struct config *freelist = 0;      /* List of free configurations */
+static struct config *current = 0;       /* Top of list of configurations */
+static struct config **currentend = 0;   /* Last on list of configs */
+static struct config *basis = 0;         /* Top of list of basis configs */
+static struct config **basisend = 0;     /* End of list of basis configs */
+
+/* Return a pointer to a new configuration */
+PRIVATE struct config *newconfig(){
+  struct config *newcfg;
+  if( freelist==0 ){
+    int i;
+    int amt = 3;
+    freelist = (struct config *)calloc( amt, sizeof(struct config) );
+    if( freelist==0 ){
+      fprintf(stderr,"Unable to allocate memory for a new configuration.");
+      exit(1);
+    }
+    for(i=0; i<amt-1; i++) freelist[i].next = &freelist[i+1];
+    freelist[amt-1].next = 0;
+  }
+  newcfg = freelist;
+  freelist = freelist->next;
+  return newcfg;
+}
+
+/* The configuration "old" is no longer used */
+PRIVATE void deleteconfig(struct config *old)
+{
+  old->next = freelist;
+  freelist = old;
+}
+
+/* Initialized the configuration list builder */
+void Configlist_init(){
+  current = 0;
+  currentend = &current;
+  basis = 0;
+  basisend = &basis;
+  Configtable_init();
+  return;
+}
+
+/* Initialized the configuration list builder */
+void Configlist_reset(){
+  current = 0;
+  currentend = &current;
+  basis = 0;
+  basisend = &basis;
+  Configtable_clear(0);
+  return;
+}
+
+/* Add another configuration to the configuration list */
+struct config *Configlist_add(
+  struct rule *rp,    /* The rule */
+  int dot             /* Index into the RHS of the rule where the dot goes */
+){
+  struct config *cfp, model;
+
+  assert( currentend!=0 );
+  model.rp = rp;
+  model.dot = dot;
+  cfp = Configtable_find(&model);
+  if( cfp==0 ){
+    cfp = newconfig();
+    cfp->rp = rp;
+    cfp->dot = dot;
+    cfp->fws = SetNew();
+    cfp->stp = 0;
+    cfp->fplp = cfp->bplp = 0;
+    cfp->next = 0;
+    cfp->bp = 0;
+    *currentend = cfp;
+    currentend = &cfp->next;
+    Configtable_insert(cfp);
+  }
+  return cfp;
+}
+
+/* Add a basis configuration to the configuration list */
+struct config *Configlist_addbasis(struct rule *rp, int dot)
+{
+  struct config *cfp, model;
+
+  assert( basisend!=0 );
+  assert( currentend!=0 );
+  model.rp = rp;
+  model.dot = dot;
+  cfp = Configtable_find(&model);
+  if( cfp==0 ){
+    cfp = newconfig();
+    cfp->rp = rp;
+    cfp->dot = dot;
+    cfp->fws = SetNew();
+    cfp->stp = 0;
+    cfp->fplp = cfp->bplp = 0;
+    cfp->next = 0;
+    cfp->bp = 0;
+    *currentend = cfp;
+    currentend = &cfp->next;
+    *basisend = cfp;
+    basisend = &cfp->bp;
+    Configtable_insert(cfp);
+  }
+  return cfp;
+}
+
+/* Compute the closure of the configuration list */
+void Configlist_closure(struct lemon *lemp)
+{
+  struct config *cfp, *newcfp;
+  struct rule *rp, *newrp;
+  struct symbol *sp, *xsp;
+  int i, dot;
+
+  assert( currentend!=0 );
+  for(cfp=current; cfp; cfp=cfp->next){
+    rp = cfp->rp;
+    dot = cfp->dot;
+    if( dot>=rp->nrhs ) continue;
+    sp = rp->rhs[dot];
+    if( sp->type==NONTERMINAL ){
+      if( sp->rule==0 && sp!=lemp->errsym ){
+        ErrorMsg(lemp->filename,rp->line,"Nonterminal \"%s\" has no rules.",
+          sp->name);
+        lemp->errorcnt++;
+      }
+      for(newrp=sp->rule; newrp; newrp=newrp->nextlhs){
+        newcfp = Configlist_add(newrp,0);
+        for(i=dot+1; i<rp->nrhs; i++){
+          xsp = rp->rhs[i];
+          if( xsp->type==TERMINAL ){
+            SetAdd(newcfp->fws,xsp->index);
+            break;
+          }else if( xsp->type==MULTITERMINAL ){
+            int k;
+            for(k=0; k<xsp->nsubsym; k++){
+              SetAdd(newcfp->fws, xsp->subsym[k]->index);
+            }
+            break;
+          }else{
+            SetUnion(newcfp->fws,xsp->firstset);
+            if( xsp->lambda==LEMON_FALSE ) break;
+          }
+        }
+        if( i==rp->nrhs ) Plink_add(&cfp->fplp,newcfp);
+      }
+    }
+  }
+  return;
+}
+
+/* Sort the configuration list */
+void Configlist_sort(){
+  current = (struct config*)msort((char*)current,(char**)&(current->next),
+                                  Configcmp);
+  currentend = 0;
+  return;
+}
+
+/* Sort the basis configuration list */
+void Configlist_sortbasis(){
+  basis = (struct config*)msort((char*)current,(char**)&(current->bp),
+                                Configcmp);
+  basisend = 0;
+  return;
+}
+
+/* Return a pointer to the head of the configuration list and
+** reset the list */
+struct config *Configlist_return(){
+  struct config *old;
+  old = current;
+  current = 0;
+  currentend = 0;
+  return old;
+}
+
+/* Return a pointer to the head of the configuration list and
+** reset the list */
+struct config *Configlist_basis(){
+  struct config *old;
+  old = basis;
+  basis = 0;
+  basisend = 0;
+  return old;
+}
+
+/* Free all elements of the given configuration list */
+void Configlist_eat(struct config *cfp)
+{
+  struct config *nextcfp;
+  for(; cfp; cfp=nextcfp){
+    nextcfp = cfp->next;
+    assert( cfp->fplp==0 );
+    assert( cfp->bplp==0 );
+    if( cfp->fws ) SetFree(cfp->fws);
+    deleteconfig(cfp);
+  }
+  return;
+}
+/***************** From the file "error.c" *********************************/
+/*
+** Code for printing error message.
+*/
+
+void ErrorMsg(const char *filename, int lineno, const char *format, ...){
+  va_list ap;
+  fprintf(stderr, "%s:%d: ", filename, lineno);
+  va_start(ap, format);
+  vfprintf(stderr,format,ap);
+  va_end(ap);
+  fprintf(stderr, "\n");
+}
+/**************** From the file "main.c" ************************************/
+/*
+** Main program file for the LEMON parser generator.
+*/
+
+/* Report an out-of-memory condition and abort.  This function
+** is used mostly by the "MemoryCheck" macro in struct.h
+*/
+void memory_error(){
+  fprintf(stderr,"Out of memory.  Aborting...\n");
+  exit(1);
+}
+
+static int nDefine = 0;      /* Number of -D options on the command line */
+static char **azDefine = 0;  /* Name of the -D macros */
+
+/* This routine is called with the argument to each -D command-line option.
+** Add the macro defined to the azDefine array.
+*/
+static void handle_D_option(char *z){
+  char **paz;
+  nDefine++;
+  azDefine = (char **) realloc(azDefine, sizeof(azDefine[0])*nDefine);
+  if( azDefine==0 ){
+    fprintf(stderr,"out of memory\n");
+    exit(1);
+  }
+  paz = &azDefine[nDefine-1];
+  *paz = (char *) malloc( lemonStrlen(z)+1 );
+  if( *paz==0 ){
+    fprintf(stderr,"out of memory\n");
+    exit(1);
+  }
+  lemon_strcpy(*paz, z);
+  for(z=*paz; *z && *z!='='; z++){}
+  *z = 0;
+}
+
+static char *user_templatename = NULL;
+static void handle_T_option(char *z){
+  user_templatename = (char *) malloc( lemonStrlen(z)+1 );
+  if( user_templatename==0 ){
+    memory_error();
+  }
+  lemon_strcpy(user_templatename, z);
+}
+
+/* Merge together to lists of rules ordered by rule.iRule */
+static struct rule *Rule_merge(struct rule *pA, struct rule *pB){
+  struct rule *pFirst = 0;
+  struct rule **ppPrev = &pFirst;
+  while( pA && pB ){
+    if( pA->iRule<pB->iRule ){
+      *ppPrev = pA;
+      ppPrev = &pA->next;
+      pA = pA->next;
+    }else{
+      *ppPrev = pB;
+      ppPrev = &pB->next;
+      pB = pB->next;
+    }
+  }
+  if( pA ){
+    *ppPrev = pA;
+  }else{
+    *ppPrev = pB;
+  }
+  return pFirst;
+}
+
+/*
+** Sort a list of rules in order of increasing iRule value
+*/
+static struct rule *Rule_sort(struct rule *rp){
+  int i;
+  struct rule *pNext;
+  struct rule *x[32];
+  memset(x, 0, sizeof(x));
+  while( rp ){
+    pNext = rp->next;
+    rp->next = 0;
+    for(i=0; i<sizeof(x)/sizeof(x[0]) && x[i]; i++){
+      rp = Rule_merge(x[i], rp);
+      x[i] = 0;
+    }
+    x[i] = rp;
+    rp = pNext;
+  }
+  rp = 0;
+  for(i=0; i<sizeof(x)/sizeof(x[0]); i++){
+    rp = Rule_merge(x[i], rp);
+  }
+  return rp;
+}
+
+/* forward reference */
+static const char *minimum_size_type(int lwr, int upr, int *pnByte);
+
+/* Print a single line of the "Parser Stats" output
+*/
+static void stats_line(const char *zLabel, int iValue){
+  int nLabel = lemonStrlen(zLabel);
+  printf("  %s%.*s %5d\n", zLabel,
+         35-nLabel, "................................",
+         iValue);
+}
+
+/* The main program.  Parse the command line and do it... */
+int main(int argc, char **argv)
+{
+  static int version = 0;
+  static int rpflag = 0;
+  static int basisflag = 0;
+  static int compress = 0;
+  static int quiet = 0;
+  static int statistics = 0;
+  static int mhflag = 0;
+  static int nolinenosflag = 0;
+  static int noResort = 0;
+  static struct s_options options[] = {
+    {OPT_FLAG, "b", (char*)&basisflag, "Print only the basis in report."},
+    {OPT_FLAG, "c", (char*)&compress, "Don't compress the action table."},
+    {OPT_FSTR, "D", (char*)handle_D_option, "Define an %ifdef macro."},
+    {OPT_FSTR, "f", 0, "Ignored.  (Placeholder for -f compiler options.)"},
+    {OPT_FLAG, "g", (char*)&rpflag, "Print grammar without actions."},
+    {OPT_FSTR, "I", 0, "Ignored.  (Placeholder for '-I' compiler options.)"},
+    {OPT_FLAG, "m", (char*)&mhflag, "Output a makeheaders compatible file."},
+    {OPT_FLAG, "l", (char*)&nolinenosflag, "Do not print #line statements."},
+    {OPT_FSTR, "O", 0, "Ignored.  (Placeholder for '-O' compiler options.)"},
+    {OPT_FLAG, "p", (char*)&showPrecedenceConflict,
+                    "Show conflicts resolved by precedence rules"},
+    {OPT_FLAG, "q", (char*)&quiet, "(Quiet) Don't print the report file."},
+    {OPT_FLAG, "r", (char*)&noResort, "Do not sort or renumber states"},
+    {OPT_FLAG, "s", (char*)&statistics,
+                                   "Print parser stats to standard output."},
+    {OPT_FLAG, "x", (char*)&version, "Print the version number."},
+    {OPT_FSTR, "T", (char*)handle_T_option, "Specify a template file."},
+    {OPT_FSTR, "W", 0, "Ignored.  (Placeholder for '-W' compiler options.)"},
+    {OPT_FLAG,0,0,0}
+  };
+  int i;
+  int exitcode;
+  struct lemon lem;
+  struct rule *rp;
+
+  OptInit(argv,options,stderr);
+  if( version ){
+     printf("Lemon version 1.0\n");
+     exit(0); 
+  }
+  if( OptNArgs()!=1 ){
+    fprintf(stderr,"Exactly one filename argument is required.\n");
+    exit(1);
+  }
+  memset(&lem, 0, sizeof(lem));
+  lem.errorcnt = 0;
+
+  /* Initialize the machine */
+  Strsafe_init();
+  Symbol_init();
+  State_init();
+  lem.argv0 = argv[0];
+  lem.filename = OptArg(0);
+  lem.basisflag = basisflag;
+  lem.nolinenosflag = nolinenosflag;
+  Symbol_new("$");
+  lem.errsym = Symbol_new("error");
+  lem.errsym->useCnt = 0;
+
+  /* Parse the input file */
+  Parse(&lem);
+  if( lem.errorcnt ) exit(lem.errorcnt);
+  if( lem.nrule==0 ){
+    fprintf(stderr,"Empty grammar.\n");
+    exit(1);
+  }
+
+  /* Count and index the symbols of the grammar */
+  Symbol_new("{default}");
+  lem.nsymbol = Symbol_count();
+  lem.symbols = Symbol_arrayof();
+  for(i=0; i<lem.nsymbol; i++) lem.symbols[i]->index = i;
+  qsort(lem.symbols,lem.nsymbol,sizeof(struct symbol*), Symbolcmpp);
+  for(i=0; i<lem.nsymbol; i++) lem.symbols[i]->index = i;
+  while( lem.symbols[i-1]->type==MULTITERMINAL ){ i--; }
+  assert( strcmp(lem.symbols[i-1]->name,"{default}")==0 );
+  lem.nsymbol = i - 1;
+  for(i=1; ISUPPER(lem.symbols[i]->name[0]); i++);
+  lem.nterminal = i;
+
+  /* Assign sequential rule numbers.  Start with 0.  Put rules that have no
+  ** reduce action C-code associated with them last, so that the switch()
+  ** statement that selects reduction actions will have a smaller jump table.
+  */
+  for(i=0, rp=lem.rule; rp; rp=rp->next){
+    rp->iRule = rp->code ? i++ : -1;
+  }
+  for(rp=lem.rule; rp; rp=rp->next){
+    if( rp->iRule<0 ) rp->iRule = i++;
+  }
+  lem.startRule = lem.rule;
+  lem.rule = Rule_sort(lem.rule);
+
+  /* Generate a reprint of the grammar, if requested on the command line */
+  if( rpflag ){
+    Reprint(&lem);
+  }else{
+    /* Initialize the size for all follow and first sets */
+    SetSize(lem.nterminal+1);
+
+    /* Find the precedence for every production rule (that has one) */
+    FindRulePrecedences(&lem);
+
+    /* Compute the lambda-nonterminals and the first-sets for every
+    ** nonterminal */
+    FindFirstSets(&lem);
+
+    /* Compute all LR(0) states.  Also record follow-set propagation
+    ** links so that the follow-set can be computed later */
+    lem.nstate = 0;
+    FindStates(&lem);
+    lem.sorted = State_arrayof();
+
+    /* Tie up loose ends on the propagation links */
+    FindLinks(&lem);
+
+    /* Compute the follow set of every reducible configuration */
+    FindFollowSets(&lem);
+
+    /* Compute the action tables */
+    FindActions(&lem);
+
+    /* Compress the action tables */
+    if( compress==0 ) CompressTables(&lem);
+
+    /* Reorder and renumber the states so that states with fewer choices
+    ** occur at the end.  This is an optimization that helps make the
+    ** generated parser tables smaller. */
+    if( noResort==0 ) ResortStates(&lem);
+
+    /* Generate a report of the parser generated.  (the "y.output" file) */
+    if( !quiet ) ReportOutput(&lem);
+
+    /* Generate the source code for the parser */
+    ReportTable(&lem, mhflag);
+
+    /* Produce a header file for use by the scanner.  (This step is
+    ** omitted if the "-m" option is used because makeheaders will
+    ** generate the file for us.) */
+    if( !mhflag ) ReportHeader(&lem);
+  }
+  if( statistics ){
+    printf("Parser statistics:\n");
+    stats_line("terminal symbols", lem.nterminal);
+    stats_line("non-terminal symbols", lem.nsymbol - lem.nterminal);
+    stats_line("total symbols", lem.nsymbol);
+    stats_line("rules", lem.nrule);
+    stats_line("states", lem.nxstate);
+    stats_line("conflicts", lem.nconflict);
+    stats_line("action table entries", lem.nactiontab);
+    stats_line("total table size (bytes)", lem.tablesize);
+  }
+  if( lem.nconflict > 0 ){
+    fprintf(stderr,"%d parsing conflicts.\n",lem.nconflict);
+  }
+
+  /* return 0 on success, 1 on failure. */
+  exitcode = ((lem.errorcnt > 0) || (lem.nconflict > 0)) ? 1 : 0;
+  exit(exitcode);
+  return (exitcode);
+}
+/******************** From the file "msort.c" *******************************/
+/*
+** A generic merge-sort program.
+**
+** USAGE:
+** Let "ptr" be a pointer to some structure which is at the head of
+** a null-terminated list.  Then to sort the list call:
+**
+**     ptr = msort(ptr,&(ptr->next),cmpfnc);
+**
+** In the above, "cmpfnc" is a pointer to a function which compares
+** two instances of the structure and returns an integer, as in
+** strcmp.  The second argument is a pointer to the pointer to the
+** second element of the linked list.  This address is used to compute
+** the offset to the "next" field within the structure.  The offset to
+** the "next" field must be constant for all structures in the list.
+**
+** The function returns a new pointer which is the head of the list
+** after sorting.
+**
+** ALGORITHM:
+** Merge-sort.
+*/
+
+/*
+** Return a pointer to the next structure in the linked list.
+*/
+#define NEXT(A) (*(char**)(((char*)A)+offset))
+
+/*
+** Inputs:
+**   a:       A sorted, null-terminated linked list.  (May be null).
+**   b:       A sorted, null-terminated linked list.  (May be null).
+**   cmp:     A pointer to the comparison function.
+**   offset:  Offset in the structure to the "next" field.
+**
+** Return Value:
+**   A pointer to the head of a sorted list containing the elements
+**   of both a and b.
+**
+** Side effects:
+**   The "next" pointers for elements in the lists a and b are
+**   changed.
+*/
+static char *merge(
+  char *a,
+  char *b,
+  int (*cmp)(const char*,const char*),
+  int offset
+){
+  char *ptr, *head;
+
+  if( a==0 ){
+    head = b;
+  }else if( b==0 ){
+    head = a;
+  }else{
+    if( (*cmp)(a,b)<=0 ){
+      ptr = a;
+      a = NEXT(a);
+    }else{
+      ptr = b;
+      b = NEXT(b);
+    }
+    head = ptr;
+    while( a && b ){
+      if( (*cmp)(a,b)<=0 ){
+        NEXT(ptr) = a;
+        ptr = a;
+        a = NEXT(a);
+      }else{
+        NEXT(ptr) = b;
+        ptr = b;
+        b = NEXT(b);
+      }
+    }
+    if( a ) NEXT(ptr) = a;
+    else    NEXT(ptr) = b;
+  }
+  return head;
+}
+
+/*
+** Inputs:
+**   list:      Pointer to a singly-linked list of structures.
+**   next:      Pointer to pointer to the second element of the list.
+**   cmp:       A comparison function.
+**
+** Return Value:
+**   A pointer to the head of a sorted list containing the elements
+**   orginally in list.
+**
+** Side effects:
+**   The "next" pointers for elements in list are changed.
+*/
+#define LISTSIZE 30
+static char *msort(
+  char *list,
+  char **next,
+  int (*cmp)(const char*,const char*)
+){
+  unsigned long offset;
+  char *ep;
+  char *set[LISTSIZE];
+  int i;
+  offset = (unsigned long)((char*)next - (char*)list);
+  for(i=0; i<LISTSIZE; i++) set[i] = 0;
+  while( list ){
+    ep = list;
+    list = NEXT(list);
+    NEXT(ep) = 0;
+    for(i=0; i<LISTSIZE-1 && set[i]!=0; i++){
+      ep = merge(ep,set[i],cmp,offset);
+      set[i] = 0;
+    }
+    set[i] = ep;
+  }
+  ep = 0;
+  for(i=0; i<LISTSIZE; i++) if( set[i] ) ep = merge(set[i],ep,cmp,offset);
+  return ep;
+}
+/************************ From the file "option.c" **************************/
+static char **argv;
+static struct s_options *op;
+static FILE *errstream;
+
+#define ISOPT(X) ((X)[0]=='-'||(X)[0]=='+'||strchr((X),'=')!=0)
+
+/*
+** Print the command line with a carrot pointing to the k-th character
+** of the n-th field.
+*/
+static void errline(int n, int k, FILE *err)
+{
+  int spcnt, i;
+  if( argv[0] ) fprintf(err,"%s",argv[0]);
+  spcnt = lemonStrlen(argv[0]) + 1;
+  for(i=1; i<n && argv[i]; i++){
+    fprintf(err," %s",argv[i]);
+    spcnt += lemonStrlen(argv[i])+1;
+  }
+  spcnt += k;
+  for(; argv[i]; i++) fprintf(err," %s",argv[i]);
+  if( spcnt<20 ){
+    fprintf(err,"\n%*s^-- here\n",spcnt,"");
+  }else{
+    fprintf(err,"\n%*shere --^\n",spcnt-7,"");
+  }
+}
+
+/*
+** Return the index of the N-th non-switch argument.  Return -1
+** if N is out of range.
+*/
+static int argindex(int n)
+{
+  int i;
+  int dashdash = 0;
+  if( argv!=0 && *argv!=0 ){
+    for(i=1; argv[i]; i++){
+      if( dashdash || !ISOPT(argv[i]) ){
+        if( n==0 ) return i;
+        n--;
+      }
+      if( strcmp(argv[i],"--")==0 ) dashdash = 1;
+    }
+  }
+  return -1;
+}
+
+static char emsg[] = "Command line syntax error: ";
+
+/*
+** Process a flag command line argument.
+*/
+static int handleflags(int i, FILE *err)
+{
+  int v;
+  int errcnt = 0;
+  int j;
+  for(j=0; op[j].label; j++){
+    if( strncmp(&argv[i][1],op[j].label,lemonStrlen(op[j].label))==0 ) break;
+  }
+  v = argv[i][0]=='-' ? 1 : 0;
+  if( op[j].label==0 ){
+    if( err ){
+      fprintf(err,"%sundefined option.\n",emsg);
+      errline(i,1,err);
+    }
+    errcnt++;
+  }else if( op[j].arg==0 ){
+    /* Ignore this option */
+  }else if( op[j].type==OPT_FLAG ){
+    *((int*)op[j].arg) = v;
+  }else if( op[j].type==OPT_FFLAG ){
+    (*(void(*)(int))(op[j].arg))(v);
+  }else if( op[j].type==OPT_FSTR ){
+    (*(void(*)(char *))(op[j].arg))(&argv[i][2]);
+  }else{
+    if( err ){
+      fprintf(err,"%smissing argument on switch.\n",emsg);
+      errline(i,1,err);
+    }
+    errcnt++;
+  }
+  return errcnt;
+}
+
+/*
+** Process a command line switch which has an argument.
+*/
+static int handleswitch(int i, FILE *err)
+{
+  int lv = 0;
+  double dv = 0.0;
+  char *sv = 0, *end;
+  char *cp;
+  int j;
+  int errcnt = 0;
+  cp = strchr(argv[i],'=');
+  assert( cp!=0 );
+  *cp = 0;
+  for(j=0; op[j].label; j++){
+    if( strcmp(argv[i],op[j].label)==0 ) break;
+  }
+  *cp = '=';
+  if( op[j].label==0 ){
+    if( err ){
+      fprintf(err,"%sundefined option.\n",emsg);
+      errline(i,0,err);
+    }
+    errcnt++;
+  }else{
+    cp++;
+    switch( op[j].type ){
+      case OPT_FLAG:
+      case OPT_FFLAG:
+        if( err ){
+          fprintf(err,"%soption requires an argument.\n",emsg);
+          errline(i,0,err);
+        }
+        errcnt++;
+        break;
+      case OPT_DBL:
+      case OPT_FDBL:
+        dv = strtod(cp,&end);
+        if( *end ){
+          if( err ){
+            fprintf(err,
+               "%sillegal character in floating-point argument.\n",emsg);
+            errline(i,(int)((char*)end-(char*)argv[i]),err);
+          }
+          errcnt++;
+        }
+        break;
+      case OPT_INT:
+      case OPT_FINT:
+        lv = strtol(cp,&end,0);
+        if( *end ){
+          if( err ){
+            fprintf(err,"%sillegal character in integer argument.\n",emsg);
+            errline(i,(int)((char*)end-(char*)argv[i]),err);
+          }
+          errcnt++;
+        }
+        break;
+      case OPT_STR:
+      case OPT_FSTR:
+        sv = cp;
+        break;
+    }
+    switch( op[j].type ){
+      case OPT_FLAG:
+      case OPT_FFLAG:
+        break;
+      case OPT_DBL:
+        *(double*)(op[j].arg) = dv;
+        break;
+      case OPT_FDBL:
+        (*(void(*)(double))(op[j].arg))(dv);
+        break;
+      case OPT_INT:
+        *(int*)(op[j].arg) = lv;
+        break;
+      case OPT_FINT:
+        (*(void(*)(int))(op[j].arg))((int)lv);
+        break;
+      case OPT_STR:
+        *(char**)(op[j].arg) = sv;
+        break;
+      case OPT_FSTR:
+        (*(void(*)(char *))(op[j].arg))(sv);
+        break;
+    }
+  }
+  return errcnt;
+}
+
+int OptInit(char **a, struct s_options *o, FILE *err)
+{
+  int errcnt = 0;
+  argv = a;
+  op = o;
+  errstream = err;
+  if( argv && *argv && op ){
+    int i;
+    for(i=1; argv[i]; i++){
+      if( argv[i][0]=='+' || argv[i][0]=='-' ){
+        errcnt += handleflags(i,err);
+      }else if( strchr(argv[i],'=') ){
+        errcnt += handleswitch(i,err);
+      }
+    }
+  }
+  if( errcnt>0 ){
+    fprintf(err,"Valid command line options for \"%s\" are:\n",*a);
+    OptPrint();
+    exit(1);
+  }
+  return 0;
+}
+
+int OptNArgs(){
+  int cnt = 0;
+  int dashdash = 0;
+  int i;
+  if( argv!=0 && argv[0]!=0 ){
+    for(i=1; argv[i]; i++){
+      if( dashdash || !ISOPT(argv[i]) ) cnt++;
+      if( strcmp(argv[i],"--")==0 ) dashdash = 1;
+    }
+  }
+  return cnt;
+}
+
+char *OptArg(int n)
+{
+  int i;
+  i = argindex(n);
+  return i>=0 ? argv[i] : 0;
+}
+
+void OptErr(int n)
+{
+  int i;
+  i = argindex(n);
+  if( i>=0 ) errline(i,0,errstream);
+}
+
+void OptPrint(){
+  int i;
+  int max, len;
+  max = 0;
+  for(i=0; op[i].label; i++){
+    len = lemonStrlen(op[i].label) + 1;
+    switch( op[i].type ){
+      case OPT_FLAG:
+      case OPT_FFLAG:
+        break;
+      case OPT_INT:
+      case OPT_FINT:
+        len += 9;       /* length of "<integer>" */
+        break;
+      case OPT_DBL:
+      case OPT_FDBL:
+        len += 6;       /* length of "<real>" */
+        break;
+      case OPT_STR:
+      case OPT_FSTR:
+        len += 8;       /* length of "<string>" */
+        break;
+    }
+    if( len>max ) max = len;
+  }
+  for(i=0; op[i].label; i++){
+    switch( op[i].type ){
+      case OPT_FLAG:
+      case OPT_FFLAG:
+        fprintf(errstream,"  -%-*s  %s\n",max,op[i].label,op[i].message);
+        break;
+      case OPT_INT:
+      case OPT_FINT:
+        fprintf(errstream,"  -%s<integer>%*s  %s\n",op[i].label,
+          (int)(max-lemonStrlen(op[i].label)-9),"",op[i].message);
+        break;
+      case OPT_DBL:
+      case OPT_FDBL:
+        fprintf(errstream,"  -%s<real>%*s  %s\n",op[i].label,
+          (int)(max-lemonStrlen(op[i].label)-6),"",op[i].message);
+        break;
+      case OPT_STR:
+      case OPT_FSTR:
+        fprintf(errstream,"  -%s<string>%*s  %s\n",op[i].label,
+          (int)(max-lemonStrlen(op[i].label)-8),"",op[i].message);
+        break;
+    }
+  }
+}
+/*********************** From the file "parse.c" ****************************/
+/*
+** Input file parser for the LEMON parser generator.
+*/
+
+/* The state of the parser */
+enum e_state {
+  INITIALIZE,
+  WAITING_FOR_DECL_OR_RULE,
+  WAITING_FOR_DECL_KEYWORD,
+  WAITING_FOR_DECL_ARG,
+  WAITING_FOR_PRECEDENCE_SYMBOL,
+  WAITING_FOR_ARROW,
+  IN_RHS,
+  LHS_ALIAS_1,
+  LHS_ALIAS_2,
+  LHS_ALIAS_3,
+  RHS_ALIAS_1,
+  RHS_ALIAS_2,
+  PRECEDENCE_MARK_1,
+  PRECEDENCE_MARK_2,
+  RESYNC_AFTER_RULE_ERROR,
+  RESYNC_AFTER_DECL_ERROR,
+  WAITING_FOR_DESTRUCTOR_SYMBOL,
+  WAITING_FOR_DATATYPE_SYMBOL,
+  WAITING_FOR_FALLBACK_ID,
+  WAITING_FOR_WILDCARD_ID,
+  WAITING_FOR_CLASS_ID,
+  WAITING_FOR_CLASS_TOKEN
+};
+struct pstate {
+  char *filename;       /* Name of the input file */
+  int tokenlineno;      /* Linenumber at which current token starts */
+  int errorcnt;         /* Number of errors so far */
+  char *tokenstart;     /* Text of current token */
+  struct lemon *gp;     /* Global state vector */
+  enum e_state state;        /* The state of the parser */
+  struct symbol *fallback;   /* The fallback token */
+  struct symbol *tkclass;    /* Token class symbol */
+  struct symbol *lhs;        /* Left-hand side of current rule */
+  const char *lhsalias;      /* Alias for the LHS */
+  int nrhs;                  /* Number of right-hand side symbols seen */
+  struct symbol *rhs[MAXRHS];  /* RHS symbols */
+  const char *alias[MAXRHS]; /* Aliases for each RHS symbol (or NULL) */
+  struct rule *prevrule;     /* Previous rule parsed */
+  const char *declkeyword;   /* Keyword of a declaration */
+  char **declargslot;        /* Where the declaration argument should be put */
+  int insertLineMacro;       /* Add #line before declaration insert */
+  int *decllinenoslot;       /* Where to write declaration line number */
+  enum e_assoc declassoc;    /* Assign this association to decl arguments */
+  int preccounter;           /* Assign this precedence to decl arguments */
+  struct rule *firstrule;    /* Pointer to first rule in the grammar */
+  struct rule *lastrule;     /* Pointer to the most recently parsed rule */
+};
+
+/* Parse a single token */
+static void parseonetoken(struct pstate *psp)
+{
+  const char *x;
+  x = Strsafe(psp->tokenstart);     /* Save the token permanently */
+#if 0
+  printf("%s:%d: Token=[%s] state=%d\n",psp->filename,psp->tokenlineno,
+    x,psp->state);
+#endif
+  switch( psp->state ){
+    case INITIALIZE:
+      psp->prevrule = 0;
+      psp->preccounter = 0;
+      psp->firstrule = psp->lastrule = 0;
+      psp->gp->nrule = 0;
+      /* Fall thru to next case */
+    case WAITING_FOR_DECL_OR_RULE:
+      if( x[0]=='%' ){
+        psp->state = WAITING_FOR_DECL_KEYWORD;
+      }else if( ISLOWER(x[0]) ){
+        psp->lhs = Symbol_new(x);
+        psp->nrhs = 0;
+        psp->lhsalias = 0;
+        psp->state = WAITING_FOR_ARROW;
+      }else if( x[0]=='{' ){
+        if( psp->prevrule==0 ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+"There is no prior rule upon which to attach the code \
+fragment which begins on this line.");
+          psp->errorcnt++;
+        }else if( psp->prevrule->code!=0 ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+"Code fragment beginning on this line is not the first \
+to follow the previous rule.");
+          psp->errorcnt++;
+        }else{
+          psp->prevrule->line = psp->tokenlineno;
+          psp->prevrule->code = &x[1];
+          psp->prevrule->noCode = 0;
+        }
+      }else if( x[0]=='[' ){
+        psp->state = PRECEDENCE_MARK_1;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Token \"%s\" should be either \"%%\" or a nonterminal name.",
+          x);
+        psp->errorcnt++;
+      }
+      break;
+    case PRECEDENCE_MARK_1:
+      if( !ISUPPER(x[0]) ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "The precedence symbol must be a terminal.");
+        psp->errorcnt++;
+      }else if( psp->prevrule==0 ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "There is no prior rule to assign precedence \"[%s]\".",x);
+        psp->errorcnt++;
+      }else if( psp->prevrule->precsym!=0 ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+"Precedence mark on this line is not the first \
+to follow the previous rule.");
+        psp->errorcnt++;
+      }else{
+        psp->prevrule->precsym = Symbol_new(x);
+      }
+      psp->state = PRECEDENCE_MARK_2;
+      break;
+    case PRECEDENCE_MARK_2:
+      if( x[0]!=']' ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Missing \"]\" on precedence mark.");
+        psp->errorcnt++;
+      }
+      psp->state = WAITING_FOR_DECL_OR_RULE;
+      break;
+    case WAITING_FOR_ARROW:
+      if( x[0]==':' && x[1]==':' && x[2]=='=' ){
+        psp->state = IN_RHS;
+      }else if( x[0]=='(' ){
+        psp->state = LHS_ALIAS_1;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Expected to see a \":\" following the LHS symbol \"%s\".",
+          psp->lhs->name);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case LHS_ALIAS_1:
+      if( ISALPHA(x[0]) ){
+        psp->lhsalias = x;
+        psp->state = LHS_ALIAS_2;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "\"%s\" is not a valid alias for the LHS \"%s\"\n",
+          x,psp->lhs->name);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case LHS_ALIAS_2:
+      if( x[0]==')' ){
+        psp->state = LHS_ALIAS_3;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Missing \")\" following LHS alias name \"%s\".",psp->lhsalias);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case LHS_ALIAS_3:
+      if( x[0]==':' && x[1]==':' && x[2]=='=' ){
+        psp->state = IN_RHS;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Missing \"->\" following: \"%s(%s)\".",
+           psp->lhs->name,psp->lhsalias);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case IN_RHS:
+      if( x[0]=='.' ){
+        struct rule *rp;
+        rp = (struct rule *)calloc( sizeof(struct rule) + 
+             sizeof(struct symbol*)*psp->nrhs + sizeof(char*)*psp->nrhs, 1);
+        if( rp==0 ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Can't allocate enough memory for this rule.");
+          psp->errorcnt++;
+          psp->prevrule = 0;
+        }else{
+          int i;
+          rp->ruleline = psp->tokenlineno;
+          rp->rhs = (struct symbol**)&rp[1];
+          rp->rhsalias = (const char**)&(rp->rhs[psp->nrhs]);
+          for(i=0; i<psp->nrhs; i++){
+            rp->rhs[i] = psp->rhs[i];
+            rp->rhsalias[i] = psp->alias[i];
+          }
+          rp->lhs = psp->lhs;
+          rp->lhsalias = psp->lhsalias;
+          rp->nrhs = psp->nrhs;
+          rp->code = 0;
+          rp->noCode = 1;
+          rp->precsym = 0;
+          rp->index = psp->gp->nrule++;
+          rp->nextlhs = rp->lhs->rule;
+          rp->lhs->rule = rp;
+          rp->next = 0;
+          if( psp->firstrule==0 ){
+            psp->firstrule = psp->lastrule = rp;
+          }else{
+            psp->lastrule->next = rp;
+            psp->lastrule = rp;
+          }
+          psp->prevrule = rp;
+        }
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( ISALPHA(x[0]) ){
+        if( psp->nrhs>=MAXRHS ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Too many symbols on RHS of rule beginning at \"%s\".",
+            x);
+          psp->errorcnt++;
+          psp->state = RESYNC_AFTER_RULE_ERROR;
+        }else{
+          psp->rhs[psp->nrhs] = Symbol_new(x);
+          psp->alias[psp->nrhs] = 0;
+          psp->nrhs++;
+        }
+      }else if( (x[0]=='|' || x[0]=='/') && psp->nrhs>0 ){
+        struct symbol *msp = psp->rhs[psp->nrhs-1];
+        if( msp->type!=MULTITERMINAL ){
+          struct symbol *origsp = msp;
+          msp = (struct symbol *) calloc(1,sizeof(*msp));
+          memset(msp, 0, sizeof(*msp));
+          msp->type = MULTITERMINAL;
+          msp->nsubsym = 1;
+          msp->subsym = (struct symbol **) calloc(1,sizeof(struct symbol*));
+          msp->subsym[0] = origsp;
+          msp->name = origsp->name;
+          psp->rhs[psp->nrhs-1] = msp;
+        }
+        msp->nsubsym++;
+        msp->subsym = (struct symbol **) realloc(msp->subsym,
+          sizeof(struct symbol*)*msp->nsubsym);
+        msp->subsym[msp->nsubsym-1] = Symbol_new(&x[1]);
+        if( ISLOWER(x[1]) || ISLOWER(msp->subsym[0]->name[0]) ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Cannot form a compound containing a non-terminal");
+          psp->errorcnt++;
+        }
+      }else if( x[0]=='(' && psp->nrhs>0 ){
+        psp->state = RHS_ALIAS_1;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Illegal character on RHS of rule: \"%s\".",x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case RHS_ALIAS_1:
+      if( ISALPHA(x[0]) ){
+        psp->alias[psp->nrhs-1] = x;
+        psp->state = RHS_ALIAS_2;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "\"%s\" is not a valid alias for the RHS symbol \"%s\"\n",
+          x,psp->rhs[psp->nrhs-1]->name);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case RHS_ALIAS_2:
+      if( x[0]==')' ){
+        psp->state = IN_RHS;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Missing \")\" following LHS alias name \"%s\".",psp->lhsalias);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_RULE_ERROR;
+      }
+      break;
+    case WAITING_FOR_DECL_KEYWORD:
+      if( ISALPHA(x[0]) ){
+        psp->declkeyword = x;
+        psp->declargslot = 0;
+        psp->decllinenoslot = 0;
+        psp->insertLineMacro = 1;
+        psp->state = WAITING_FOR_DECL_ARG;
+        if( strcmp(x,"name")==0 ){
+          psp->declargslot = &(psp->gp->name);
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"include")==0 ){
+          psp->declargslot = &(psp->gp->include);
+        }else if( strcmp(x,"code")==0 ){
+          psp->declargslot = &(psp->gp->extracode);
+        }else if( strcmp(x,"token_destructor")==0 ){
+          psp->declargslot = &psp->gp->tokendest;
+        }else if( strcmp(x,"default_destructor")==0 ){
+          psp->declargslot = &psp->gp->vardest;
+        }else if( strcmp(x,"token_prefix")==0 ){
+          psp->declargslot = &psp->gp->tokenprefix;
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"syntax_error")==0 ){
+          psp->declargslot = &(psp->gp->error);
+        }else if( strcmp(x,"parse_accept")==0 ){
+          psp->declargslot = &(psp->gp->accept);
+        }else if( strcmp(x,"parse_failure")==0 ){
+          psp->declargslot = &(psp->gp->failure);
+        }else if( strcmp(x,"stack_overflow")==0 ){
+          psp->declargslot = &(psp->gp->overflow);
+        }else if( strcmp(x,"extra_argument")==0 ){
+          psp->declargslot = &(psp->gp->arg);
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"token_type")==0 ){
+          psp->declargslot = &(psp->gp->tokentype);
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"default_type")==0 ){
+          psp->declargslot = &(psp->gp->vartype);
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"stack_size")==0 ){
+          psp->declargslot = &(psp->gp->stacksize);
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"start_symbol")==0 ){
+          psp->declargslot = &(psp->gp->start);
+          psp->insertLineMacro = 0;
+        }else if( strcmp(x,"left")==0 ){
+          psp->preccounter++;
+          psp->declassoc = LEFT;
+          psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
+        }else if( strcmp(x,"right")==0 ){
+          psp->preccounter++;
+          psp->declassoc = RIGHT;
+          psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
+        }else if( strcmp(x,"nonassoc")==0 ){
+          psp->preccounter++;
+          psp->declassoc = NONE;
+          psp->state = WAITING_FOR_PRECEDENCE_SYMBOL;
+        }else if( strcmp(x,"destructor")==0 ){
+          psp->state = WAITING_FOR_DESTRUCTOR_SYMBOL;
+        }else if( strcmp(x,"type")==0 ){
+          psp->state = WAITING_FOR_DATATYPE_SYMBOL;
+        }else if( strcmp(x,"fallback")==0 ){
+          psp->fallback = 0;
+          psp->state = WAITING_FOR_FALLBACK_ID;
+        }else if( strcmp(x,"wildcard")==0 ){
+          psp->state = WAITING_FOR_WILDCARD_ID;
+        }else if( strcmp(x,"token_class")==0 ){
+          psp->state = WAITING_FOR_CLASS_ID;
+        }else{
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Unknown declaration keyword: \"%%%s\".",x);
+          psp->errorcnt++;
+          psp->state = RESYNC_AFTER_DECL_ERROR;
+        }
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Illegal declaration keyword: \"%s\".",x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }
+      break;
+    case WAITING_FOR_DESTRUCTOR_SYMBOL:
+      if( !ISALPHA(x[0]) ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Symbol name missing after %%destructor keyword");
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }else{
+        struct symbol *sp = Symbol_new(x);
+        psp->declargslot = &sp->destructor;
+        psp->decllinenoslot = &sp->destLineno;
+        psp->insertLineMacro = 1;
+        psp->state = WAITING_FOR_DECL_ARG;
+      }
+      break;
+    case WAITING_FOR_DATATYPE_SYMBOL:
+      if( !ISALPHA(x[0]) ){
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Symbol name missing after %%type keyword");
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }else{
+        struct symbol *sp = Symbol_find(x);
+        if((sp) && (sp->datatype)){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Symbol %%type \"%s\" already defined", x);
+          psp->errorcnt++;
+          psp->state = RESYNC_AFTER_DECL_ERROR;
+        }else{
+          if (!sp){
+            sp = Symbol_new(x);
+          }
+          psp->declargslot = &sp->datatype;
+          psp->insertLineMacro = 0;
+          psp->state = WAITING_FOR_DECL_ARG;
+        }
+      }
+      break;
+    case WAITING_FOR_PRECEDENCE_SYMBOL:
+      if( x[0]=='.' ){
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( ISUPPER(x[0]) ){
+        struct symbol *sp;
+        sp = Symbol_new(x);
+        if( sp->prec>=0 ){
+          ErrorMsg(psp->filename,psp->tokenlineno,
+            "Symbol \"%s\" has already be given a precedence.",x);
+          psp->errorcnt++;
+        }else{
+          sp->prec = psp->preccounter;
+          sp->assoc = psp->declassoc;
+        }
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Can't assign a precedence to \"%s\".",x);
+        psp->errorcnt++;
+      }
+      break;
+    case WAITING_FOR_DECL_ARG:
+      if( x[0]=='{' || x[0]=='\"' || ISALNUM(x[0]) ){
+        const char *zOld, *zNew;
+        char *zBuf, *z;
+        int nOld, n, nLine = 0, nNew, nBack;
+        int addLineMacro;
+        char zLine[50];
+        zNew = x;
+        if( zNew[0]=='"' || zNew[0]=='{' ) zNew++;
+        nNew = lemonStrlen(zNew);
+        if( *psp->declargslot ){
+          zOld = *psp->declargslot;
+        }else{
+          zOld = "";
+        }
+        nOld = lemonStrlen(zOld);
+        n = nOld + nNew + 20;
+        addLineMacro = !psp->gp->nolinenosflag && psp->insertLineMacro &&
+                        (psp->decllinenoslot==0 || psp->decllinenoslot[0]!=0);
+        if( addLineMacro ){
+          for(z=psp->filename, nBack=0; *z; z++){
+            if( *z=='\\' ) nBack++;
+          }
+          lemon_sprintf(zLine, "#line %d ", psp->tokenlineno);
+          nLine = lemonStrlen(zLine);
+          n += nLine + lemonStrlen(psp->filename) + nBack;
+        }
+        *psp->declargslot = (char *) realloc(*psp->declargslot, n);
+        zBuf = *psp->declargslot + nOld;
+        if( addLineMacro ){
+          if( nOld && zBuf[-1]!='\n' ){
+            *(zBuf++) = '\n';
+          }
+          memcpy(zBuf, zLine, nLine);
+          zBuf += nLine;
+          *(zBuf++) = '"';
+          for(z=psp->filename; *z; z++){
+            if( *z=='\\' ){
+              *(zBuf++) = '\\';
+            }
+            *(zBuf++) = *z;
+          }
+          *(zBuf++) = '"';
+          *(zBuf++) = '\n';
+        }
+        if( psp->decllinenoslot && psp->decllinenoslot[0]==0 ){
+          psp->decllinenoslot[0] = psp->tokenlineno;
+        }
+        memcpy(zBuf, zNew, nNew);
+        zBuf += nNew;
+        *zBuf = 0;
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else{
+        ErrorMsg(psp->filename,psp->tokenlineno,
+          "Illegal argument to %%%s: %s",psp->declkeyword,x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }
+      break;
+    case WAITING_FOR_FALLBACK_ID:
+      if( x[0]=='.' ){
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( !ISUPPER(x[0]) ){
+        ErrorMsg(psp->filename, psp->tokenlineno,
+          "%%fallback argument \"%s\" should be a token", x);
+        psp->errorcnt++;
+      }else{
+        struct symbol *sp = Symbol_new(x);
+        if( psp->fallback==0 ){
+          psp->fallback = sp;
+        }else if( sp->fallback ){
+          ErrorMsg(psp->filename, psp->tokenlineno,
+            "More than one fallback assigned to token %s", x);
+          psp->errorcnt++;
+        }else{
+          sp->fallback = psp->fallback;
+          psp->gp->has_fallback = 1;
+        }
+      }
+      break;
+    case WAITING_FOR_WILDCARD_ID:
+      if( x[0]=='.' ){
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( !ISUPPER(x[0]) ){
+        ErrorMsg(psp->filename, psp->tokenlineno,
+          "%%wildcard argument \"%s\" should be a token", x);
+        psp->errorcnt++;
+      }else{
+        struct symbol *sp = Symbol_new(x);
+        if( psp->gp->wildcard==0 ){
+          psp->gp->wildcard = sp;
+        }else{
+          ErrorMsg(psp->filename, psp->tokenlineno,
+            "Extra wildcard to token: %s", x);
+          psp->errorcnt++;
+        }
+      }
+      break;
+    case WAITING_FOR_CLASS_ID:
+      if( !ISLOWER(x[0]) ){
+        ErrorMsg(psp->filename, psp->tokenlineno,
+          "%%token_class must be followed by an identifier: ", x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+     }else if( Symbol_find(x) ){
+        ErrorMsg(psp->filename, psp->tokenlineno,
+          "Symbol \"%s\" already used", x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }else{
+        psp->tkclass = Symbol_new(x);
+        psp->tkclass->type = MULTITERMINAL;
+        psp->state = WAITING_FOR_CLASS_TOKEN;
+      }
+      break;
+    case WAITING_FOR_CLASS_TOKEN:
+      if( x[0]=='.' ){
+        psp->state = WAITING_FOR_DECL_OR_RULE;
+      }else if( ISUPPER(x[0]) || ((x[0]=='|' || x[0]=='/') && ISUPPER(x[1])) ){
+        struct symbol *msp = psp->tkclass;
+        msp->nsubsym++;
+        msp->subsym = (struct symbol **) realloc(msp->subsym,
+          sizeof(struct symbol*)*msp->nsubsym);
+        if( !ISUPPER(x[0]) ) x++;
+        msp->subsym[msp->nsubsym-1] = Symbol_new(x);
+      }else{
+        ErrorMsg(psp->filename, psp->tokenlineno,
+          "%%token_class argument \"%s\" should be a token", x);
+        psp->errorcnt++;
+        psp->state = RESYNC_AFTER_DECL_ERROR;
+      }
+      break;
+    case RESYNC_AFTER_RULE_ERROR:
+/*      if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE;
+**      break; */
+    case RESYNC_AFTER_DECL_ERROR:
+      if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE;
+      if( x[0]=='%' ) psp->state = WAITING_FOR_DECL_KEYWORD;
+      break;
+  }
+}
+
+/* Run the preprocessor over the input file text.  The global variables
+** azDefine[0] through azDefine[nDefine-1] contains the names of all defined
+** macros.  This routine looks for "%ifdef" and "%ifndef" and "%endif" and
+** comments them out.  Text in between is also commented out as appropriate.
+*/
+static void preprocess_input(char *z){
+  int i, j, k, n;
+  int exclude = 0;
+  int start = 0;
+  int lineno = 1;
+  int start_lineno = 1;
+  for(i=0; z[i]; i++){
+    if( z[i]=='\n' ) lineno++;
+    if( z[i]!='%' || (i>0 && z[i-1]!='\n') ) continue;
+    if( strncmp(&z[i],"%endif",6)==0 && ISSPACE(z[i+6]) ){
+      if( exclude ){
+        exclude--;
+        if( exclude==0 ){
+          for(j=start; j<i; j++) if( z[j]!='\n' ) z[j] = ' ';
+        }
+      }
+      for(j=i; z[j] && z[j]!='\n'; j++) z[j] = ' ';
+    }else if( (strncmp(&z[i],"%ifdef",6)==0 && ISSPACE(z[i+6]))
+          || (strncmp(&z[i],"%ifndef",7)==0 && ISSPACE(z[i+7])) ){
+      if( exclude ){
+        exclude++;
+      }else{
+        for(j=i+7; ISSPACE(z[j]); j++){}
+        for(n=0; z[j+n] && !ISSPACE(z[j+n]); n++){}
+        exclude = 1;
+        for(k=0; k<nDefine; k++){
+          if( strncmp(azDefine[k],&z[j],n)==0 && lemonStrlen(azDefine[k])==n ){
+            exclude = 0;
+            break;
+          }
+        }
+        if( z[i+3]=='n' ) exclude = !exclude;
+        if( exclude ){
+          start = i;
+          start_lineno = lineno;
+        }
+      }
+      for(j=i; z[j] && z[j]!='\n'; j++) z[j] = ' ';
+    }
+  }
+  if( exclude ){
+    fprintf(stderr,"unterminated %%ifdef starting on line %d\n", start_lineno);
+    exit(1);
+  }
+}
+
+/* In spite of its name, this function is really a scanner.  It read
+** in the entire input file (all at once) then tokenizes it.  Each
+** token is passed to the function "parseonetoken" which builds all
+** the appropriate data structures in the global state vector "gp".
+*/
+void Parse(struct lemon *gp)
+{
+  struct pstate ps;
+  FILE *fp;
+  char *filebuf;
+  unsigned int filesize;
+  int lineno;
+  int c;
+  char *cp, *nextcp;
+  int startline = 0;
+
+  memset(&ps, '\0', sizeof(ps));
+  ps.gp = gp;
+  ps.filename = gp->filename;
+  ps.errorcnt = 0;
+  ps.state = INITIALIZE;
+
+  /* Begin by reading the input file */
+  fp = fopen(ps.filename,"rb");
+  if( fp==0 ){
+    ErrorMsg(ps.filename,0,"Can't open this file for reading.");
+    gp->errorcnt++;
+    return;
+  }
+  fseek(fp,0,2);
+  filesize = ftell(fp);
+  rewind(fp);
+  filebuf = (char *)malloc( filesize+1 );
+  if( filesize>100000000 || filebuf==0 ){
+    ErrorMsg(ps.filename,0,"Input file too large.");
+    gp->errorcnt++;
+    fclose(fp);
+    return;
+  }
+  if( fread(filebuf,1,filesize,fp)!=filesize ){
+    ErrorMsg(ps.filename,0,"Can't read in all %d bytes of this file.",
+      filesize);
+    free(filebuf);
+    gp->errorcnt++;
+    fclose(fp);
+    return;
+  }
+  fclose(fp);
+  filebuf[filesize] = 0;
+
+  /* Make an initial pass through the file to handle %ifdef and %ifndef */
+  preprocess_input(filebuf);
+
+  /* Now scan the text of the input file */
+  lineno = 1;
+  for(cp=filebuf; (c= *cp)!=0; ){
+    if( c=='\n' ) lineno++;              /* Keep track of the line number */
+    if( ISSPACE(c) ){ cp++; continue; }  /* Skip all white space */
+    if( c=='/' && cp[1]=='/' ){          /* Skip C++ style comments */
+      cp+=2;
+      while( (c= *cp)!=0 && c!='\n' ) cp++;
+      continue;
+    }
+    if( c=='/' && cp[1]=='*' ){          /* Skip C style comments */
+      cp+=2;
+      while( (c= *cp)!=0 && (c!='/' || cp[-1]!='*') ){
+        if( c=='\n' ) lineno++;
+        cp++;
+      }
+      if( c ) cp++;
+      continue;
+    }
+    ps.tokenstart = cp;                /* Mark the beginning of the token */
+    ps.tokenlineno = lineno;           /* Linenumber on which token begins */
+    if( c=='\"' ){                     /* String literals */
+      cp++;
+      while( (c= *cp)!=0 && c!='\"' ){
+        if( c=='\n' ) lineno++;
+        cp++;
+      }
+      if( c==0 ){
+        ErrorMsg(ps.filename,startline,
+"String starting on this line is not terminated before the end of the file.");
+        ps.errorcnt++;
+        nextcp = cp;
+      }else{
+        nextcp = cp+1;
+      }
+    }else if( c=='{' ){               /* A block of C code */
+      int level;
+      cp++;
+      for(level=1; (c= *cp)!=0 && (level>1 || c!='}'); cp++){
+        if( c=='\n' ) lineno++;
+        else if( c=='{' ) level++;
+        else if( c=='}' ) level--;
+        else if( c=='/' && cp[1]=='*' ){  /* Skip comments */
+          int prevc;
+          cp = &cp[2];
+          prevc = 0;
+          while( (c= *cp)!=0 && (c!='/' || prevc!='*') ){
+            if( c=='\n' ) lineno++;
+            prevc = c;
+            cp++;
+          }
+        }else if( c=='/' && cp[1]=='/' ){  /* Skip C++ style comments too */
+          cp = &cp[2];
+          while( (c= *cp)!=0 && c!='\n' ) cp++;
+          if( c ) lineno++;
+        }else if( c=='\'' || c=='\"' ){    /* String a character literals */
+          int startchar, prevc;
+          startchar = c;
+          prevc = 0;
+          for(cp++; (c= *cp)!=0 && (c!=startchar || prevc=='\\'); cp++){
+            if( c=='\n' ) lineno++;
+            if( prevc=='\\' ) prevc = 0;
+            else              prevc = c;
+          }
+        }
+      }
+      if( c==0 ){
+        ErrorMsg(ps.filename,ps.tokenlineno,
+"C code starting on this line is not terminated before the end of the file.");
+        ps.errorcnt++;
+        nextcp = cp;
+      }else{
+        nextcp = cp+1;
+      }
+    }else if( ISALNUM(c) ){          /* Identifiers */
+      while( (c= *cp)!=0 && (ISALNUM(c) || c=='_') ) cp++;
+      nextcp = cp;
+    }else if( c==':' && cp[1]==':' && cp[2]=='=' ){ /* The operator "::=" */
+      cp += 3;
+      nextcp = cp;
+    }else if( (c=='/' || c=='|') && ISALPHA(cp[1]) ){
+      cp += 2;
+      while( (c = *cp)!=0 && (ISALNUM(c) || c=='_') ) cp++;
+      nextcp = cp;
+    }else{                          /* All other (one character) operators */
+      cp++;
+      nextcp = cp;
+    }
+    c = *cp;
+    *cp = 0;                        /* Null terminate the token */
+    parseonetoken(&ps);             /* Parse the token */
+    *cp = (char)c;                  /* Restore the buffer */
+    cp = nextcp;
+  }
+  free(filebuf);                    /* Release the buffer after parsing */
+  gp->rule = ps.firstrule;
+  gp->errorcnt = ps.errorcnt;
+}
+/*************************** From the file "plink.c" *********************/
+/*
+** Routines processing configuration follow-set propagation links
+** in the LEMON parser generator.
+*/
+static struct plink *plink_freelist = 0;
+
+/* Allocate a new plink */
+struct plink *Plink_new(){
+  struct plink *newlink;
+
+  if( plink_freelist==0 ){
+    int i;
+    int amt = 100;
+    plink_freelist = (struct plink *)calloc( amt, sizeof(struct plink) );
+    if( plink_freelist==0 ){
+      fprintf(stderr,
+      "Unable to allocate memory for a new follow-set propagation link.\n");
+      exit(1);
+    }
+    for(i=0; i<amt-1; i++) plink_freelist[i].next = &plink_freelist[i+1];
+    plink_freelist[amt-1].next = 0;
+  }
+  newlink = plink_freelist;
+  plink_freelist = plink_freelist->next;
+  return newlink;
+}
+
+/* Add a plink to a plink list */
+void Plink_add(struct plink **plpp, struct config *cfp)
+{
+  struct plink *newlink;
+  newlink = Plink_new();
+  newlink->next = *plpp;
+  *plpp = newlink;
+  newlink->cfp = cfp;
+}
+
+/* Transfer every plink on the list "from" to the list "to" */
+void Plink_copy(struct plink **to, struct plink *from)
+{
+  struct plink *nextpl;
+  while( from ){
+    nextpl = from->next;
+    from->next = *to;
+    *to = from;
+    from = nextpl;
+  }
+}
+
+/* Delete every plink on the list */
+void Plink_delete(struct plink *plp)
+{
+  struct plink *nextpl;
+
+  while( plp ){
+    nextpl = plp->next;
+    plp->next = plink_freelist;
+    plink_freelist = plp;
+    plp = nextpl;
+  }
+}
+/*********************** From the file "report.c" **************************/
+/*
+** Procedures for generating reports and tables in the LEMON parser generator.
+*/
+
+/* Generate a filename with the given suffix.  Space to hold the
+** name comes from malloc() and must be freed by the calling
+** function.
+*/
+PRIVATE char *file_makename(struct lemon *lemp, const char *suffix)
+{
+  char *name;
+  char *cp;
+
+  name = (char*)malloc( lemonStrlen(lemp->filename) + lemonStrlen(suffix) + 5 );
+  if( name==0 ){
+    fprintf(stderr,"Can't allocate space for a filename.\n");
+    exit(1);
+  }
+  lemon_strcpy(name,lemp->filename);
+  cp = strrchr(name,'.');
+  if( cp ) *cp = 0;
+  lemon_strcat(name,suffix);
+  return name;
+}
+
+/* Open a file with a name based on the name of the input file,
+** but with a different (specified) suffix, and return a pointer
+** to the stream */
+PRIVATE FILE *file_open(
+  struct lemon *lemp,
+  const char *suffix,
+  const char *mode
+){
+  FILE *fp;
+
+  if( lemp->outname ) free(lemp->outname);
+  lemp->outname = file_makename(lemp, suffix);
+  fp = fopen(lemp->outname,mode);
+  if( fp==0 && *mode=='w' ){
+    fprintf(stderr,"Can't open file \"%s\".\n",lemp->outname);
+    lemp->errorcnt++;
+    return 0;
+  }
+  return fp;
+}
+
+/* Duplicate the input file without comments and without actions 
+** on rules */
+void Reprint(struct lemon *lemp)
+{
+  struct rule *rp;
+  struct symbol *sp;
+  int i, j, maxlen, len, ncolumns, skip;
+  printf("// Reprint of input file \"%s\".\n// Symbols:\n",lemp->filename);
+  maxlen = 10;
+  for(i=0; i<lemp->nsymbol; i++){
+    sp = lemp->symbols[i];
+    len = lemonStrlen(sp->name);
+    if( len>maxlen ) maxlen = len;
+  }
+  ncolumns = 76/(maxlen+5);
+  if( ncolumns<1 ) ncolumns = 1;
+  skip = (lemp->nsymbol + ncolumns - 1)/ncolumns;
+  for(i=0; i<skip; i++){
+    printf("//");
+    for(j=i; j<lemp->nsymbol; j+=skip){
+      sp = lemp->symbols[j];
+      assert( sp->index==j );
+      printf(" %3d %-*.*s",j,maxlen,maxlen,sp->name);
+    }
+    printf("\n");
+  }
+  for(rp=lemp->rule; rp; rp=rp->next){
+    printf("%s",rp->lhs->name);
+    /*    if( rp->lhsalias ) printf("(%s)",rp->lhsalias); */
+    printf(" ::=");
+    for(i=0; i<rp->nrhs; i++){
+      sp = rp->rhs[i];
+      if( sp->type==MULTITERMINAL ){
+        printf(" %s", sp->subsym[0]->name);
+        for(j=1; j<sp->nsubsym; j++){
+          printf("|%s", sp->subsym[j]->name);
+        }
+      }else{
+        printf(" %s", sp->name);
+      }
+      /* if( rp->rhsalias[i] ) printf("(%s)",rp->rhsalias[i]); */
+    }
+    printf(".");
+    if( rp->precsym ) printf(" [%s]",rp->precsym->name);
+    /* if( rp->code ) printf("\n    %s",rp->code); */
+    printf("\n");
+  }
+}
+
+/* Print a single rule.
+*/
+void RulePrint(FILE *fp, struct rule *rp, int iCursor){
+  struct symbol *sp;
+  int i, j;
+  fprintf(fp,"%s ::=",rp->lhs->name);
+  for(i=0; i<=rp->nrhs; i++){
+    if( i==iCursor ) fprintf(fp," *");
+    if( i==rp->nrhs ) break;
+    sp = rp->rhs[i];
+    if( sp->type==MULTITERMINAL ){
+      fprintf(fp," %s", sp->subsym[0]->name);
+      for(j=1; j<sp->nsubsym; j++){
+        fprintf(fp,"|%s",sp->subsym[j]->name);
+      }
+    }else{
+      fprintf(fp," %s", sp->name);
+    }
+  }
+}
+
+/* Print the rule for a configuration.
+*/
+void ConfigPrint(FILE *fp, struct config *cfp){
+  RulePrint(fp, cfp->rp, cfp->dot);
+}
+
+/* #define TEST */
+#if 0
+/* Print a set */
+PRIVATE void SetPrint(out,set,lemp)
+FILE *out;
+char *set;
+struct lemon *lemp;
+{
+  int i;
+  char *spacer;
+  spacer = "";
+  fprintf(out,"%12s[","");
+  for(i=0; i<lemp->nterminal; i++){
+    if( SetFind(set,i) ){
+      fprintf(out,"%s%s",spacer,lemp->symbols[i]->name);
+      spacer = " ";
+    }
+  }
+  fprintf(out,"]\n");
+}
+
+/* Print a plink chain */
+PRIVATE void PlinkPrint(out,plp,tag)
+FILE *out;
+struct plink *plp;
+char *tag;
+{
+  while( plp ){
+    fprintf(out,"%12s%s (state %2d) ","",tag,plp->cfp->stp->statenum);
+    ConfigPrint(out,plp->cfp);
+    fprintf(out,"\n");
+    plp = plp->next;
+  }
+}
+#endif
+
+/* Print an action to the given file descriptor.  Return FALSE if
+** nothing was actually printed.
+*/
+int PrintAction(
+  struct action *ap,          /* The action to print */
+  FILE *fp,                   /* Print the action here */
+  int indent                  /* Indent by this amount */
+){
+  int result = 1;
+  switch( ap->type ){
+    case SHIFT: {
+      struct state *stp = ap->x.stp;
+      fprintf(fp,"%*s shift        %-7d",indent,ap->sp->name,stp->statenum);
+      break;
+    }
+    case REDUCE: {
+      struct rule *rp = ap->x.rp;
+      fprintf(fp,"%*s reduce       %-7d",indent,ap->sp->name,rp->iRule);
+      RulePrint(fp, rp, -1);
+      break;
+    }
+    case SHIFTREDUCE: {
+      struct rule *rp = ap->x.rp;
+      fprintf(fp,"%*s shift-reduce %-7d",indent,ap->sp->name,rp->iRule);
+      RulePrint(fp, rp, -1);
+      break;
+    }
+    case ACCEPT:
+      fprintf(fp,"%*s accept",indent,ap->sp->name);
+      break;
+    case ERROR:
+      fprintf(fp,"%*s error",indent,ap->sp->name);
+      break;
+    case SRCONFLICT:
+    case RRCONFLICT:
+      fprintf(fp,"%*s reduce       %-7d ** Parsing conflict **",
+        indent,ap->sp->name,ap->x.rp->iRule);
+      break;
+    case SSCONFLICT:
+      fprintf(fp,"%*s shift        %-7d ** Parsing conflict **", 
+        indent,ap->sp->name,ap->x.stp->statenum);
+      break;
+    case SH_RESOLVED:
+      if( showPrecedenceConflict ){
+        fprintf(fp,"%*s shift        %-7d -- dropped by precedence",
+                indent,ap->sp->name,ap->x.stp->statenum);
+      }else{
+        result = 0;
+      }
+      break;
+    case RD_RESOLVED:
+      if( showPrecedenceConflict ){
+        fprintf(fp,"%*s reduce %-7d -- dropped by precedence",
+                indent,ap->sp->name,ap->x.rp->iRule);
+      }else{
+        result = 0;
+      }
+      break;
+    case NOT_USED:
+      result = 0;
+      break;
+  }
+  if( result && ap->spOpt ){
+    fprintf(fp,"  /* because %s==%s */", ap->sp->name, ap->spOpt->name);
+  }
+  return result;
+}
+
+/* Generate the "*.out" log file */
+void ReportOutput(struct lemon *lemp)
+{
+  int i;
+  struct state *stp;
+  struct config *cfp;
+  struct action *ap;
+  FILE *fp;
+
+  fp = file_open(lemp,".out","wb");
+  if( fp==0 ) return;
+  for(i=0; i<lemp->nxstate; i++){
+    stp = lemp->sorted[i];
+    fprintf(fp,"State %d:\n",stp->statenum);
+    if( lemp->basisflag ) cfp=stp->bp;
+    else                  cfp=stp->cfp;
+    while( cfp ){
+      char buf[20];
+      if( cfp->dot==cfp->rp->nrhs ){
+        lemon_sprintf(buf,"(%d)",cfp->rp->iRule);
+        fprintf(fp,"    %5s ",buf);
+      }else{
+        fprintf(fp,"          ");
+      }
+      ConfigPrint(fp,cfp);
+      fprintf(fp,"\n");
+#if 0
+      SetPrint(fp,cfp->fws,lemp);
+      PlinkPrint(fp,cfp->fplp,"To  ");
+      PlinkPrint(fp,cfp->bplp,"From");
+#endif
+      if( lemp->basisflag ) cfp=cfp->bp;
+      else                  cfp=cfp->next;
+    }
+    fprintf(fp,"\n");
+    for(ap=stp->ap; ap; ap=ap->next){
+      if( PrintAction(ap,fp,30) ) fprintf(fp,"\n");
+    }
+    fprintf(fp,"\n");
+  }
+  fprintf(fp, "----------------------------------------------------\n");
+  fprintf(fp, "Symbols:\n");
+  for(i=0; i<lemp->nsymbol; i++){
+    int j;
+    struct symbol *sp;
+
+    sp = lemp->symbols[i];
+    fprintf(fp, "  %3d: %s", i, sp->name);
+    if( sp->type==NONTERMINAL ){
+      fprintf(fp, ":");
+      if( sp->lambda ){
+        fprintf(fp, " <lambda>");
+      }
+      for(j=0; j<lemp->nterminal; j++){
+        if( sp->firstset && SetFind(sp->firstset, j) ){
+          fprintf(fp, " %s", lemp->symbols[j]->name);
+        }
+      }
+    }
+    fprintf(fp, "\n");
+  }
+  fclose(fp);
+  return;
+}
+
+/* Search for the file "name" which is in the same directory as
+** the exacutable */
+PRIVATE char *pathsearch(char *argv0, char *name, int modemask)
+{
+  const char *pathlist;
+  char *pathbufptr;
+  char *pathbuf;
+  char *path,*cp;
+  char c;
+
+#ifdef __WIN32__
+  cp = strrchr(argv0,'\\');
+#else
+  cp = strrchr(argv0,'/');
+#endif
+  if( cp ){
+    c = *cp;
+    *cp = 0;
+    path = (char *)malloc( lemonStrlen(argv0) + lemonStrlen(name) + 2 );
+    if( path ) lemon_sprintf(path,"%s/%s",argv0,name);
+    *cp = c;
+  }else{
+    pathlist = getenv("PATH");
+    if( pathlist==0 ) pathlist = ".:/bin:/usr/bin";
+    pathbuf = (char *) malloc( lemonStrlen(pathlist) + 1 );
+    path = (char *)malloc( lemonStrlen(pathlist)+lemonStrlen(name)+2 );
+    if( (pathbuf != 0) && (path!=0) ){
+      pathbufptr = pathbuf;
+      lemon_strcpy(pathbuf, pathlist);
+      while( *pathbuf ){
+        cp = strchr(pathbuf,':');
+        if( cp==0 ) cp = &pathbuf[lemonStrlen(pathbuf)];
+        c = *cp;
+        *cp = 0;
+        lemon_sprintf(path,"%s/%s",pathbuf,name);
+        *cp = c;
+        if( c==0 ) pathbuf[0] = 0;
+        else pathbuf = &cp[1];
+        if( access(path,modemask)==0 ) break;
+      }
+      free(pathbufptr);
+    }
+  }
+  return path;
+}
+
+/* Given an action, compute the integer value for that action
+** which is to be put in the action table of the generated machine.
+** Return negative if no action should be generated.
+*/
+PRIVATE int compute_action(struct lemon *lemp, struct action *ap)
+{
+  int act;
+  switch( ap->type ){
+    case SHIFT:  act = ap->x.stp->statenum;                        break;
+    case SHIFTREDUCE: act = ap->x.rp->iRule + lemp->nstate;        break;
+    case REDUCE: act = ap->x.rp->iRule + lemp->nstate+lemp->nrule; break;
+    case ERROR:  act = lemp->nstate + lemp->nrule*2;               break;
+    case ACCEPT: act = lemp->nstate + lemp->nrule*2 + 1;           break;
+    default:     act = -1; break;
+  }
+  return act;
+}
+
+#define LINESIZE 1000
+/* The next cluster of routines are for reading the template file
+** and writing the results to the generated parser */
+/* The first function transfers data from "in" to "out" until
+** a line is seen which begins with "%%".  The line number is
+** tracked.
+**
+** if name!=0, then any word that begin with "Parse" is changed to
+** begin with *name instead.
+*/
+PRIVATE void tplt_xfer(char *name, FILE *in, FILE *out, int *lineno)
+{
+  int i, iStart;
+  char line[LINESIZE];
+  while( fgets(line,LINESIZE,in) && (line[0]!='%' || line[1]!='%') ){
+    (*lineno)++;
+    iStart = 0;
+    if( name ){
+      for(i=0; line[i]; i++){
+        if( line[i]=='P' && strncmp(&line[i],"Parse",5)==0
+          && (i==0 || !ISALPHA(line[i-1]))
+        ){
+          if( i>iStart ) fprintf(out,"%.*s",i-iStart,&line[iStart]);
+          fprintf(out,"%s",name);
+          i += 4;
+          iStart = i+1;
+        }
+      }
+    }
+    fprintf(out,"%s",&line[iStart]);
+  }
+}
+
+/* The next function finds the template file and opens it, returning
+** a pointer to the opened file. */
+PRIVATE FILE *tplt_open(struct lemon *lemp)
+{
+  static char templatename[] = "lempar.c";
+  char buf[1000];
+  FILE *in;
+  char *tpltname;
+  char *cp;
+
+  /* first, see if user specified a template filename on the command line. */
+  if (user_templatename != 0) {
+    if( access(user_templatename,004)==-1 ){
+      fprintf(stderr,"Can't find the parser driver template file \"%s\".\n",
+        user_templatename);
+      lemp->errorcnt++;
+      return 0;
+    }
+    in = fopen(user_templatename,"rb");
+    if( in==0 ){
+      fprintf(stderr,"Can't open the template file \"%s\".\n",
+              user_templatename);
+      lemp->errorcnt++;
+      return 0;
+    }
+    return in;
+  }
+
+  cp = strrchr(lemp->filename,'.');
+  if( cp ){
+    lemon_sprintf(buf,"%.*s.lt",(int)(cp-lemp->filename),lemp->filename);
+  }else{
+    lemon_sprintf(buf,"%s.lt",lemp->filename);
+  }
+  if( access(buf,004)==0 ){
+    tpltname = buf;
+  }else if( access(templatename,004)==0 ){
+    tpltname = templatename;
+  }else{
+    tpltname = pathsearch(lemp->argv0,templatename,0);
+  }
+  if( tpltname==0 ){
+    fprintf(stderr,"Can't find the parser driver template file \"%s\".\n",
+    templatename);
+    lemp->errorcnt++;
+    return 0;
+  }
+  in = fopen(tpltname,"rb");
+  if( in==0 ){
+    fprintf(stderr,"Can't open the template file \"%s\".\n",templatename);
+    lemp->errorcnt++;
+    return 0;
+  }
+  return in;
+}
+
+/* Print a #line directive line to the output file. */
+PRIVATE void tplt_linedir(FILE *out, int lineno, char *filename)
+{
+  fprintf(out,"#line %d \"",lineno);
+  while( *filename ){
+    if( *filename == '\\' ) putc('\\',out);
+    putc(*filename,out);
+    filename++;
+  }
+  fprintf(out,"\"\n");
+}
+
+/* Print a string to the file and keep the linenumber up to date */
+PRIVATE void tplt_print(FILE *out, struct lemon *lemp, char *str, int *lineno)
+{
+  if( str==0 ) return;
+  while( *str ){
+    putc(*str,out);
+    if( *str=='\n' ) (*lineno)++;
+    str++;
+  }
+  if( str[-1]!='\n' ){
+    putc('\n',out);
+    (*lineno)++;
+  }
+  if (!lemp->nolinenosflag) {
+    (*lineno)++; tplt_linedir(out,*lineno,lemp->outname); 
+  }
+  return;
+}
+
+/*
+** The following routine emits code for the destructor for the
+** symbol sp
+*/
+void emit_destructor_code(
+  FILE *out,
+  struct symbol *sp,
+  struct lemon *lemp,
+  int *lineno
+){
+ char *cp = 0;
+
+ if( sp->type==TERMINAL ){
+   cp = lemp->tokendest;
+   if( cp==0 ) return;
+   fprintf(out,"{\n"); (*lineno)++;
+ }else if( sp->destructor ){
+   cp = sp->destructor;
+   fprintf(out,"{\n"); (*lineno)++;
+   if( !lemp->nolinenosflag ){
+     (*lineno)++;
+     tplt_linedir(out,sp->destLineno,lemp->filename);
+   }
+ }else if( lemp->vardest ){
+   cp = lemp->vardest;
+   if( cp==0 ) return;
+   fprintf(out,"{\n"); (*lineno)++;
+ }else{
+   assert( 0 );  /* Cannot happen */
+ }
+ for(; *cp; cp++){
+   if( *cp=='$' && cp[1]=='$' ){
+     fprintf(out,"(yypminor->yy%d)",sp->dtnum);
+     cp++;
+     continue;
+   }
+   if( *cp=='\n' ) (*lineno)++;
+   fputc(*cp,out);
+ }
+ fprintf(out,"\n"); (*lineno)++;
+ if (!lemp->nolinenosflag) { 
+   (*lineno)++; tplt_linedir(out,*lineno,lemp->outname); 
+ }
+ fprintf(out,"}\n"); (*lineno)++;
+ return;
+}
+
+/*
+** Return TRUE (non-zero) if the given symbol has a destructor.
+*/
+int has_destructor(struct symbol *sp, struct lemon *lemp)
+{
+  int ret;
+  if( sp->type==TERMINAL ){
+    ret = lemp->tokendest!=0;
+  }else{
+    ret = lemp->vardest!=0 || sp->destructor!=0;
+  }
+  return ret;
+}
+
+/*
+** Append text to a dynamically allocated string.  If zText is 0 then
+** reset the string to be empty again.  Always return the complete text
+** of the string (which is overwritten with each call).
+**
+** n bytes of zText are stored.  If n==0 then all of zText up to the first
+** \000 terminator is stored.  zText can contain up to two instances of
+** %d.  The values of p1 and p2 are written into the first and second
+** %d.
+**
+** If n==-1, then the previous character is overwritten.
+*/
+PRIVATE char *append_str(const char *zText, int n, int p1, int p2){
+  static char empty[1] = { 0 };
+  static char *z = 0;
+  static int alloced = 0;
+  static int used = 0;
+  int c;
+  char zInt[40];
+  if( zText==0 ){
+    if( used==0 && z!=0 ) z[0] = 0;
+    used = 0;
+    return z;
+  }
+  if( n<=0 ){
+    if( n<0 ){
+      used += n;
+      assert( used>=0 );
+    }
+    n = lemonStrlen(zText);
+  }
+  if( (int) (n+sizeof(zInt)*2+used) >= alloced ){
+    alloced = n + sizeof(zInt)*2 + used + 200;
+    z = (char *) realloc(z,  alloced);
+  }
+  if( z==0 ) return empty;
+  while( n-- > 0 ){
+    c = *(zText++);
+    if( c=='%' && n>0 && zText[0]=='d' ){
+      lemon_sprintf(zInt, "%d", p1);
+      p1 = p2;
+      lemon_strcpy(&z[used], zInt);
+      used += lemonStrlen(&z[used]);
+      zText++;
+      n--;
+    }else{
+      z[used++] = (char)c;
+    }
+  }
+  z[used] = 0;
+  return z;
+}
+
+/*
+** Write and transform the rp->code string so that symbols are expanded.
+** Populate the rp->codePrefix and rp->codeSuffix strings, as appropriate.
+**
+** Return 1 if the expanded code requires that "yylhsminor" local variable
+** to be defined.
+*/
+PRIVATE int translate_code(struct lemon *lemp, struct rule *rp){
+  char *cp, *xp;
+  int i;
+  int rc = 0;            /* True if yylhsminor is used */
+  int dontUseRhs0 = 0;   /* If true, use of left-most RHS label is illegal */
+  const char *zSkip = 0; /* The zOvwrt comment within rp->code, or NULL */
+  char lhsused = 0;      /* True if the LHS element has been used */
+  char lhsdirect;        /* True if LHS writes directly into stack */
+  char used[MAXRHS];     /* True for each RHS element which is used */
+  char zLhs[50];         /* Convert the LHS symbol into this string */
+  char zOvwrt[900];      /* Comment that to allow LHS to overwrite RHS */
+
+  for(i=0; i<rp->nrhs; i++) used[i] = 0;
+  lhsused = 0;
+
+  if( rp->code==0 ){
+    static char newlinestr[2] = { '\n', '\0' };
+    rp->code = newlinestr;
+    rp->line = rp->ruleline;
+    rp->noCode = 1;
+  }else{
+    rp->noCode = 0;
+  }
+
+
+  if( rp->nrhs==0 ){
+    /* If there are no RHS symbols, then writing directly to the LHS is ok */
+    lhsdirect = 1;
+  }else if( rp->rhsalias[0]==0 ){
+    /* The left-most RHS symbol has no value.  LHS direct is ok.  But
+    ** we have to call the distructor on the RHS symbol first. */
+    lhsdirect = 1;
+    if( has_destructor(rp->rhs[0],lemp) ){
+      append_str(0,0,0,0);
+      append_str("  yy_destructor(yypParser,%d,&yymsp[%d].minor);\n", 0,
+                 rp->rhs[0]->index,1-rp->nrhs);
+      rp->codePrefix = Strsafe(append_str(0,0,0,0));
+      rp->noCode = 0;
+    }
+  }else if( rp->lhsalias==0 ){
+    /* There is no LHS value symbol. */
+    lhsdirect = 1;
+  }else if( strcmp(rp->lhsalias,rp->rhsalias[0])==0 ){
+    /* The LHS symbol and the left-most RHS symbol are the same, so 
+    ** direct writing is allowed */
+    lhsdirect = 1;
+    lhsused = 1;
+    used[0] = 1;
+    if( rp->lhs->dtnum!=rp->rhs[0]->dtnum ){
+      ErrorMsg(lemp->filename,rp->ruleline,
+        "%s(%s) and %s(%s) share the same label but have "
+        "different datatypes.",
+        rp->lhs->name, rp->lhsalias, rp->rhs[0]->name, rp->rhsalias[0]);
+      lemp->errorcnt++;
+    }    
+  }else{
+    lemon_sprintf(zOvwrt, "/*%s-overwrites-%s*/",
+                  rp->lhsalias, rp->rhsalias[0]);
+    zSkip = strstr(rp->code, zOvwrt);
+    if( zSkip!=0 ){
+      /* The code contains a special comment that indicates that it is safe
+      ** for the LHS label to overwrite left-most RHS label. */
+      lhsdirect = 1;
+    }else{
+      lhsdirect = 0;
+    }
+  }
+  if( lhsdirect ){
+    sprintf(zLhs, "yymsp[%d].minor.yy%d",1-rp->nrhs,rp->lhs->dtnum);
+  }else{
+    rc = 1;
+    sprintf(zLhs, "yylhsminor.yy%d",rp->lhs->dtnum);
+  }
+
+  append_str(0,0,0,0);
+
+  /* This const cast is wrong but harmless, if we're careful. */
+  for(cp=(char *)rp->code; *cp; cp++){
+    if( cp==zSkip ){
+      append_str(zOvwrt,0,0,0);
+      cp += lemonStrlen(zOvwrt)-1;
+      dontUseRhs0 = 1;
+      continue;
+    }
+    if( ISALPHA(*cp) && (cp==rp->code || (!ISALNUM(cp[-1]) && cp[-1]!='_')) ){
+      char saved;
+      for(xp= &cp[1]; ISALNUM(*xp) || *xp=='_'; xp++);
+      saved = *xp;
+      *xp = 0;
+      if( rp->lhsalias && strcmp(cp,rp->lhsalias)==0 ){
+        append_str(zLhs,0,0,0);
+        cp = xp;
+        lhsused = 1;
+      }else{
+        for(i=0; i<rp->nrhs; i++){
+          if( rp->rhsalias[i] && strcmp(cp,rp->rhsalias[i])==0 ){
+            if( i==0 && dontUseRhs0 ){
+              ErrorMsg(lemp->filename,rp->ruleline,
+                 "Label %s used after '%s'.",
+                 rp->rhsalias[0], zOvwrt);
+              lemp->errorcnt++;
+            }else if( cp!=rp->code && cp[-1]=='@' ){
+              /* If the argument is of the form @X then substituted
+              ** the token number of X, not the value of X */
+              append_str("yymsp[%d].major",-1,i-rp->nrhs+1,0);
+            }else{
+              struct symbol *sp = rp->rhs[i];
+              int dtnum;
+              if( sp->type==MULTITERMINAL ){
+                dtnum = sp->subsym[0]->dtnum;
+              }else{
+                dtnum = sp->dtnum;
+              }
+              append_str("yymsp[%d].minor.yy%d",0,i-rp->nrhs+1, dtnum);
+            }
+            cp = xp;
+            used[i] = 1;
+            break;
+          }
+        }
+      }
+      *xp = saved;
+    }
+    append_str(cp, 1, 0, 0);
+  } /* End loop */
+
+  /* Main code generation completed */
+  cp = append_str(0,0,0,0);
+  if( cp && cp[0] ) rp->code = Strsafe(cp);
+  append_str(0,0,0,0);
+
+  /* Check to make sure the LHS has been used */
+  if( rp->lhsalias && !lhsused ){
+    ErrorMsg(lemp->filename,rp->ruleline,
+      "Label \"%s\" for \"%s(%s)\" is never used.",
+        rp->lhsalias,rp->lhs->name,rp->lhsalias);
+    lemp->errorcnt++;
+  }
+
+  /* Generate destructor code for RHS minor values which are not referenced.
+  ** Generate error messages for unused labels and duplicate labels.
+  */
+  for(i=0; i<rp->nrhs; i++){
+    if( rp->rhsalias[i] ){
+      if( i>0 ){
+        int j;
+        if( rp->lhsalias && strcmp(rp->lhsalias,rp->rhsalias[i])==0 ){
+          ErrorMsg(lemp->filename,rp->ruleline,
+            "%s(%s) has the same label as the LHS but is not the left-most "
+            "symbol on the RHS.",
+            rp->rhs[i]->name, rp->rhsalias);
+          lemp->errorcnt++;
+        }
+        for(j=0; j<i; j++){
+          if( rp->rhsalias[j] && strcmp(rp->rhsalias[j],rp->rhsalias[i])==0 ){
+            ErrorMsg(lemp->filename,rp->ruleline,
+              "Label %s used for multiple symbols on the RHS of a rule.",
+              rp->rhsalias[i]);
+            lemp->errorcnt++;
+            break;
+          }
+        }
+      }
+      if( !used[i] ){
+        ErrorMsg(lemp->filename,rp->ruleline,
+          "Label %s for \"%s(%s)\" is never used.",
+          rp->rhsalias[i],rp->rhs[i]->name,rp->rhsalias[i]);
+        lemp->errorcnt++;
+      }
+    }else if( i>0 && has_destructor(rp->rhs[i],lemp) ){
+      append_str("  yy_destructor(yypParser,%d,&yymsp[%d].minor);\n", 0,
+         rp->rhs[i]->index,i-rp->nrhs+1);
+    }
+  }
+
+  /* If unable to write LHS values directly into the stack, write the
+  ** saved LHS value now. */
+  if( lhsdirect==0 ){
+    append_str("  yymsp[%d].minor.yy%d = ", 0, 1-rp->nrhs, rp->lhs->dtnum);
+    append_str(zLhs, 0, 0, 0);
+    append_str(";\n", 0, 0, 0);
+  }
+
+  /* Suffix code generation complete */
+  cp = append_str(0,0,0,0);
+  if( cp && cp[0] ){
+    rp->codeSuffix = Strsafe(cp);
+    rp->noCode = 0;
+  }
+
+  return rc;
+}
+
+/* 
+** Generate code which executes when the rule "rp" is reduced.  Write
+** the code to "out".  Make sure lineno stays up-to-date.
+*/
+PRIVATE void emit_code(
+  FILE *out,
+  struct rule *rp,
+  struct lemon *lemp,
+  int *lineno
+){
+ const char *cp;
+
+ /* Setup code prior to the #line directive */
+ if( rp->codePrefix && rp->codePrefix[0] ){
+   fprintf(out, "{%s", rp->codePrefix);
+   for(cp=rp->codePrefix; *cp; cp++){ if( *cp=='\n' ) (*lineno)++; }
+ }
+
+ /* Generate code to do the reduce action */
+ if( rp->code ){
+   if( !lemp->nolinenosflag ){
+     (*lineno)++;
+     tplt_linedir(out,rp->line,lemp->filename);
+   }
+   fprintf(out,"{%s",rp->code);
+   for(cp=rp->code; *cp; cp++){ if( *cp=='\n' ) (*lineno)++; }
+   fprintf(out,"}\n"); (*lineno)++;
+   if( !lemp->nolinenosflag ){
+     (*lineno)++;
+     tplt_linedir(out,*lineno,lemp->outname);
+   }
+ }
+
+ /* Generate breakdown code that occurs after the #line directive */
+ if( rp->codeSuffix && rp->codeSuffix[0] ){
+   fprintf(out, "%s", rp->codeSuffix);
+   for(cp=rp->codeSuffix; *cp; cp++){ if( *cp=='\n' ) (*lineno)++; }
+ }
+
+ if( rp->codePrefix ){
+   fprintf(out, "}\n"); (*lineno)++;
+ }
+
+ return;
+}
+
+/*
+** Print the definition of the union used for the parser's data stack.
+** This union contains fields for every possible data type for tokens
+** and nonterminals.  In the process of computing and printing this
+** union, also set the ".dtnum" field of every terminal and nonterminal
+** symbol.
+*/
+void print_stack_union(
+  FILE *out,                  /* The output stream */
+  struct lemon *lemp,         /* The main info structure for this parser */
+  int *plineno,               /* Pointer to the line number */
+  int mhflag                  /* True if generating makeheaders output */
+){
+  int lineno = *plineno;    /* The line number of the output */
+  char **types;             /* A hash table of datatypes */
+  int arraysize;            /* Size of the "types" array */
+  int maxdtlength;          /* Maximum length of any ".datatype" field. */
+  char *stddt;              /* Standardized name for a datatype */
+  int i,j;                  /* Loop counters */
+  unsigned hash;            /* For hashing the name of a type */
+  const char *name;         /* Name of the parser */
+
+  /* Allocate and initialize types[] and allocate stddt[] */
+  arraysize = lemp->nsymbol * 2;
+  types = (char**)calloc( arraysize, sizeof(char*) );
+  if( types==0 ){
+    fprintf(stderr,"Out of memory.\n");
+    exit(1);
+  }
+  for(i=0; i<arraysize; i++) types[i] = 0;
+  maxdtlength = 0;
+  if( lemp->vartype ){
+    maxdtlength = lemonStrlen(lemp->vartype);
+  }
+  for(i=0; i<lemp->nsymbol; i++){
+    int len;
+    struct symbol *sp = lemp->symbols[i];
+    if( sp->datatype==0 ) continue;
+    len = lemonStrlen(sp->datatype);
+    if( len>maxdtlength ) maxdtlength = len;
+  }
+  stddt = (char*)malloc( maxdtlength*2 + 1 );
+  if( stddt==0 ){
+    fprintf(stderr,"Out of memory.\n");
+    exit(1);
+  }
+
+  /* Build a hash table of datatypes. The ".dtnum" field of each symbol
+  ** is filled in with the hash index plus 1.  A ".dtnum" value of 0 is
+  ** used for terminal symbols.  If there is no %default_type defined then
+  ** 0 is also used as the .dtnum value for nonterminals which do not specify
+  ** a datatype using the %type directive.
+  */
+  for(i=0; i<lemp->nsymbol; i++){
+    struct symbol *sp = lemp->symbols[i];
+    char *cp;
+    if( sp==lemp->errsym ){
+      sp->dtnum = arraysize+1;
+      continue;
+    }
+    if( sp->type!=NONTERMINAL || (sp->datatype==0 && lemp->vartype==0) ){
+      sp->dtnum = 0;
+      continue;
+    }
+    cp = sp->datatype;
+    if( cp==0 ) cp = lemp->vartype;
+    j = 0;
+    while( ISSPACE(*cp) ) cp++;
+    while( *cp ) stddt[j++] = *cp++;
+    while( j>0 && ISSPACE(stddt[j-1]) ) j--;
+    stddt[j] = 0;
+    if( lemp->tokentype && strcmp(stddt, lemp->tokentype)==0 ){
+      sp->dtnum = 0;
+      continue;
+    }
+    hash = 0;
+    for(j=0; stddt[j]; j++){
+      hash = hash*53 + stddt[j];
+    }
+    hash = (hash & 0x7fffffff)%arraysize;
+    while( types[hash] ){
+      if( strcmp(types[hash],stddt)==0 ){
+        sp->dtnum = hash + 1;
+        break;
+      }
+      hash++;
+      if( hash>=(unsigned)arraysize ) hash = 0;
+    }
+    if( types[hash]==0 ){
+      sp->dtnum = hash + 1;
+      types[hash] = (char*)malloc( lemonStrlen(stddt)+1 );
+      if( types[hash]==0 ){
+        fprintf(stderr,"Out of memory.\n");
+        exit(1);
+      }
+      lemon_strcpy(types[hash],stddt);
+    }
+  }
+
+  /* Print out the definition of YYTOKENTYPE and YYMINORTYPE */
+  name = lemp->name ? lemp->name : "Parse";
+  lineno = *plineno;
+  if( mhflag ){ fprintf(out,"#if INTERFACE\n"); lineno++; }
+  fprintf(out,"#define %sTOKENTYPE %s\n",name,
+    lemp->tokentype?lemp->tokentype:"void*");  lineno++;
+  if( mhflag ){ fprintf(out,"#endif\n"); lineno++; }
+  fprintf(out,"typedef union {\n"); lineno++;
+  fprintf(out,"  int yyinit;\n"); lineno++;
+  fprintf(out,"  %sTOKENTYPE yy0;\n",name); lineno++;
+  for(i=0; i<arraysize; i++){
+    if( types[i]==0 ) continue;
+    fprintf(out,"  %s yy%d;\n",types[i],i+1); lineno++;
+    free(types[i]);
+  }
+  if( lemp->errsym->useCnt ){
+    fprintf(out,"  int yy%d;\n",lemp->errsym->dtnum); lineno++;
+  }
+  free(stddt);
+  free(types);
+  fprintf(out,"} YYMINORTYPE;\n"); lineno++;
+  *plineno = lineno;
+}
+
+/*
+** Return the name of a C datatype able to represent values between
+** lwr and upr, inclusive.  If pnByte!=NULL then also write the sizeof
+** for that type (1, 2, or 4) into *pnByte.
+*/
+static const char *minimum_size_type(int lwr, int upr, int *pnByte){
+  const char *zType = "int";
+  int nByte = 4;
+  if( lwr>=0 ){
+    if( upr<=255 ){
+      zType = "unsigned char";
+      nByte = 1;
+    }else if( upr<65535 ){
+      zType = "unsigned short int";
+      nByte = 2;
+    }else{
+      zType = "unsigned int";
+      nByte = 4;
+    }
+  }else if( lwr>=-127 && upr<=127 ){
+    zType = "signed char";
+    nByte = 1;
+  }else if( lwr>=-32767 && upr<32767 ){
+    zType = "short";
+    nByte = 2;
+  }
+  if( pnByte ) *pnByte = nByte;
+  return zType;
+}
+
+/*
+** Each state contains a set of token transaction and a set of
+** nonterminal transactions.  Each of these sets makes an instance
+** of the following structure.  An array of these structures is used
+** to order the creation of entries in the yy_action[] table.
+*/
+struct axset {
+  struct state *stp;   /* A pointer to a state */
+  int isTkn;           /* True to use tokens.  False for non-terminals */
+  int nAction;         /* Number of actions */
+  int iOrder;          /* Original order of action sets */
+};
+
+/*
+** Compare to axset structures for sorting purposes
+*/
+static int axset_compare(const void *a, const void *b){
+  struct axset *p1 = (struct axset*)a;
+  struct axset *p2 = (struct axset*)b;
+  int c;
+  c = p2->nAction - p1->nAction;
+  if( c==0 ){
+    c = p1->iOrder - p2->iOrder;
+  }
+  assert( c!=0 || p1==p2 );
+  return c;
+}
+
+/*
+** Write text on "out" that describes the rule "rp".
+*/
+static void writeRuleText(FILE *out, struct rule *rp){
+  int j;
+  fprintf(out,"%s ::=", rp->lhs->name);
+  for(j=0; j<rp->nrhs; j++){
+    struct symbol *sp = rp->rhs[j];
+    if( sp->type!=MULTITERMINAL ){
+      fprintf(out," %s", sp->name);
+    }else{
+      int k;
+      fprintf(out," %s", sp->subsym[0]->name);
+      for(k=1; k<sp->nsubsym; k++){
+        fprintf(out,"|%s",sp->subsym[k]->name);
+      }
+    }
+  }
+}
+
+
+/* Generate C source code for the parser */
+void ReportTable(
+  struct lemon *lemp,
+  int mhflag     /* Output in makeheaders format if true */
+){
+  FILE *out, *in;
+  char line[LINESIZE];
+  int  lineno;
+  struct state *stp;
+  struct action *ap;
+  struct rule *rp;
+  struct acttab *pActtab;
+  int i, j, n, sz;
+  int szActionType;     /* sizeof(YYACTIONTYPE) */
+  int szCodeType;       /* sizeof(YYCODETYPE)   */
+  const char *name;
+  int mnTknOfst, mxTknOfst;
+  int mnNtOfst, mxNtOfst;
+  struct axset *ax;
+
+  in = tplt_open(lemp);
+  if( in==0 ) return;
+  out = file_open(lemp,".c","wb");
+  if( out==0 ){
+    fclose(in);
+    return;
+  }
+  lineno = 1;
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate the include code, if any */
+  tplt_print(out,lemp,lemp->include,&lineno);
+  if( mhflag ){
+    char *incName = file_makename(lemp, ".h");
+    fprintf(out,"#include \"%s\"\n", incName); lineno++;
+    free(incName);
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate #defines for all tokens */
+  if( mhflag ){
+    const char *prefix;
+    fprintf(out,"#if INTERFACE\n"); lineno++;
+    if( lemp->tokenprefix ) prefix = lemp->tokenprefix;
+    else                    prefix = "";
+    for(i=1; i<lemp->nterminal; i++){
+      fprintf(out,"#define %s%-30s %2d\n",prefix,lemp->symbols[i]->name,i);
+      lineno++;
+    }
+    fprintf(out,"#endif\n"); lineno++;
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate the defines */
+  fprintf(out,"#define YYCODETYPE %s\n",
+    minimum_size_type(0, lemp->nsymbol+1, &szCodeType)); lineno++;
+  fprintf(out,"#define YYNOCODE %d\n",lemp->nsymbol+1);  lineno++;
+  fprintf(out,"#define YYACTIONTYPE %s\n",
+    minimum_size_type(0,lemp->nstate+lemp->nrule*2+5,&szActionType)); lineno++;
+  if( lemp->wildcard ){
+    fprintf(out,"#define YYWILDCARD %d\n",
+       lemp->wildcard->index); lineno++;
+  }
+  print_stack_union(out,lemp,&lineno,mhflag);
+  fprintf(out, "#ifndef YYSTACKDEPTH\n"); lineno++;
+  if( lemp->stacksize ){
+    fprintf(out,"#define YYSTACKDEPTH %s\n",lemp->stacksize);  lineno++;
+  }else{
+    fprintf(out,"#define YYSTACKDEPTH 100\n");  lineno++;
+  }
+  fprintf(out, "#endif\n"); lineno++;
+  if( mhflag ){
+    fprintf(out,"#if INTERFACE\n"); lineno++;
+  }
+  name = lemp->name ? lemp->name : "Parse";
+  if( lemp->arg && lemp->arg[0] ){
+    i = lemonStrlen(lemp->arg);
+    while( i>=1 && ISSPACE(lemp->arg[i-1]) ) i--;
+    while( i>=1 && (ISALNUM(lemp->arg[i-1]) || lemp->arg[i-1]=='_') ) i--;
+    fprintf(out,"#define %sARG_SDECL %s;\n",name,lemp->arg);  lineno++;
+    fprintf(out,"#define %sARG_PDECL ,%s\n",name,lemp->arg);  lineno++;
+    fprintf(out,"#define %sARG_FETCH %s = yypParser->%s\n",
+                 name,lemp->arg,&lemp->arg[i]);  lineno++;
+    fprintf(out,"#define %sARG_STORE yypParser->%s = %s\n",
+                 name,&lemp->arg[i],&lemp->arg[i]);  lineno++;
+  }else{
+    fprintf(out,"#define %sARG_SDECL\n",name);  lineno++;
+    fprintf(out,"#define %sARG_PDECL\n",name);  lineno++;
+    fprintf(out,"#define %sARG_FETCH\n",name); lineno++;
+    fprintf(out,"#define %sARG_STORE\n",name); lineno++;
+  }
+  if( mhflag ){
+    fprintf(out,"#endif\n"); lineno++;
+  }
+  if( lemp->errsym->useCnt ){
+    fprintf(out,"#define YYERRORSYMBOL %d\n",lemp->errsym->index); lineno++;
+    fprintf(out,"#define YYERRSYMDT yy%d\n",lemp->errsym->dtnum); lineno++;
+  }
+  if( lemp->has_fallback ){
+    fprintf(out,"#define YYFALLBACK 1\n");  lineno++;
+  }
+
+  /* Compute the action table, but do not output it yet.  The action
+  ** table must be computed before generating the YYNSTATE macro because
+  ** we need to know how many states can be eliminated.
+  */
+  ax = (struct axset *) calloc(lemp->nxstate*2, sizeof(ax[0]));
+  if( ax==0 ){
+    fprintf(stderr,"malloc failed\n");
+    exit(1);
+  }
+  for(i=0; i<lemp->nxstate; i++){
+    stp = lemp->sorted[i];
+    ax[i*2].stp = stp;
+    ax[i*2].isTkn = 1;
+    ax[i*2].nAction = stp->nTknAct;
+    ax[i*2+1].stp = stp;
+    ax[i*2+1].isTkn = 0;
+    ax[i*2+1].nAction = stp->nNtAct;
+  }
+  mxTknOfst = mnTknOfst = 0;
+  mxNtOfst = mnNtOfst = 0;
+  /* In an effort to minimize the action table size, use the heuristic
+  ** of placing the largest action sets first */
+  for(i=0; i<lemp->nxstate*2; i++) ax[i].iOrder = i;
+  qsort(ax, lemp->nxstate*2, sizeof(ax[0]), axset_compare);
+  pActtab = acttab_alloc();
+  for(i=0; i<lemp->nxstate*2 && ax[i].nAction>0; i++){
+    stp = ax[i].stp;
+    if( ax[i].isTkn ){
+      for(ap=stp->ap; ap; ap=ap->next){
+        int action;
+        if( ap->sp->index>=lemp->nterminal ) continue;
+        action = compute_action(lemp, ap);
+        if( action<0 ) continue;
+        acttab_action(pActtab, ap->sp->index, action);
+      }
+      stp->iTknOfst = acttab_insert(pActtab);
+      if( stp->iTknOfst<mnTknOfst ) mnTknOfst = stp->iTknOfst;
+      if( stp->iTknOfst>mxTknOfst ) mxTknOfst = stp->iTknOfst;
+    }else{
+      for(ap=stp->ap; ap; ap=ap->next){
+        int action;
+        if( ap->sp->index<lemp->nterminal ) continue;
+        if( ap->sp->index==lemp->nsymbol ) continue;
+        action = compute_action(lemp, ap);
+        if( action<0 ) continue;
+        acttab_action(pActtab, ap->sp->index, action);
+      }
+      stp->iNtOfst = acttab_insert(pActtab);
+      if( stp->iNtOfst<mnNtOfst ) mnNtOfst = stp->iNtOfst;
+      if( stp->iNtOfst>mxNtOfst ) mxNtOfst = stp->iNtOfst;
+    }
+#if 0  /* Uncomment for a trace of how the yy_action[] table fills out */
+    { int jj, nn;
+      for(jj=nn=0; jj<pActtab->nAction; jj++){
+        if( pActtab->aAction[jj].action<0 ) nn++;
+      }
+      printf("%4d: State %3d %s n: %2d size: %5d freespace: %d\n",
+             i, stp->statenum, ax[i].isTkn ? "Token" : "Var  ",
+             ax[i].nAction, pActtab->nAction, nn);
+    }
+#endif
+  }
+  free(ax);
+
+  /* Mark rules that are actually used for reduce actions after all
+  ** optimizations have been applied
+  */
+  for(rp=lemp->rule; rp; rp=rp->next) rp->doesReduce = LEMON_FALSE;
+  for(i=0; i<lemp->nxstate; i++){
+    for(ap=lemp->sorted[i]->ap; ap; ap=ap->next){
+      if( ap->type==REDUCE || ap->type==SHIFTREDUCE ){
+        ap->x.rp->doesReduce = i;
+      }
+    }
+  }
+
+  /* Finish rendering the constants now that the action table has
+  ** been computed */
+  fprintf(out,"#define YYNSTATE             %d\n",lemp->nxstate);  lineno++;
+  fprintf(out,"#define YYNRULE              %d\n",lemp->nrule);  lineno++;
+  fprintf(out,"#define YY_MAX_SHIFT         %d\n",lemp->nxstate-1); lineno++;
+  fprintf(out,"#define YY_MIN_SHIFTREDUCE   %d\n",lemp->nstate); lineno++;
+  i = lemp->nstate + lemp->nrule;
+  fprintf(out,"#define YY_MAX_SHIFTREDUCE   %d\n", i-1); lineno++;
+  fprintf(out,"#define YY_MIN_REDUCE        %d\n", i); lineno++;
+  i = lemp->nstate + lemp->nrule*2;
+  fprintf(out,"#define YY_MAX_REDUCE        %d\n", i-1); lineno++;
+  fprintf(out,"#define YY_ERROR_ACTION      %d\n", i); lineno++;
+  fprintf(out,"#define YY_ACCEPT_ACTION     %d\n", i+1); lineno++;
+  fprintf(out,"#define YY_NO_ACTION         %d\n", i+2); lineno++;
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Now output the action table and its associates:
+  **
+  **  yy_action[]        A single table containing all actions.
+  **  yy_lookahead[]     A table containing the lookahead for each entry in
+  **                     yy_action.  Used to detect hash collisions.
+  **  yy_shift_ofst[]    For each state, the offset into yy_action for
+  **                     shifting terminals.
+  **  yy_reduce_ofst[]   For each state, the offset into yy_action for
+  **                     shifting non-terminals after a reduce.
+  **  yy_default[]       Default action for each state.
+  */
+
+  /* Output the yy_action table */
+  lemp->nactiontab = n = acttab_size(pActtab);
+  lemp->tablesize += n*szActionType;
+  fprintf(out,"#define YY_ACTTAB_COUNT (%d)\n", n); lineno++;
+  fprintf(out,"static const YYACTIONTYPE yy_action[] = {\n"); lineno++;
+  for(i=j=0; i<n; i++){
+    int action = acttab_yyaction(pActtab, i);
+    if( action<0 ) action = lemp->nstate + lemp->nrule + 2;
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", action);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "};\n"); lineno++;
+
+  /* Output the yy_lookahead table */
+  lemp->tablesize += n*szCodeType;
+  fprintf(out,"static const YYCODETYPE yy_lookahead[] = {\n"); lineno++;
+  for(i=j=0; i<n; i++){
+    int la = acttab_yylookahead(pActtab, i);
+    if( la<0 ) la = lemp->nsymbol;
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", la);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "};\n"); lineno++;
+
+  /* Output the yy_shift_ofst[] table */
+  n = lemp->nxstate;
+  while( n>0 && lemp->sorted[n-1]->iTknOfst==NO_OFFSET ) n--;
+  fprintf(out, "#define YY_SHIFT_USE_DFLT (%d)\n", lemp->nactiontab); lineno++;
+  fprintf(out, "#define YY_SHIFT_COUNT    (%d)\n", n-1); lineno++;
+  fprintf(out, "#define YY_SHIFT_MIN      (%d)\n", mnTknOfst); lineno++;
+  fprintf(out, "#define YY_SHIFT_MAX      (%d)\n", mxTknOfst); lineno++;
+  fprintf(out, "static const %s yy_shift_ofst[] = {\n", 
+       minimum_size_type(mnTknOfst, lemp->nterminal+lemp->nactiontab, &sz));
+       lineno++;
+  lemp->tablesize += n*sz;
+  for(i=j=0; i<n; i++){
+    int ofst;
+    stp = lemp->sorted[i];
+    ofst = stp->iTknOfst;
+    if( ofst==NO_OFFSET ) ofst = lemp->nactiontab;
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", ofst);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "};\n"); lineno++;
+
+  /* Output the yy_reduce_ofst[] table */
+  fprintf(out, "#define YY_REDUCE_USE_DFLT (%d)\n", mnNtOfst-1); lineno++;
+  n = lemp->nxstate;
+  while( n>0 && lemp->sorted[n-1]->iNtOfst==NO_OFFSET ) n--;
+  fprintf(out, "#define YY_REDUCE_COUNT (%d)\n", n-1); lineno++;
+  fprintf(out, "#define YY_REDUCE_MIN   (%d)\n", mnNtOfst); lineno++;
+  fprintf(out, "#define YY_REDUCE_MAX   (%d)\n", mxNtOfst); lineno++;
+  fprintf(out, "static const %s yy_reduce_ofst[] = {\n", 
+          minimum_size_type(mnNtOfst-1, mxNtOfst, &sz)); lineno++;
+  lemp->tablesize += n*sz;
+  for(i=j=0; i<n; i++){
+    int ofst;
+    stp = lemp->sorted[i];
+    ofst = stp->iNtOfst;
+    if( ofst==NO_OFFSET ) ofst = mnNtOfst - 1;
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", ofst);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "};\n"); lineno++;
+
+  /* Output the default action table */
+  fprintf(out, "static const YYACTIONTYPE yy_default[] = {\n"); lineno++;
+  n = lemp->nxstate;
+  lemp->tablesize += n*szActionType;
+  for(i=j=0; i<n; i++){
+    stp = lemp->sorted[i];
+    if( j==0 ) fprintf(out," /* %5d */ ", i);
+    fprintf(out, " %4d,", stp->iDfltReduce+lemp->nstate+lemp->nrule);
+    if( j==9 || i==n-1 ){
+      fprintf(out, "\n"); lineno++;
+      j = 0;
+    }else{
+      j++;
+    }
+  }
+  fprintf(out, "};\n"); lineno++;
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate the table of fallback tokens.
+  */
+  if( lemp->has_fallback ){
+    int mx = lemp->nterminal - 1;
+    while( mx>0 && lemp->symbols[mx]->fallback==0 ){ mx--; }
+    lemp->tablesize += (mx+1)*szCodeType;
+    for(i=0; i<=mx; i++){
+      struct symbol *p = lemp->symbols[i];
+      if( p->fallback==0 ){
+        fprintf(out, "    0,  /* %10s => nothing */\n", p->name);
+      }else{
+        fprintf(out, "  %3d,  /* %10s => %s */\n", p->fallback->index,
+          p->name, p->fallback->name);
+      }
+      lineno++;
+    }
+  }
+  tplt_xfer(lemp->name, in, out, &lineno);
+
+  /* Generate a table containing the symbolic name of every symbol
+  */
+  for(i=0; i<lemp->nsymbol; i++){
+    lemon_sprintf(line,"\"%s\",",lemp->symbols[i]->name);
+    fprintf(out,"  %-15s",line);
+    if( (i&3)==3 ){ fprintf(out,"\n"); lineno++; }
+  }
+  if( (i&3)!=0 ){ fprintf(out,"\n"); lineno++; }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate a table containing a text string that describes every
+  ** rule in the rule set of the grammar.  This information is used
+  ** when tracing REDUCE actions.
+  */
+  for(i=0, rp=lemp->rule; rp; rp=rp->next, i++){
+    assert( rp->iRule==i );
+    fprintf(out," /* %3d */ \"", i);
+    writeRuleText(out, rp);
+    fprintf(out,"\",\n"); lineno++;
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes every time a symbol is popped from
+  ** the stack while processing errors or while destroying the parser. 
+  ** (In other words, generate the %destructor actions)
+  */
+  if( lemp->tokendest ){
+    int once = 1;
+    for(i=0; i<lemp->nsymbol; i++){
+      struct symbol *sp = lemp->symbols[i];
+      if( sp==0 || sp->type!=TERMINAL ) continue;
+      if( once ){
+        fprintf(out, "      /* TERMINAL Destructor */\n"); lineno++;
+        once = 0;
+      }
+      fprintf(out,"    case %d: /* %s */\n", sp->index, sp->name); lineno++;
+    }
+    for(i=0; i<lemp->nsymbol && lemp->symbols[i]->type!=TERMINAL; i++);
+    if( i<lemp->nsymbol ){
+      emit_destructor_code(out,lemp->symbols[i],lemp,&lineno);
+      fprintf(out,"      break;\n"); lineno++;
+    }
+  }
+  if( lemp->vardest ){
+    struct symbol *dflt_sp = 0;
+    int once = 1;
+    for(i=0; i<lemp->nsymbol; i++){
+      struct symbol *sp = lemp->symbols[i];
+      if( sp==0 || sp->type==TERMINAL ||
+          sp->index<=0 || sp->destructor!=0 ) continue;
+      if( once ){
+        fprintf(out, "      /* Default NON-TERMINAL Destructor */\n"); lineno++;
+        once = 0;
+      }
+      fprintf(out,"    case %d: /* %s */\n", sp->index, sp->name); lineno++;
+      dflt_sp = sp;
+    }
+    if( dflt_sp!=0 ){
+      emit_destructor_code(out,dflt_sp,lemp,&lineno);
+    }
+    fprintf(out,"      break;\n"); lineno++;
+  }
+  for(i=0; i<lemp->nsymbol; i++){
+    struct symbol *sp = lemp->symbols[i];
+    if( sp==0 || sp->type==TERMINAL || sp->destructor==0 ) continue;
+    if( sp->destLineno<0 ) continue;  /* Already emitted */
+    fprintf(out,"    case %d: /* %s */\n", sp->index, sp->name); lineno++;
+
+    /* Combine duplicate destructors into a single case */
+    for(j=i+1; j<lemp->nsymbol; j++){
+      struct symbol *sp2 = lemp->symbols[j];
+      if( sp2 && sp2->type!=TERMINAL && sp2->destructor
+          && sp2->dtnum==sp->dtnum
+          && strcmp(sp->destructor,sp2->destructor)==0 ){
+         fprintf(out,"    case %d: /* %s */\n",
+                 sp2->index, sp2->name); lineno++;
+         sp2->destLineno = -1;  /* Avoid emitting this destructor again */
+      }
+    }
+
+    emit_destructor_code(out,lemp->symbols[i],lemp,&lineno);
+    fprintf(out,"      break;\n"); lineno++;
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes whenever the parser stack overflows */
+  tplt_print(out,lemp,lemp->overflow,&lineno);
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate the table of rule information 
+  **
+  ** Note: This code depends on the fact that rules are number
+  ** sequentually beginning with 0.
+  */
+  for(rp=lemp->rule; rp; rp=rp->next){
+    fprintf(out,"  { %d, %d },\n",rp->lhs->index,rp->nrhs); lineno++;
+  }
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which execution during each REDUCE action */
+  i = 0;
+  for(rp=lemp->rule; rp; rp=rp->next){
+    i += translate_code(lemp, rp);
+  }
+  if( i ){
+    fprintf(out,"        YYMINORTYPE yylhsminor;\n"); lineno++;
+  }
+  /* First output rules other than the default: rule */
+  for(rp=lemp->rule; rp; rp=rp->next){
+    struct rule *rp2;               /* Other rules with the same action */
+    if( rp->codeEmitted ) continue;
+    if( rp->noCode ){
+      /* No C code actions, so this will be part of the "default:" rule */
+      continue;
+    }
+    fprintf(out,"      case %d: /* ", rp->iRule);
+    writeRuleText(out, rp);
+    fprintf(out, " */\n"); lineno++;
+    for(rp2=rp->next; rp2; rp2=rp2->next){
+      if( rp2->code==rp->code && rp2->codePrefix==rp->codePrefix
+             && rp2->codeSuffix==rp->codeSuffix ){
+        fprintf(out,"      case %d: /* ", rp2->iRule);
+        writeRuleText(out, rp2);
+        fprintf(out," */ yytestcase(yyruleno==%d);\n", rp2->iRule); lineno++;
+        rp2->codeEmitted = 1;
+      }
+    }
+    emit_code(out,rp,lemp,&lineno);
+    fprintf(out,"        break;\n"); lineno++;
+    rp->codeEmitted = 1;
+  }
+  /* Finally, output the default: rule.  We choose as the default: all
+  ** empty actions. */
+  fprintf(out,"      default:\n"); lineno++;
+  for(rp=lemp->rule; rp; rp=rp->next){
+    if( rp->codeEmitted ) continue;
+    assert( rp->noCode );
+    fprintf(out,"      /* (%d) ", rp->iRule);
+    writeRuleText(out, rp);
+    if( rp->doesReduce ){
+      fprintf(out, " */ yytestcase(yyruleno==%d);\n", rp->iRule); lineno++;
+    }else{
+      fprintf(out, " (OPTIMIZED OUT) */ assert(yyruleno!=%d);\n",
+              rp->iRule); lineno++;
+    }
+  }
+  fprintf(out,"        break;\n"); lineno++;
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes if a parse fails */
+  tplt_print(out,lemp,lemp->failure,&lineno);
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes when a syntax error occurs */
+  tplt_print(out,lemp,lemp->error,&lineno);
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Generate code which executes when the parser accepts its input */
+  tplt_print(out,lemp,lemp->accept,&lineno);
+  tplt_xfer(lemp->name,in,out,&lineno);
+
+  /* Append any addition code the user desires */
+  tplt_print(out,lemp,lemp->extracode,&lineno);
+
+  fclose(in);
+  fclose(out);
+  return;
+}
+
+/* Generate a header file for the parser */
+void ReportHeader(struct lemon *lemp)
+{
+  FILE *out, *in;
+  const char *prefix;
+  char line[LINESIZE];
+  char pattern[LINESIZE];
+  int i;
+
+  if( lemp->tokenprefix ) prefix = lemp->tokenprefix;
+  else                    prefix = "";
+  in = file_open(lemp,".h","rb");
+  if( in ){
+    int nextChar;
+    for(i=1; i<lemp->nterminal && fgets(line,LINESIZE,in); i++){
+      lemon_sprintf(pattern,"#define %s%-30s %3d\n",
+                    prefix,lemp->symbols[i]->name,i);
+      if( strcmp(line,pattern) ) break;
+    }
+    nextChar = fgetc(in);
+    fclose(in);
+    if( i==lemp->nterminal && nextChar==EOF ){
+      /* No change in the file.  Don't rewrite it. */
+      return;
+    }
+  }
+  out = file_open(lemp,".h","wb");
+  if( out ){
+    for(i=1; i<lemp->nterminal; i++){
+      fprintf(out,"#define %s%-30s %3d\n",prefix,lemp->symbols[i]->name,i);
+    }
+    fclose(out);  
+  }
+  return;
+}
+
+/* Reduce the size of the action tables, if possible, by making use
+** of defaults.
+**
+** In this version, we take the most frequent REDUCE action and make
+** it the default.  Except, there is no default if the wildcard token
+** is a possible look-ahead.
+*/
+void CompressTables(struct lemon *lemp)
+{
+  struct state *stp;
+  struct action *ap, *ap2, *nextap;
+  struct rule *rp, *rp2, *rbest;
+  int nbest, n;
+  int i;
+  int usesWildcard;
+
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    nbest = 0;
+    rbest = 0;
+    usesWildcard = 0;
+
+    for(ap=stp->ap; ap; ap=ap->next){
+      if( ap->type==SHIFT && ap->sp==lemp->wildcard ){
+        usesWildcard = 1;
+      }
+      if( ap->type!=REDUCE ) continue;
+      rp = ap->x.rp;
+      if( rp->lhsStart ) continue;
+      if( rp==rbest ) continue;
+      n = 1;
+      for(ap2=ap->next; ap2; ap2=ap2->next){
+        if( ap2->type!=REDUCE ) continue;
+        rp2 = ap2->x.rp;
+        if( rp2==rbest ) continue;
+        if( rp2==rp ) n++;
+      }
+      if( n>nbest ){
+        nbest = n;
+        rbest = rp;
+      }
+    }
+ 
+    /* Do not make a default if the number of rules to default
+    ** is not at least 1 or if the wildcard token is a possible
+    ** lookahead.
+    */
+    if( nbest<1 || usesWildcard ) continue;
+
+
+    /* Combine matching REDUCE actions into a single default */
+    for(ap=stp->ap; ap; ap=ap->next){
+      if( ap->type==REDUCE && ap->x.rp==rbest ) break;
+    }
+    assert( ap );
+    ap->sp = Symbol_new("{default}");
+    for(ap=ap->next; ap; ap=ap->next){
+      if( ap->type==REDUCE && ap->x.rp==rbest ) ap->type = NOT_USED;
+    }
+    stp->ap = Action_sort(stp->ap);
+
+    for(ap=stp->ap; ap; ap=ap->next){
+      if( ap->type==SHIFT ) break;
+      if( ap->type==REDUCE && ap->x.rp!=rbest ) break;
+    }
+    if( ap==0 ){
+      stp->autoReduce = 1;
+      stp->pDfltReduce = rbest;
+    }
+  }
+
+  /* Make a second pass over all states and actions.  Convert
+  ** every action that is a SHIFT to an autoReduce state into
+  ** a SHIFTREDUCE action.
+  */
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    for(ap=stp->ap; ap; ap=ap->next){
+      struct state *pNextState;
+      if( ap->type!=SHIFT ) continue;
+      pNextState = ap->x.stp;
+      if( pNextState->autoReduce && pNextState->pDfltReduce!=0 ){
+        ap->type = SHIFTREDUCE;
+        ap->x.rp = pNextState->pDfltReduce;
+      }
+    }
+  }
+
+  /* If a SHIFTREDUCE action specifies a rule that has a single RHS term
+  ** (meaning that the SHIFTREDUCE will land back in the state where it
+  ** started) and if there is no C-code associated with the reduce action,
+  ** then we can go ahead and convert the action to be the same as the
+  ** action for the RHS of the rule.
+  */
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    for(ap=stp->ap; ap; ap=nextap){
+      nextap = ap->next;
+      if( ap->type!=SHIFTREDUCE ) continue;
+      rp = ap->x.rp;
+      if( rp->noCode==0 ) continue;
+      if( rp->nrhs!=1 ) continue;
+#if 1
+      /* Only apply this optimization to non-terminals.  It would be OK to
+      ** apply it to terminal symbols too, but that makes the parser tables
+      ** larger. */
+      if( ap->sp->index<lemp->nterminal ) continue;
+#endif
+      /* If we reach this point, it means the optimization can be applied */
+      nextap = ap;
+      for(ap2=stp->ap; ap2 && (ap2==ap || ap2->sp!=rp->lhs); ap2=ap2->next){}
+      assert( ap2!=0 );
+      ap->spOpt = ap2->sp;
+      ap->type = ap2->type;
+      ap->x = ap2->x;
+    }
+  }
+}
+
+
+/*
+** Compare two states for sorting purposes.  The smaller state is the
+** one with the most non-terminal actions.  If they have the same number
+** of non-terminal actions, then the smaller is the one with the most
+** token actions.
+*/
+static int stateResortCompare(const void *a, const void *b){
+  const struct state *pA = *(const struct state**)a;
+  const struct state *pB = *(const struct state**)b;
+  int n;
+
+  n = pB->nNtAct - pA->nNtAct;
+  if( n==0 ){
+    n = pB->nTknAct - pA->nTknAct;
+    if( n==0 ){
+      n = pB->statenum - pA->statenum;
+    }
+  }
+  assert( n!=0 );
+  return n;
+}
+
+
+/*
+** Renumber and resort states so that states with fewer choices
+** occur at the end.  Except, keep state 0 as the first state.
+*/
+void ResortStates(struct lemon *lemp)
+{
+  int i;
+  struct state *stp;
+  struct action *ap;
+
+  for(i=0; i<lemp->nstate; i++){
+    stp = lemp->sorted[i];
+    stp->nTknAct = stp->nNtAct = 0;
+    stp->iDfltReduce = lemp->nrule;  /* Init dflt action to "syntax error" */
+    stp->iTknOfst = NO_OFFSET;
+    stp->iNtOfst = NO_OFFSET;
+    for(ap=stp->ap; ap; ap=ap->next){
+      int iAction = compute_action(lemp,ap);
+      if( iAction>=0 ){
+        if( ap->sp->index<lemp->nterminal ){
+          stp->nTknAct++;
+        }else if( ap->sp->index<lemp->nsymbol ){
+          stp->nNtAct++;
+        }else{
+          assert( stp->autoReduce==0 || stp->pDfltReduce==ap->x.rp );
+          stp->iDfltReduce = iAction - lemp->nstate - lemp->nrule;
+        }
+      }
+    }
+  }
+  qsort(&lemp->sorted[1], lemp->nstate-1, sizeof(lemp->sorted[0]),
+        stateResortCompare);
+  for(i=0; i<lemp->nstate; i++){
+    lemp->sorted[i]->statenum = i;
+  }
+  lemp->nxstate = lemp->nstate;
+  while( lemp->nxstate>1 && lemp->sorted[lemp->nxstate-1]->autoReduce ){
+    lemp->nxstate--;
+  }
+}
+
+
+/***************** From the file "set.c" ************************************/
+/*
+** Set manipulation routines for the LEMON parser generator.
+*/
+
+static int size = 0;
+
+/* Set the set size */
+void SetSize(int n)
+{
+  size = n+1;
+}
+
+/* Allocate a new set */
+char *SetNew(){
+  char *s;
+  s = (char*)calloc( size, 1);
+  if( s==0 ){
+    extern void memory_error();
+    memory_error();
+  }
+  return s;
+}
+
+/* Deallocate a set */
+void SetFree(char *s)
+{
+  free(s);
+}
+
+/* Add a new element to the set.  Return TRUE if the element was added
+** and FALSE if it was already there. */
+int SetAdd(char *s, int e)
+{
+  int rv;
+  assert( e>=0 && e<size );
+  rv = s[e];
+  s[e] = 1;
+  return !rv;
+}
+
+/* Add every element of s2 to s1.  Return TRUE if s1 changes. */
+int SetUnion(char *s1, char *s2)
+{
+  int i, progress;
+  progress = 0;
+  for(i=0; i<size; i++){
+    if( s2[i]==0 ) continue;
+    if( s1[i]==0 ){
+      progress = 1;
+      s1[i] = 1;
+    }
+  }
+  return progress;
+}
+/********************** From the file "table.c" ****************************/
+/*
+** All code in this file has been automatically generated
+** from a specification in the file
+**              "table.q"
+** by the associative array code building program "aagen".
+** Do not edit this file!  Instead, edit the specification
+** file, then rerun aagen.
+*/
+/*
+** Code for processing tables in the LEMON parser generator.
+*/
+
+PRIVATE unsigned strhash(const char *x)
+{
+  unsigned h = 0;
+  while( *x ) h = h*13 + *(x++);
+  return h;
+}
+
+/* Works like strdup, sort of.  Save a string in malloced memory, but
+** keep strings in a table so that the same string is not in more
+** than one place.
+*/
+const char *Strsafe(const char *y)
+{
+  const char *z;
+  char *cpy;
+
+  if( y==0 ) return 0;
+  z = Strsafe_find(y);
+  if( z==0 && (cpy=(char *)malloc( lemonStrlen(y)+1 ))!=0 ){
+    lemon_strcpy(cpy,y);
+    z = cpy;
+    Strsafe_insert(z);
+  }
+  MemoryCheck(z);
+  return z;
+}
+
+/* There is one instance of the following structure for each
+** associative array of type "x1".
+*/
+struct s_x1 {
+  int size;               /* The number of available slots. */
+                          /*   Must be a power of 2 greater than or */
+                          /*   equal to 1 */
+  int count;              /* Number of currently slots filled */
+  struct s_x1node *tbl;  /* The data stored here */
+  struct s_x1node **ht;  /* Hash table for lookups */
+};
+
+/* There is one instance of this structure for every data element
+** in an associative array of type "x1".
+*/
+typedef struct s_x1node {
+  const char *data;        /* The data */
+  struct s_x1node *next;   /* Next entry with the same hash */
+  struct s_x1node **from;  /* Previous link */
+} x1node;
+
+/* There is only one instance of the array, which is the following */
+static struct s_x1 *x1a;
+
+/* Allocate a new associative array */
+void Strsafe_init(){
+  if( x1a ) return;
+  x1a = (struct s_x1*)malloc( sizeof(struct s_x1) );
+  if( x1a ){
+    x1a->size = 1024;
+    x1a->count = 0;
+    x1a->tbl = (x1node*)calloc(1024, sizeof(x1node) + sizeof(x1node*));
+    if( x1a->tbl==0 ){
+      free(x1a);
+      x1a = 0;
+    }else{
+      int i;
+      x1a->ht = (x1node**)&(x1a->tbl[1024]);
+      for(i=0; i<1024; i++) x1a->ht[i] = 0;
+    }
+  }
+}
+/* Insert a new record into the array.  Return TRUE if successful.
+** Prior data with the same key is NOT overwritten */
+int Strsafe_insert(const char *data)
+{
+  x1node *np;
+  unsigned h;
+  unsigned ph;
+
+  if( x1a==0 ) return 0;
+  ph = strhash(data);
+  h = ph & (x1a->size-1);
+  np = x1a->ht[h];
+  while( np ){
+    if( strcmp(np->data,data)==0 ){
+      /* An existing entry with the same key is found. */
+      /* Fail because overwrite is not allows. */
+      return 0;
+    }
+    np = np->next;
+  }
+  if( x1a->count>=x1a->size ){
+    /* Need to make the hash table bigger */
+    int i,arrSize;
+    struct s_x1 array;
+    array.size = arrSize = x1a->size*2;
+    array.count = x1a->count;
+    array.tbl = (x1node*)calloc(arrSize, sizeof(x1node) + sizeof(x1node*));
+    if( array.tbl==0 ) return 0;  /* Fail due to malloc failure */
+    array.ht = (x1node**)&(array.tbl[arrSize]);
+    for(i=0; i<arrSize; i++) array.ht[i] = 0;
+    for(i=0; i<x1a->count; i++){
+      x1node *oldnp, *newnp;
+      oldnp = &(x1a->tbl[i]);
+      h = strhash(oldnp->data) & (arrSize-1);
+      newnp = &(array.tbl[i]);
+      if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
+      newnp->next = array.ht[h];
+      newnp->data = oldnp->data;
+      newnp->from = &(array.ht[h]);
+      array.ht[h] = newnp;
+    }
+    free(x1a->tbl);
+    *x1a = array;
+  }
+  /* Insert the new data */
+  h = ph & (x1a->size-1);
+  np = &(x1a->tbl[x1a->count++]);
+  np->data = data;
+  if( x1a->ht[h] ) x1a->ht[h]->from = &(np->next);
+  np->next = x1a->ht[h];
+  x1a->ht[h] = np;
+  np->from = &(x1a->ht[h]);
+  return 1;
+}
+
+/* Return a pointer to data assigned to the given key.  Return NULL
+** if no such key. */
+const char *Strsafe_find(const char *key)
+{
+  unsigned h;
+  x1node *np;
+
+  if( x1a==0 ) return 0;
+  h = strhash(key) & (x1a->size-1);
+  np = x1a->ht[h];
+  while( np ){
+    if( strcmp(np->data,key)==0 ) break;
+    np = np->next;
+  }
+  return np ? np->data : 0;
+}
+
+/* Return a pointer to the (terminal or nonterminal) symbol "x".
+** Create a new symbol if this is the first time "x" has been seen.
+*/
+struct symbol *Symbol_new(const char *x)
+{
+  struct symbol *sp;
+
+  sp = Symbol_find(x);
+  if( sp==0 ){
+    sp = (struct symbol *)calloc(1, sizeof(struct symbol) );
+    MemoryCheck(sp);
+    sp->name = Strsafe(x);
+    sp->type = ISUPPER(*x) ? TERMINAL : NONTERMINAL;
+    sp->rule = 0;
+    sp->fallback = 0;
+    sp->prec = -1;
+    sp->assoc = UNK;
+    sp->firstset = 0;
+    sp->lambda = LEMON_FALSE;
+    sp->destructor = 0;
+    sp->destLineno = 0;
+    sp->datatype = 0;
+    sp->useCnt = 0;
+    Symbol_insert(sp,sp->name);
+  }
+  sp->useCnt++;
+  return sp;
+}
+
+/* Compare two symbols for sorting purposes.  Return negative,
+** zero, or positive if a is less then, equal to, or greater
+** than b.
+**
+** Symbols that begin with upper case letters (terminals or tokens)
+** must sort before symbols that begin with lower case letters
+** (non-terminals).  And MULTITERMINAL symbols (created using the
+** %token_class directive) must sort at the very end. Other than
+** that, the order does not matter.
+**
+** We find experimentally that leaving the symbols in their original
+** order (the order they appeared in the grammar file) gives the
+** smallest parser tables in SQLite.
+*/
+int Symbolcmpp(const void *_a, const void *_b)
+{
+  const struct symbol *a = *(const struct symbol **) _a;
+  const struct symbol *b = *(const struct symbol **) _b;
+  int i1 = a->type==MULTITERMINAL ? 3 : a->name[0]>'Z' ? 2 : 1;
+  int i2 = b->type==MULTITERMINAL ? 3 : b->name[0]>'Z' ? 2 : 1;
+  return i1==i2 ? a->index - b->index : i1 - i2;
+}
+
+/* There is one instance of the following structure for each
+** associative array of type "x2".
+*/
+struct s_x2 {
+  int size;               /* The number of available slots. */
+                          /*   Must be a power of 2 greater than or */
+                          /*   equal to 1 */
+  int count;              /* Number of currently slots filled */
+  struct s_x2node *tbl;  /* The data stored here */
+  struct s_x2node **ht;  /* Hash table for lookups */
+};
+
+/* There is one instance of this structure for every data element
+** in an associative array of type "x2".
+*/
+typedef struct s_x2node {
+  struct symbol *data;     /* The data */
+  const char *key;         /* The key */
+  struct s_x2node *next;   /* Next entry with the same hash */
+  struct s_x2node **from;  /* Previous link */
+} x2node;
+
+/* There is only one instance of the array, which is the following */
+static struct s_x2 *x2a;
+
+/* Allocate a new associative array */
+void Symbol_init(){
+  if( x2a ) return;
+  x2a = (struct s_x2*)malloc( sizeof(struct s_x2) );
+  if( x2a ){
+    x2a->size = 128;
+    x2a->count = 0;
+    x2a->tbl = (x2node*)calloc(128, sizeof(x2node) + sizeof(x2node*));
+    if( x2a->tbl==0 ){
+      free(x2a);
+      x2a = 0;
+    }else{
+      int i;
+      x2a->ht = (x2node**)&(x2a->tbl[128]);
+      for(i=0; i<128; i++) x2a->ht[i] = 0;
+    }
+  }
+}
+/* Insert a new record into the array.  Return TRUE if successful.
+** Prior data with the same key is NOT overwritten */
+int Symbol_insert(struct symbol *data, const char *key)
+{
+  x2node *np;
+  unsigned h;
+  unsigned ph;
+
+  if( x2a==0 ) return 0;
+  ph = strhash(key);
+  h = ph & (x2a->size-1);
+  np = x2a->ht[h];
+  while( np ){
+    if( strcmp(np->key,key)==0 ){
+      /* An existing entry with the same key is found. */
+      /* Fail because overwrite is not allows. */
+      return 0;
+    }
+    np = np->next;
+  }
+  if( x2a->count>=x2a->size ){
+    /* Need to make the hash table bigger */
+    int i,arrSize;
+    struct s_x2 array;
+    array.size = arrSize = x2a->size*2;
+    array.count = x2a->count;
+    array.tbl = (x2node*)calloc(arrSize, sizeof(x2node) + sizeof(x2node*));
+    if( array.tbl==0 ) return 0;  /* Fail due to malloc failure */
+    array.ht = (x2node**)&(array.tbl[arrSize]);
+    for(i=0; i<arrSize; i++) array.ht[i] = 0;
+    for(i=0; i<x2a->count; i++){
+      x2node *oldnp, *newnp;
+      oldnp = &(x2a->tbl[i]);
+      h = strhash(oldnp->key) & (arrSize-1);
+      newnp = &(array.tbl[i]);
+      if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
+      newnp->next = array.ht[h];
+      newnp->key = oldnp->key;
+      newnp->data = oldnp->data;
+      newnp->from = &(array.ht[h]);
+      array.ht[h] = newnp;
+    }
+    free(x2a->tbl);
+    *x2a = array;
+  }
+  /* Insert the new data */
+  h = ph & (x2a->size-1);
+  np = &(x2a->tbl[x2a->count++]);
+  np->key = key;
+  np->data = data;
+  if( x2a->ht[h] ) x2a->ht[h]->from = &(np->next);
+  np->next = x2a->ht[h];
+  x2a->ht[h] = np;
+  np->from = &(x2a->ht[h]);
+  return 1;
+}
+
+/* Return a pointer to data assigned to the given key.  Return NULL
+** if no such key. */
+struct symbol *Symbol_find(const char *key)
+{
+  unsigned h;
+  x2node *np;
+
+  if( x2a==0 ) return 0;
+  h = strhash(key) & (x2a->size-1);
+  np = x2a->ht[h];
+  while( np ){
+    if( strcmp(np->key,key)==0 ) break;
+    np = np->next;
+  }
+  return np ? np->data : 0;
+}
+
+/* Return the n-th data.  Return NULL if n is out of range. */
+struct symbol *Symbol_Nth(int n)
+{
+  struct symbol *data;
+  if( x2a && n>0 && n<=x2a->count ){
+    data = x2a->tbl[n-1].data;
+  }else{
+    data = 0;
+  }
+  return data;
+}
+
+/* Return the size of the array */
+int Symbol_count()
+{
+  return x2a ? x2a->count : 0;
+}
+
+/* Return an array of pointers to all data in the table.
+** The array is obtained from malloc.  Return NULL if memory allocation
+** problems, or if the array is empty. */
+struct symbol **Symbol_arrayof()
+{
+  struct symbol **array;
+  int i,arrSize;
+  if( x2a==0 ) return 0;
+  arrSize = x2a->count;
+  array = (struct symbol **)calloc(arrSize, sizeof(struct symbol *));
+  if( array ){
+    for(i=0; i<arrSize; i++) array[i] = x2a->tbl[i].data;
+  }
+  return array;
+}
+
+/* Compare two configurations */
+int Configcmp(const char *_a,const char *_b)
+{
+  const struct config *a = (struct config *) _a;
+  const struct config *b = (struct config *) _b;
+  int x;
+  x = a->rp->index - b->rp->index;
+  if( x==0 ) x = a->dot - b->dot;
+  return x;
+}
+
+/* Compare two states */
+PRIVATE int statecmp(struct config *a, struct config *b)
+{
+  int rc;
+  for(rc=0; rc==0 && a && b;  a=a->bp, b=b->bp){
+    rc = a->rp->index - b->rp->index;
+    if( rc==0 ) rc = a->dot - b->dot;
+  }
+  if( rc==0 ){
+    if( a ) rc = 1;
+    if( b ) rc = -1;
+  }
+  return rc;
+}
+
+/* Hash a state */
+PRIVATE unsigned statehash(struct config *a)
+{
+  unsigned h=0;
+  while( a ){
+    h = h*571 + a->rp->index*37 + a->dot;
+    a = a->bp;
+  }
+  return h;
+}
+
+/* Allocate a new state structure */
+struct state *State_new()
+{
+  struct state *newstate;
+  newstate = (struct state *)calloc(1, sizeof(struct state) );
+  MemoryCheck(newstate);
+  return newstate;
+}
+
+/* There is one instance of the following structure for each
+** associative array of type "x3".
+*/
+struct s_x3 {
+  int size;               /* The number of available slots. */
+                          /*   Must be a power of 2 greater than or */
+                          /*   equal to 1 */
+  int count;              /* Number of currently slots filled */
+  struct s_x3node *tbl;  /* The data stored here */
+  struct s_x3node **ht;  /* Hash table for lookups */
+};
+
+/* There is one instance of this structure for every data element
+** in an associative array of type "x3".
+*/
+typedef struct s_x3node {
+  struct state *data;                  /* The data */
+  struct config *key;                   /* The key */
+  struct s_x3node *next;   /* Next entry with the same hash */
+  struct s_x3node **from;  /* Previous link */
+} x3node;
+
+/* There is only one instance of the array, which is the following */
+static struct s_x3 *x3a;
+
+/* Allocate a new associative array */
+void State_init(){
+  if( x3a ) return;
+  x3a = (struct s_x3*)malloc( sizeof(struct s_x3) );
+  if( x3a ){
+    x3a->size = 128;
+    x3a->count = 0;
+    x3a->tbl = (x3node*)calloc(128, sizeof(x3node) + sizeof(x3node*));
+    if( x3a->tbl==0 ){
+      free(x3a);
+      x3a = 0;
+    }else{
+      int i;
+      x3a->ht = (x3node**)&(x3a->tbl[128]);
+      for(i=0; i<128; i++) x3a->ht[i] = 0;
+    }
+  }
+}
+/* Insert a new record into the array.  Return TRUE if successful.
+** Prior data with the same key is NOT overwritten */
+int State_insert(struct state *data, struct config *key)
+{
+  x3node *np;
+  unsigned h;
+  unsigned ph;
+
+  if( x3a==0 ) return 0;
+  ph = statehash(key);
+  h = ph & (x3a->size-1);
+  np = x3a->ht[h];
+  while( np ){
+    if( statecmp(np->key,key)==0 ){
+      /* An existing entry with the same key is found. */
+      /* Fail because overwrite is not allows. */
+      return 0;
+    }
+    np = np->next;
+  }
+  if( x3a->count>=x3a->size ){
+    /* Need to make the hash table bigger */
+    int i,arrSize;
+    struct s_x3 array;
+    array.size = arrSize = x3a->size*2;
+    array.count = x3a->count;
+    array.tbl = (x3node*)calloc(arrSize, sizeof(x3node) + sizeof(x3node*));
+    if( array.tbl==0 ) return 0;  /* Fail due to malloc failure */
+    array.ht = (x3node**)&(array.tbl[arrSize]);
+    for(i=0; i<arrSize; i++) array.ht[i] = 0;
+    for(i=0; i<x3a->count; i++){
+      x3node *oldnp, *newnp;
+      oldnp = &(x3a->tbl[i]);
+      h = statehash(oldnp->key) & (arrSize-1);
+      newnp = &(array.tbl[i]);
+      if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
+      newnp->next = array.ht[h];
+      newnp->key = oldnp->key;
+      newnp->data = oldnp->data;
+      newnp->from = &(array.ht[h]);
+      array.ht[h] = newnp;
+    }
+    free(x3a->tbl);
+    *x3a = array;
+  }
+  /* Insert the new data */
+  h = ph & (x3a->size-1);
+  np = &(x3a->tbl[x3a->count++]);
+  np->key = key;
+  np->data = data;
+  if( x3a->ht[h] ) x3a->ht[h]->from = &(np->next);
+  np->next = x3a->ht[h];
+  x3a->ht[h] = np;
+  np->from = &(x3a->ht[h]);
+  return 1;
+}
+
+/* Return a pointer to data assigned to the given key.  Return NULL
+** if no such key. */
+struct state *State_find(struct config *key)
+{
+  unsigned h;
+  x3node *np;
+
+  if( x3a==0 ) return 0;
+  h = statehash(key) & (x3a->size-1);
+  np = x3a->ht[h];
+  while( np ){
+    if( statecmp(np->key,key)==0 ) break;
+    np = np->next;
+  }
+  return np ? np->data : 0;
+}
+
+/* Return an array of pointers to all data in the table.
+** The array is obtained from malloc.  Return NULL if memory allocation
+** problems, or if the array is empty. */
+struct state **State_arrayof()
+{
+  struct state **array;
+  int i,arrSize;
+  if( x3a==0 ) return 0;
+  arrSize = x3a->count;
+  array = (struct state **)calloc(arrSize, sizeof(struct state *));
+  if( array ){
+    for(i=0; i<arrSize; i++) array[i] = x3a->tbl[i].data;
+  }
+  return array;
+}
+
+/* Hash a configuration */
+PRIVATE unsigned confighash(struct config *a)
+{
+  unsigned h=0;
+  h = h*571 + a->rp->index*37 + a->dot;
+  return h;
+}
+
+/* There is one instance of the following structure for each
+** associative array of type "x4".
+*/
+struct s_x4 {
+  int size;               /* The number of available slots. */
+                          /*   Must be a power of 2 greater than or */
+                          /*   equal to 1 */
+  int count;              /* Number of currently slots filled */
+  struct s_x4node *tbl;  /* The data stored here */
+  struct s_x4node **ht;  /* Hash table for lookups */
+};
+
+/* There is one instance of this structure for every data element
+** in an associative array of type "x4".
+*/
+typedef struct s_x4node {
+  struct config *data;                  /* The data */
+  struct s_x4node *next;   /* Next entry with the same hash */
+  struct s_x4node **from;  /* Previous link */
+} x4node;
+
+/* There is only one instance of the array, which is the following */
+static struct s_x4 *x4a;
+
+/* Allocate a new associative array */
+void Configtable_init(){
+  if( x4a ) return;
+  x4a = (struct s_x4*)malloc( sizeof(struct s_x4) );
+  if( x4a ){
+    x4a->size = 64;
+    x4a->count = 0;
+    x4a->tbl = (x4node*)calloc(64, sizeof(x4node) + sizeof(x4node*));
+    if( x4a->tbl==0 ){
+      free(x4a);
+      x4a = 0;
+    }else{
+      int i;
+      x4a->ht = (x4node**)&(x4a->tbl[64]);
+      for(i=0; i<64; i++) x4a->ht[i] = 0;
+    }
+  }
+}
+/* Insert a new record into the array.  Return TRUE if successful.
+** Prior data with the same key is NOT overwritten */
+int Configtable_insert(struct config *data)
+{
+  x4node *np;
+  unsigned h;
+  unsigned ph;
+
+  if( x4a==0 ) return 0;
+  ph = confighash(data);
+  h = ph & (x4a->size-1);
+  np = x4a->ht[h];
+  while( np ){
+    if( Configcmp((const char *) np->data,(const char *) data)==0 ){
+      /* An existing entry with the same key is found. */
+      /* Fail because overwrite is not allows. */
+      return 0;
+    }
+    np = np->next;
+  }
+  if( x4a->count>=x4a->size ){
+    /* Need to make the hash table bigger */
+    int i,arrSize;
+    struct s_x4 array;
+    array.size = arrSize = x4a->size*2;
+    array.count = x4a->count;
+    array.tbl = (x4node*)calloc(arrSize, sizeof(x4node) + sizeof(x4node*));
+    if( array.tbl==0 ) return 0;  /* Fail due to malloc failure */
+    array.ht = (x4node**)&(array.tbl[arrSize]);
+    for(i=0; i<arrSize; i++) array.ht[i] = 0;
+    for(i=0; i<x4a->count; i++){
+      x4node *oldnp, *newnp;
+      oldnp = &(x4a->tbl[i]);
+      h = confighash(oldnp->data) & (arrSize-1);
+      newnp = &(array.tbl[i]);
+      if( array.ht[h] ) array.ht[h]->from = &(newnp->next);
+      newnp->next = array.ht[h];
+      newnp->data = oldnp->data;
+      newnp->from = &(array.ht[h]);
+      array.ht[h] = newnp;
+    }
+    free(x4a->tbl);
+    *x4a = array;
+  }
+  /* Insert the new data */
+  h = ph & (x4a->size-1);
+  np = &(x4a->tbl[x4a->count++]);
+  np->data = data;
+  if( x4a->ht[h] ) x4a->ht[h]->from = &(np->next);
+  np->next = x4a->ht[h];
+  x4a->ht[h] = np;
+  np->from = &(x4a->ht[h]);
+  return 1;
+}
+
+/* Return a pointer to data assigned to the given key.  Return NULL
+** if no such key. */
+struct config *Configtable_find(struct config *key)
+{
+  int h;
+  x4node *np;
+
+  if( x4a==0 ) return 0;
+  h = confighash(key) & (x4a->size-1);
+  np = x4a->ht[h];
+  while( np ){
+    if( Configcmp((const char *) np->data,(const char *) key)==0 ) break;
+    np = np->next;
+  }
+  return np ? np->data : 0;
+}
+
+/* Remove all data from the table.  Pass each data to the function "f"
+** as it is removed.  ("f" may be null to avoid this step.) */
+void Configtable_clear(int(*f)(struct config *))
+{
+  int i;
+  if( x4a==0 || x4a->count==0 ) return;
+  if( f ) for(i=0; i<x4a->count; i++) (*f)(x4a->tbl[i].data);
+  for(i=0; i<x4a->size; i++) x4a->ht[i] = 0;
+  x4a->count = 0;
+  return;
+}
diff --git a/lemon-src/lempar.js b/lemon-src/lempar.js
new file mode 100644
index 0000000..e86d627
--- /dev/null
+++ b/lemon-src/lempar.js
@@ -0,0 +1,775 @@
+/*
+** 2000-05-29
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+** Based on SQLite distribution v3.17.0
+** Adopted for JavaScript by Artem Butusov <art.sormy@gmail.com>
+**
+*************************************************************************
+** Driver template for the LEMON parser generator.
+**
+** The "lemon" program processes an LALR(1) input grammar file, then uses
+** this template to construct a parser.  The "lemon" program inserts text
+** at each "%%" line.  Also, any "P-a-r-s-e" identifer prefix (without the
+** interstitial "-" characters) contained in this template is changed into
+** the value of the %name directive from the grammar.  Otherwise, the content
+** of this template is copied straight through into the generate parser
+** source file.
+**
+** The following is the concatenation of all %include directives from the
+** input grammar file:
+*/
+/************ Begin %include sections from the grammar ************************/
+%%
+/**************** End of %include directives **********************************/
+function Parse() {
+/* These constants specify the various numeric values for terminal symbols
+** in a format understandable to "makeheaders".
+***************** Begin makeheaders token definitions *************************/
+%%
+/**************** End makeheaders token definitions ***************************/
+
+/* The next sections is a series of control #defines.
+** various aspects of the generated parser.
+**    YYNOCODE           is a number of type YYCODETYPE that is not used for
+**                       any terminal or nonterminal symbol.
+**    YYFALLBACK         If defined, this indicates that one or more tokens
+**                       (also known as: "terminal symbols") have fall-back
+**                       values which should be used if the original symbol
+**                       would not parse.  This permits keywords to sometimes
+**                       be used as identifiers, for example.
+**    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
+**                       zero the stack is dynamically sized using realloc()
+**    YYERRORSYMBOL      is the code number of the error symbol.  If not
+**                       defined, then do no error processing.
+**    YYNSTATE           the combined number of states.
+**    YYNRULE            the number of rules in the grammar
+**    YY_MAX_SHIFT       Maximum value for shift actions
+**    YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
+**    YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
+**    YY_MIN_REDUCE      Maximum value for reduce actions
+**    YY_ERROR_ACTION    The yy_action[] code for syntax error
+**    YY_ACCEPT_ACTION   The yy_action[] code for accept
+**    YY_NO_ACTION       The yy_action[] code for no-op
+*/
+/************* Begin control #defines *****************************************/
+%%
+/************* End control #defines *******************************************/
+
+/* Define the yytestcase() macro to be a no-op if is not already defined
+** otherwise.
+**
+** Applications can choose to define yytestcase() in the %include section
+** to a macro that can assist in verifying code coverage.  For production
+** code the yytestcase() macro should be turned off.  But it is useful
+** for testing.
+*/
+if (!this.yytestcase) {
+  this.yytestcase = function () {};
+}
+
+
+/* Next are the tables used to determine what action to take based on the
+** current state and lookahead token.  These tables are used to implement
+** functions that take a state number and lookahead value and return an
+** action integer.
+**
+** Suppose the action integer is N.  Then the action is determined as
+** follows
+**
+**   0 <= N <= YY_MAX_SHIFT             Shift N.  That is, push the lookahead
+**                                      token onto the stack and goto state N.
+**
+**   N between YY_MIN_SHIFTREDUCE       Shift to an arbitrary state then
+**     and YY_MAX_SHIFTREDUCE           reduce by rule N-YY_MIN_SHIFTREDUCE.
+**
+**   N between YY_MIN_REDUCE            Reduce by rule N-YY_MIN_REDUCE
+**     and YY_MAX_REDUCE
+**
+**   N == YY_ERROR_ACTION               A syntax error has occurred.
+**
+**   N == YY_ACCEPT_ACTION              The parser accepts its input.
+**
+**   N == YY_NO_ACTION                  No such action.  Denotes unused
+**                                      slots in the yy_action[] table.
+**
+** The action table is constructed as a single large table named yy_action[].
+** Given state S and lookahead X, the action is computed as either:
+**
+**    (A)   N = yy_action[ yy_shift_ofst[S] + X ]
+**    (B)   N = yy_default[S]
+**
+** The (A) formula is preferred.  The B formula is used instead if:
+**    (1)  The yy_shift_ofst[S]+X value is out of range, or
+**    (2)  yy_lookahead[yy_shift_ofst[S]+X] is not equal to X, or
+**    (3)  yy_shift_ofst[S] equal YY_SHIFT_USE_DFLT.
+** (Implementation note: YY_SHIFT_USE_DFLT is chosen so that
+** YY_SHIFT_USE_DFLT+X will be out of range for all possible lookaheads X.
+** Hence only tests (1) and (2) need to be evaluated.)
+**
+** The formulas above are for computing the action when the lookahead is
+** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
+** a reduce action) then the yy_reduce_ofst[] array is used in place of
+** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
+** YY_SHIFT_USE_DFLT.
+**
+** The following are the tables generated in this section:
+**
+**  yy_action[]        A single table containing all actions.
+**  yy_lookahead[]     A table containing the lookahead for each entry in
+**                     yy_action.  Used to detect hash collisions.
+**  yy_shift_ofst[]    For each state, the offset into yy_action for
+**                     shifting terminals.
+**  yy_reduce_ofst[]   For each state, the offset into yy_action for
+**                     shifting non-terminals after a reduce.
+**  yy_default[]       Default action for each state.
+**
+*********** Begin parsing tables **********************************************/
+%%
+/********** End of lemon-generated parsing tables *****************************/
+
+/* The next table maps tokens (terminal symbols) into fallback tokens.
+** If a construct like the following:
+**
+**      %fallback ID X Y Z.
+**
+** appears in the grammar, then ID becomes a fallback token for X, Y,
+** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
+** but it does not parse, the type of the token is changed to ID and
+** the parse is retried before an error is thrown.
+**
+** This feature can be used, for example, to cause some keywords in a language
+** to revert to identifiers if they keyword does not apply in the context where
+** it appears.
+*/
+this.yyFallback = [
+%%
+];
+
+/* The following structure represents a single element of the
+** parser's stack.  Information stored includes:
+**
+**   +  The state number for the parser at this level of the stack.
+**
+**   +  The value of the token stored at this level of the stack.
+**      (In other words, the "major" token.)
+**
+**   +  The semantic value stored at this level of the stack.  This is
+**      the information used by the action routines in the grammar.
+**      It is sometimes called the "minor" token.
+**
+** After the "shift" half of a SHIFTREDUCE action, the stateno field
+** actually contains the reduce action for the second half of the
+** SHIFTREDUCE.
+*/
+//{
+//  stateno,  /* The state-number, or reduce action in SHIFTREDUCE */
+//  major,    /* The major token value.  This is the code
+//            ** number for the token at this stack level */
+//  minor,    /* The user-supplied minor token value.  This
+//            ** is the value of the token  */
+//}
+
+/* The state of the parser is completely contained in an instance of
+** the following structure */
+this.yyhwm = 0;               /* High-water mark of the stack */
+this.yyerrcnt = -1;           /* Shifts left before out of the error */
+this.yystack = null;          /* The parser's stack */
+this.yyidx = -1;              /* Stack index of current element in the stack */
+
+this.yyTraceCallback = null;
+this.yyTracePrompt = "";
+
+/*
+** Turn parser tracing on by giving a stream to which to write the trace
+** and a prompt to preface each trace message.  Tracing is turned off
+** by making either argument NULL
+**
+** Inputs:
+** <ul>
+** <li> A callback to which trace output should be written.
+**      If NULL, then tracing is turned off.
+** <li> A prefix string written at the beginning of every
+**      line of trace output. Default is "".
+** </ul>
+**
+** Outputs:
+** None.
+*/
+this.setTraceCallback = function (callback, prompt) {
+  this.yyTraceCallback = callback;
+  this.yyTracePrompt = prompt || "";
+}
+
+this.trace = function (message) {
+  this.yyTraceCallback(this.yyTracePrompt + message + "\n");
+}
+
+/* For tracing shifts, the names of all terminals and nonterminals
+** are required.  The following table supplies these names */
+this.yyTokenName = [
+%%
+];
+
+/* For tracing reduce actions, the names of all rules are required.
+*/
+this.yyRuleName = [
+%%
+];
+/*
+** Try to increase the size of the parser stack.  Return the number
+** of errors.  Return 0 on success.
+*/
+this.yyGrowStack = function () {
+  // fix me: yystksz*2 + 100
+  this.yystack.push({
+    stateno: undefined,
+    major: undefined,
+    minor: undefined
+  });
+}
+
+/* Initialize a new parser that has already been allocated.
+*/
+this.init = function () {
+  this.yyhwm = 0;
+  this.yyerrcnt = -1;
+  this.yyidx = 0;
+  if (this.YYSTACKDEPTH <= 0) {
+    this.yystack = [];
+    this.yyGrowStack();
+  } else {
+    this.yystack = new Array(this.YYSTACKDEPTH);
+    for (var i = 0; i < this.YYSTACKDEPTH; i++) {
+      this.yystack[i] = {
+        stateno: undefined,
+        major: undefined,
+        minor: undefined
+      };
+    }
+  }
+  var yytos = this.yystack[0];
+  yytos.stateno = 0;
+  yytos.major = 0;
+}
+
+/* The following function deletes the "minor type" or semantic value
+** associated with a symbol.  The symbol can be either a terminal
+** or nonterminal. "yymajor" is the symbol code, and "yypminor" is
+** a pointer to the value to be deleted.  The code used to do the
+** deletions is derived from the %destructor and/or %token_destructor
+** directives of the input grammar.
+*/
+this.yy_destructor = function (
+  yymajor,  /* Type code for object to destroy */
+  yyminor   /* The object to be destroyed */
+) {
+  switch (yymajor) {
+    /* Here is inserted the actions which take place when a
+    ** terminal or non-terminal is destroyed.  This can happen
+    ** when the symbol is popped from the stack during a
+    ** reduce or during error processing or when a parser is
+    ** being destroyed before it is finished parsing.
+    **
+    ** Note: during a reduce, the only symbols destroyed are those
+    ** which appear on the RHS of the rule, but which are *not* used
+    ** inside the C code.
+    */
+/********* Begin destructor definitions ***************************************/
+%%
+/********* End destructor definitions *****************************************/
+    default:  break;   /* If no destructor action specified: do nothing */
+  }
+}
+
+/*
+** Pop the parser's stack once.
+**
+** If there is a destructor routine associated with the token which
+** is popped from the stack, then call it.
+*/
+this.yy_pop_parser_stack = function () {
+  // assert( pParser->yytos!=0 );
+  // assert( pParser->yytos > pParser->yystack );
+  var yytos = this.yystack[this.yyidx];
+
+  if (this.yyTraceCallback) {
+    this.trace("Popping " + this.yyTokenName[yytos.major]);
+  }
+  this.yy_destructor(yytos.major, yytos.minor);
+
+  this.yyidx--;
+}
+
+/*
+** Clear all secondary memory allocations from the parser
+*/
+this.finalize = function () {
+  while (this.yyidx > 0) {
+    this.yy_pop_parser_stack();
+  }
+  this.yystack = null;
+}
+
+/*
+** Return the peak depth of the stack for a parser.
+*/
+this.getStackPeak = function () {
+  return this.yyhwm;
+}
+
+/*
+** Find the appropriate action for a parser given the terminal
+** look-ahead token iLookAhead.
+*/
+this.yy_find_shift_action = function (
+  iLookAhead     /* The look-ahead token */
+) {
+  var yytos = this.yystack[this.yyidx];
+  var stateno = yytos.stateno;
+
+  if (stateno >= this.YY_MIN_REDUCE) {
+    return stateno;
+  }
+
+  // assert( stateno <= YY_SHIFT_COUNT );
+
+  do {
+    var i = this.yy_shift_ofst[stateno];
+    // assert( iLookAhead!=YYNOCODE );
+    i += iLookAhead;
+    if (i < 0 || i >= this.yy_action.length || this.yy_lookahead[i] != iLookAhead) {
+      if (this.YYFALLBACK) {
+        var iFallback;  /* Fallback token */
+        if ((iLookAhead < this.yyFallback.length)
+          && (iFallback = this.yyFallback[iLookAhead]) != 0
+        ) {
+          if (this.yyTraceCallback) {
+            this.trace("FALLBACK " + this.yyTokenName[iLookAhead] + " => " + this.yyTokenName[iFallback]);
+          }
+        }
+        // assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
+        iLookAhead = iFallback;
+        continue;
+      }
+
+      if (this.YYWILDCARD) {
+        var j = i - iLookAhead + this.YYWILDCARD;
+        var cond1 = (this.YY_SHIFT_MIN + this.YYWILDCARD) < 0 ? j >= 0 : true;
+        var cond2 = (this.YY_SHIFT_MAX + this.YYWILDCARD) >= this.yy_action.length ? j < this.yy_action.length : true;
+        if (cond1 && cond2 && this.yy_lookahead[j] == this.YYWILDCARD && iLookAhead > 0) {
+          if (this.yyTraceCallback) {
+            this.trace("WILDCARD " + this.yyTokenName[iLookAhead] + " => " + this.yyTokenName[this.YYWILDCARD]);
+          }
+          return this.yy_action[j];
+        }
+      }
+
+      return this.yy_default[stateno];
+    } else {
+      return this.yy_action[i];
+    }
+  } while (true);
+}
+
+/*
+** Find the appropriate action for a parser given the non-terminal
+** look-ahead token iLookAhead.
+*/
+this.yy_find_reduce_action = function (
+  stateno,       /* Current state number */
+  iLookAhead     /* The look-ahead token */
+) {
+  if (this.YYERRORSYMBOL) {
+    if (stateno > this.YY_REDUCE_COUNT) {
+      return this.yy_default[stateno];
+    }
+  } else {
+    // assert( stateno<=YY_REDUCE_COUNT );
+  }
+
+  var i = this.yy_reduce_ofst[stateno];
+  // assert( i!=YY_REDUCE_USE_DFLT );
+  // assert( iLookAhead!=YYNOCODE );
+  i += iLookAhead;
+
+  if (this.YYERRORSYMBOL) {
+    if (i < 0 || i >= this.yy_action.length || this.yy_lookahead[i] != iLookAhead) {
+      return this.yy_default[stateno];
+    }
+  } else {
+    // assert( i>=0 && i<YY_ACTTAB_COUNT );
+    // assert( yy_lookahead[i]==iLookAhead );
+  }
+
+  return this.yy_action[i];
+}
+
+/*
+** The following routine is called if the stack overflows.
+*/
+this.yyStackOverflow = function () {
+  if (this.yyTraceCallback) {
+    this.trace("Stack Overflow!");
+  }
+
+  while (this.yyidx > 0) {
+    this.yy_pop_parser_stack();
+  }
+  /* Here code is inserted which will execute if the parser
+  ** stack every overflows */
+/******** Begin %stack_overflow code ******************************************/
+%%
+/******** End %stack_overflow code ********************************************/
+}
+
+/*
+** Print tracing information for a SHIFT action
+*/
+this.yyTraceShift = function (yyNewState) {
+  if (this.yyTraceCallback) {
+    var yytos = this.yystack[this.yyidx];
+    if (yyNewState < this.YYNSTATE) {
+      this.trace("Shift '" + this.yyTokenName[yytos.major] + "', go to state " + yyNewState);
+    } else {
+      this.trace("Shift '" + this.yyTokenName[yytos.major] + "'");
+    }
+  }
+}
+
+/*
+** Perform a shift action.
+*/
+this.yy_shift = function (
+  yyNewState,    /* The new state to shift in */
+  yyMajor,       /* The major token to shift in */
+  yyMinor        /* The minor token to shift in */
+) {
+  this.yyidx++;
+
+  if (this.yyidx > this.yyhwm) {
+    this.yyhwm++;
+    // assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
+  }
+
+  if (this.YYSTACKDEPTH > 0) {
+    if (this.yyidx >= this.YYSTACKDEPTH) {
+      this.yyidx--;
+      this.yyStackOverflow();
+      return;
+    }
+  } else {
+    if (this.yyidx >= this.yystack.length) {
+      this.yyGrowStack();
+    }
+  }
+
+  if (yyNewState > this.YY_MAX_SHIFT) {
+    yyNewState += this.YY_MIN_REDUCE - this.YY_MIN_SHIFTREDUCE;
+  }
+
+  var yytos = this.yystack[this.yyidx];
+  yytos.stateno = yyNewState;
+  yytos.major = yyMajor;
+  yytos.minor = yyMinor;
+
+  this.yyTraceShift(yyNewState);
+}
+
+/* The following table contains information about every rule that
+** is used during the reduce.
+*/
+//{
+//  lhs,      /* Symbol on the left-hand side of the rule */
+//  nrhs,     /* Number of right-hand side symbols in the rule */
+//}
+this.yyRuleInfo = [
+%%
+];
+
+/*
+** Perform a reduce action and the shift that must immediately
+** follow the reduce.
+*/
+this.yy_reduce = function (
+  yyruleno        /* Number of the rule by which to reduce */
+){
+  var yymsp = this.yystack[this.yyidx]; /* The top of the parser's stack */
+
+  if (yyruleno < this.yyRuleName.length) {
+    var yysize = this.yyRuleInfo[yyruleno].nrhs;
+    var ruleName = this.yyRuleName[yyruleno];
+    var newStateNo = this.yystack[this.yyidx - yysize].stateno;
+    if (this.yyTraceCallback) {
+      this.trace("Reduce [" + ruleName + "], go to state " + newStateNo + ".");
+    }
+  }
+
+  /* Check that the stack is large enough to grow by a single entry
+  ** if the RHS of the rule is empty.  This ensures that there is room
+  ** enough on the stack to push the LHS value */
+  if (this.yyRuleInfo[yyruleno].nrhs == 0) {
+    if (this.yyidx > this.yyhwm) {
+      this.yyhwm++;
+      // assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
+    }
+    if (this.YYSTACKDEPTH > 0) {
+      if (this.yyidx >= this.YYSTACKDEPTH - 1) {
+        this.yyStackOverflow();
+        return;
+      }
+    } else {
+      if (this.yyidx >= this.yystack.length - 1) {
+        this.yyGrowStack();
+        yymsp = this.yystack[this.yyidx];
+      }
+    }
+  }
+
+  var yylhsminor;
+  switch (yyruleno) {
+  /* Beginning here are the reduction cases.  A typical example
+  ** follows:
+  **   case 0:
+  **  #line <lineno> <grammarfile>
+  **     { ... }           // User supplied code
+  **  #line <lineno> <thisfile>
+  **     break;
+  */
+/********** Begin reduce actions **********************************************/
+%%
+/********** End reduce actions ************************************************/
+  };
+  // assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
+
+  var yygoto = this.yyRuleInfo[yyruleno].lhs;    /* The next state */
+  var yysize = this.yyRuleInfo[yyruleno].nrhs;   /* Amount to pop the stack */
+  var yyact = this.yy_find_reduce_action(   /* The next action */
+    this.yystack[this.yyidx - yysize].stateno,
+    yygoto
+  );
+  if (yyact <= this.YY_MAX_SHIFTREDUCE) {
+    if (yyact > this.YY_MAX_SHIFT) {
+      yyact += this.YY_MIN_REDUCE - this.YY_MIN_SHIFTREDUCE;
+    }
+    this.yyidx -= yysize - 1;
+    yymsp = this.yystack[this.yyidx];
+    yymsp.stateno = yyact;
+    yymsp.major = yygoto;
+    this.yyTraceShift(yyact);
+  } else {
+    // assert( yyact == YY_ACCEPT_ACTION );
+    this.yyidx -= yysize;
+    this.yy_accept();
+  }
+}
+
+/*
+** The following code executes when the parse fails
+*/
+this.yy_parse_failed = function () {
+  if (this.yyTraceCallback) {
+    this.trace("Fail!");
+  }
+  while (this.yyidx > 0) {
+    this.yy_pop_parser_stack();
+  }
+  /* Here code is inserted which will be executed whenever the
+  ** parser fails */
+/************ Begin %parse_failure code ***************************************/
+%%
+/************ End %parse_failure code *****************************************/
+}
+
+/*
+** The following code executes when a syntax error first occurs.
+*/
+this.yy_syntax_error = function (
+  yymajor,        /* The major type of the error token */
+  yyminor         /* The minor type of the error token */
+) {
+  var TOKEN = yyminor;
+/************ Begin %syntax_error code ****************************************/
+%%
+/************ End %syntax_error code ******************************************/
+}
+
+/*
+** The following is executed when the parser accepts
+*/
+this.yy_accept = function () {
+  if (this.yyTraceCallback) {
+    this.trace("Accept!");
+  }
+  if (!this.YYNOERRORRECOVERY) {
+    this.yyerrcnt = -1;
+  }
+  // assert( yypParser->yytos==yypParser->yystack );
+  /* Here code is inserted which will be executed whenever the
+  ** parser accepts */
+/*********** Begin %parse_accept code *****************************************/
+%%
+/*********** End %parse_accept code *******************************************/
+}
+
+/* The main parser program.
+** The first argument is a pointer to a structure obtained from
+** "ParseAlloc" which describes the current state of the parser.
+** The second argument is the major token number.  The third is
+** the minor token.  The fourth optional argument is whatever the
+** user wants (and specified in the grammar) and is available for
+** use by the action routines.
+**
+** Inputs:
+** <ul>
+** <li> A pointer to the parser (an opaque structure.)
+** <li> The major token number.
+** <li> The minor token number.
+** <li> An option argument of a grammar-specified type.
+** </ul>
+**
+** Outputs:
+** None.
+*/
+this.parse = function (
+  yymajor,                  /* The major token code number */
+  yyminor                   /* The value for the token */
+) {
+  var yyact;            /* The parser action. */
+  var yyendofinput;     /* True if we are at the end of input */
+  var yyerrorhit = 0;   /* True if yymajor has invoked an error */
+
+  //assert( yypParser->yytos!=0 );
+
+  if (yymajor === undefined || yymajor === null) {
+    yymajor = 0;
+  }
+
+  yyendofinput = yymajor == 0;
+
+  if (this.yyTraceCallback) {
+    this.trace("Input '" + this.yyTokenName[yymajor] + "'");
+  }
+
+  do {
+    yyact = this.yy_find_shift_action(yymajor);
+    if (yyact <= this.YY_MAX_SHIFTREDUCE) { // check me?
+      this.yy_shift(yyact, yymajor, yyminor);
+      if (!this.YYNOERRORRECOVERY) {
+        this.yyerrcnt--;
+      }
+      yymajor = this.YYNOCODE;
+    } else if (yyact <= this.YY_MAX_REDUCE) { // check me?
+      this.yy_reduce(yyact - this.YY_MIN_REDUCE); // check me?
+    } else {
+      // assert( yyact == YY_ERROR_ACTION );
+      if (this.yyTraceCallback) {
+        this.trace("Syntax Error!");
+      }
+      if (this.YYERRORSYMBOL) {
+        /* A syntax error has occurred.
+        ** The response to an error depends upon whether or not the
+        ** grammar defines an error token "ERROR".
+        **
+        ** This is what we do if the grammar does define ERROR:
+        **
+        **  * Call the %syntax_error function.
+        **
+        **  * Begin popping the stack until we enter a state where
+        **    it is legal to shift the error symbol, then shift
+        **    the error symbol.
+        **
+        **  * Set the error count to three.
+        **
+        **  * Begin accepting and shifting new tokens.  No new error
+        **    processing will occur until three tokens have been
+        **    shifted successfully.
+        **
+        */
+        if (this.yyerrcnt < 0) {
+          this.yy_syntax_error(yymajor, yyminor);
+        }
+        var yymx = this.yystack[this.yyidx].major;
+        if (yymx == this.YYERRORSYMBOL || yyerrorhit) {
+          if (this.yyTraceCallback) {
+            this.trace("Discard input token " + this.yyTokenName[yymajor]);
+          }
+          this.yy_destructor(yymajor, yyminor);
+          yymajor = this.YYNOCODE;
+        } else {
+          while (this.yyidx >= 0
+              && yymx != this.YYERRORSYMBOL
+              && (yyact = this.yy_find_reduce_action(
+                          this.yystack[this.yyidx].stateno,
+                          this.YYERRORSYMBOL)) >= this.YY_MIN_REDUCE // check me?
+          ) {
+            this.yy_pop_parser_stack();
+          }
+          if (this.yyidx < 0 || yymajor == 0) {
+            this.yy_destructor(yymajor, yyminor);
+            this.yy_parse_failed();
+            if (!this.YYNOERRORRECOVERY) {
+              this.yyerrcnt = -1;
+            }
+            yymajor = this.YYNOCODE;
+          } else if (yymx != this.YYERRORSYMBOL) {
+            this.yy_shift(yyact, this.YYERRORSYMBOL, yyminor); // check me?
+          }
+        }
+        this.yyerrcnt = 3;
+        yyerrorhit = 1;
+      } else if (this.YYNOERRORRECOVERY) {
+        /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
+        ** do any kind of error recovery.  Instead, simply invoke the syntax
+        ** error routine and continue going as if nothing had happened.
+        **
+        ** Applications can set this macro (for example inside %include) if
+        ** they intend to abandon the parse upon the first syntax error seen.
+        */
+        this.yy_syntax_error(yymajor, yyminor);
+        this.yy_destructor(yymajor, yyminor);
+        yymajor = this.YYNOCODE;
+      } else {  /* YYERRORSYMBOL is not defined */
+        /* This is what we do if the grammar does not define ERROR:
+        **
+        **  * Report an error message, and throw away the input token.
+        **
+        **  * If the input token is $, then fail the parse.
+        **
+        ** As before, subsequent error messages are suppressed until
+        ** three input tokens have been successfully shifted.
+        */
+        if (this.yyerrcnt <= 0) {
+          this.yy_syntax_error(yymajor, yyminor);
+        }
+        this.yyerrcnt = 3;
+        this.yy_destructor(yymajor, yyminor);
+        if (yyendofinput) {
+          this.yy_parse_failed();
+          if (!this.YYNOERRORRECOVERY) {
+            this.yyerrcnt = -1;
+          }
+        }
+        yymajor = this.YYNOCODE;
+      }
+    }
+  } while (yymajor != this.YYNOCODE && this.yyidx > 0);
+
+  if (this.yyTraceCallback) {
+    var remainingTokens = [];
+    for (var i = 1; i <= this.yyidx; i++) {
+      remainingTokens.push(this.yyTokenName[this.yystack[i].major]);
+    }
+    this.trace("Return. Stack=[" + remainingTokens.join(" ") + "]");
+  }
+}
+
+this.init();
+
+} // function Parse()
diff --git a/main.js b/main.js
new file mode 100644
index 0000000..08e1989
--- /dev/null
+++ b/main.js
@@ -0,0 +1,54 @@
+/**
+ * Created by Aleksey Chichenkov <a.chichenkov@initi.ru> on 1/28/19.
+ */
+
+var js_beautify = require("js-beautify");
+var args = require("args-parser")(process.argv);
+var fs = require("fs");
+var exec = require('child_process').exec;
+
+var program_path = "./lemon-src/lemon-js";
+var parser_path = "parsers/filters/";
+var file_name = "parser.y";
+var temp_file_name = "temp_parser.y";
+
+
+var update_parser_y = function () {
+    var source_parser_y = fs.readFileSync(parser_path + file_name, "utf8");
+
+    var result = /&&.*?REPLACER\{(.*?)\}&&/gm.exec(source_parser_y);
+    if(result) {
+        var file_path = result[1];
+        var process_code = fs.readFileSync(file_path, "utf8");
+
+        source_parser_y = source_parser_y.replace(/&&.*?REPLACER\{(.*?)\}&&/gm, process_code);
+
+        fs.writeFileSync(parser_path + temp_file_name, source_parser_y);
+    }
+};
+
+var post_process_parser = function () {
+    var out_js = fs.readFileSync(parser_path + "temp_parser.js", "utf8");
+    out_js = js_beautify(out_js, {indent_size: 4, space_in_empty_paren: true});
+    fs.writeFileSync(parser_path + "parser.js", out_js);
+
+    var temp_parser_out = fs.readFileSync(parser_path + "temp_parser.out", "utf8");
+    fs.writeFileSync(parser_path + "parser.out", temp_parser_out);
+};
+
+var start = function () {
+    update_parser_y();
+
+    exec(program_path + " " + parser_path + temp_file_name + " -l", function(err, stdout, stderr) {
+        err && console.log("ERROR: ", err);
+        err && process.exit(1);
+
+        post_process_parser();
+
+        fs.unlinkSync(parser_path + temp_file_name);
+        fs.unlinkSync(parser_path + "temp_parser.js");
+        fs.unlinkSync(parser_path + "temp_parser.out");
+    });
+};
+
+start();
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
new file mode 100644
index 0000000..12a31c9
--- /dev/null
+++ b/package-lock.json
@@ -0,0 +1,223 @@
+{
+  "name": "lemon-js-generator",
+  "requires": true,
+  "lockfileVersion": 1,
+  "dependencies": {
+    "@types/node": {
+      "version": "10.12.18",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-10.12.18.tgz",
+      "integrity": "sha512-fh+pAqt4xRzPfqA6eh3Z2y6fyZavRIumvjhaCL753+TVkGKGhpPeyrJG2JftD0T9q4GF00KjefsQ+PQNDdWQaQ=="
+    },
+    "@types/semver": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/@types/semver/-/semver-5.5.0.tgz",
+      "integrity": "sha512-41qEJgBH/TWgo5NFSvBCJ1qkoi3Q6ONSF2avrHq1LVEZfYpdHmj0y9SuTK+u9ZhG1sYQKBL1AWXKyLWP4RaUoQ=="
+    },
+    "abbrev": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",
+      "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q=="
+    },
+    "args-parser": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/args-parser/-/args-parser-1.1.0.tgz",
+      "integrity": "sha1-YlO/zWlNJ5/mPqr9eNYo0UoF/6k="
+    },
+    "balanced-match": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz",
+      "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c="
+    },
+    "brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "requires": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "commander": {
+      "version": "2.19.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.19.0.tgz",
+      "integrity": "sha512-6tvAOO+D6OENvRAh524Dh9jcfKTYDQAqvqezbCW82xj5X0pSrcpxtvRKHLG0yBY6SD7PSDrJaj+0AiOcKVd1Xg=="
+    },
+    "concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s="
+    },
+    "config-chain": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.12.tgz",
+      "integrity": "sha512-a1eOIcu8+7lUInge4Rpf/n4Krkf3Dd9lqhljRzII1/Zno/kRtUWnznPO3jOKBmTEktkt3fkxisUcivoj0ebzoA==",
+      "requires": {
+        "ini": "^1.3.4",
+        "proto-list": "~1.2.1"
+      }
+    },
+    "editorconfig": {
+      "version": "0.15.2",
+      "resolved": "https://registry.npmjs.org/editorconfig/-/editorconfig-0.15.2.tgz",
+      "integrity": "sha512-GWjSI19PVJAM9IZRGOS+YKI8LN+/sjkSjNyvxL5ucqP9/IqtYNXBaQ/6c/hkPNYQHyOHra2KoXZI/JVpuqwmcQ==",
+      "requires": {
+        "@types/node": "^10.11.7",
+        "@types/semver": "^5.5.0",
+        "commander": "^2.19.0",
+        "lru-cache": "^4.1.3",
+        "semver": "^5.6.0",
+        "sigmund": "^1.0.1"
+      }
+    },
+    "fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8="
+    },
+    "glob": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz",
+      "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==",
+      "requires": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.0.4",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      }
+    },
+    "inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+      "requires": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "inherits": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
+      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4="
+    },
+    "ini": {
+      "version": "1.3.5",
+      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.5.tgz",
+      "integrity": "sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw=="
+    },
+    "js-beautify": {
+      "version": "1.8.9",
+      "resolved": "https://registry.npmjs.org/js-beautify/-/js-beautify-1.8.9.tgz",
+      "integrity": "sha512-MwPmLywK9RSX0SPsUJjN7i+RQY9w/yC17Lbrq9ViEefpLRgqAR2BgrMN2AbifkUuhDV8tRauLhLda/9+bE0YQA==",
+      "requires": {
+        "config-chain": "^1.1.12",
+        "editorconfig": "^0.15.2",
+        "glob": "^7.1.3",
+        "mkdirp": "~0.5.0",
+        "nopt": "~4.0.1"
+      }
+    },
+    "lru-cache": {
+      "version": "4.1.5",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz",
+      "integrity": "sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==",
+      "requires": {
+        "pseudomap": "^1.0.2",
+        "yallist": "^2.1.2"
+      }
+    },
+    "minimatch": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
+      "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+      "requires": {
+        "brace-expansion": "^1.1.7"
+      }
+    },
+    "minimist": {
+      "version": "0.0.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz",
+      "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0="
+    },
+    "mkdirp": {
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz",
+      "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=",
+      "requires": {
+        "minimist": "0.0.8"
+      }
+    },
+    "nopt": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/nopt/-/nopt-4.0.1.tgz",
+      "integrity": "sha1-0NRoWv1UFRk8jHUFYC0NF81kR00=",
+      "requires": {
+        "abbrev": "1",
+        "osenv": "^0.1.4"
+      }
+    },
+    "once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=",
+      "requires": {
+        "wrappy": "1"
+      }
+    },
+    "os-homedir": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz",
+      "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M="
+    },
+    "os-tmpdir": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz",
+      "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ="
+    },
+    "osenv": {
+      "version": "0.1.5",
+      "resolved": "https://registry.npmjs.org/osenv/-/osenv-0.1.5.tgz",
+      "integrity": "sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==",
+      "requires": {
+        "os-homedir": "^1.0.0",
+        "os-tmpdir": "^1.0.0"
+      }
+    },
+    "path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18="
+    },
+    "proto-list": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz",
+      "integrity": "sha1-IS1b/hMYMGpCD2QCuOJv85ZHqEk="
+    },
+    "pseudomap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz",
+      "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM="
+    },
+    "semver": {
+      "version": "5.6.0",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-5.6.0.tgz",
+      "integrity": "sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg=="
+    },
+    "sigmund": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/sigmund/-/sigmund-1.0.1.tgz",
+      "integrity": "sha1-P/IfGYytIXX587eBhT/ZTQ0ZtZA="
+    },
+    "wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
+    },
+    "yallist": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz",
+      "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI="
+    }
+  }
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..33ef518
--- /dev/null
+++ b/package.json
@@ -0,0 +1,14 @@
+{
+  "name": "lemon-js-generator",
+  "requires": true,
+  "lockfileVersion": 1,
+  "license": "MIT",
+  "author": {
+    "name": "chichenkov",
+    "email": "rolahd@yandex.ru"
+  },
+  "dependencies": {
+    "args-parser": "^1.1.0",
+    "js-beautify": "^1.8.9"
+  }
+}
diff --git a/parsers/filters/lexer.js b/parsers/filters/lexer.js
new file mode 100644
index 0000000..0badc26
--- /dev/null
+++ b/parsers/filters/lexer.js
@@ -0,0 +1,1922 @@
+/* Generated by re2c 1.0.3 on Fri Jan 25 16:37:52 2019 */
+var types = [
+    "LSB",
+    "RSB",
+    "LCB",
+    "RCB",
+    "COLON",
+    "COMMA",
+    "DOT",
+    "REM",
+    "GT",
+    "GTE",
+    "LT",
+    "LTE",
+    "EQ",
+    "NEQ",
+    "LIKE",
+    "NLIKE",
+    "AND",
+    "OR",
+    "NOT",
+    "ADDRESS",
+    "TIME",
+    "TIMEDIFF",
+    "INTEGER_LITERAL",
+    "FLOAT_LITERAL",
+    "BOOL_LITERAL",
+    "ID"
+];
+
+var errors = {
+    "-2": "not found close quote or singleQuote",
+    "-1": "not found any lexemes or errors or anything else",
+    "0": "success",
+    "1": "found unknown symbol"
+};
+
+var Lexer = function(_string) {
+    this._last_found_lexeme = {
+        error: -1
+    };
+    this._end = false;
+    this._error = false;
+    this._string = _string;
+    this._state = 1;
+    this._yy_char = null;
+    this._yy_lex_start = 0;
+    this._yy_cursor = 0;
+    this._yy_marker = 0;
+    this._yy_accept = 0;
+};
+
+Lexer.prototype = {
+    types: types,
+    errors: errors,
+    _notFoundCloseQuote: function() {
+        this._error = true;
+        this._last_found_lexeme = {
+            error: 2,
+            start: this._yy_lex_start,
+            end: this._yy_cursor
+        };
+
+        console.log(print_f("LEXER: Not found close quote start: %s", this._yy_cursor));
+    },
+    _unknownSymbol: function() {
+        this._error = true;
+        this._last_found_lexeme = {
+            error: 1,
+            start: this._yy_lex_start,
+            end: this._yy_cursor
+        };
+
+        console.log(print_f("LEXER: Found unknown symbol on position: %s", this._yy_cursor));
+    },
+    _foundLexeme: function(_lexeme) {
+        console.log(print_f("LEXER: found lex: %s; start: %s; end: %s; result => %s", _lexeme, this._yy_lex_start, this._yy_cursor, this._string.substring(this._yy_lex_start, this._yy_cursor)));
+        this._last_found_lexeme = {
+            error: 0,
+            lexeme: _lexeme,
+            start: this._yy_lex_start,
+            end: this._yy_cursor
+        };
+    },
+    _endOfString: function() {
+        console.log(print_f("LEXER: search end\n"));
+        this._end = true;
+        this._last_found_lexeme = {
+            error: -2
+        };
+    },
+    _searchString: function() {
+        var _quote = this._string[this._yy_cursor - 1];
+        var found_back_slash = false;
+        while (this._yy_cursor < this._string.length) {
+            this._yy_char = this._string[this._yy_cursor];
+            if (_quote == '"') {
+                switch (this._yy_char) {
+                    case "\\":
+                        found_back_slash = true;
+                        break;
+                    case '"':
+                        if (!found_back_slash) {
+                            this._yy_cursor++;
+                            this._foundLexeme("STRING_LITERAL");
+                            return;
+                        }
+                        found_back_slash = false;
+                        break;
+                }
+            } else if (_quote == "'") {
+                switch (this._yy_char) {
+                    case "\\":
+                        found_back_slash = true;
+                        break;
+                    case "'":
+                        if (!found_back_slash) {
+                            this._yy_cursor++;
+                            this._foundLexeme("STRING_LITERAL");
+                            return;
+                        }
+                        found_back_slash = false;
+                        break;
+                }
+            }
+            this._yy_cursor++;
+        }
+
+        this._notFoundCloseQuote();
+    },
+    _set_next: function() {
+        this._yy_accept = 0;
+        this._state = 1;
+        this._yy_lex_start = this._yy_cursor;
+        this._yy_marker = this._yy_cursor;
+    },
+    next: function() {
+        if (this._end || this._error) return null;
+
+        this.search();
+        return this.token();
+    },
+    token: function() {
+        return this._last_found_lexeme;
+    },
+    search: function() {
+        if (this._end) return false;
+
+        while (true) {
+            switch (this._state) {
+                case 1:
+                    this._yy_char = this._string[this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case undefined:
+                                this._state = 2;
+                                break;
+                            case '\t':
+                            case '\n':
+                            case '\r':
+                            case ' ':
+                                this._state = 6;
+                                break;
+                            case '!':
+                                this._state = 8;
+                                break;
+                            case '"':
+                            case '\'':
+                                this._state = 9;
+                                break;
+                            case '%':
+                                this._state = 11;
+                                break;
+                            case '(':
+                                this._state = 13;
+                                break;
+                            case ')':
+                                this._state = 15;
+                                break;
+                            case ',':
+                                this._state = 17;
+                                break;
+                            case '-':
+                                this._state = 19;
+                                break;
+                            case '.':
+                                this._state = 20;
+                                break;
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                this._state = 22;
+                                break;
+                            case ':':
+                                this._state = 25;
+                                break;
+                            case '<':
+                                this._state = 27;
+                                break;
+                            case '=':
+                                this._state = 29;
+                                break;
+                            case '>':
+                                this._state = 30;
+                                break;
+                            case 'A':
+                                this._state = 32;
+                                break;
+                            case 'B':
+                            case 'C':
+                            case 'D':
+                            case 'E':
+                            case 'G':
+                            case 'H':
+                            case 'I':
+                            case 'J':
+                            case 'K':
+                            case 'M':
+                            case 'P':
+                            case 'Q':
+                            case 'R':
+                            case 'S':
+                            case 'U':
+                            case 'V':
+                            case 'W':
+                            case 'X':
+                            case 'Y':
+                            case 'Z':
+                            case '_':
+                            case 'b':
+                            case 'c':
+                            case 'd':
+                            case 'e':
+                            case 'g':
+                            case 'h':
+                            case 'i':
+                            case 'j':
+                            case 'k':
+                            case 'm':
+                            case 'p':
+                            case 'q':
+                            case 'r':
+                            case 's':
+                            case 'u':
+                            case 'v':
+                            case 'w':
+                            case 'x':
+                            case 'y':
+                            case 'z':
+                                this._state = 34;
+                                break;
+                            case 'F':
+                            case 'f':
+                                this._state = 36;
+                                break;
+                            case 'L':
+                            case 'l':
+                                this._state = 37;
+                                break;
+                            case 'N':
+                            case 'n':
+                                this._state = 38;
+                                break;
+                            case 'O':
+                            case 'o':
+                                this._state = 39;
+                                break;
+                            case 'T':
+                                this._state = 40;
+                                break;
+                            case '[':
+                                this._state = 41;
+                                break;
+                            case ']':
+                                this._state = 43;
+                                break;
+                            case 'a':
+                                this._state = 45;
+                                break;
+                            case 't':
+                                this._state = 46;
+                                break;
+                            default:
+                                this._state = 4;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 2:
+                    ++this._yy_cursor; {
+                        this._endOfString();
+                        return;
+                    }
+                case 4:
+                    ++this._yy_cursor;
+                case 5:
+                    {
+                        this._unknownSymbol();this._set_next();
+                        return;
+                    }
+                case 6:
+                    ++this._yy_cursor; {
+                        this._set_next();
+                        break;
+                    }
+                case 8:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '=':
+                                this._state = 47;
+                                break;
+                            default:
+                                this._state = 5;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 9:
+                    ++this._yy_cursor; {
+                        this._state = 100000000;
+                        break;
+                    }
+                case 11:
+                    ++this._yy_cursor; {
+                        this._foundLexeme("REM");
+                        this._set_next();
+                        return;
+                    }
+                case 13:
+                    ++this._yy_cursor; {
+                        this._foundLexeme("LCB");
+                        this._set_next();
+                        return;
+                    }
+                case 15:
+                    ++this._yy_cursor; {
+                        this._foundLexeme("RCB");
+                        this._set_next();
+                        return;
+                    }
+                case 17:
+                    ++this._yy_cursor; {
+                        this._foundLexeme("COMMA");
+                        this._set_next();
+                        return;
+                    }
+                case 19:
+                    this._yy_accept = 0;
+                    this._yy_char = this._string[(this._yy_marker = ++this._yy_cursor)];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '.':
+                                this._state = 49;
+                                break;
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                this._state = 22;
+                                break;
+                            default:
+                                this._state = 5;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 20:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                this._state = 51;
+                                break;
+                            default:
+                                this._state = 21;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 21:
+                    {
+                        this._foundLexeme("DOT");this._set_next();
+                        return;
+                    }
+                case 22:
+                    this._yy_accept = 1;
+                    this._yy_char = this._string[(this._yy_marker = ++this._yy_cursor)];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '.':
+                                this._state = 49;
+                                break;
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                this._state = 22;
+                                break;
+                            default:
+                                this._state = 24;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 24:
+                    {
+                        this._foundLexeme("INTEGER_LITERAL");this._set_next();
+                        return;
+                    }
+                case 25:
+                    ++this._yy_cursor; {
+                        this._foundLexeme("COLON");
+                        this._set_next();
+                        return;
+                    }
+                case 27:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '=':
+                                this._state = 54;
+                                break;
+                            default:
+                                this._state = 28;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 28:
+                    {
+                        this._foundLexeme("LT");this._set_next();
+                        return;
+                    }
+                case 29:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '=':
+                                this._state = 56;
+                                break;
+                            default:
+                                this._state = 5;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 30:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '=':
+                                this._state = 58;
+                                break;
+                            default:
+                                this._state = 31;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 31:
+                    {
+                        this._foundLexeme("GT");this._set_next();
+                        return;
+                    }
+                case 32:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'N':
+                            case 'n':
+                                this._state = 60;
+                                break;
+                            case 'd':
+                                this._state = 61;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 33:
+                    {
+                        this._foundLexeme("ID");this._set_next();
+                        return;
+                    }
+                case 34:
+                    this._yy_char = this._string[++this._yy_cursor];
+                case 35:
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                            case 'A':
+                            case 'B':
+                            case 'C':
+                            case 'D':
+                            case 'E':
+                            case 'F':
+                            case 'G':
+                            case 'H':
+                            case 'I':
+                            case 'J':
+                            case 'K':
+                            case 'L':
+                            case 'M':
+                            case 'N':
+                            case 'O':
+                            case 'P':
+                            case 'Q':
+                            case 'R':
+                            case 'S':
+                            case 'T':
+                            case 'U':
+                            case 'V':
+                            case 'W':
+                            case 'X':
+                            case 'Y':
+                            case 'Z':
+                            case '_':
+                            case 'a':
+                            case 'b':
+                            case 'c':
+                            case 'd':
+                            case 'e':
+                            case 'f':
+                            case 'g':
+                            case 'h':
+                            case 'i':
+                            case 'j':
+                            case 'k':
+                            case 'l':
+                            case 'm':
+                            case 'n':
+                            case 'o':
+                            case 'p':
+                            case 'q':
+                            case 'r':
+                            case 's':
+                            case 't':
+                            case 'u':
+                            case 'v':
+                            case 'w':
+                            case 'x':
+                            case 'y':
+                            case 'z':
+                                this._state = 34;
+                                break;
+                            default:
+                                this._state = 33;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 36:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'A':
+                            case 'a':
+                                this._state = 62;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 37:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'I':
+                            case 'i':
+                                this._state = 63;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 38:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'L':
+                            case 'l':
+                                this._state = 64;
+                                break;
+                            case 'O':
+                            case 'o':
+                                this._state = 65;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 39:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'R':
+                            case 'r':
+                                this._state = 66;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 40:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'R':
+                            case 'r':
+                                this._state = 68;
+                                break;
+                            case 'i':
+                                this._state = 69;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 41:
+                    ++this._yy_cursor; {
+                        this._foundLexeme("LSB");
+                        this._set_next();
+                        return;
+                    }
+                case 43:
+                    ++this._yy_cursor; {
+                        this._foundLexeme("RSB");
+                        this._set_next();
+                        return;
+                    }
+                case 45:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'N':
+                            case 'n':
+                                this._state = 60;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 46:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'R':
+                            case 'r':
+                                this._state = 68;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 47:
+                    ++this._yy_cursor; {
+                        this._foundLexeme("NEQ");
+                        this._set_next();
+                        return;
+                    }
+                case 49:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                this._state = 51;
+                                break;
+                            default:
+                                this._state = 50;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 50:
+                    this._yy_cursor = this._yy_marker;
+                    switch (this._yy_accept) {
+                        case 0:
+                            this._state = 5;
+                            break;
+                        case 1:
+                            this._state = 24;
+                            break;
+                        default:
+                            this._state = 53;
+                            break;
+                    }
+                case 51:
+                    this._yy_accept = 2;
+                    this._yy_char = this._string[(this._yy_marker = ++this._yy_cursor)];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                this._state = 51;
+                                break;
+                            case 'e':
+                                this._state = 70;
+                                break;
+                            default:
+                                this._state = 53;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 53:
+                    {
+                        this._foundLexeme("FLOAT_LITERAL");this._set_next();
+                        return;
+                    }
+                case 54:
+                    ++this._yy_cursor; {
+                        this._foundLexeme("LTE");
+                        this._set_next();
+                        return;
+                    }
+                case 56:
+                    ++this._yy_cursor; {
+                        this._foundLexeme("EQ");
+                        this._set_next();
+                        return;
+                    }
+                case 58:
+                    ++this._yy_cursor; {
+                        this._foundLexeme("GTE");
+                        this._set_next();
+                        return;
+                    }
+                case 60:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'D':
+                            case 'd':
+                                this._state = 71;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 61:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'd':
+                                this._state = 73;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 62:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'L':
+                            case 'l':
+                                this._state = 74;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 63:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'K':
+                            case 'k':
+                                this._state = 75;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 64:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'I':
+                            case 'i':
+                                this._state = 76;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 65:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'T':
+                            case 't':
+                                this._state = 77;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 66:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                            case 'A':
+                            case 'B':
+                            case 'C':
+                            case 'D':
+                            case 'E':
+                            case 'F':
+                            case 'G':
+                            case 'H':
+                            case 'I':
+                            case 'J':
+                            case 'K':
+                            case 'L':
+                            case 'M':
+                            case 'N':
+                            case 'O':
+                            case 'P':
+                            case 'Q':
+                            case 'R':
+                            case 'S':
+                            case 'T':
+                            case 'U':
+                            case 'V':
+                            case 'W':
+                            case 'X':
+                            case 'Y':
+                            case 'Z':
+                            case '_':
+                            case 'a':
+                            case 'b':
+                            case 'c':
+                            case 'd':
+                            case 'e':
+                            case 'f':
+                            case 'g':
+                            case 'h':
+                            case 'i':
+                            case 'j':
+                            case 'k':
+                            case 'l':
+                            case 'm':
+                            case 'n':
+                            case 'o':
+                            case 'p':
+                            case 'q':
+                            case 'r':
+                            case 's':
+                            case 't':
+                            case 'u':
+                            case 'v':
+                            case 'w':
+                            case 'x':
+                            case 'y':
+                            case 'z':
+                                this._state = 34;
+                                break;
+                            default:
+                                this._state = 67;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 67:
+                    {
+                        this._foundLexeme("OR");this._set_next();
+                        return;
+                    }
+                case 68:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'U':
+                            case 'u':
+                                this._state = 79;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 69:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'm':
+                                this._state = 80;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 70:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '-':
+                                this._state = 81;
+                                break;
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                this._state = 82;
+                                break;
+                            default:
+                                this._state = 50;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 71:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                            case 'A':
+                            case 'B':
+                            case 'C':
+                            case 'D':
+                            case 'E':
+                            case 'F':
+                            case 'G':
+                            case 'H':
+                            case 'I':
+                            case 'J':
+                            case 'K':
+                            case 'L':
+                            case 'M':
+                            case 'N':
+                            case 'O':
+                            case 'P':
+                            case 'Q':
+                            case 'R':
+                            case 'S':
+                            case 'T':
+                            case 'U':
+                            case 'V':
+                            case 'W':
+                            case 'X':
+                            case 'Y':
+                            case 'Z':
+                            case '_':
+                            case 'a':
+                            case 'b':
+                            case 'c':
+                            case 'd':
+                            case 'e':
+                            case 'f':
+                            case 'g':
+                            case 'h':
+                            case 'i':
+                            case 'j':
+                            case 'k':
+                            case 'l':
+                            case 'm':
+                            case 'n':
+                            case 'o':
+                            case 'p':
+                            case 'q':
+                            case 'r':
+                            case 's':
+                            case 't':
+                            case 'u':
+                            case 'v':
+                            case 'w':
+                            case 'x':
+                            case 'y':
+                            case 'z':
+                                this._state = 34;
+                                break;
+                            default:
+                                this._state = 72;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 72:
+                    {
+                        this._foundLexeme("AND");this._set_next();
+                        return;
+                    }
+                case 73:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'r':
+                                this._state = 84;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 74:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'S':
+                            case 's':
+                                this._state = 79;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 75:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'E':
+                            case 'e':
+                                this._state = 85;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 76:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'K':
+                            case 'k':
+                                this._state = 87;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 77:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                            case 'A':
+                            case 'B':
+                            case 'C':
+                            case 'D':
+                            case 'E':
+                            case 'F':
+                            case 'G':
+                            case 'H':
+                            case 'I':
+                            case 'J':
+                            case 'K':
+                            case 'L':
+                            case 'M':
+                            case 'N':
+                            case 'O':
+                            case 'P':
+                            case 'Q':
+                            case 'R':
+                            case 'S':
+                            case 'T':
+                            case 'U':
+                            case 'V':
+                            case 'W':
+                            case 'X':
+                            case 'Y':
+                            case 'Z':
+                            case '_':
+                            case 'a':
+                            case 'b':
+                            case 'c':
+                            case 'd':
+                            case 'e':
+                            case 'f':
+                            case 'g':
+                            case 'h':
+                            case 'i':
+                            case 'j':
+                            case 'k':
+                            case 'l':
+                            case 'm':
+                            case 'n':
+                            case 'o':
+                            case 'p':
+                            case 'q':
+                            case 'r':
+                            case 's':
+                            case 't':
+                            case 'u':
+                            case 'v':
+                            case 'w':
+                            case 'x':
+                            case 'y':
+                            case 'z':
+                                this._state = 34;
+                                break;
+                            default:
+                                this._state = 78;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 78:
+                    {
+                        this._foundLexeme("NOT");this._set_next();
+                        return;
+                    }
+                case 79:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'E':
+                            case 'e':
+                                this._state = 88;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 80:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'e':
+                                this._state = 90;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 81:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                this._state = 82;
+                                break;
+                            default:
+                                this._state = 50;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 82:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                                this._state = 82;
+                                break;
+                            default:
+                                this._state = 53;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 84:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'e':
+                                this._state = 92;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 85:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                            case 'A':
+                            case 'B':
+                            case 'C':
+                            case 'D':
+                            case 'E':
+                            case 'F':
+                            case 'G':
+                            case 'H':
+                            case 'I':
+                            case 'J':
+                            case 'K':
+                            case 'L':
+                            case 'M':
+                            case 'N':
+                            case 'O':
+                            case 'P':
+                            case 'Q':
+                            case 'R':
+                            case 'S':
+                            case 'T':
+                            case 'U':
+                            case 'V':
+                            case 'W':
+                            case 'X':
+                            case 'Y':
+                            case 'Z':
+                            case '_':
+                            case 'a':
+                            case 'b':
+                            case 'c':
+                            case 'd':
+                            case 'e':
+                            case 'f':
+                            case 'g':
+                            case 'h':
+                            case 'i':
+                            case 'j':
+                            case 'k':
+                            case 'l':
+                            case 'm':
+                            case 'n':
+                            case 'o':
+                            case 'p':
+                            case 'q':
+                            case 'r':
+                            case 's':
+                            case 't':
+                            case 'u':
+                            case 'v':
+                            case 'w':
+                            case 'x':
+                            case 'y':
+                            case 'z':
+                                this._state = 34;
+                                break;
+                            default:
+                                this._state = 86;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 86:
+                    {
+                        this._foundLexeme("LIKE");this._set_next();
+                        return;
+                    }
+                case 87:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'E':
+                            case 'e':
+                                this._state = 93;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 88:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                            case 'A':
+                            case 'B':
+                            case 'C':
+                            case 'D':
+                            case 'E':
+                            case 'F':
+                            case 'G':
+                            case 'H':
+                            case 'I':
+                            case 'J':
+                            case 'K':
+                            case 'L':
+                            case 'M':
+                            case 'N':
+                            case 'O':
+                            case 'P':
+                            case 'Q':
+                            case 'R':
+                            case 'S':
+                            case 'T':
+                            case 'U':
+                            case 'V':
+                            case 'W':
+                            case 'X':
+                            case 'Y':
+                            case 'Z':
+                            case '_':
+                            case 'a':
+                            case 'b':
+                            case 'c':
+                            case 'd':
+                            case 'e':
+                            case 'f':
+                            case 'g':
+                            case 'h':
+                            case 'i':
+                            case 'j':
+                            case 'k':
+                            case 'l':
+                            case 'm':
+                            case 'n':
+                            case 'o':
+                            case 'p':
+                            case 'q':
+                            case 'r':
+                            case 's':
+                            case 't':
+                            case 'u':
+                            case 'v':
+                            case 'w':
+                            case 'x':
+                            case 'y':
+                            case 'z':
+                                this._state = 34;
+                                break;
+                            default:
+                                this._state = 89;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 89:
+                    {
+                        this._foundLexeme("BOOL_LITERAL");this._set_next();
+                        return;
+                    }
+                case 90:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                            case 'A':
+                            case 'B':
+                            case 'C':
+                            case 'E':
+                            case 'F':
+                            case 'G':
+                            case 'H':
+                            case 'I':
+                            case 'J':
+                            case 'K':
+                            case 'L':
+                            case 'M':
+                            case 'N':
+                            case 'O':
+                            case 'P':
+                            case 'Q':
+                            case 'R':
+                            case 'S':
+                            case 'T':
+                            case 'U':
+                            case 'V':
+                            case 'W':
+                            case 'X':
+                            case 'Y':
+                            case 'Z':
+                            case '_':
+                            case 'a':
+                            case 'b':
+                            case 'c':
+                            case 'd':
+                            case 'e':
+                            case 'f':
+                            case 'g':
+                            case 'h':
+                            case 'i':
+                            case 'j':
+                            case 'k':
+                            case 'l':
+                            case 'm':
+                            case 'n':
+                            case 'o':
+                            case 'p':
+                            case 'q':
+                            case 'r':
+                            case 's':
+                            case 't':
+                            case 'u':
+                            case 'v':
+                            case 'w':
+                            case 'x':
+                            case 'y':
+                            case 'z':
+                                this._state = 34;
+                                break;
+                            case 'D':
+                                this._state = 95;
+                                break;
+                            default:
+                                this._state = 91;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 91:
+                    {
+                        this._foundLexeme("TIME");this._set_next();
+                        return;
+                    }
+                case 92:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 's':
+                                this._state = 96;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 93:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                            case 'A':
+                            case 'B':
+                            case 'C':
+                            case 'D':
+                            case 'E':
+                            case 'F':
+                            case 'G':
+                            case 'H':
+                            case 'I':
+                            case 'J':
+                            case 'K':
+                            case 'L':
+                            case 'M':
+                            case 'N':
+                            case 'O':
+                            case 'P':
+                            case 'Q':
+                            case 'R':
+                            case 'S':
+                            case 'T':
+                            case 'U':
+                            case 'V':
+                            case 'W':
+                            case 'X':
+                            case 'Y':
+                            case 'Z':
+                            case '_':
+                            case 'a':
+                            case 'b':
+                            case 'c':
+                            case 'd':
+                            case 'e':
+                            case 'f':
+                            case 'g':
+                            case 'h':
+                            case 'i':
+                            case 'j':
+                            case 'k':
+                            case 'l':
+                            case 'm':
+                            case 'n':
+                            case 'o':
+                            case 'p':
+                            case 'q':
+                            case 'r':
+                            case 's':
+                            case 't':
+                            case 'u':
+                            case 'v':
+                            case 'w':
+                            case 'x':
+                            case 'y':
+                            case 'z':
+                                this._state = 34;
+                                break;
+                            default:
+                                this._state = 94;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 94:
+                    {
+                        this._foundLexeme("NLIKE");this._set_next();
+                        return;
+                    }
+                case 95:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'i':
+                                this._state = 97;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 96:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 's':
+                                this._state = 98;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 97:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'f':
+                                this._state = 100;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 98:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                            case 'A':
+                            case 'B':
+                            case 'C':
+                            case 'D':
+                            case 'E':
+                            case 'F':
+                            case 'G':
+                            case 'H':
+                            case 'I':
+                            case 'J':
+                            case 'K':
+                            case 'L':
+                            case 'M':
+                            case 'N':
+                            case 'O':
+                            case 'P':
+                            case 'Q':
+                            case 'R':
+                            case 'S':
+                            case 'T':
+                            case 'U':
+                            case 'V':
+                            case 'W':
+                            case 'X':
+                            case 'Y':
+                            case 'Z':
+                            case '_':
+                            case 'a':
+                            case 'b':
+                            case 'c':
+                            case 'd':
+                            case 'e':
+                            case 'f':
+                            case 'g':
+                            case 'h':
+                            case 'i':
+                            case 'j':
+                            case 'k':
+                            case 'l':
+                            case 'm':
+                            case 'n':
+                            case 'o':
+                            case 'p':
+                            case 'q':
+                            case 'r':
+                            case 's':
+                            case 't':
+                            case 'u':
+                            case 'v':
+                            case 'w':
+                            case 'x':
+                            case 'y':
+                            case 'z':
+                                this._state = 34;
+                                break;
+                            default:
+                                this._state = 99;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 99:
+                    {
+                        this._foundLexeme("ADDRESS");this._set_next();
+                        return;
+                    }
+                case 100:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case 'f':
+                                this._state = 101;
+                                break;
+                            default:
+                                this._state = 35;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 101:
+                    this._yy_char = this._string[++this._yy_cursor];
+                    (function() {
+                        switch (this._yy_char) {
+                            case '0':
+                            case '1':
+                            case '2':
+                            case '3':
+                            case '4':
+                            case '5':
+                            case '6':
+                            case '7':
+                            case '8':
+                            case '9':
+                            case 'A':
+                            case 'B':
+                            case 'C':
+                            case 'D':
+                            case 'E':
+                            case 'F':
+                            case 'G':
+                            case 'H':
+                            case 'I':
+                            case 'J':
+                            case 'K':
+                            case 'L':
+                            case 'M':
+                            case 'N':
+                            case 'O':
+                            case 'P':
+                            case 'Q':
+                            case 'R':
+                            case 'S':
+                            case 'T':
+                            case 'U':
+                            case 'V':
+                            case 'W':
+                            case 'X':
+                            case 'Y':
+                            case 'Z':
+                            case '_':
+                            case 'a':
+                            case 'b':
+                            case 'c':
+                            case 'd':
+                            case 'e':
+                            case 'f':
+                            case 'g':
+                            case 'h':
+                            case 'i':
+                            case 'j':
+                            case 'k':
+                            case 'l':
+                            case 'm':
+                            case 'n':
+                            case 'o':
+                            case 'p':
+                            case 'q':
+                            case 'r':
+                            case 's':
+                            case 't':
+                            case 'u':
+                            case 'v':
+                            case 'w':
+                            case 'x':
+                            case 'y':
+                            case 'z':
+                                this._state = 34;
+                                break;
+                            default:
+                                this._state = 102;
+                                break;
+                        }
+                    }.bind(this))();
+                    break;
+                case 102:
+                    {
+                        this._foundLexeme("TIMEDIFF");this._set_next();
+                        return;
+                    }
+                case 100000000:
+                    {
+                        this._searchString();this._set_next();
+                        return;
+                    }
+            }
+        }
+    }
+};
+
+
+var print_f = function() {
+    var r_str = "";
+    var next = arguments[0];
+
+    var rx = /(%[a-zA-Z]{1})/;
+    var a = 1,
+        match;
+    while (match = rx.exec(next)) {
+        var prev = next.substring(0, match.index);
+        var macro = next.substring(match.index + 1, match.index + 2);
+        next = next.substring(match.index + 2, next.length);
+        r_str += prev;
+
+        var arg = arguments[a];
+
+        if (arg !== undefined) {
+            switch (macro) {
+                case "s":
+                    r_str += arg.toString();
+                    break;
+                case "i":
+                    r_str += parseInt(arg);
+                    break;
+                case "f":
+                    r_str += parseFloat(arg);
+                    break;
+            }
+        } else {
+            r_str += "%" + macro;
+        }
+        a++;
+    }
+
+    r_str += next;
+
+    return r_str;
+};
+module.exports = Lexer
\ No newline at end of file
diff --git a/parsers/filters/parser.js b/parsers/filters/parser.js
new file mode 100644
index 0000000..dafe5e6
--- /dev/null
+++ b/parsers/filters/parser.js
@@ -0,0 +1,1152 @@
+/*
+ ** 2000-05-29
+ **
+ ** The author disclaims copyright to this source code.  In place of
+ ** a legal notice, here is a blessing:
+ **
+ **    May you do good and not evil.
+ **    May you find forgiveness for yourself and forgive others.
+ **    May you share freely, never taking more than you give.
+ **
+ ** Based on SQLite distribution v3.17.0
+ ** Adopted for JavaScript by Artem Butusov <art.sormy@gmail.com>
+ **
+ *************************************************************************
+ ** Driver template for the LEMON parser generator.
+ **
+ ** The "lemon" program processes an LALR(1) input grammar file, then uses
+ ** this template to construct a parser.  The "lemon" program inserts text
+ ** at each "%%" line.  Also, any "P-a-r-s-e" identifer prefix (without the
+ ** interstitial "-" characters) contained in this template is changed into
+ ** the value of the %name directive from the grammar.  Otherwise, the content
+ ** of this template is copied straight through into the generate parser
+ ** source file.
+ **
+ ** The following is the concatenation of all %include directives from the
+ ** input grammar file:
+ */
+/************ Begin %include sections from the grammar ************************/
+
+// include something
+/**************** End of %include directives **********************************/
+function Parser() {
+    /* These constants specify the various numeric values for terminal symbols
+     ** in a format understandable to "makeheaders".
+     ***************** Begin makeheaders token definitions *************************/
+    this.TOKEN_OR = 1;
+    this.TOKEN_AND = 2;
+    this.TOKEN_NOT = 3;
+    this.TOKEN_INTEGER_LITERAL = 4;
+    this.TOKEN_STRING_LITERAL = 5;
+    this.TOKEN_ID = 6;
+    this.TOKEN_EQ = 7;
+    this.TOKEN_LCB = 8;
+    this.TOKEN_RCB = 9;
+    this.TOKEN_COMMA = 10;
+    this.TOKEN_ADDRESS = 11;
+    this.TOKEN_LSB = 12;
+    this.TOKEN_RSB = 13;
+    /**************** End makeheaders token definitions ***************************/
+
+    /* The next sections is a series of control #defines.
+     ** various aspects of the generated parser.
+     **    YYNOCODE           is a number of type YYCODETYPE that is not used for
+     **                       any terminal or nonterminal symbol.
+     **    YYFALLBACK         If defined, this indicates that one or more tokens
+     **                       (also known as: "terminal symbols") have fall-back
+     **                       values which should be used if the original symbol
+     **                       would not parse.  This permits keywords to sometimes
+     **                       be used as identifiers, for example.
+     **    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
+     **                       zero the stack is dynamically sized using realloc()
+     **    YYERRORSYMBOL      is the code number of the error symbol.  If not
+     **                       defined, then do no error processing.
+     **    YYNSTATE           the combined number of states.
+     **    YYNRULE            the number of rules in the grammar
+     **    YY_MAX_SHIFT       Maximum value for shift actions
+     **    YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
+     **    YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
+     **    YY_MIN_REDUCE      Maximum value for reduce actions
+     **    YY_ERROR_ACTION    The yy_action[] code for syntax error
+     **    YY_ACCEPT_ACTION   The yy_action[] code for accept
+     **    YY_NO_ACTION       The yy_action[] code for no-op
+     */
+    /************* Begin control #defines *****************************************/
+    this.YYNOCODE = 27;
+    this.YYSTACKDEPTH = 100;
+    this.YYFALLBACK = false;
+    this.YYNSTATE = 12;
+    this.YYNRULE = 17;
+    this.YY_MAX_SHIFT = 11;
+    this.YY_MIN_SHIFTREDUCE = 26;
+    this.YY_MAX_SHIFTREDUCE = 42;
+    this.YY_MIN_REDUCE = 43;
+    this.YY_MAX_REDUCE = 59;
+    this.YY_ERROR_ACTION = 60;
+    this.YY_ACCEPT_ACTION = 61;
+    this.YY_NO_ACTION = 62;
+    /************* End control #defines *******************************************/
+
+    /* Define the yytestcase() macro to be a no-op if is not already defined
+     ** otherwise.
+     **
+     ** Applications can choose to define yytestcase() in the %include section
+     ** to a macro that can assist in verifying code coverage.  For production
+     ** code the yytestcase() macro should be turned off.  But it is useful
+     ** for testing.
+     */
+    if (!this.yytestcase) {
+        this.yytestcase = function() {};
+    }
+
+
+    /* Next are the tables used to determine what action to take based on the
+     ** current state and lookahead token.  These tables are used to implement
+     ** functions that take a state number and lookahead value and return an
+     ** action integer.
+     **
+     ** Suppose the action integer is N.  Then the action is determined as
+     ** follows
+     **
+     **   0 <= N <= YY_MAX_SHIFT             Shift N.  That is, push the lookahead
+     **                                      token onto the stack and goto state N.
+     **
+     **   N between YY_MIN_SHIFTREDUCE       Shift to an arbitrary state then
+     **     and YY_MAX_SHIFTREDUCE           reduce by rule N-YY_MIN_SHIFTREDUCE.
+     **
+     **   N between YY_MIN_REDUCE            Reduce by rule N-YY_MIN_REDUCE
+     **     and YY_MAX_REDUCE
+     **
+     **   N == YY_ERROR_ACTION               A syntax error has occurred.
+     **
+     **   N == YY_ACCEPT_ACTION              The parser accepts its input.
+     **
+     **   N == YY_NO_ACTION                  No such action.  Denotes unused
+     **                                      slots in the yy_action[] table.
+     **
+     ** The action table is constructed as a single large table named yy_action[].
+     ** Given state S and lookahead X, the action is computed as either:
+     **
+     **    (A)   N = yy_action[ yy_shift_ofst[S] + X ]
+     **    (B)   N = yy_default[S]
+     **
+     ** The (A) formula is preferred.  The B formula is used instead if:
+     **    (1)  The yy_shift_ofst[S]+X value is out of range, or
+     **    (2)  yy_lookahead[yy_shift_ofst[S]+X] is not equal to X, or
+     **    (3)  yy_shift_ofst[S] equal YY_SHIFT_USE_DFLT.
+     ** (Implementation note: YY_SHIFT_USE_DFLT is chosen so that
+     ** YY_SHIFT_USE_DFLT+X will be out of range for all possible lookaheads X.
+     ** Hence only tests (1) and (2) need to be evaluated.)
+     **
+     ** The formulas above are for computing the action when the lookahead is
+     ** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
+     ** a reduce action) then the yy_reduce_ofst[] array is used in place of
+     ** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
+     ** YY_SHIFT_USE_DFLT.
+     **
+     ** The following are the tables generated in this section:
+     **
+     **  yy_action[]        A single table containing all actions.
+     **  yy_lookahead[]     A table containing the lookahead for each entry in
+     **                     yy_action.  Used to detect hash collisions.
+     **  yy_shift_ofst[]    For each state, the offset into yy_action for
+     **                     shifting terminals.
+     **  yy_reduce_ofst[]   For each state, the offset into yy_action for
+     **                     shifting non-terminals after a reduce.
+     **  yy_default[]       Default action for each state.
+     **
+     *********** Begin parsing tables **********************************************/
+    this.yy_action = [
+        /*     0 */
+        61, 6, 27, 2, 30, 11, 34, 35, 5, 10,
+        /*    10 */
+        36, 30, 11, 34, 35, 33, 9, 7, 30, 11,
+        /*    20 */
+        34, 35, 28, 32, 29, 31, 43, 1, 2, 37,
+        /*    30 */
+        42, 41, 38, 8, 4, 3,
+    ];
+    this.yy_lookahead = [
+        /*     0 */
+        15, 16, 4, 2, 19, 20, 21, 22, 16, 11,
+        /*    10 */
+        9, 19, 20, 21, 22, 16, 23, 24, 19, 20,
+        /*    20 */
+        21, 22, 17, 18, 5, 6, 0, 8, 2, 5,
+        /*    30 */
+        25, 13, 5, 10, 12, 7,
+    ];
+    this.YY_SHIFT_USE_DFLT = 36;
+    this.YY_SHIFT_COUNT = 11;
+    this.YY_SHIFT_MIN = -2;
+    this.YY_SHIFT_MAX = 28;
+    this.yy_shift_ofst = [
+        /*     0 */
+        19, 19, 19, -2, 24, 1, 26, 18, 27, 23,
+        /*    10 */
+        22, 28,
+    ];
+    this.YY_REDUCE_USE_DFLT = -16;
+    this.YY_REDUCE_COUNT = 4;
+    this.YY_REDUCE_MIN = -15;
+    this.YY_REDUCE_MAX = 5;
+    this.yy_reduce_ofst = [
+        /*     0 */
+        -15, -8, -1, 5, -7,
+    ];
+    this.yy_default = [
+        /*     0 */
+        60, 60, 60, 60, 57, 60, 60, 60, 60, 56,
+        /*    10 */
+        60, 60,
+    ];
+    /********** End of lemon-generated parsing tables *****************************/
+
+    /* The next table maps tokens (terminal symbols) into fallback tokens.
+     ** If a construct like the following:
+     **
+     **      %fallback ID X Y Z.
+     **
+     ** appears in the grammar, then ID becomes a fallback token for X, Y,
+     ** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
+     ** but it does not parse, the type of the token is changed to ID and
+     ** the parse is retried before an error is thrown.
+     **
+     ** This feature can be used, for example, to cause some keywords in a language
+     ** to revert to identifiers if they keyword does not apply in the context where
+     ** it appears.
+     */
+    this.yyFallback = [];
+
+    /* The following structure represents a single element of the
+     ** parser's stack.  Information stored includes:
+     **
+     **   +  The state number for the parser at this level of the stack.
+     **
+     **   +  The value of the token stored at this level of the stack.
+     **      (In other words, the "major" token.)
+     **
+     **   +  The semantic value stored at this level of the stack.  This is
+     **      the information used by the action routines in the grammar.
+     **      It is sometimes called the "minor" token.
+     **
+     ** After the "shift" half of a SHIFTREDUCE action, the stateno field
+     ** actually contains the reduce action for the second half of the
+     ** SHIFTREDUCE.
+     */
+    //{
+    //  stateno,  /* The state-number, or reduce action in SHIFTREDUCE */
+    //  major,    /* The major token value.  This is the code
+    //            ** number for the token at this stack level */
+    //  minor,    /* The user-supplied minor token value.  This
+    //            ** is the value of the token  */
+    //}
+
+    /* The state of the parser is completely contained in an instance of
+     ** the following structure */
+    this.yyhwm = 0; /* High-water mark of the stack */
+    this.yyerrcnt = -1; /* Shifts left before out of the error */
+    this.yystack = null; /* The parser's stack */
+    this.yyidx = -1; /* Stack index of current element in the stack */
+
+    this.yyTraceCallback = null;
+    this.yyTracePrompt = "";
+
+    /*
+     ** Turn parser tracing on by giving a stream to which to write the trace
+     ** and a prompt to preface each trace message.  Tracing is turned off
+     ** by making either argument NULL
+     **
+     ** Inputs:
+     ** <ul>
+     ** <li> A callback to which trace output should be written.
+     **      If NULL, then tracing is turned off.
+     ** <li> A prefix string written at the beginning of every
+     **      line of trace output. Default is "".
+     ** </ul>
+     **
+     ** Outputs:
+     ** None.
+     */
+    this.setTraceCallback = function(callback, prompt) {
+        this.yyTraceCallback = callback;
+        this.yyTracePrompt = prompt || "";
+    }
+
+    this.trace = function(message) {
+        this.yyTraceCallback(this.yyTracePrompt + message + "\n");
+    }
+
+    /* For tracing shifts, the names of all terminals and nonterminals
+     ** are required.  The following table supplies these names */
+    this.yyTokenName = [
+        "$", "OR", "AND", "NOT",
+        "INTEGER_LITERAL", "STRING_LITERAL", "ID", "EQ",
+        "LCB", "RCB", "COMMA", "ADDRESS",
+        "LSB", "RSB", "error", "main",
+        "expr", "integer", "literal", "string",
+        "id", "eq", "and", "address_literal_content",
+        "address_literal_content_or_empty", "address_literal",
+    ];
+
+    /* For tracing reduce actions, the names of all rules are required.
+     */
+    this.yyRuleName = [
+        /*   0 */
+        "main ::= expr",
+        /*   1 */
+        "integer ::= INTEGER_LITERAL",
+        /*   2 */
+        "literal ::= integer",
+        /*   3 */
+        "string ::= STRING_LITERAL",
+        /*   4 */
+        "id ::= string",
+        /*   5 */
+        "id ::= ID",
+        /*   6 */
+        "eq ::= id EQ literal",
+        /*   7 */
+        "and ::= expr AND expr",
+        /*   8 */
+        "expr ::= eq",
+        /*   9 */
+        "expr ::= and",
+        /*  10 */
+        "expr ::= LCB expr RCB",
+        /*  11 */
+        "address_literal_content ::= STRING_LITERAL",
+        /*  12 */
+        "address_literal_content ::= address_literal_content COMMA STRING_LITERAL",
+        /*  13 */
+        "address_literal_content_or_empty ::= address_literal_content",
+        /*  14 */
+        "address_literal_content_or_empty ::=",
+        /*  15 */
+        "address_literal ::= ADDRESS LSB address_literal_content_or_empty RSB",
+        /*  16 */
+        "literal ::= address_literal",
+    ];
+    /*
+     ** Try to increase the size of the parser stack.  Return the number
+     ** of errors.  Return 0 on success.
+     */
+    this.yyGrowStack = function() {
+        // fix me: yystksz*2 + 100
+        this.yystack.push({
+            stateno: undefined,
+            major: undefined,
+            minor: undefined
+        });
+    }
+
+    /* Initialize a new parser that has already been allocated.
+     */
+    this.init = function() {
+        this.yyhwm = 0;
+        this.yyerrcnt = -1;
+        this.yyidx = 0;
+        if (this.YYSTACKDEPTH <= 0) {
+            this.yystack = [];
+            this.yyGrowStack();
+        } else {
+            this.yystack = new Array(this.YYSTACKDEPTH);
+            for (var i = 0; i < this.YYSTACKDEPTH; i++) {
+                this.yystack[i] = {
+                    stateno: undefined,
+                    major: undefined,
+                    minor: undefined
+                };
+            }
+        }
+        var yytos = this.yystack[0];
+        yytos.stateno = 0;
+        yytos.major = 0;
+    }
+
+    /* The following function deletes the "minor type" or semantic value
+     ** associated with a symbol.  The symbol can be either a terminal
+     ** or nonterminal. "yymajor" is the symbol code, and "yypminor" is
+     ** a pointer to the value to be deleted.  The code used to do the
+     ** deletions is derived from the %destructor and/or %token_destructor
+     ** directives of the input grammar.
+     */
+    this.yy_destructor = function(
+        yymajor, /* Type code for object to destroy */
+        yyminor /* The object to be destroyed */
+    ) {
+        switch (yymajor) {
+            /* Here is inserted the actions which take place when a
+             ** terminal or non-terminal is destroyed.  This can happen
+             ** when the symbol is popped from the stack during a
+             ** reduce or during error processing or when a parser is
+             ** being destroyed before it is finished parsing.
+             **
+             ** Note: during a reduce, the only symbols destroyed are those
+             ** which appear on the RHS of the rule, but which are *not* used
+             ** inside the C code.
+             */
+            /********* Begin destructor definitions ***************************************/
+            /********* End destructor definitions *****************************************/
+            default:
+                break; /* If no destructor action specified: do nothing */
+        }
+    }
+
+    /*
+     ** Pop the parser's stack once.
+     **
+     ** If there is a destructor routine associated with the token which
+     ** is popped from the stack, then call it.
+     */
+    this.yy_pop_parser_stack = function() {
+        // assert( pParser->yytos!=0 );
+        // assert( pParser->yytos > pParser->yystack );
+        var yytos = this.yystack[this.yyidx];
+
+        if (this.yyTraceCallback) {
+            this.trace("Popping " + this.yyTokenName[yytos.major]);
+        }
+        this.yy_destructor(yytos.major, yytos.minor);
+
+        this.yyidx--;
+    }
+
+    /*
+     ** Clear all secondary memory allocations from the parser
+     */
+    this.finalize = function() {
+        while (this.yyidx > 0) {
+            this.yy_pop_parser_stack();
+        }
+        this.yystack = null;
+    }
+
+    /*
+     ** Return the peak depth of the stack for a parser.
+     */
+    this.getStackPeak = function() {
+        return this.yyhwm;
+    }
+
+    /*
+     ** Find the appropriate action for a parser given the terminal
+     ** look-ahead token iLookAhead.
+     */
+    this.yy_find_shift_action = function(
+        iLookAhead /* The look-ahead token */
+    ) {
+        var yytos = this.yystack[this.yyidx];
+        var stateno = yytos.stateno;
+
+        if (stateno >= this.YY_MIN_REDUCE) {
+            return stateno;
+        }
+
+        // assert( stateno <= YY_SHIFT_COUNT );
+
+        do {
+            var i = this.yy_shift_ofst[stateno];
+            // assert( iLookAhead!=YYNOCODE );
+            i += iLookAhead;
+            if (i < 0 || i >= this.yy_action.length || this.yy_lookahead[i] != iLookAhead) {
+                if (this.YYFALLBACK) {
+                    var iFallback; /* Fallback token */
+                    if ((iLookAhead < this.yyFallback.length) &&
+                        (iFallback = this.yyFallback[iLookAhead]) != 0
+                    ) {
+                        if (this.yyTraceCallback) {
+                            this.trace("FALLBACK " + this.yyTokenName[iLookAhead] + " => " + this.yyTokenName[iFallback]);
+                        }
+                    }
+                    // assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
+                    iLookAhead = iFallback;
+                    continue;
+                }
+
+                if (this.YYWILDCARD) {
+                    var j = i - iLookAhead + this.YYWILDCARD;
+                    var cond1 = (this.YY_SHIFT_MIN + this.YYWILDCARD) < 0 ? j >= 0 : true;
+                    var cond2 = (this.YY_SHIFT_MAX + this.YYWILDCARD) >= this.yy_action.length ? j < this.yy_action.length : true;
+                    if (cond1 && cond2 && this.yy_lookahead[j] == this.YYWILDCARD && iLookAhead > 0) {
+                        if (this.yyTraceCallback) {
+                            this.trace("WILDCARD " + this.yyTokenName[iLookAhead] + " => " + this.yyTokenName[this.YYWILDCARD]);
+                        }
+                        return this.yy_action[j];
+                    }
+                }
+
+                return this.yy_default[stateno];
+            } else {
+                return this.yy_action[i];
+            }
+        } while (true);
+    }
+
+    /*
+     ** Find the appropriate action for a parser given the non-terminal
+     ** look-ahead token iLookAhead.
+     */
+    this.yy_find_reduce_action = function(
+        stateno, /* Current state number */
+        iLookAhead /* The look-ahead token */
+    ) {
+        if (this.YYERRORSYMBOL) {
+            if (stateno > this.YY_REDUCE_COUNT) {
+                return this.yy_default[stateno];
+            }
+        } else {
+            // assert( stateno<=YY_REDUCE_COUNT );
+        }
+
+        var i = this.yy_reduce_ofst[stateno];
+        // assert( i!=YY_REDUCE_USE_DFLT );
+        // assert( iLookAhead!=YYNOCODE );
+        i += iLookAhead;
+
+        if (this.YYERRORSYMBOL) {
+            if (i < 0 || i >= this.yy_action.length || this.yy_lookahead[i] != iLookAhead) {
+                return this.yy_default[stateno];
+            }
+        } else {
+            // assert( i>=0 && i<YY_ACTTAB_COUNT );
+            // assert( yy_lookahead[i]==iLookAhead );
+        }
+
+        return this.yy_action[i];
+    }
+
+    /*
+     ** The following routine is called if the stack overflows.
+     */
+    this.yyStackOverflow = function() {
+        if (this.yyTraceCallback) {
+            this.trace("Stack Overflow!");
+        }
+
+        while (this.yyidx > 0) {
+            this.yy_pop_parser_stack();
+        }
+        /* Here code is inserted which will execute if the parser
+         ** stack every overflows */
+        /******** Begin %stack_overflow code ******************************************/
+        /******** End %stack_overflow code ********************************************/
+    }
+
+    /*
+     ** Print tracing information for a SHIFT action
+     */
+    this.yyTraceShift = function(yyNewState) {
+        if (this.yyTraceCallback) {
+            var yytos = this.yystack[this.yyidx];
+            if (yyNewState < this.YYNSTATE) {
+                this.trace("Shift '" + this.yyTokenName[yytos.major] + "', go to state " + yyNewState);
+            } else {
+                this.trace("Shift '" + this.yyTokenName[yytos.major] + "'");
+            }
+        }
+    }
+
+    /*
+     ** Perform a shift action.
+     */
+    this.yy_shift = function(
+        yyNewState, /* The new state to shift in */
+        yyMajor, /* The major token to shift in */
+        yyMinor /* The minor token to shift in */
+    ) {
+        this.yyidx++;
+
+        if (this.yyidx > this.yyhwm) {
+            this.yyhwm++;
+            // assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
+        }
+
+        if (this.YYSTACKDEPTH > 0) {
+            if (this.yyidx >= this.YYSTACKDEPTH) {
+                this.yyidx--;
+                this.yyStackOverflow();
+                return;
+            }
+        } else {
+            if (this.yyidx >= this.yystack.length) {
+                this.yyGrowStack();
+            }
+        }
+
+        if (yyNewState > this.YY_MAX_SHIFT) {
+            yyNewState += this.YY_MIN_REDUCE - this.YY_MIN_SHIFTREDUCE;
+        }
+
+        var yytos = this.yystack[this.yyidx];
+        yytos.stateno = yyNewState;
+        yytos.major = yyMajor;
+        yytos.minor = yyMinor;
+
+        this.yyTraceShift(yyNewState);
+    }
+
+    /* The following table contains information about every rule that
+     ** is used during the reduce.
+     */
+    //{
+    //  lhs,      /* Symbol on the left-hand side of the rule */
+    //  nrhs,     /* Number of right-hand side symbols in the rule */
+    //}
+    this.yyRuleInfo = [{
+            lhs: 15,
+            nrhs: 1
+        },
+        {
+            lhs: 17,
+            nrhs: 1
+        },
+        {
+            lhs: 18,
+            nrhs: 1
+        },
+        {
+            lhs: 19,
+            nrhs: 1
+        },
+        {
+            lhs: 20,
+            nrhs: 1
+        },
+        {
+            lhs: 20,
+            nrhs: 1
+        },
+        {
+            lhs: 21,
+            nrhs: 3
+        },
+        {
+            lhs: 22,
+            nrhs: 3
+        },
+        {
+            lhs: 16,
+            nrhs: 1
+        },
+        {
+            lhs: 16,
+            nrhs: 1
+        },
+        {
+            lhs: 16,
+            nrhs: 3
+        },
+        {
+            lhs: 23,
+            nrhs: 1
+        },
+        {
+            lhs: 23,
+            nrhs: 3
+        },
+        {
+            lhs: 24,
+            nrhs: 1
+        },
+        {
+            lhs: 24,
+            nrhs: 0
+        },
+        {
+            lhs: 25,
+            nrhs: 4
+        },
+        {
+            lhs: 18,
+            nrhs: 1
+        },
+    ];
+
+    /*
+     ** Perform a reduce action and the shift that must immediately
+     ** follow the reduce.
+     */
+    this.yy_reduce = function(
+        yyruleno /* Number of the rule by which to reduce */
+    ) {
+        var yymsp = this.yystack[this.yyidx]; /* The top of the parser's stack */
+
+        if (yyruleno < this.yyRuleName.length) {
+            var yysize = this.yyRuleInfo[yyruleno].nrhs;
+            var ruleName = this.yyRuleName[yyruleno];
+            var newStateNo = this.yystack[this.yyidx - yysize].stateno;
+            if (this.yyTraceCallback) {
+                this.trace("Reduce [" + ruleName + "], go to state " + newStateNo + ".");
+            }
+        }
+
+        /* Check that the stack is large enough to grow by a single entry
+         ** if the RHS of the rule is empty.  This ensures that there is room
+         ** enough on the stack to push the LHS value */
+        if (this.yyRuleInfo[yyruleno].nrhs == 0) {
+            if (this.yyidx > this.yyhwm) {
+                this.yyhwm++;
+                // assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack));
+            }
+            if (this.YYSTACKDEPTH > 0) {
+                if (this.yyidx >= this.YYSTACKDEPTH - 1) {
+                    this.yyStackOverflow();
+                    return;
+                }
+            } else {
+                if (this.yyidx >= this.yystack.length - 1) {
+                    this.yyGrowStack();
+                    yymsp = this.yystack[this.yyidx];
+                }
+            }
+        }
+
+        var yylhsminor;
+        switch (yyruleno) {
+            /* Beginning here are the reduction cases.  A typical example
+             ** follows:
+             **   case 0:
+             **  #line <lineno> <grammarfile>
+             **     { ... }           // User supplied code
+             **  #line <lineno> <thisfile>
+             **     break;
+             */
+            /********** Begin reduce actions **********************************************/
+            case 0:
+                /* main ::= expr */ {
+                    _result.root_node = this.yystack[this.yyidx + 0].minor
+                }
+                break;
+            case 1:
+                /* integer ::= INTEGER_LITERAL */ {
+                    yylhsminor = new Node({
+                        type: "INTEGER_LITERAL",
+                        lexeme: this.yystack[this.yyidx + 0].minor.lexeme,
+                        start: this.yystack[this.yyidx + 0].minor.start,
+                        end: this.yystack[this.yyidx + 0].minor.end
+                    })
+                }
+                this.yystack[this.yyidx + 0].minor = yylhsminor;
+                break;
+            case 2:
+                /* literal ::= integer */ {
+                    yylhsminor = new Node({
+                        type: "literal",
+                        children: [this.yystack[this.yyidx + 0].minor]
+                    })
+                }
+                this.yystack[this.yyidx + 0].minor = yylhsminor;
+                break;
+            case 3:
+                /* string ::= STRING_LITERAL */ {
+                    yylhsminor = new Node({
+                        type: "STRING_LITERAL",
+                        lexeme: this.yystack[this.yyidx + 0].minor.lexeme,
+                        start: this.yystack[this.yyidx + 0].minor.start,
+                        end: this.yystack[this.yyidx + 0].minor.end
+                    })
+                }
+                this.yystack[this.yyidx + 0].minor = yylhsminor;
+                break;
+            case 4:
+                /* id ::= string */ {
+                    yylhsminor = new Node({
+                        type: "id",
+                        children: [this.yystack[this.yyidx + 0].minor]
+                    });
+                }
+                this.yystack[this.yyidx + 0].minor = yylhsminor;
+                break;
+            case 5:
+                /* id ::= ID */ {
+                    yylhsminor = new Node({
+                        type: "ID",
+                        lexeme: this.yystack[this.yyidx + 0].minor.lexeme,
+                        start: this.yystack[this.yyidx + 0].minor.start,
+                        end: this.yystack[this.yyidx + 0].minor.end
+                    })
+                }
+                this.yystack[this.yyidx + 0].minor = yylhsminor;
+                break;
+            case 6:
+                /* eq ::= id EQ literal */ {
+                    yylhsminor = new Node({
+                        type: "eq",
+                        children: [
+                            this.yystack[this.yyidx + -2].minor,
+                            new Node({
+                                type: "EQ",
+                                lexeme: this.yystack[this.yyidx + -1].minor.lexeme,
+                                start: this.yystack[this.yyidx + -1].minor.start,
+                                end: this.yystack[this.yyidx + -1].minor.end
+                            }),
+                            this.yystack[this.yyidx + 0].minor
+                        ]
+                    })
+                }
+                this.yystack[this.yyidx + -2].minor = yylhsminor;
+                break;
+            case 7:
+                /* and ::= expr AND expr */ {
+                    yylhsminor = new Node({
+                        type: "and",
+                        children: [
+                            this.yystack[this.yyidx + -2].minor,
+                            this.yystack[this.yyidx + 0].minor
+                        ]
+                    })
+                }
+                this.yystack[this.yyidx + -2].minor = yylhsminor;
+                break;
+            case 8:
+                /* expr ::= eq */ {
+                    yylhsminor = new Node({
+                        type: "expr",
+                        children: [this.yystack[this.yyidx + 0].minor]
+                    })
+                }
+                this.yystack[this.yyidx + 0].minor = yylhsminor;
+                break;
+            case 9:
+                /* expr ::= and */
+            case 13:
+                /* address_literal_content_or_empty ::= address_literal_content */ this.yytestcase(yyruleno == 13); {
+                    yylhsminor = this.yystack[this.yyidx + 0].minor;
+                }
+                this.yystack[this.yyidx + 0].minor = yylhsminor;
+                break;
+            case 10:
+                /* expr ::= LCB expr RCB */ {
+                    this.yystack[this.yyidx + -2].minor = this.yystack[this.yyidx + -1].minor;
+                }
+                break;
+            case 11:
+                /* address_literal_content ::= STRING_LITERAL */ {
+                    yylhsminor = new Node({
+                        children: [
+                            new Node({
+                                type: "STRING_LITERAL",
+                                lexeme: this.yystack[this.yyidx + 0].minor.lexeme,
+                                start: this.yystack[this.yyidx + 0].minor.start,
+                                end: this.yystack[this.yyidx + 0].minor.end
+                            })
+                        ]
+                    });
+                }
+                this.yystack[this.yyidx + 0].minor = yylhsminor;
+                break;
+            case 12:
+                /* address_literal_content ::= address_literal_content COMMA STRING_LITERAL */ {
+                    this.yystack[this.yyidx + -2].minor.add(new Node({
+                        type: "STRING_LITERAL",
+                        lexeme: this.yystack[this.yyidx + 0].minor.lexeme,
+                        start: this.yystack[this.yyidx + 0].minor.start,
+                        end: this.yystack[this.yyidx + 0].minor.end
+                    }));
+                    yylhsminor = this.yystack[this.yyidx + -2].minor;
+                }
+                this.yystack[this.yyidx + -2].minor = yylhsminor;
+                break;
+            case 14:
+                /* address_literal_content_or_empty ::= */ {
+                    this.yystack[this.yyidx + 1].minor = new Node({
+                        type: "address_literal_content"
+                    });
+                }
+                break;
+            case 15:
+                /* address_literal ::= ADDRESS LSB address_literal_content_or_empty RSB */ {
+                    this.yystack[this.yyidx + -3].minor = new Node({
+                        type: "address_literal",
+                        children: this.yystack[this.yyidx + -1].minor.children
+                    });
+                }
+                break;
+            case 16:
+                /* literal ::= address_literal */ {
+                    yylhsminor = new Node({
+                        type: "literal",
+                        children: [this.yystack[this.yyidx + 0].minor]
+                    });
+                }
+                this.yystack[this.yyidx + 0].minor = yylhsminor;
+                break;
+            default:
+                break;
+                /********** End reduce actions ************************************************/
+        };
+        // assert( yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );
+
+        var yygoto = this.yyRuleInfo[yyruleno].lhs; /* The next state */
+        var yysize = this.yyRuleInfo[yyruleno].nrhs; /* Amount to pop the stack */
+        var yyact = this.yy_find_reduce_action( /* The next action */
+            this.yystack[this.yyidx - yysize].stateno,
+            yygoto
+        );
+        if (yyact <= this.YY_MAX_SHIFTREDUCE) {
+            if (yyact > this.YY_MAX_SHIFT) {
+                yyact += this.YY_MIN_REDUCE - this.YY_MIN_SHIFTREDUCE;
+            }
+            this.yyidx -= yysize - 1;
+            yymsp = this.yystack[this.yyidx];
+            yymsp.stateno = yyact;
+            yymsp.major = yygoto;
+            this.yyTraceShift(yyact);
+        } else {
+            // assert( yyact == YY_ACCEPT_ACTION );
+            this.yyidx -= yysize;
+            this.yy_accept();
+        }
+    }
+
+    /*
+     ** The following code executes when the parse fails
+     */
+    this.yy_parse_failed = function() {
+        if (this.yyTraceCallback) {
+            this.trace("Fail!");
+        }
+        while (this.yyidx > 0) {
+            this.yy_pop_parser_stack();
+        }
+        /* Here code is inserted which will be executed whenever the
+         ** parser fails */
+        /************ Begin %parse_failure code ***************************************/
+        /************ End %parse_failure code *****************************************/
+    }
+
+    /*
+     ** The following code executes when a syntax error first occurs.
+     */
+    this.yy_syntax_error = function(
+        yymajor, /* The major type of the error token */
+        yyminor /* The minor type of the error token */
+    ) {
+        var TOKEN = yyminor;
+        /************ Begin %syntax_error code ****************************************/
+
+        console.log("Syntax error");
+        /************ End %syntax_error code ******************************************/
+    }
+
+    /*
+     ** The following is executed when the parser accepts
+     */
+    this.yy_accept = function() {
+        if (this.yyTraceCallback) {
+            this.trace("Accept!");
+        }
+        if (!this.YYNOERRORRECOVERY) {
+            this.yyerrcnt = -1;
+        }
+        // assert( yypParser->yytos==yypParser->yystack );
+        /* Here code is inserted which will be executed whenever the
+         ** parser accepts */
+        /*********** Begin %parse_accept code *****************************************/
+        /*********** End %parse_accept code *******************************************/
+    }
+
+    /* The main parser program.
+     ** The first argument is a pointer to a structure obtained from
+     ** "ParserAlloc" which describes the current state of the parser.
+     ** The second argument is the major token number.  The third is
+     ** the minor token.  The fourth optional argument is whatever the
+     ** user wants (and specified in the grammar) and is available for
+     ** use by the action routines.
+     **
+     ** Inputs:
+     ** <ul>
+     ** <li> A pointer to the parser (an opaque structure.)
+     ** <li> The major token number.
+     ** <li> The minor token number.
+     ** <li> An option argument of a grammar-specified type.
+     ** </ul>
+     **
+     ** Outputs:
+     ** None.
+     */
+    this.parse = function(
+        yymajor, /* The major token code number */
+        yyminor /* The value for the token */
+    ) {
+        var yyact; /* The parser action. */
+        var yyendofinput; /* True if we are at the end of input */
+        var yyerrorhit = 0; /* True if yymajor has invoked an error */
+
+        //assert( yypParser->yytos!=0 );
+
+        if (yymajor === undefined || yymajor === null) {
+            yymajor = 0;
+        }
+
+        yyendofinput = yymajor == 0;
+
+        if (this.yyTraceCallback) {
+            this.trace("Input '" + this.yyTokenName[yymajor] + "'");
+        }
+
+        do {
+            yyact = this.yy_find_shift_action(yymajor);
+            if (yyact <= this.YY_MAX_SHIFTREDUCE) { // check me?
+                this.yy_shift(yyact, yymajor, yyminor);
+                if (!this.YYNOERRORRECOVERY) {
+                    this.yyerrcnt--;
+                }
+                yymajor = this.YYNOCODE;
+            } else if (yyact <= this.YY_MAX_REDUCE) { // check me?
+                this.yy_reduce(yyact - this.YY_MIN_REDUCE); // check me?
+            } else {
+                // assert( yyact == YY_ERROR_ACTION );
+                if (this.yyTraceCallback) {
+                    this.trace("Syntax Error!");
+                }
+                if (this.YYERRORSYMBOL) {
+                    /* A syntax error has occurred.
+                     ** The response to an error depends upon whether or not the
+                     ** grammar defines an error token "ERROR".
+                     **
+                     ** This is what we do if the grammar does define ERROR:
+                     **
+                     **  * Call the %syntax_error function.
+                     **
+                     **  * Begin popping the stack until we enter a state where
+                     **    it is legal to shift the error symbol, then shift
+                     **    the error symbol.
+                     **
+                     **  * Set the error count to three.
+                     **
+                     **  * Begin accepting and shifting new tokens.  No new error
+                     **    processing will occur until three tokens have been
+                     **    shifted successfully.
+                     **
+                     */
+                    if (this.yyerrcnt < 0) {
+                        this.yy_syntax_error(yymajor, yyminor);
+                    }
+                    var yymx = this.yystack[this.yyidx].major;
+                    if (yymx == this.YYERRORSYMBOL || yyerrorhit) {
+                        if (this.yyTraceCallback) {
+                            this.trace("Discard input token " + this.yyTokenName[yymajor]);
+                        }
+                        this.yy_destructor(yymajor, yyminor);
+                        yymajor = this.YYNOCODE;
+                    } else {
+                        while (this.yyidx >= 0 &&
+                            yymx != this.YYERRORSYMBOL &&
+                            (yyact = this.yy_find_reduce_action(
+                                this.yystack[this.yyidx].stateno,
+                                this.YYERRORSYMBOL)) >= this.YY_MIN_REDUCE // check me?
+                        ) {
+                            this.yy_pop_parser_stack();
+                        }
+                        if (this.yyidx < 0 || yymajor == 0) {
+                            this.yy_destructor(yymajor, yyminor);
+                            this.yy_parse_failed();
+                            if (!this.YYNOERRORRECOVERY) {
+                                this.yyerrcnt = -1;
+                            }
+                            yymajor = this.YYNOCODE;
+                        } else if (yymx != this.YYERRORSYMBOL) {
+                            this.yy_shift(yyact, this.YYERRORSYMBOL, yyminor); // check me?
+                        }
+                    }
+                    this.yyerrcnt = 3;
+                    yyerrorhit = 1;
+                } else if (this.YYNOERRORRECOVERY) {
+                    /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
+                     ** do any kind of error recovery.  Instead, simply invoke the syntax
+                     ** error routine and continue going as if nothing had happened.
+                     **
+                     ** Applications can set this macro (for example inside %include) if
+                     ** they intend to abandon the parse upon the first syntax error seen.
+                     */
+                    this.yy_syntax_error(yymajor, yyminor);
+                    this.yy_destructor(yymajor, yyminor);
+                    yymajor = this.YYNOCODE;
+                } else {
+                    /* YYERRORSYMBOL is not defined */
+                    /* This is what we do if the grammar does not define ERROR:
+                     **
+                     **  * Report an error message, and throw away the input token.
+                     **
+                     **  * If the input token is $, then fail the parse.
+                     **
+                     ** As before, subsequent error messages are suppressed until
+                     ** three input tokens have been successfully shifted.
+                     */
+                    if (this.yyerrcnt <= 0) {
+                        this.yy_syntax_error(yymajor, yyminor);
+                    }
+                    this.yyerrcnt = 3;
+                    this.yy_destructor(yymajor, yyminor);
+                    if (yyendofinput) {
+                        this.yy_parse_failed();
+                        if (!this.YYNOERRORRECOVERY) {
+                            this.yyerrcnt = -1;
+                        }
+                    }
+                    yymajor = this.YYNOCODE;
+                }
+            }
+        } while (yymajor != this.YYNOCODE && this.yyidx > 0);
+
+        if (this.yyTraceCallback) {
+            var remainingTokens = [];
+            for (var i = 1; i <= this.yyidx; i++) {
+                remainingTokens.push(this.yyTokenName[this.yystack[i].major]);
+            }
+            this.trace("Return. Stack=[" + remainingTokens.join(" ") + "]");
+        }
+    }
+
+    this.init();
+
+} // function Parser()
+
+/**
+ * Created by Aleksey Chichenkov <a.chichenkov@initi.ru> on 1/28/19.
+ */
+
+var Lexer = require('./lexer.js');
+
+var Node = function(_options) {
+    this.type = _options.type || "none";
+    this.children = _options.children || [];
+    this.lexeme = _options.lexeme || null;
+    this.start = _options.start || 0;
+    this.end = _options.end || 0;
+};
+
+Node.prototype = {
+    add: function(_node) {
+        this.children.push(_node);
+    }
+};
+
+var _result = {};
+
+var LemonJS = function(_input) {
+
+    var parser = new Parser();
+    // var lexer = new Lexer("abc == 1 and abc1 == 2 and (bbc == 5)");
+    var lexer = new Lexer(_input);
+
+    var token;
+    while (token = lexer.next()) {
+        console.log("PARSE", token.lexeme);
+        parser.parse(parser["TOKEN_" + token.lexeme], token);
+    }
+    parser.parse();
+    return _result;
+};
+
+var fs = require("fs");
+
+fs.mkdirSync("tests");
+
+var test_and = LemonJS("abc == 1 and abc1 == 2 and (bbc == 5)");
+fs.writeFileSync("tests/out_test_and.json", JSON.stringify(test_and, true, 3));
+
+var test_address = LemonJS('abc == Address ["a", "b", "c"]');
+fs.writeFileSync("tests/out_tree_address.json", JSON.stringify(test_address, true, 3));
\ No newline at end of file
diff --git a/parsers/filters/parser.out b/parsers/filters/parser.out
new file mode 100644
index 0000000..ee9bc1b
--- /dev/null
+++ b/parsers/filters/parser.out
@@ -0,0 +1,155 @@
+State 0:
+          main ::= * expr
+          string ::= * STRING_LITERAL
+          id ::= * string
+          id ::= * ID
+          eq ::= * id EQ literal
+          and ::= * expr AND expr
+          expr ::= * eq
+          expr ::= * and
+          expr ::= * LCB expr RCB
+
+                STRING_LITERAL shift-reduce 3      string ::= STRING_LITERAL
+                            ID shift-reduce 5      id ::= ID
+                           LCB shift        1      
+                          main accept
+                          expr shift        6      
+                        string shift-reduce 4      id ::= string
+                            id shift        11     
+                            eq shift-reduce 8      expr ::= eq
+                           and shift-reduce 9      expr ::= and
+
+State 1:
+          string ::= * STRING_LITERAL
+          id ::= * string
+          id ::= * ID
+          eq ::= * id EQ literal
+          and ::= * expr AND expr
+          expr ::= * eq
+          expr ::= * and
+          expr ::= * LCB expr RCB
+          expr ::= LCB * expr RCB
+
+                STRING_LITERAL shift-reduce 3      string ::= STRING_LITERAL
+                            ID shift-reduce 5      id ::= ID
+                           LCB shift        1      
+                          expr shift        5      
+                        string shift-reduce 4      id ::= string
+                            id shift        11     
+                            eq shift-reduce 8      expr ::= eq
+                           and shift-reduce 9      expr ::= and
+
+State 2:
+          string ::= * STRING_LITERAL
+          id ::= * string
+          id ::= * ID
+          eq ::= * id EQ literal
+          and ::= * expr AND expr
+          and ::= expr AND * expr
+          expr ::= * eq
+          expr ::= * and
+          expr ::= * LCB expr RCB
+
+                STRING_LITERAL shift-reduce 3      string ::= STRING_LITERAL
+                            ID shift-reduce 5      id ::= ID
+                           LCB shift        1      
+                          expr shift-reduce 7      and ::= expr AND expr
+                        string shift-reduce 4      id ::= string
+                            id shift        11     
+                            eq shift-reduce 8      expr ::= eq
+                           and shift-reduce 9      expr ::= and
+
+State 3:
+          integer ::= * INTEGER_LITERAL
+          literal ::= * integer
+          eq ::= id EQ * literal
+          address_literal ::= * ADDRESS LSB address_literal_content_or_empty RSB
+          literal ::= * address_literal
+
+               INTEGER_LITERAL shift-reduce 1      integer ::= INTEGER_LITERAL
+                       ADDRESS shift        10     
+                       integer shift-reduce 2      literal ::= integer
+                       literal shift-reduce 6      eq ::= id EQ literal
+               address_literal shift-reduce 16     literal ::= address_literal
+
+State 4:
+          address_literal_content ::= * STRING_LITERAL
+          address_literal_content ::= * address_literal_content COMMA STRING_LITERAL
+          address_literal_content_or_empty ::= * address_literal_content
+     (14) address_literal_content_or_empty ::= *
+          address_literal ::= ADDRESS LSB * address_literal_content_or_empty RSB
+
+                STRING_LITERAL shift-reduce 11     address_literal_content ::= STRING_LITERAL
+       address_literal_content shift        9      
+address_literal_content_or_empty shift        7      
+                     {default} reduce       14     address_literal_content_or_empty ::=
+
+State 5:
+          and ::= expr * AND expr
+          expr ::= LCB expr * RCB
+
+                           AND shift        2      
+                           RCB shift-reduce 10     expr ::= LCB expr RCB
+
+State 6:
+      (0) main ::= expr *
+          and ::= expr * AND expr
+
+                             $ reduce       0      main ::= expr
+                           AND shift        2      
+
+State 7:
+          address_literal ::= ADDRESS LSB address_literal_content_or_empty * RSB
+
+                           RSB shift-reduce 15     address_literal ::= ADDRESS LSB address_literal_content_or_empty RSB
+
+State 8:
+          address_literal_content ::= address_literal_content COMMA * STRING_LITERAL
+
+                STRING_LITERAL shift-reduce 12     address_literal_content ::= address_literal_content COMMA STRING_LITERAL
+
+State 9:
+          address_literal_content ::= address_literal_content * COMMA STRING_LITERAL
+     (13) address_literal_content_or_empty ::= address_literal_content *
+
+                         COMMA shift        8      
+                     {default} reduce       13     address_literal_content_or_empty ::= address_literal_content
+
+State 10:
+          address_literal ::= ADDRESS * LSB address_literal_content_or_empty RSB
+
+                           LSB shift        4      
+
+State 11:
+          eq ::= id * EQ literal
+
+                            EQ shift        3      
+
+----------------------------------------------------
+Symbols:
+    0: $:
+    1: OR
+    2: AND
+    3: NOT
+    4: INTEGER_LITERAL
+    5: STRING_LITERAL
+    6: ID
+    7: EQ
+    8: LCB
+    9: RCB
+   10: COMMA
+   11: ADDRESS
+   12: LSB
+   13: RSB
+   14: error:
+   15: main: STRING_LITERAL ID LCB
+   16: expr: STRING_LITERAL ID LCB
+   17: integer: INTEGER_LITERAL
+   18: literal: INTEGER_LITERAL ADDRESS
+   19: string: STRING_LITERAL
+   20: id: STRING_LITERAL ID
+   21: eq: STRING_LITERAL ID
+   22: and: STRING_LITERAL ID LCB
+   23: address_literal_content: STRING_LITERAL
+   24: address_literal_content_or_empty: <lambda> STRING_LITERAL
+   25: address_literal: ADDRESS
diff --git a/parsers/filters/parser.y b/parsers/filters/parser.y
new file mode 100644
index 0000000..407c569
--- /dev/null
+++ b/parsers/filters/parser.y
@@ -0,0 +1,152 @@
+%name Parser
+
+%token_prefix TOKEN_
+
+%left OR.
+%left AND.
+%right NOT.
+
+%include {
+    // include something
+}
+
+%code {
+    &&REPLACER{process.js}&&
+}
+
+%syntax_error {
+    console.log("Syntax error");
+}
+
+main ::= expr(A) . {
+     _result.root_node = A
+}
+
+integer(A) ::= INTEGER_LITERAL(B) . {
+    A = new Node({
+        type: "INTEGER_LITERAL",
+        lexeme: B.lexeme,
+        start: B.start,
+        end: B.end
+    })
+}
+
+literal(A) ::= integer(B) . {
+    A = new Node({
+        type: "literal",
+        children: [B]
+    })
+}
+
+string(A) ::= STRING_LITERAL(B) . {
+    A = new Node({
+        type: "STRING_LITERAL",
+        lexeme: B.lexeme,
+        start: B.start,
+        end: B.end
+    })
+}
+
+id(A) ::= string(B) . {
+    A = new Node({
+        type: "id",
+        children: [B]
+    });
+}
+
+id(A) ::= ID(B) . {
+    A = new Node({
+        type: "ID",
+        lexeme: B.lexeme,
+        start: B.start,
+        end: B.end
+    })
+}
+
+eq(A) ::= id(B) EQ(C) literal(D) . {
+    A = new Node({
+        type: "eq",
+        children: [
+            B,
+            new Node({
+                type: "EQ",
+                lexeme: C.lexeme,
+                start: C.start,
+                end: C.end
+            }),
+            D
+        ]
+    })
+}
+
+and(A) ::= expr(B) AND expr(D) . {
+    A = new Node({
+        type: "and",
+        children: [
+            B,
+            D
+        ]
+    })
+}
+
+expr(A) ::= eq(B) . {
+    A = new Node({
+        type: "expr",
+        children: [B]
+    })
+}
+
+expr(A) ::= and(B) . {
+    A = B;
+}
+
+expr(A) ::= LCB expr(C) RCB . {
+    A = C;
+}
+
+address_literal_content(A) ::= STRING_LITERAL(B) . {
+    A = new Node({
+        children: [
+            new Node({
+                type: "STRING_LITERAL",
+                lexeme: B.lexeme,
+                start: B.start,
+                end: B.end
+            })
+        ]
+    });
+}
+
+address_literal_content(A) ::= address_literal_content(B) COMMA STRING_LITERAL(C) . {
+    B.add(new Node({
+        type: "STRING_LITERAL",
+        lexeme: C.lexeme,
+        start: C.start,
+        end: C.end
+    }));
+    A = B;
+}
+
+address_literal_content_or_empty(A) ::= address_literal_content(B) . {
+    A = B;
+}
+
+address_literal_content_or_empty(A) ::= . {
+    A = new Node({
+        type: "address_literal_content"
+    });
+}
+
+address_literal(A) ::= ADDRESS LSB address_literal_content_or_empty(C) RSB . {
+    A = new Node({
+        type: "address_literal",
+        children: C.children
+    });
+}
+
+literal(A) ::= address_literal(B) . {
+    A = new Node({
+        type: "literal",
+        children: [B]
+    });
+}
diff --git a/process.js b/process.js
new file mode 100644
index 0000000..b1dea3f
--- /dev/null
+++ b/process.js
@@ -0,0 +1,370 @@
+/**
+ * Created by Aleksey Chichenkov <a.chichenkov@initi.ru> on 1/28/19.
+ */
+
+var fs = require("fs");
+var Lexer = require('./lexer.js');
+
+var tokens = (function () {
+
+    var std = (function () {
+        var protos = "__protos__";
+        var keys = "__keys__";
+
+
+        /**
+         * Return unique data
+         *
+         * @param {Object[]} _arr - prototypes of inheritance classes
+         * @param {Object} _main - prototype of resulting class
+         *
+         * @return {Object}
+         * */
+        var unique = function (_arr, _main) {
+            var result = Object.create(null);
+            var to_remove = [];
+
+            for (var i = 0, e = _arr.length; i != e; ++i) {
+                var item = _arr[i];
+
+                for (var key in item) {
+                    if (key in result) {
+                        to_remove.push(key);
+                        continue;
+                    }
+
+                    result[key] = item[key];
+                }
+
+                if (keys in item) {
+                    for (var ii = 0, ee = item[keys].length; ii != ee; ++ii) {
+                        var key = item[keys][ii];
+                        if (key in result) {
+                            to_remove.push(key);
+                            continue;
+                        }
+
+                        result[key] = item[key];
+                    }
+                }
+            }
+
+            for (var i = 0; i != to_remove.length; ++i) {
+                delete result[to_remove[i]];
+            }
+
+            for (var key in _main) {
+                result[key] = _main[key];
+            }
+
+            return result;
+        };
+
+        /**
+         * Create OOP class
+         *
+         * @param {Function[]} _constrs - inheritance classes
+         * @param {Object} _proto - prototype of resulting class
+         * @param {Object?} _static - static data
+         *
+         * @return {Function}
+         * */
+        var class_creator = function (_constrs, _proto, _static) {
+            _constrs = _constrs || [];
+            _proto = _proto || [];
+            _static = _static || [];
+
+            var constr;
+            if (_proto && _proto.hasOwnProperty("constructor")) {
+                constr = _proto.constructor;
+                delete _proto.constructor;
+            } else {
+                constr = function () {
+                    for (var i = 0; i != _constrs.length; ++i) {
+                        _constrs[i].apply(this, arguments);
+                    }
+                };
+            }
+
+            var proto = Object.create(null);
+            Object.defineProperty(proto, protos, {
+                "value": []
+            });
+            Object.defineProperty(proto, keys, {
+                "value": []
+            });
+
+            /************************FOR MEMBERS*******************************/
+            for (var i = 0, e = _constrs.length; i != e; ++i) {
+                proto[protos].push(_constrs[i].prototype);
+            }
+
+            var m_un = unique(proto[protos], _proto);
+            for (var key in m_un) {
+                proto[keys].push(key);
+
+                Object.defineProperty(proto, key, {
+                    "value": m_un[key]
+                });
+            }
+            /************************FOR MEMBERS END***************************/
+
+            /************************FOR STATICS*******************************/
+            var s_un = unique(_constrs, _static);
+            for (var key in s_un) {
+                Object.defineProperty(constr, key, {
+                    "value": s_un[key],
+                    "enumerable": true
+                });
+            }
+            /************************FOR STATICS END***************************/
+
+
+            Object.defineProperties(constr, {
+                "pr": {
+                    "value": proto
+                },
+                "prototype": {
+                    "value": proto
+                }
+            });
+
+            Object.freeze(proto);
+            Object.freeze(constr);
+
+            return constr;
+        };
+
+        /**
+         * Check if target has prototype
+         *
+         * @param {Object} _target - checkable instance
+         * @param {Object} _proto - posible prototype
+         *
+         * */
+        var check = function (_target, _proto) {
+            for (var i = 0; i != _target[protos].length; ++i) {
+                var t_proto = _target[protos][i];
+                if (t_proto == _proto) {
+                    return true;
+                }
+
+                if (t_proto[protos]) {
+                    if (check(t_proto, _proto))
+                        return true;
+                }
+            }
+
+            return false;
+        };
+
+        /**
+         * Check if target is instance of class
+         *
+         * @param {Object} _target - checkable instance
+         * @param {Function} _constr - posible constructor
+         *
+         * */
+        var class_check = function (_target, _constr) {
+            if (_target instanceof _constr) {
+                return true;
+            }
+
+            return check(_target, _constr.prototype);
+        };
+
+        return {
+            class: class_creator,
+            class_check: class_check
+        };
+    })();
+    var tools = {
+        merge: function (_obj) {
+            var target = Object.create(null);
+            var i = 0, e = arguments.length;
+            for (; i != e; ++i) {
+                var options = arguments[i];
+
+                for (var key in options) {
+                    if (options[key] === undefined && target === options[key])
+                        continue;
+
+                    target[key] = options[key];
+                }
+            }
+
+            return target;
+        }
+    };
+
+    var Node = std.class([], {
+        constructor: function Node(_options) {
+            var base = tools.merge({
+                children: []
+            }, _options);
+
+            this.children = base.children;
+        },
+        add: function (_n) {
+            this.children.push(_n);
+            return this;
+        }
+    });
+
+    var Lexeme = std.class([Node], {
+        constructor: function Lexeme(_options) {
+            var base = tools.merge({
+                start: -1,
+                end: -1,
+                type: null,
+                value: null
+            }, _options);
+
+            Node.call(this, base);
+
+            this.start = base.start;
+            this.end = base.end;
+            this.type = base.type;
+            this.value = base.value;
+        }
+    });
+
+    var Rule = std.class([Node], {
+        constructor: function NonTerminal(_options) {
+            var base = tools.merge({}, _options);
+
+            Node.call(this, base);
+        }
+    });
+
+    var string_literal = std.class([Rule], {
+        constructor: function string_literal(_options) {
+            var base = tools.merge({}, _options);
+
+            Rule.call(this, base);
+        }
+    });
+
+
+    var integer_literal = std.class([Rule], {
+        constructor: function integer_literal(_options) {
+            var base = tools.merge({}, _options);
+
+            Rule.call(this, base);
+        }
+    });
+
+    var id = std.class([Rule], {
+        constructor: function id(_options) {
+            var base = tools.merge({}, _options);
+
+            Rule.call(this, base);
+        }
+    });
+
+    var literal = std.class([Rule], {
+        constructor: function literal(_options) {
+            var base = tools.merge({}, _options);
+
+            Rule.call(this, base);
+        }
+    });
+
+    var eq = std.class([Rule], {
+        constructor: function eq(_options) {
+            var base = tools.merge({
+                id: null,
+                EQ: null,
+                literal: null
+            }, _options);
+
+            Rule.call(this, base);
+
+            this.id = base.id;
+            this.EQ = base.EQ;
+            this.literal = base.literal;
+        },
+        set_id: function (_n) {
+            this._id = _n;
+        },
+        set_EQ: function (_n) {
+            this._EQ = _n;
+        },
+        set_literal: function (_n) {
+            this._literal = _n;
+        }
+    });
+
+    var and = std.class([Rule], {
+        constructor: function and(_options) {
+            var base = tools.merge({
+                lexpr: null,
+                AND: null,
+                rexpr: null
+            }, _options);
+
+            Rule.call(this, base);
+
+            this.lexpr = base.lexpr;
+            this.AND = base.AND;
+            this.rexpr = base.rexpr;
+        },
+        set_lexpr: function (_n) {
+            this._lexpr = _n;
+        },
+        set_AND: function (_n) {
+            this._AND = _n;
+        },
+        set_rexpr: function (_n) {
+            this._rexpr = _n;
+        }
+    });
+
+    var expr = std.class([Rule], {
+        constructor: function expr(_options) {
+            var base = tools.merge({}, _options);
+
+            Rule.call(this, base);
+        }
+    });
+
+    return {
+        // terminal
+        LEXEME: Lexeme,
+
+        // non terminal
+        string_literal: string_literal,
+        integer_literal: integer_literal,
+        id: id,
+        literal: literal,
+        eq: eq,
+        and: and,
+        expr: expr,
+    }
+
+})();
+
+
+
+
+var _result = {};
+var LemonJS = function (_input) {
+    var parser = new Parser();
+    var lexer = new Lexer(_input);
+    var token;
+    while (token = lexer.next()) {
+        console.log("PARSE", token.lexeme);
+        parser.parse(parser["TOKEN_" + token.lexeme], token);
+    }
+    parser.parse();
+    return _result;
+};
+
+
+fs.mkdirSync("tests");
+
+var test_and = LemonJS("abc == 1 and abc1 == 2 and (bbc == 5)");
+fs.writeFileSync("tests/out_test_and.json", JSON.stringify(test_and, true, 3));
+
+var test_address = LemonJS('abc == Address ["a", "b", "c"]');
+fs.writeFileSync("tests/out_tree_address.json", JSON.stringify(test_address, true, 3));
diff --git a/tests/out_test_and.json b/tests/out_test_and.json
new file mode 100644
index 0000000..31c6466
--- /dev/null
+++ b/tests/out_test_and.json
@@ -0,0 +1,153 @@
+{
+   "root_node": {
+      "type": "and",
+      "children": [
+         {
+            "type": "and",
+            "children": [
+               {
+                  "type": "expr",
+                  "children": [
+                     {
+                        "type": "eq",
+                        "children": [
+                           {
+                              "type": "ID",
+                              "children": [],
+                              "lexeme": "ID",
+                              "start": 0,
+                              "end": 3
+                           },
+                           {
+                              "type": "EQ",
+                              "children": [],
+                              "lexeme": "EQ",
+                              "start": 4,
+                              "end": 6
+                           },
+                           {
+                              "type": "literal",
+                              "children": [
+                                 {
+                                    "type": "INTEGER_LITERAL",
+                                    "children": [],
+                                    "lexeme": "INTEGER_LITERAL",
+                                    "start": 7,
+                                    "end": 8
+                                 }
+                              ],
+                              "lexeme": null,
+                              "start": 0,
+                              "end": 0
+                           }
+                        ],
+                        "lexeme": null,
+                        "start": 0,
+                        "end": 0
+                     }
+                  ],
+                  "lexeme": null,
+                  "start": 0,
+                  "end": 0
+               },
+               {
+                  "type": "expr",
+                  "children": [
+                     {
+                        "type": "eq",
+                        "children": [
+                           {
+                              "type": "ID",
+                              "children": [],
+                              "lexeme": "ID",
+                              "start": 13,
+                              "end": 17
+                           },
+                           {
+                              "type": "EQ",
+                              "children": [],
+                              "lexeme": "EQ",
+                              "start": 18,
+                              "end": 20
+                           },
+                           {
+                              "type": "literal",
+                              "children": [
+                                 {
+                                    "type": "INTEGER_LITERAL",
+                                    "children": [],
+                                    "lexeme": "INTEGER_LITERAL",
+                                    "start": 21,
+                                    "end": 22
+                                 }
+                              ],
+                              "lexeme": null,
+                              "start": 0,
+                              "end": 0
+                           }
+                        ],
+                        "lexeme": null,
+                        "start": 0,
+                        "end": 0
+                     }
+                  ],
+                  "lexeme": null,
+                  "start": 0,
+                  "end": 0
+               }
+            ],
+            "lexeme": null,
+            "start": 0,
+            "end": 0
+         },
+         {
+            "type": "expr",
+            "children": [
+               {
+                  "type": "eq",
+                  "children": [
+                     {
+                        "type": "ID",
+                        "children": [],
+                        "lexeme": "ID",
+                        "start": 28,
+                        "end": 31
+                     },
+                     {
+                        "type": "EQ",
+                        "children": [],
+                        "lexeme": "EQ",
+                        "start": 32,
+                        "end": 34
+                     },
+                     {
+                        "type": "literal",
+                        "children": [
+                           {
+                              "type": "INTEGER_LITERAL",
+                              "children": [],
+                              "lexeme": "INTEGER_LITERAL",
+                              "start": 35,
+                              "end": 36
+                           }
+                        ],
+                        "lexeme": null,
+                        "start": 0,
+                        "end": 0
+                     }
+                  ],
+                  "lexeme": null,
+                  "start": 0,
+                  "end": 0
+               }
+            ],
+            "lexeme": null,
+            "start": 0,
+            "end": 0
+         }
+      ],
+      "lexeme": null,
+      "start": 0,
+      "end": 0
+   }
+}
\ No newline at end of file
diff --git a/tests/out_tree_address.json b/tests/out_tree_address.json
new file mode 100644
index 0000000..809b86e
--- /dev/null
+++ b/tests/out_tree_address.json
@@ -0,0 +1,69 @@
+{
+   "root_node": {
+      "type": "expr",
+      "children": [
+         {
+            "type": "eq",
+            "children": [
+               {
+                  "type": "ID",
+                  "children": [],
+                  "lexeme": "ID",
+                  "start": 0,
+                  "end": 3
+               },
+               {
+                  "type": "EQ",
+                  "children": [],
+                  "lexeme": "EQ",
+                  "start": 4,
+                  "end": 6
+               },
+               {
+                  "type": "literal",
+                  "children": [
+                     {
+                        "type": "address_literal",
+                        "children": [
+                           {
+                              "type": "STRING_LITERAL",
+                              "children": [],
+                              "lexeme": "STRING_LITERAL",
+                              "start": 16,
+                              "end": 19
+                           },
+                           {
+                              "type": "STRING_LITERAL",
+                              "children": [],
+                              "lexeme": "STRING_LITERAL",
+                              "start": 21,
+                              "end": 24
+                           },
+                           {
+                              "type": "STRING_LITERAL",
+                              "children": [],
+                              "lexeme": "STRING_LITERAL",
+                              "start": 26,
+                              "end": 29
+                           }
+                        ],
+                        "lexeme": null,
+                        "start": 0,
+                        "end": 0
+                     }
+                  ],
+                  "lexeme": null,
+                  "start": 0,
+                  "end": 0
+               }
+            ],
+            "lexeme": null,
+            "start": 0,
+            "end": 0
+         }
+      ],
+      "lexeme": null,
+      "start": 0,
+      "end": 0
+   }
+}
\ No newline at end of file