an initial LALR(1) parsing algorithm.  still to do: generalize to GLR
adding saving/restoring of parse tables -- just saving the rules and
the action/goto tables, there's no need to save the state sets themselves.
mishandled error case
adding parens around all binary operators, because I seem to have
forgotten the precedence rules.  also, fixing the handling of turning
tokens into literal values, which was evidently broken.
adding sectioning comments, adding checks for LALR ambiguity, and
improving error messages somewhat
initial implementation of GLR algorithm.  No optimizations for mini-LR
parsing yet, but it does appear to parse at least one ambiguous
grammar correctly...
fixing infinite loop caused by wrong index variables, also, wrong
field name.
possibly-correct GLR algorithm, that now seems to reduce things in
proper order and produces all parse trees.  (At least for ambiguous
arithmetic, it produces Catalan numbers of parses, which is correct...)
fixing derivability relation, making grammar work for both LALR and
GLR parsing (by checking for LALR ambiguity and adding an EOF token to
the start rule only if GLR parsing is necessary), fixing GLR handling
of token->lit conversion, fixing a wrong-argument-order bug in
constructing tree nodes in LALR parsing (how did that slip through?),
renamed "##AMBIG##" to "--CHOICE--" so it's a valid Racket identifier...
temporary milestone
another interim milestone -- more efficient LR(0) item computation,
that might even be right...
more interim updates: making the serialized parser smaller
hooray -- things are now parsing and then they crash at a
right-nullable rule.  but that's progress!
New algorithm -- the RNGLR algorithm.  seems to be mostly working,
though there are bugs remaining.  This algorithm seems far less
tolerant of the Token/Lit split personality, so I've removed Lits for
now.  Parsing some example grammars produces slightly-wrong results,
and I don't quite know why, yet.  Also, serializing/deserializing the
grammar tables no longer quite works, but that's easily fixable.
fixed bug that produced erroneous parse trees -- was using f
instead of red.f, and f was bound to item.f, which happened to be
off-by-one in the test example, but more generally was the wrong
binding for f.

also, added printing of the GSS and SPPF as dot files.  Still to add
printing of the LALR DFA and the associated action table.
Nearly-working code!  The grammar as produced by bnf-grammar.js does
in fact parse Pyret code successfully (at least with the
mini-grammar), but the grammar as reconstituted by serializing and
deserializing doesn't work right.  So, more work needed there.
Fixing computation of first sets (for grammar symbols and for
strings), and fixing infinite looping bug in reducer().  The engine
now can parse the full Pyret grammar (suitably modified to use only
tokens instead of string literals) and construct a parser for that
grammar, then use that parser to parse an actual Pyret program!  Still
to do: serializing/deserializing of the grammar, so it doesn't have to
be recomputed every time.
fixes for Pyret tokenizer to produce correct Pyret tokens...
Working parser!  Successfully parses several actual Pyret files, and
works from the deserialized parser, rather than recomputing it every
time from scratch
adding checks to ensure that position information is well-nested along
the tree structure, and implementing the constructUniqueParse algorithm