"Fossies" - the Fresh Open Source Software Archive

Member "ragel-7.0.4/src/ChangeLog" (10 Jan 2021, 95953 Bytes) of package /linux/misc/ragel-7.0.4.tar.gz:

As a special service "Fossies" has tried to format the requested text file into HTML format (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file.

    1 Ragel 7.0.1 - Aug XXX, 2018
    2 ===========================
    3  -Condition implemenation rewritten. Previously utilized an extension of the
    4   alphabet space to encode "character when A". The character was looked up, the
    5   applicable condition set determined, a constant value was added to the
    6   character value, then the real transition looked up. Now a more natural
    7   implemation has the transition encoded in two levels of lists. The first
    8   level is indexed by the alphabet character, which is unmodified. This tells
    9   us which condition set to execute. The result of the condition execution is
   10   an integer that is looked up in a second level list. This new condition
   11   implementation allows for a much less complicated implemation, and does not
   12   rely on available bits in the alphabet space.
   13  -Conditions now properly execution on EOF.
   14  -Added a Condition-based repetition operator.
   15  -Ragel frontend is now colm-based. The grammar is separated into a core ragel
   16   grammar that can then be extended for different host languages.
   17  -Intermediate codegen language was added and non-C/ASM code generators are now
   18   based on the intermediate language. Separate ragel executable files are used
   19   to implement the different host languages.
   20  -Restrictions on action-based jumping to and calling of state machines in
   21   languages where it cannot be implemented properly (no goto in host language).
   22   These statements must be replaced with the "next" version, which does not
   23   jump out of the action, but instead causes the jump/call after the action
   24   list.
   25  -Added NFA features. This includes repetition and support for large unions of
   26   expressions. The operator can create a deterministic prefix, the depth of
   27   which is configurable, before NFA alternation begins.
   28  -Consolodating code in the different code generation styles.
   30 Ragel 6.10 - Mar 24, 2017
   31 =========================
   32  -C codegen: test P vs PE in goto/call/ret statements in EOF actions, just
   33   before re-entering. If at the end of the input block then the EOF check is
   34   jumped to. This change prevents overrunning the buffer if control flow is
   35   issued in an EOF action without fixing the input pointer first. If a program
   36   properly issues an fhold before the control flow the program won't be
   37   affected.
   38  -Updated action label generation. The previous set of conditions for
   39   generating the label didn't cover actions coming from the eofAction pointer
   40   (eof trans covered since it points into the set of transitions).
   41  -Use separate signed/unsigned values for host type min/max. Using separate
   42   values avoids the need to type cast before the data goes into FsmCtx structs.
   43   Keep it in native types until it is used.
   44  -Optionally do not generate entry point variables. Adds noentry write option
   45   for data.
   46  -Various warning elimination and build updates.
   48 Ragel 6.9 - Oct 13, 2014
   49 ========================
   50  -updated command-line synopsis
   51  -ocaml: fix missing semicolon
   52  -ocaml: support -G1
   53  -ocaml: choose a unique name for type state
   54  -ruby: reduce the amount of calls to GET_WIDE_KEY()
   55  -union test case: warning fix
   56  -omit line directives around expression-oriented write statements
   57  -use AS_IF and test command to check if the DIST file is present
   58  -added missing std:: using
   59  -go: added '//line' directive support
   61 Ragel 6.8 - Feb 11, 2013
   62 ========================
   64  -The -G2 code generator for Go1 was rewritten. Table, flat and switch-based
   65   code generators were added. (Anton Ageev)
   66  -The CXXFLAGS variable is not longer set in the configure script.
   68 Ragel 6.7 - May 22, 2011
   69 ========================
   70  -The C vim file now supports L,l on the end of literal numbers, other syntax
   71   highlighting fixes.
   72  -Added an explicit cast when modifying _trans to eliminate compiler warnings 
   73   on Windows/VC++
   74  -Fix for ruby 1.9 compatibility.
   75  -Fix for include directories (-I option) on Windows/VC++
   76  -Can now rename data variable in C# code generator.
   77  -Fix for non-char alphtype in C# code generator.
   78  -Fix for signedness of wide char in C code generator. when comparing the wide
   79   type against a literal we need to pick the right signedness for the literal.
   80  -Fixed arithmetic overflow in generated C# code. The C# _acts and _nacts vars
   81   should not be typed based on the size of the array elements they point to.
   82   Fixes a bug reported by Attila Sztupák.
   83  -Made the -L option work for Ruby.
   84  -Enhanced ragel.m4 (from Diego).
   85  -Applied GO patch from Justine Tunney.
   86  -Applied D2 patch from Johannes Pfau.
   87  -Applied Ocaml patch from ygrek.
   89 Ragel 6.6 - Dec 2, 2009
   90 =======================
   91  -Applied a number of patches from Diego Elio 'Flameeyes' Pettenò. Should not
   92   be modifying the program's arguments. Problem raised by const correctness in
   93   gcc 4.4. Other const-correctness and include fixes provided.
   94  -Fixed improper allocation of checks in makeIncludePathChecks.
   95  -Fixed segfault when there are no machine instantiations.
   96  -Fixed wrong line directives. Line directives need to use the fileName stored
   97   in the InputLoc stuctures from the parse trees, not the root source file,
   98   otherwise actions in included files will have the wrong source file names
   99   associated with the text.
  100  -Made a number of build system improvements. We locate the DIST file using
  101   $srcdir and source it. It contains settings for build_parsers and
  102   build_manual. This allows the user of a dist to enable only one.
  103  -Added missing files to doc/Makefile.am and examples/Makefile.am.
  104  -Added checks for pdflatex and fig2dev is build_manual is on.
  105  -Use automake --foreign so we don't need to have INSTALL and NEWS present.
  106  -Ragel VIM syntax files should be specialized by host language. Updated the
  107   VIM syntax files.
  108  -Added examples to the dist. Added unicode2ragel.rb to EXTRA_DIST in contrib.
  109  -Moved unicode2ragel.rb to the contrib directory.
  111 Ragel 6.5 - May 18, 2009
  112 ========================
  113  -Fixed a bug in graphviz generation. Ragel crashed when using -V and -M and
  114   the specified machine referenced another machine that wasn't included in the
  115   build.
  116  -The name "CS" is in use on OpenSolaris, changed to vCS to ease compiling
  117   Ragel there.
  118  -Converted to automake.
  119  -REALLY fixed a bug that was intended to be fixed in 6.4:
  120      Fixed a problem reading hex numbers that have the high bit set when the
  121      alphabet is signed and we are on 64 bit. This was reported by _why. The
  122      fix was provided by Wialliam Morgan. The literal 0xffffffff was used for
  123      a fully set long when -1L should be used instead.
  124   A null patch (whitespace changes) must have gotten checked after I was
  125   testing with and without the critical one-line patch and I forgot to enable
  126   make sure it was enabled in the final checkin version.
  128 Ragel 6.4 - Mar 22, 2009
  129 ========================
  130  -Moved back to a single executable. The old intermediate format can still be
  131   generated using the -x option. Ragel was split into frontend and backend
  132   programs in version 5.0. This was done to encourage interoperability with
  133   other tools. Since then, ragel has been made to work with qfsm, with ragel
  134   producing the intermediate format and qfsm consuming it. However, there has
  135   been no use of Ragel as a consumer of state machine data, with Ragel used as
  136   a code generator for DFAs. This is not surprising given that much of the
  137   complexity of Ragel is in the frontend, where the regular language to DFA
  138   compilation happens. Since the full benefits of the split have not
  139   materialized, and the split increases the complexity for users, Ragel has
  140   been made once again into a single executable. 
  141  -Applied a fix to the documentation Makefile from John D. Mitchell.
  142  -Use CXXFLAGS instead of CFLAGS for C++ compiling. Patch from Diego
  143   'Flameeyes' Pettenò.
  144  -Added support for DESTDIR variable. Patch from Diego 'Flameeyes' Pettenò.
  145  -Added a script called unicode2ragel.rb for generating unicode machines to
  146   the examples directory. From Rakan El-Khalil.
  147  -Fixed a copy-paste error in the documentation that was reported by Jose
  148   Quinteiro.
  149  -Added three new write commands:
  150      write start;
  151      write first_final;
  152      write error;
  153   These generate a reference to the start, first final and error state. When
  154   there are many different machine specifications in one file it is easy to
  155   get the prefix for these wrong (especially when you do a lot of copy-pasting
  156   of boilerplate). The problem can be avoided by using write commands.
  157  -Fixed a problem reading hex numbers that have the high bit set when the
  158   alphabet is signed and we are on 64 bit. This was reported by _why. The fix
  159   was provided by Wialliam Morgan. The literal 0xffffffff was used for a fully
  160   set long when -1L should be used instead.
  162 Ragel 6.3 - Aug 29, 2008
  163 ========================
  164  -Fixed an assertion that is too strong. In the condition code we need to copy
  165   transitions that have non-empty lmActionTable arrays so we don't assert
  166   emptiness in the constructor. Lift out the assertion and copy the array in
  167   the constructor.
  168  -Fixed and improved multiple include prevention. We now track the entire
  169   include history of a parser state to prevent duplicates.
  170  -Fixed crash on failed lookup of goto/call/etc target.
  172 Ragel 6.2 - May 9, 2008
  173 =======================
  174  -Bug fix: The lm_switch actions needs to set p from tokend when there is no
  175   user action.
  176  -Bug fix: when not using indices we can't use a transitions's id to identify
  177   the eof transition to take. Instead add the transition to the end of the
  178   transition list and store its position in a new var called pos. The pos var
  179   is then used as the index.
  180  -Bug fix: an fnext followed by an fbreak in -G2 was not working. The fbreak
  181   was not aware that the fnext causes the cs variable to be forced active. In
  182   this case fbreak does not need to save cs because it is already current.
  183  -Bug fix: need to compute the low and high character-space keys from the
  184   condition-trans overlap when computing an expansion. Can't use the range
  185   supplied from the condition overlap since they may not match. An incorrect
  186   machine that accepted 1(!cond1, !cond2) was generated for the following
  187   grammar. This bug was reported by Tim Chklovski.
  188       c = 2 @matched_c;
  189       sc1 = 1..2 when cond1;
  190       sc2 = 1..2 when cond2;
  191       main := sc1 | c | sc2;
  192  -Bug fix: error messages in start label analysis of join operations were
  193   causing assertion failures because location info was not set. Fixed by
  194   adding locations.
  195  -Include and import file searching now searches for the file name given based
  196   on the location of the current file, not ragel's current path.
  197   Additional search locations can be given using the -I option.
  198  -Rubinius code generation was updated to the latest Rubinius. Patch from Evan
  199   Phoenix.
  200  -Switched from strcasecmp to strcmp for testing long arguments.
  201  -Applied a patch from Andrei Polushin for setting the error message format.
  202      --error-format=gnu (default)
  203      --error-fromat=msvc
  204  -Now using the _WIN32 define instead of _WIN32. Other MSVC compilation
  205   improvments from Andrei Polushin.
  206  -Added the hyperref package to the manual. 
  208 Ragel 6.1 - Mar 26, 2008
  209 ========================
  210  -Scanners now ensure that any leaving actions at the end of a pattern are
  211   executed. They are always executed before the pattern action.
  212  -Added an option -d for turning off the removal of duplicate actions from
  213   actions lists.
  214  -Need to unset the final state status of the start state in kleene star if it
  215   is set. It is possible to crash ragel when the warning is ignored.
  216  -In the dot file generation we need to print any actions that are in
  217   State::eofTrans. These come from scanners only.
  218  -Use @docdir@ for the docdir Makefile variable.
  219  -Check for ar and ranlib in the configure script.
  221 Ragel 6.0 - Jan 12, 2008
  222 ========================
  223  -Removed the 'noend' write option from examples/atoi.rl. This example is
  224   referenced a lot as a first example and as such it shouldn't contain a
  225   special purpose write option like 'noend'.
  226  -Introcuded the "eof" variable for indicating the end of file. The p variable
  227   is checked against eof when the processing loop reaches the end of a block.
  228   If p == eof at this time then the EOF actions are executed. The variable is
  229   required only when EOF actions have been emebedded.
  230  -The "write eof" command is no longer needed and was removed.
  231  -Scanners now use EOF actions to generate tokens. This eliminates the need to
  232   flush the last token.
  233  -Restructured the Java driver; a switch statement with fallthrough cases are
  234   now used to emulate gotos.
  235  -Ruby code generation was also restructured. Gotos are elmulated using a
  236   series of if tests. 
  237  -Went back to 3.X semantics for >, % and error actions. The > operator also
  238   embeds a leaving action/priority into the start state if it is final. If EOF
  239   happens in a state with a leaving operator then the leaving action is
  240   executed. If EOF happens in a non-final state that has an error action, the
  241   error action is executed.
  242  -The "ragel" program now executes frontend and backend processes separately,
  243   connecting them with a temporary file in the current directory. Without the
  244   -x option the "ragel" program marshals arguments and calls the frontend and
  245   backend. With the -x option the "ragel" program acts as the frontend only.
  246  -Added name finding for executables. If any forward slash is found in argv0
  247   then it is assumed that the path is explicit and the path to the backend
  248   executable should be derived from that. Whe check that location and also go
  249   up one then inside a directory of the same name in case we are executing
  250   from the source tree. If no forward slash is found it is assumed the file is
  251   being run from the installed location. The PREFIX supplied during
  252   configuration is used.
  253  -On windows GetModuleFileNameEx is used to find out where the the current
  254   process's binary is. That location is searched first. If that fails then we
  255   go up one directory and look for the executable inside a directory of the
  256   same name in case we are executing from the source tree.
  257  -Changed the -l option in rlgen-cd to -L because it is covered in the
  258   frontend. Added a passthrough in the frontend for the backend options.
  259  -Dot file generation can now be invoked using the -V option to ragel. We
  260   now require an input file. If standard in is used then we don't have a file
  261   name on which to base the output.
  262  -Able to build native windows executables using Cygwin+MinGW. 
  263  -Patch from David Waite: Large arrays are now created by copying in the data
  264   from smaller arrays using System.arraycopy(). This eliminates the debug data
  265   associated with explicit initialization statements. It is also much easier
  266   on the java compiler which can run out of memory compiling very large
  267   machines. The downside is that it takes slightly longer to initialize static
  268   data at run time.
  269  -The fbreak statement now advances p.
  270  -In the :> :>> and <: operators it was possible for the priority assignment
  271   to be bypassed via the zero length string. In :> this was fixed
  272   automatically with the semantics change to the entering priority operator.
  273   If the start state is final it now embeds a leaving action into it,
  274   preventing persistance through the zero length string. In :>> and <: this
  275   was fixed explicitly. With <: the entering priority operator was used and
  276   with :> a special exception was added. Since it uses the finishing
  277   transition operator it also adds a leaving priority to the start state if it
  278   is final.
  279  -Ranlib is now run on the archives. Patch from Kenny MacDermid.
  280  -The case statement syntax in ruby code generation used a form depreciated in
  281   Ruby 1.9. Updated it.
  282  -Made a number of fixes that eliminate warnings in GCC 4.3. Mostly concern
  283   the now depreciate automatic conversion of string contsants to "char*" type.
  284   Other fixes include adding parenthesis around && within ||.
  285  -The "tokstart" and "tokend" variables were changed to "ts" and "te".
  287 Ragel 5.25 - Dec 24, 2007
  288 =========================
  289  -Fixed segfault reported by Ryan Phelps. Affected Java and Ruby code
  290   generation. The dataExpr variable was not initialized.
  291  -Fixed incorrect case label in test/runtests. Caused Objective-C tests to be
  292   ignored.
  293  -Added missing include to common.cpp.
  295 Ragel 5.24 - Sep 16, 2007
  296 =========================
  297  -Applied patch from Victor Hugo Borja <vic@rubyforge.org>. This patch
  298   implements -T1 -F0 -F1 and -G0 in the ruby code generator. Goto-driven code
  299   generation is experimental and requires rubinius asm directives (specify
  300   with --rbx option). These code generators pass all the ruby tests.
  301  -If the condition embedding code runs out of available characters in the
  302   keyspace an error message is emitted.
  303  -The first example that appeared in the manual used the special-purpose
  304   'noend' write option. This caused confusion. Now a basic example appears
  305   first.
  306  -Added two new statements: prepush and postpop. These are code blocks that
  307   are written out during call and return statements. The prepush code is
  308   written immediately before pushing the current state to the state stack
  309   during a call. The postpop code is written immediately after popping the
  310   current state during return. These can be used to implement a dynamically
  311   resizable stack. 
  313 Ragel 5.23 - Jul 24, 2007
  314 =========================
  315  -Eliminated the use of callcc as an alternative to goto. Instead, the named
  316   breaks implementation used in the Java code generator is imitated using
  317   control flow variables.
  318  -Improved the error message given when there is a write statement but no
  319   machine instantiations and hence no state machine.
  320  -Documentation improvements: updates to "Machine Instantiation", "Write Init"
  321   and "Write Exports" sectons. Added the "Variables Used by Ragel" section.
  322  -Renamed "Entering Actions" to "Starting Actions."
  323  -Other documentation updates.
  325 Ragel 5.22 - June 14, 2007
  326 ==========================
  327  -Bug fix: need to isolate the start state of a scanner before setting the
  328   to-state and from-state actions which clear and set tokstart. This affected
  329   very simple scanners only. Most scanners have an isolated start state due to
  330   the pattern structure.
  331  -Bug fix: when -S or -M was given the ragel version number was not emitted,
  332   causing the backend to reject the intermediate format. From Tim Potter.
  333  -The p varialbe is now set up at the beginning of a scanner action, rather
  334   than at the end. This leaves scanner actions free to manipulate p and
  335   removes the need for the special holdTE and execTE (TE for tokend) versions
  336   of hold and exec. It also removes the need to set p = tokend-1 immediately
  337   before any control flow. We loose the ability to determine where in the
  338   input stream a scanner action is executed, however this information is of
  339   little use because it is primarily an artifact of the scanner implementation
  340   (sometimes the last char, other times later on). The gains of this change
  341   are consistency and simplicity.
  342  -The "data" variable (used in Java and Ruby code generation only) can now be
  343   overridden using the variable statement.
  345 Ragel 5.21 - May 9, 2007
  346 ========================
  347  -Fixed an inconsistency in the value of p following an error. In the C
  348   directly executable code (rlgen-cd -G2) p is left at the character where
  349   the error occurred, which is correct. In all other code generators it was
  350   left at the following character. This was fixed. Now in all code generators
  351   p is left at the character where the error occurred.
  352  -Bug fix: when fhold was used in scanner pattern actions which get executed
  353   on the last character of the pattern (pattern matches which do not require
  354   any lookahead), fhold was modifying p instead of tokend. This was fixed and
  355   the patact.rl test was modified to cover the case.
  356  -Fixed typos in the guide, improved the state action embedding operator
  357   section and added subsections on the variable, import, and export
  358   statements.
  359  -Implemented a better solution than the pri hack for resolving the '-'
  360   ambiguity: force a shortest match of term.
  361  -Fixed bugs in the binary searching for condition keys in both the Ruby and
  362   Java code generation. 
  363  -Can now embed the negative sense of a condition. Added a language-
  364   independent test case for this feature and the necessary transformation
  365   support.
  366  -Added new condition embedding syntax:
  367     expr inwhen cond   - The transitions into the machine (starting transitions).
  368     expr outwhen cond  - The pending transitions out of the machine.
  369  -The argument to the variable statement which affects the name of the current
  370   state variable was changed from "curstate" to "cs" (the default name used
  371   for the current state)
  372  -Implemented the other variables names in the variable statement. Now all
  373   variables (p, pe, cs, top, stack, act, tokstart, tokend) can be renamed.
  374  -Parse errors in the intermediate XML file now cause the backend to exit
  375   immediately rather then forge on. The recovery infrastructure isn't there
  376   and segfaults are likely.
  377  -When no input is given to the backend program, it should not print an error
  378   message, it should just return a non-zero exit status. The assumption is
  379   that the frontend printed an error.
  380  -The version number is now included in the intermediate file. An error is
  381   emitted if there is a mismatch.
  382  -The alphabet type is now communicated from the frontend to the backend using
  383   a one-word internal name instead of an array offset.
  384  -The Ruby host language types had been just copied from Java. Reduced them to
  385   two basic types: char and int, both signed with the usual C sizes.
  387 Ragel 5.20 - Apr 7, 2007
  388 ========================
  389  -The cs variable is now always initialized, unless the "nocs" option is given
  390   to the write init command. If there is no main machine, cs is initialized to
  391   the entry point defined by the last machine instantiation.
  392  -A number of fixes were made to the Ruby code generator.
  393  -The frontend now scans ruby comments and regular expressions.
  394  -A transformation for Ruby was added to the language-independent test suite.
  395   The Ruby code generator passes on all the language-independent tests.
  396  -A new Ruby test and two language-independent tests were added.
  397  -Some portability fixes were made (Patches from Josef Goettgens and Aaron
  398   Campbell).
  399  -Fixed a make dependency bug which caused a problem for parallel building
  400   (Patch from Jeremy Hinegardner).
  402 Ragel 5.19 - Mar 14, 2007
  403 =========================
  404  -Added an import statement to ragel. This statement takes a literal string as
  405   an argument, interprets it as a file name, then scrapes the file for
  406   sequences of tokens that match the following forms. Tokens inside ragel
  407   sections are ignored. An example is in test/import1.rl
  408     name = number
  409     name = lit_string
  410     "define" name number
  411     "define" name lit_string
  412  -Added an export mechanism which writes defines for single character machines
  413   that have been tagged with the export keyword in their definition. Defines
  414   are used for C, ints for D, Java and Ruby. Examples of the export feature
  415   are in test/export*.rl.
  416  -All machine instantiations are now always generated, even if they are not
  417   referenced. In the backend, entry points for all instantiations are written
  418   out alongside start, error and first final states.
  419  -If the main machine is not present then do not emit an error. Generate the
  420   machine without a start state and do not initialize cs in the write init
  421   code.
  422  -Added an option -l to rlgen-cd which inhibits the writing of #line
  423   directives.
  424  -Added a new syntax for verbose embeddings. This adds parentheses: 
  425       $from(action_name);
  426   Verbose embeddings without parentheses can make code difficult to read
  427   because they force a space in the middle of an action embedding. There is a
  428   tendency to associtate spaces with concatenation. Without syntax
  429   highlighting to make it clear that the embedding type is a keyword, the
  430   problem is especially bad. The danger is that a verbose embedding could be
  431   read as an embedding of the keyword representing the empbedding type. With
  432   parentheses, verbose embeddings read much more clearly.
  433  -Conditions now have a forced order when more than one is executed on a
  434   single character. Previously ordering relied on pointers, which caused
  435   results to vary by compiler. Ordering is now done using conditon action
  436   declaration order. This fixes the failure of cond4.rl which occured with
  437   g++ 4.1 and other compiler versions.
  438  -In the port from flex to ragel, the name separator :: in Ragel code was
  439   lost. Added it back.
  440  -In the examples directory switched from rlcodegen to rlgen-cd. Silenced a
  441   warning in statechart.rl.
  442  -In the root makefile the distclean target was fixed. It was calling clean in
  443   the subdirs. In docs, the clean target was not deleting the new manpages for
  444   the rlgen-* programs. Fixed.
  445  -Portability and other fixes from Josef Goettgens were applied.
  446  -The @datadir@ and @mandir@ variables are made use of in doc/Makefile.in for
  447   specifying where documentation should be installed. Patch from Marcus
  448   Rueckert. 
  450 Ragel 5.18 - Feb 13, 2007
  451 =========================
  452  -There is now a 100% correspondence between state id numbers in the
  453   intermediate XML file, Graphviz dot files and generated code. This was
  454   achieved by moving code which determines if the error state is necessary
  455   into the frontend, and then assigning state numbers before writing out the
  456   intermediate file.
  457  -Backened class structure was reorganized to make it easier to add new code
  458   generators without having to also modify the existing code generators.
  459  -The C and D code generation executable was changed to rlgen-cd.
  460  -The Java code generation was split out into it's own exectuable (rlgen-java)
  461   to allow it to freely diverge from the C/D-based code generation.
  462  -The graphviz dot file generation was also split out to it's own executable
  463   (rlgen-dot).
  464  -The Ruby code generation patch from Victor Hugo Borja was added. This is
  465   highly experimental code and is not yet completely functional. It is in the
  466   executable rlgen-ruby.
  467  -The problem with large state machine machines in Java was fixed. This
  468   problem was discovered by Colin Fleming, who also contributed a patch.
  469   Rather than specify arrays as comma-separated lists of literals, array
  470   initialization is now done in a static function. This is the approach used
  471   by the Java compiler. Unlike the compiler Ragel is careful split large
  472   initilization functions.
  473  -The manual was expanded and reorganized somewhat.
  474  -Eliminated per-example directories in examples/.
  475  -Made some fixes to the pullscan.rl example.
  476  -In the frontend CR characters are now treated as whitespace.
  477  -Updated to the latest aapl. This completely eliminates the shallowCopy
  478   function. With that, a definitive memory leak is fixed.
  479  -Control codes with escape sequences are now printable characters (-p
  480   option). Also, the space character is now printed as SP.
  481  -Fixed the null dereference and consequential segfault which occurred when
  482   trying to create empty machines with [] and // and /a[]b/. 
  483  -Fixed the segfault which occured when a machine reference failed.
  484  -Discontinuing ragel.spec. It is more appropriate for this to be written by
  485   package maintenance developers.
  487 Ragel 5.17 - Jan 28, 2007
  488 =========================
  489  -The scanners and parsers in both the frontend and backend programs were
  490   completely rewritten using Ragel and Kelbt.
  491  -The '%when condition' syntax was functioning like '$when condition'. This
  492   was fixed.
  493  -In the Vim syntax file fixes to the matching of embedding operators were
  494   made. Also, improvements to the sync patterns were made.
  495  -Added pullscan.rl to the examples directory. It is an example of doing
  496   pull-based scanning. Also, xmlscan.rl in rlcodegen is a pull scanner.
  497  -The introduction chapter of the manual was improved. The manually-drawn
  498   figures for the examples were replaced with graphviz-drawn figures.
  500 Ragel 5.16 - Nov 20, 2006
  501 =========================
  502  -Policy change: the fhold and fexec directives did not function correctly in
  503   scanner pattern actions. In this context manipulations of p may be lost or
  504   made invalid. In the previous version of Ragel they were banned because of
  505   this. Instead of banning these directives they have been fixed. The fexec
  506   and fhold directives now manipulate tokend, which is now always used to
  507   update p when the action terminates.
  509 Ragel 5.15 - Oct 31, 2006
  510 =========================
  511  -A language independent test harness was introduced. Test cases can be
  512   written using a custom mini-language in the embedded actions. This
  513   mini-language is then translated to C, D and Java when generating the
  514   language-specific test cases.
  515  -Several existing tests have been ported to the language-independent format
  516   and a number of new language-independent test cases have been added.
  517  -The state-based embedding operators which access states that are not the
  518   start state and are not final (the 'middle' states) have changed. They
  519   were:
  520     <@/    eof action into middle states
  521     <@!    error action into middle states
  522     <@^    local error action into middle states
  523     <@~    to-state action into middle states
  524     <@*    from-state action into middle states
  525   They are now:
  526     <>/    eof action into middle states
  527     <>!    error action into middle states
  528     <>^    local error action into middle states
  529     <>~    to-state action into middle states
  530     <>*    from-state action into middle states
  531  -The verbose form of embeddings using the <- operator have been removed.
  532   This syntax was difficult to remember.
  533  -A new verbose form of state-based embedding operators have been added.
  534   These are like the symbol versions, except they replace the symbols:
  535     /  !  ^  ~  *
  536   with literal keywords:
  537     eof err lerr to from
  538  -The following words have been promoted to keywords:
  539     when eof err lerr to from
  540  -The write statment now gets its own lexical scope in the scanner to ensure
  541   that commands are passed through as is (not affected by keywords).
  542  -Bug fix: in the code generation of fret in scanner actions the adjustment to
  543   p that is needed in some cases (dependent on content of patterns) was not
  544   happening.
  545  -The fhold directive, which decrements p, cannot be permitted in the pattern
  546   action of a scanner item because it will not behave consistently. At the end
  547   of a pattern action p could be decremented, set to a new value or left
  548   alone. This depends on the contents of the scanner's patterns. The user
  549   cannot be expected to predict what will happen to p.
  550  -Conditions in D code require a cast to the widec type when computing widec.
  551  -Like Java, D code also needs if (true) branches for control flow in actions
  552   in order to fool the unreachable code detector. This is now abstracted in
  553   all code generators using the CTRL_FLOW() function.
  554  -The NULL_ITEM value in java code should be -1. This is needed for
  555   maintaining tokstart.
  557 Ragel 5.14 - Oct 1, 2006
  558 ========================
  559  -Fixed the check for use of fcall in actions embedded within longest match
  560   items. It was emitting an error if an item's longest-match action had an
  561   fcall, which is allowed. This bug was introduced while fixing a segfault in
  562   version 5.8.
  563  -A new minimization option was added: MinimizeMostOps (-l). This option
  564   minimizes at every operation except on chains of expressions and chains of
  565   terms (eg, union and concat). On these chains it minimizes only at the last
  566   operation. This makes test cases with many states compile faster, without
  567   killing the performance on grammars like strings2.rl.
  568  -The -l minimiziation option was made the default.
  569  -Fixes to Java code: Use of the fc value did not work, now fixed. Static data
  570   is now declared with the final keyword. Patch from Colin Fleming. Conditions
  571   now work when generating Java code.
  572  -The option -p was added to rlcodegen which causes printable characters to be
  573   printed in GraphViz output. Patch from Colin Fleming.
  574  -The "element" keyword no longer exists, removed from vim syntax file.
  575   Updated keyword highlighting.
  576  -The host language selection is now made in the frontend.
  577  -Native host language types are now used when specifying the alphtype.
  578   Previously all languages used the set defined by C, and these were mapped to
  579   the appropriate type in the backend.
  581 Ragel 5.13 - Sep 7, 2006
  582 ========================
  583  -Fixed a careless error which broke Java code generation.
  585 Ragel 5.12 - Sep 7, 2006
  586 ========================
  587  -The -o flag did not work in combination with -V. This was fixed.
  588  -The split code generation format uses only the required number of digits
  589   when writing out the number in the file name of each part.
  590  -The -T0, -F0 and -G0 codegens should write out the action list iteration
  591   variables only when there are regular, to state or from state actions. The
  592   code gens should not use anyActions().
  593  -If two states have the same EOF actions, they are written out in the finish
  594   routine as one case.
  595  -The split and in-place goto formats would sometimes generate _out when it is
  596   not needed. This was fixed.
  597  -Improved the basic partitioning in the split code gen. The last partition
  598   would sometimes be empty. This was fixed.
  599  -Use of 'fcall *' was not causing top to be initialized. Fixed.
  600  -Implemented a Java backend, specified with -J. Only the table-based format
  601   is supported.
  602  -Implemented range compression in the frontend. This has no effect on the
  603   generated code, however it reduces the work of the backend and any programs
  604   that read the intermediate format.
  606 Ragel 5.11 - Aug 10, 2006
  607 =========================
  608  -Added a variable to the configure.in script which allows the building of
  609   the parsers to be turned off (BUILD_PARSERS). Parser building is off by
  610   default for released versions. 
  611  -Removed configure tests for bison defines header file. Use --defines=file
  612   instead. 
  613  -Configure script doesn't test for bison, flex and gperf when building of the
  614   parsers is turned off.
  615  -Removed check for YYLTYPE structure from configure script. Since shipped
  616   code will not build parsers by default, we don't need to be as accomodating
  617   of other versions of bison. 
  618  -Added a missing include that showed up with g++ 2.95.3.
  619  -Failed configure test for Objective-C compiler is now silent.
  621 Ragel 5.10 - Jul 31, 2006
  622 =========================
  623  -Moved the check for error state higher in the table-based processing loop.
  624  -Replaced naive implementations of condition searching with proper ones. In
  625   the table-based formats the searching is also table-based. In the directly
  626   executed formats the searching is also directly executable.
  627  -The minimization process was made aware of conditions.
  628  -A problem with the condition implementation was fixed. Previously we were
  629   taking pointers to transitions and then using them after a call to
  630   outTransCopy, which was a bad idea because they may be changed by the call.
  631  -Added test mailbox3.rl which is based on mailbox2.rl but includes conditions
  632   for restricting header and message body lengths.  
  633  -Eliminated the initial one-character backup of p just before resuming
  634   execution.
  635  -Added the -s option to the frontend for printing statistics. This currently
  636   includes just the number of states. 
  637  -Sped up the generation of the in-place goto-driven (-G2) code style.
  638  -Implemented a split version of in-place goto-driven code style. This code
  639   generation style is suitable for producing fast implementations of very
  640   large machines. Partitioning is currently naive. In the future a
  641   high-quality partitioning program will be employed. The flag for accessing
  642   this feature is -Pn, where n is the number of partitions.
  643  -Converted mailbox1.rl, strings2.rl and cppscan1.rl tests to support the
  644   split code generation.
  645  -Fixes and updates were made to the runtests script: added -c for compiling
  646   only, changed the -me option to -e, and added support for testing the split
  647   code style.
  649 Ragel 5.9 - Jul 19, 2006
  650 ========================
  651  -Fixed a bug in the include system which caused malformed output from the
  652   frontend when the include was made from a multi-line machine spec and the
  653   included file ended in a single line spec (or vice versa).
  654  -Static data is now const.
  655  -Actions which referenced states but were not embedded caused the frontend to
  656   segfault, now fixed.
  657  -Manual now built with pdflatex.
  658  -The manual was reorganized and expanded. Chapter sequence is now:
  659   Introduction, Constructing Machines, Embedding Actions, Controlling
  660   Nondeterminism and Interfacing to the Host program.
  662 Ragel 5.8 - Jun 17, 2006
  663 ========================
  664  -The internal representation of the alphabet type has been encapsulated
  665   into a class and all operations on it have been defined as C++ operators.
  666  -The condition implementation now supports range transitions. This allows
  667   conditions to be embedded into arbitrary machines. Conditions are still
  668   exprimental.
  669  -More condition embedding operators were added
  670    1. Isolate the start state and embed a condition into all transitions
  671       leaving it:   
  672       >when cond   OR   >?cond
  673    2. Embed a condition into all transitions:
  674       when cond    OR   $when cond   OR   $?cond
  675    3. Embed a condition into pending out transitions:
  676       %when cond   OR   %?cond
  677  -Improvements were made to the determinization process to support pending out
  678   conditions.
  679  -The Vim sytax file was fixed so that :> doesn't cause the match of a label.
  680  -The test suite was converted to a single-file format which uses less disk
  681   space than the old directory-per-test format.
  683 Ragel 5.7 - May 14, 2006
  684 ========================
  685  -Conditions will not be embedded like actions because they involve a
  686   manipulation of the state machine they are specified in. They have therefore
  687   been taken out of the verbose action embedding form (using the <- compound
  688   symbol). A new syntax for specifying conditions has been created: 
  689   m = '\n' when {i==4};
  690  -Fixed a bug which prevented state machine commands like fcurs, fcall, fret,
  691   etc, from being accounted for in from-state actions and to-state actions.
  692   This prevented some necessary support code from being generated.
  693  -Implemented condition testing in remaining code generators.
  694  -Configure script now checks for gperf, which is required for building.
  695  -Added support for case-insensitive literal strings (in addition to regexes).
  696   A case-insensitive string is made by appending an 'i' to the literal, as in
  697   'cmd'i or "cmd"i.
  698  -Fixed a bug which caused all or expressions inside of all regular
  699   expressions to be case-insensitive. For example /[fo]o bar/ would make the
  700   [fo] part case-insensitive even though no 'i' was given following the
  701   regular expression.
  703 Ragel 5.6 - Apr 1, 2006
  704 =======================
  705  -Added a left-guarded concatenation operator. This operator <: is equivalent
  706   to ( expr1 $1 . expr2 >0 ). It is useful if you want to prefix a sequence
  707   with a sequence of a subset of the characters it matches. For example, one
  708   can consume leading whitespace before tokenizing a sequence of whitespace
  709   separated words: ( ' '* <: ( ' '+ | [a-z]+ )** )
  710  -Removed context embedding code, which has been dead since 5.0.
  712 Ragel 5.5 - Mar 28, 2006
  713 ========================
  714  -Implemented a case-insensitive option for regular expressions: /get/i.
  715  -If no input file is given to the ragel program it reads from standard input.
  716  -The label of the start state has been changed from START to IN to save on
  717   required screen space.
  718  -Bug fix: \0 was not working in literal strings, due to a change that reduced
  719   memory usage by concatenating components of literal strings.  Token data
  720   length is now passed from the scanner to the paser so that we do not need to
  721   rely on null termination. 
  723 Ragel 5.4 - Mar 12, 2006
  724 ========================
  725  -Eliminated the default transition from the frontend implementation. This
  726   default transition was a space-saving optimization that at best could reduce
  727   the number of allocated transitions by one half. Unfortunately it
  728   complicated the implementation and this stood in the way of introducing
  729   conditionals. The default transition may be reintroduced in the future.
  730  -Added entry-guarded concatenation. This operator :>, is syntactic sugar
  731   for expr1 $0 . expr >1. This operator terminates the matching of the first
  732   machine when a first character of the second machine is matched. For
  733   example in any* . ';' we never leave the any* machine. If we use any* :> ';'
  734   then the any* machine is terminiated upon matching the semi-colon.
  735  -Added finish-guarded concatenation. This operator :>>, is syntactic sugar
  736   for expr1 $0 . expr @1. This operator is like entry guarded concatenation
  737   except the first machine is terminated when the second machine enters a
  738   final state. This is useful for delaying the guard until a full pattern is
  739   matched. For example as in '/*' any* :>> '*/'.
  740  -Added strong subtraction. Where regular subtraction removes from the first
  741   machine any strings that are matched by the second machine, strong
  742   subtraction removes any strings from the first that contain any strings of
  743   the second as a substring. Strong subtraction is syntactic sugar for 
  744   expr1 - ( any* expr2 any* ).
  745  -Eliminated the use of priorities from the examples. Replaced with
  746   subtraction, guarded concatenation and longest-match kleene star.
  747  -Did some initial work on supporting conditional transitions. Far from
  748   complete and very buggy. This code will only be active when conditionals are
  749   used.
  751 Ragel 5.3 - Jan 27, 2006
  752 ========================
  753  -Added missing semi-colons that cause the build to fail when using older
  754   versions of Bison.
  755  -Fix for D code: if the contents of an fexec is a single word, the generated
  756   code will get interpreted as a C-style cast. Adding two brackets prevents
  757   this. Can now turn eliminate the "access this.;" in cppscan5 that was used to
  758   get around this problem.
  759  -Improved some of the tag names in the intermediate format.
  760  -Added unsigned long to the list of supported alphabet types.
  761  -Added ids of actions and action lists to XML intermediate format. Makes it
  762   more human readable.
  763  -Updated to latest Aapl package.
  765 Ragel 5.2 - Jan 6, 2006
  766 ========================
  767  -Ragel emits an error if the target of fentry, fcall, fgoto or fnext is inside
  768   a longest match operator, or if an action embedding in a longest match
  769   machine uses fcall. The fcall command can still be used in pattern actions.
  770  -Made improvements to the clang, rlscan, awkemu and cppscan examples.
  771  -Some fixes to generated label names: they should all be prefixed with _.
  772  -A fix to the Vim syntax highlighting script was made
  773  -Many fixes and updates to the documentation. All important features and
  774   concepts are now documented. A second chapter describing Ragel's use
  775   was added.
  777 Ragel 5.1 - Dec 22, 2005
  778 ========================
  779  -Fixes to the matching of section delimiters in Vim syntax file.
  780  -If there is a longest match machine, the tokend var is now initialized by
  781   write init. This is not necessary for correct functionality, however
  782   prevents compiler warnings.
  783  -The rlscan example was ported to the longest match operator and changed to
  784   emit XML data.
  785  -Fix to the error handling in the frontend: if there are errors in the lookup
  786   of names at machine generation time then do not emit anything.
  787  -If not compiling the full machine in the frontend (by using -M), avoid
  788   errors and segfaults caused by names that are not part of the compiled
  789   machine.
  790  -Longest match bug fix: need to init tokstart when returing from fsm calls
  791   that are inside longest match actions.
  792  -In Graphviz drawing, the arrow into the start state is not a real
  793   transition, do not draw to-state actions on the label.
  794  -A bug fix to the handling of non-tag data within an XML tag was made.
  795  -Backend exit value fixed: since the parser now accepts nothing so as to
  796   avoid a redundant parse error when the frontend dies, we must force an
  797   error. The backend should now be properly reporting errors.
  798  -The longest match machine now has it's start state set final. An LM machine
  799   is in a final state when it has not matched anything, when it has matched
  800   and accepted a token and is ready for another, and when it has matched a
  801   token but is waiting for some lookahead before determining what to do about
  802   it (similar to kleene star).
  803  -Element statement removed from some tests.
  804  -Entry point names are propagated to the backend and used to label the entry
  805   point arrows in Graphviz output.
  807 Ragel 5.0 - Dec 17, 2005
  808 ========================
  809  (additional details in V5 release notes)
  810  -Ragel has been split into two executables: A frontend which compiles
  811   machines and emits them in an XML format, and a backend which generates code
  812   or a Graphviz dot file from the XML input. The purpose of this split is to
  813   allow Ragel to interface with other tools by means of the XML intermediate
  814   format and to reduce complexity by strictly separating the previously
  815   entangled phases. The intermediate format will provide a better platform
  816   inspecting compiled machines and for extending Ragel to support other host
  817   languages.
  818  -The host language interface has been reduced significantly. Ragel no longer
  819   expects the machine to be implemented as a structure or class and does not
  820   generate functions corresponding to initialization, execution and EOF.
  821   Instead, Ragel just generates the code of these components, allowing all of
  822   them to be placed in a single function if desired. The user specifies a
  823   machine in the usual manner, then indicates at which place in the program
  824   text the state machine code is to be generated. This is done using the write
  825   statement. It is possible to specify to Ragel how it should access the
  826   variables it needs (such as the current state) using the access statement.
  827  -The host language embedding delimiters have been changed. Single line
  828   machines start with '%%' and end at newline. Multiline machines start with
  829   '%%{' and end with '}%%'. The machine name is given with the machine
  830   statement at the very beginning of the specification. This purpose of this
  831   change is to make it easier separate Ragel code from the host language. This
  832   will ease the addition of supported host languages.
  833  -The structure and class parsing which was previously able to extract a
  834   machine's name has been removed since this feature is dependent on the host
  835   language and inhibits the move towards a more language-independent frontend.
  836  -The init, element and interface statements have been made obsolete by the
  837   new host language interface and have been removed.
  838  -The fexec action statement has been changed to take only the new position to
  839   move to. This statement is more useful for moving backwards and reparsing
  840   input than for specifying a whole new buffer entirely and has been shifted
  841   to this new use. Giving it only one argument also simplifies the parsing of
  842   host code embedded in a Ragel specification. This will ease the addition of
  843   supported host languages.
  844  -Introduced the fbreak statement, which allows one to stop processing data
  845   immediately. The machine ends up in the state that the current transition
  846   was to go to. The current character is not changed.
  847  -Introduced the noend option for writing the execute code. This inhibits
  848   checking if we have reached pe. The machine will run until it goes into the
  849   error state or fbreak is hit. This allows one to parse null-terminate
  850   strings without first computing the length.
  851  -The execute code now breaks out of the processing loop when it moves into
  852   the error state. Previously it would run until pe was hit. Breaking out
  853   makes the noend option useful when an error is encountered and allows
  854   user code to determine where in the input the error occured. It also
  855   eliminates needlessly iterating the input buffer.
  856  -Introduced the noerror, nofinal and noprefix options for writing the machine
  857   data. The first two inhibit the writing of the error state and the
  858   first-final state should they not be needed. The noprefix eliminates the
  859   prefixing of the data items with the machine name.
  860  -Support for the D language has been added. This is specified in the backend
  861   with the -D switch.
  862  -Since the new host language interface has been reduced considerably, Ragel
  863   no longer needs to distinguish between C-based languages. Support for C, C++
  864   and Objective-C has been folded into one option in the backend: -C
  865  -The code generator has been made independent of the languages that it
  866   supports by pushing the language dependent apsects down into the lower
  867   levels of the code generator.
  868  -Many improvements to the longest match construction were made. It is no
  869   longer considered experimental. A longest match machine must appear at the
  870   top level of a machine instantiation. Since it does not generate a pure
  871   state machine (it may need to backtrack), it cannot be used as an operand to
  872   other operators.
  873  -References to the current character and current state are now completely
  874   banned in EOF actions.
  876 Ragel 4.2 - Sep 16, 2005
  877 ========================
  878  (additional details in V4 release notes)
  879  -Fixed a bug in the longest match operator. In some states it's possible that
  880   we either match a token or match nothing at all. In these states we need to
  881   consult the LmSwitch on error so it must be prepared to execute an error
  882   handler. We therefore need to init act to this error value (which is zero).
  883   We can compute if we need to do this and the code generator emits the
  884   initialization only if necessary. 
  885  -Changed the definition of the token end of longest match actions. It now
  886   points to one past the last token. This makes computing the token length
  887   easier because you don't have to add one. The longest match variables token
  888   start, action identifier and token end are now properly initialized in
  889   generated code. They don't need to be initialized in the user's code.
  890  -Implemented to-state and from-state actions. These actions are executed on
  891   transitions into the state (after the in transition's actions) and on
  892   transitions out of the state (before the out transition's actions). See V4
  893   release notes for more information.
  894  -Since there are no longer any action embedding operators that embed both on
  895   transitions and on EOF, any actions that exist in both places will be there
  896   because the user has explicitly done so. Presuming this case is rare, and
  897   with code duplication in the hands of the user, we therefore give the EOF
  898   actions their own action switch in the finish() function. This is further
  899   motivated by the fact that the best solution is to do the same for to-state
  900   and from-state actions in the main loop.
  901  -Longest match actions can now be specified using a named action. Since a
  902   word following a longest match item conflicts with the concatenation of a
  903   named machine, the => symbol must come immediately before a named action.
  904  -The longest match operator permits action and machine definitions in the
  905   middle of a longest match construction. These are parsed as if they came
  906   before the machine definition they are contained in. Permitting action and
  907   machine definitions in a longest match construction allows objects to be
  908   defined closer to their use.
  909  -The longest match operator can now handle longest match items with no
  910   action, where previously Ragel segfaulted.
  911  -Updated to Aapl post 2.12.
  912  -Fixed a bug in epsilon transition name lookups. After doing a name lookup
  913   the result was stored in the parse tree. This is wrong because if a machine
  914   is used more than once, each time it may resolve to different targets,
  915   however it will be stored in the same place. We now store name resolutions
  916   in a separated data structure so that each walk of a parse tree uses the
  917   name resolved during the corresponding walk in the name lookup pass.
  918  -The operators used to embed context and actions into states have been
  919   modified. The V4 release notes contain the full details.
  920  -Added zlen builtin machine to represent the zero length machine. Eventually
  921   the name "null" will be phased out in favour of zlen because it is unclear
  922   whether null matches the zero length string or if it does not match any
  923   string at all (as does the empty builtin).
  924  -Added verbose versions of action, context and priority embedding. See the V4
  925   release notes for the full details. A small example: 
  926       machine <- all exec { foo(); } <- final eof act1
  927  -Bugfix for machines with epsilon ops, but no join operations. I had 
  928   wrongfully assumed that because epsilon ops can only increase connectivity,
  929   that no states are ever merged and therefore a call to fillInStates() is not
  930   necessary. In reality, epsilon transitions within one machine can induce the
  931   merging of states. In the following, state 2 follows two paths on 'i':
  932       main := 'h' -> i 'i h' i: 'i';
  933  -Changed the license of the guide from a custom "do not propagate modified
  934   versions of this document" license to the GPL.
  936 Ragel 4.1 - Jun 26, 2005
  937 ========================
  938  (additional details in V4 release notes)
  939  -A bug in include processing was fixed. Surrounding code in an include file
  940   was being passed through to the output when it should be ignored. Includes
  941   are only for including portions of another machine into he current. This
  942   went unnoticed because all tested includes were wrapped in #ifndef ...
  943   #endif directives and so did not affect the compilation of the file making
  944   the include.
  945  -Fixes were made to Vim syntax highlighting file.
  946  -Duplicate actions are now removed from action lists.
  947  -The character-level negation operator ^ was added. This operator produces a
  948   machine that matches single characters that are not matched by the machine
  949   it is applied to. This unary prefix operator has the same precedence level
  950   as !.
  951  -The use of + to specify the a positive literal number was discontinued.
  952  -The parser now assigns the subtraction operator a higher precedence than
  953   the negation of literal number.
  955 Ragel 4.0 - May 26, 2005
  956 ========================
  957  (additional details in V4 release notes)
  958  -Operators now strictly embed into a machine either on a specific class of
  959   characters or on EOF, but never both. This gives a cleaner association
  960   between the operators and the physical state machine entitites they operate
  961   on. This change is made up of several parts:
  962   1. '%' operator embeds only into leaving characters.
  963   2. All global and local error operators only embed on error character
  964      transitions, their action will not be triggerend on EOF in non-final
  965      states.
  966   3. EOF action embedding operators have been added for all classes of states
  967      to make up for functionality removed from other operators. These are 
  968      >/ $/ @/ %/.
  969   4. Start transition operator '>' no longer implicitly embeds into leaving
  970      transtions when start state is final.
  971  -Ragel now emits warnings about the improper use of statements and values in
  972   action code that is embedded as an EOF action. Warnings are emitted for fpc,
  973   fc, fexec, fbuf and fblen.
  974  -Added a longest match construction operator |* machine opt-action; ... *|.
  975   This is for repetition where an ability to revert to a shorter, previously
  976   matched item is required. This is the same behaviour as flex and re2c. The
  977   longest match operator is not a pure FSM construction, it introduces
  978   transitions that implicitly hold the current character or reset execution to
  979   a previous location in the input. Use of this operator requires the caller
  980   of the machine to occasionally hold onto data after a call to the exectute
  981   routine. Use of machines generated with this operator as the input to other
  982   operators may have undefined results. See examples/cppscan for an example.
  983   This is very experimental code.
  984  -Action ids are only assigned to actions that are referenced in the final
  985   constructed machine, preventing gaps in the action id sequence. Previously
  986   an action id was assigned if the action was referenced during parsing.
  987  -Machine specifications now begin with %% and are followed with an optional
  988   name and either a single Ragel statement or a sequence of statements
  989   enclosed in {}.
  990  -Ragel no longer generates the FSM's structure or class. It is up to the user
  991   to declare the structure and to give it a variable named curs of type
  992   integer. If the machine uses the call stack the user must also declare a
  993   array of integers named stack and an integer variable named top.
  994  -In the case of Objective-C, Ragel no longer generates the interface or
  995   implementation directives, allowing the user to declare additional methods.
  996  -If a machine specification does not have a name then Ragel tries to find a
  997   name for it by first checking if the specification is inside a struct, class
  998   or interface. If it is not then it uses the name of the previous machine
  999   specification. If still no name is found then this is an error.
 1000  -Fsm specifications now persist in memory and statements accumulate.
 1001  -Ragel now has an include statement for including the statements of a machine
 1002   spec in another file (perhaps because it is the corresponding header file).
 1003   The include statement can also be used to draw in the statements of another
 1004   fsm spec in the current file.
 1005  -The fstack statement is now obsolete and has been removed.
 1006  -A new statement, simply 'interface;', indicates that ragel should generate
 1007   the machine's interface. If Ragel sees the main machine it generates the
 1008   code sections of the machine. Previously, the header portion was generated
 1009   if the (now removed) struct statement was found and code was generated if
 1010   any machine definition was found.
 1011  -Fixed a bug in the resolution of fsm name references in actions. The name
 1012   resolution code did not recurse into inline code items with children
 1013   (fgoto*, fcall*, fnext*, and fexec), causing a segfault at code generation
 1014   time.
 1015  -Cleaned up the code generators. FsmCodeGen was made into a virtual base
 1016   class allowing for the language/output-style specific classes to inherit
 1017   both a language specific and style-specific base class while retaining only
 1018   one copy of FsmCodeGen. Language specific output can now be moved into the
 1019   language specific code generators, requiring less duplication of code in the
 1020   language/output-style specific leaf classes.
 1021  -Fixed bugs in fcall* implementation of IpgGoto code generation.
 1022  -If the element type has not been defined Ragel now uses a constant version
 1023   of the alphtype, not the exact alphtype. In most cases the data pointer of
 1024   the execute routine should be const. A non-const element type can still be
 1025   defined with the element statement.
 1026  -The fc special value now uses getkey for retrieving the current char rather
 1027   than *_p, which is wrong if the element type is a structure.
 1028  -User guide converted to TeX and updated for new 4.0 syntax and semantics.
 1030 Ragel 3.7 - Oct 31, 2004
 1031 ========================
 1032  -Bug fix: unreferenced machine instantiations causing segfault due to name
 1033   tree and parse tree walk becomming out of syncronization.
 1034  -Rewrote representation of inline code blocks using a tree data structure.
 1035   This allows special keywords such as fbuf to be used as the operatands of
 1036   other fsm commands.
 1037  -Documentation updates.
 1038  -When deciding whether or not to generate machine instantiations, search the
 1039   entire name tree beneath the instantiation for references, not just the
 1040   root.
 1041  -Removed stray ';' in keller2.rl
 1042  -Added fexec for restarting the machine with new buffer data (state stays the
 1043   same), fbuf for retrieving the the start of the buf, and fblen for
 1044   retrieving the orig buffer length.
 1045  -Implemented test/cppscan2 using fexec. This allows token emitting and restart
 1046   to stay inside the execute routine, instead of leaving and re-entering on
 1047   every token.
 1048  -Changed examples/cppscan to use fexec and thereby go much faster.
 1049  -Implemented flex and re2c versions of examples/cppscan. Ragel version
 1050   goes faster than flex version but not as fast as re2c version.
 1051  -Merged in Objective-C patch from Erich Ocean.
 1052  -Turned off syncing with stdio in C++ tests to make them go faster.
 1053  -Renamed C++ code generaion classes with the Cpp Prefix instead of CC to make
 1054   them easier to read.
 1055  -In the finish function emit fbuf as 0 cast to a pointer to the element type
 1056   so it's type is not interpreted as an integer.
 1057  -The number -128 underflows char alphabets on some architectures. Removed
 1058   uses of it in tests.
 1059  -Disabled the keller2 test because it causes problems on many architectures
 1060   due to its large size and compilation requirements.
 1062 Ragel 3.6 - Jul 10, 2004
 1063 ========================
 1064  -Many documentation updates.
 1065  -When resolving names, return a set of values so that a reference in an
 1066   action block that is embedded more than once won't report distinct entry
 1067   points that are actually the same.
 1068  -Implemented flat tables. Stores a linear array of indices into the
 1069   transition array and only a low and high key value. Faster than binary
 1070   searching for keys but not usable for large alphabets.
 1071  -Fixed bug in deleting of transitions leftover from converstion from bst to
 1072   list implementation of transitions. Other code cleanup.
 1073  -In table based output calculate the cost of using an index. Don't use if
 1074   cheaper. 
 1075  -Changed fstate() value available in init and action code to to fentry() to
 1076   reflect the fact that the values returned are intended to be used as targets
 1077   in fgoto, fnext and fcall statements. The returned state is not a unique
 1078   state representing the label. There can be any number of states representing
 1079   a label.
 1080  -Added keller2 test, C++ scanning tests and C++ scanning example.
 1081  -In table based output split up transitions into targets and actions. This
 1082   allows actions to be omitted.
 1083  -Broke the components of the state array into separate arrays. Requires
 1084   adding some fields where they could previously be omitted, however allows
 1085   finer grained control over the sizes of items and an overal size reduction.
 1086   Also means that state numbers are not an offset into the state array but
 1087   instead a sequence of numbers, meaning the context array does not have any
 1088   wasted bits.
 1089  -Action lists and transition also have their types chosen to be the smallest
 1090   possible for accomodating the contained values.
 1091  -Changed curs state stored in fsm struct from _cs to curs. Keep fsm->curs ==
 1092   -1 while in machine. Added tests curs1 and curs2.
 1093  -Implemented the notion of context. Context can be embedded in states using
 1094   >:, $:, @: and %: operators. These embed a named context into start states,
 1095   all states, non-start/non-final and final states. If the context is declared
 1096   using a context statment
 1097     context name;
 1098   then the context can be quered for any state using fsm_name_ctx_name(state)
 1099   in C code and fsm_name::ctx_name(state) in C++ code. This feature makes it
 1100   possible to determine what "part" of the machine is currently active.
 1101  -Fixed crash on machine generation of graphs with no final state. If there
 1102   is no reference to a final state in a join operation, don't generate one. 
 1103  -Updated Vim sytax: added labels to inline code, added various C++ keywords.
 1104   Don't highlight name separations as labels. Added switch labels, improved
 1105   alphtype, element and getkey.
 1106  -Fixed line info in error reporting of bad epsilon trans. 
 1107  -Fixed fstate() for tab code gen.
 1108  -Removed references to malloc.h.
 1110 Ragel 3.5 - May 29, 2004
 1111 ========================
 1112  -When parse errors occur, the partially generated output file is deleted and
 1113   an non-zero exit status is returned.
 1114  -Updated Vim syntax file.
 1115  -Implemented the setting of the element type that is passed to the execute
 1116   routine as well as method for specifying how ragel should retrive the key
 1117   from the element type. This lets ragel process arbitrary structures inside
 1118   of which is the key that is parsed.
 1119       element struct Element;
 1120       getkey fpc->character;
 1121  -The current state is now implemented with an int across all machines. This
 1122   simplifies working with current state variables. For example this allows a
 1123   call stack to be implemented in user code.
 1124  -Implemented a method for retrieving the current state, the target state, and
 1125   any named states. 
 1126       fcurs           -retrieve the current state
 1127       ftargs          -retrieve the target state
 1128       fstate(name)    -retrieve a named state.
 1129  -Implemented a mechanism for jumping to and calling to a state stored in a
 1130   variable.
 1131       fgoto *<expr>;  -goto the state returned by the C/C++ expression.
 1132       fcall *<expr>;  -call the state returned by the C/C++ expression.
 1133  -Implemented a mechanism for specifying the next state without immediately
 1134   transfering control there (any code following statement is executed).
 1135       fnext label;    -set the state pointed to by label as the next state.
 1136       fnext *<expr>;  -set the state returned by the C/C++ expression as the
 1137                        next.
 1138  -Action references are determined from the final machine instead of during
 1139   the parse tree walk. Some actions can be referenced in the parse tree but not
 1140   show up in the final machine. Machine analysis is now done based on this new
 1141   computation.
 1142  -Named state lookup now employs a breadth-first search in the lookup and
 1143   allows the user to fully qualify names, making it possible to specify
 1144   jumps/calls into parts of the machine deep in the name hierarchy. Each part
 1145   of name (separated by ::) employs a breadth first search from it's starting
 1146   point.
 1147  -Name references now must always refer to a single state. Since references to
 1148   multiple states is not normally intended, it no longer happens
 1149   automatically. This frees the programmer from thinking about whether or not
 1150   a state reference is unique. It also avoids the added complexity of
 1151   determining when to merge the targets of multiple references. The effect of
 1152   references to multiple states can be explicitly created using the join
 1153   operator and epsilon transitions.
 1154  -M option was split into -S and -M. -S specifies the machine spec to generate
 1155   for graphviz output and dumping. -M specifies the machine definition or
 1156   instantiation.
 1157  -Machine function parameters are now prefixed with and underscore to
 1158   avoid the hiding of class members.
 1160 Ragel 3.4 - May 8, 2004
 1161 =======================
 1162  -Added the longest match kleene star operator **, which is synonymous 
 1163   with ( ( <machine> ) $0 %1 ) *.
 1164  -Epsilon operators distinguish between leaving transitions (going to an
 1165   another expression in a comma separated list) and non-leaving transitions.
 1166   Leaving actions and priorities are appropriately transferred.
 1167  -Relative priority of following ops changed to:
 1168       1. Action/Priority 
 1169       2. Epsilon 
 1170       3. Label
 1171   If label is done first then the isolation of the start state in > operators
 1172   will cause the label to point to the old start state that doesn't have the
 1173   new action/priority.
 1174  -Merged >! and >~, @! and @~, %! and %~, and $! and $~ operators to have one
 1175   set of global error action operators (>!, @!, %! and $!) that are invoked on
 1176   error by unexpected characters as well as by unexepected EOF.
 1177  -Added the fpc keyword for use in action code. This is a pointer to the
 1178   current character. *fpc == fc. If an action is invoked on EOF then fpc == 0.
 1179  -Added >^, @^, %^, and $^ local error operators. Global error operators (>!,
 1180   @!, $!, and %!) cause actions to be invoked if the final machine fails.
 1181   Local error actions cause actions to be invoked if if the current machine
 1182   fails.
 1183  -Changed error operators to mean embed global/local error actions in:
 1184      >! and !^  -the start state.
 1185      @! and @^  -states that are not the start state and are not final.
 1186      %! and %^  -final states.
 1187      $! and $^  -all states.
 1188  -Added >@! which is synonymous >! then @!
 1189  -Added >@^ which is synonymous >^ then @^
 1190  -Added @%! which is synonymous @! then %!
 1191  -Added @%^ which is synonymous >^ then @^
 1192  -FsmGraph representation of transition lists was changed from a mapping of
 1193   alphabet key -> transition objects using a BST to simply a list of
 1194   transition objects. Since the transitions are no longer divided by
 1195   single/range, the fast finding of transition objects by key is no longer
 1196   required functionality and can be eliminated. This new implementation uses
 1197   the same amount of memory however causes less allocations. It also make more
 1198   sense for supporting error transitions with actions. Previously an error
 1199   transition was represented by a null value in the BST.
 1200  -Regular expression ranges are checked to ensure that lower <= upper.
 1201  -Added printf-like example.
 1202  -Added atoi2, erract2, and gotcallret to the test suite.
 1203  -Improved build test to support make -jN and simplified the compiling and
 1204   running of tests.
 1206 Ragel 3.3 - Mar 7, 2004
 1207 =======================
 1208  -Portability bug fixes were made. Minimum and maximum integer values are
 1209   now taken from the system. An alignment problem on 64bit systems
 1210   was fixed.
 1212 Ragel 3.2 - Feb 28, 2004
 1213 ========================
 1214  -Added a Vim syntax file.
 1215  -Eliminated length var from generated execute code in favour of an end
 1216   pointer. Using length requires two variables be read and written. Using an
 1217   end pointer requires one variable read and written and one read. Results in
 1218   more optimizable code.
 1219  -Minimization is now on by default.
 1220  -States are ordered in output by depth first search.
 1221  -Bug in minimization fixed. States were not being distinguished based on
 1222   error actions. 
 1223  -Added null and empty builtin machines.
 1224  -Added EOF error action operators. These are >~, >@, $~, and %~. EOF error
 1225   operators embed actions to take if the EOF is seen and interpreted as an
 1226   error. The operators correspond to the following states:
 1227     -the start state
 1228     -any state with a transition to a final state
 1229     -any state with a transiion out
 1230     -a final state
 1231  -Fixed bug in generation of unreference machine vars using -M. Unreferenced
 1232   vars don't have a name tree built underneath when starting from
 1233   instantiations. Need to instead build the name tree starting at the var.
 1234  -Calls, returns, holds and references to fc in out action code are now
 1235   handled for ipgoto output.
 1236  -Only actions referenced by an instantiated machine expression are put into
 1237   the action index and written out.
 1238  -Added rlscan, an example that lexes Ragel input.
 1240 Ragel 3.1 - Feb 18, 2004
 1241 ========================
 1242  -Duplicates in OR literals are removed and no longer cause an assertion
 1243   failure.
 1244  -Duplicate entry points used in goto and call statements are made into
 1245   deterministic entry points.
 1246  -Base FsmGraph code moved from aapl into ragel, as an increasing amount
 1247   of specialization is required. Too much time was spent attempting to
 1248   keep it as a general purpose template.
 1249  -FsmGraph code de-templatized and heirarchy squashed to a single class.
 1250  -Single transitions taken out of FsmGraph code. In the machine construction
 1251   stage, transitions are now implemented only with ranges and default
 1252   transtions. This reduces memory consumption, simplifies code and prevents
 1253   covered transitions. However it requires the automated selection of single
 1254   transitions to keep goto-driven code lean.
 1255  -Machine reduction completely rewritten to be in-place. As duplicate
 1256   transitions and actions are found and the machine is converted to a format
 1257   suitable for writing as C code or as GraphViz input, the memory allocated
 1258   for states and transitions is reused, instead of newly allocated.
 1259  -New reduction code consolodates ranges, selects a default transition, and
 1260   selects single transitions with the goal of joining ranges that are split by
 1261   any number of single characters.
 1262  -Line directive changed from "# <num> <file>" to the more common format
 1263   "#line <num> <file>".
 1264  -Operator :! changed to @!. This should have happened in last release.
 1265  -Added params example.
 1267 Ragel 3.0 - Jan 22, 2004
 1268 ========================
 1269  -Ragel now parses the contents of struct statements and action code. 
 1270  -The keyword fc replaces the use of *p to reference the current character in
 1271   action code.
 1272  -Machine instantiations other than main are allowed.
 1273  -Call, jump and return statements are now available in action code. This
 1274   facility makes it possible to jump to an error handling machine, call a
 1275   sub-machine for parsing a field or to follow paths through a machine as
 1276   determined by arbitrary C code.
 1277  -Added labels to the language. Labels can be used anywhere in a machine
 1278   expression to define an entry point. Also references to machine definitions
 1279   cause the implicit creation of a label.
 1280  -Added epsilon transitions to the language. Epsilon operators may reference
 1281   labels in the current name scope resolved when join operators are evaluated
 1282   and at the root of the expression tree of machine assignment/instantiation.
 1283  -Added the comma operator, which joins machines together without drawing any
 1284   transitions between them. This operator is useful in combination with
 1285   labels, the epsilon operator and user code transitions for defining machines
 1286   using the named state and transition list paradigm. It is also useful for
 1287   invoking transitions based on some analysis of the input or on the
 1288   environment.
 1289  -Added >!, :!, $!, %! operators for specifying actions to take should the
 1290   machine fail. These operators embed actions to execute if the machine
 1291   fails in
 1292     -the start state
 1293     -any state with a transition to a final state
 1294     -any state with a transiion out
 1295     -a final state
 1296   The general rule is that if an action embedding operator embeds an action
 1297   into a set of transitions T, then the error-counterpart with a !  embeds an
 1298   action into the error transition taken when any transition T is a candidate,
 1299   but does not match the input.
 1300  -The finishing augmentation operator ':' has been changed to '@'. This
 1301   frees the ':' symbol for machine labels and avoids hacks to the parser to
 1302   allow the use of ':' for both labels and finishing augmentations. The best
 1303   hack required that label names be distinct from machine definition names as
 1304   in main := word : word; This restriction is not good because labels are
 1305   local to the machine that they are used in whereas machine names are global
 1306   entities. Label name choices should not be restricted by the set of names
 1307   that are in use for machines.
 1308  -Named priority syntax now requires parenthesis surrounding the name and
 1309   value pair. This avoids grammar ambiguities now that the ',' operator has
 1310   been introduced and makes it more clear that the name and value are an
 1311   asscociated pair.
 1312  -Backslashes are escaped in line directive paths.
 1314 Ragel 2.2 - Oct 6, 2003
 1315 =======================
 1316  -Added {n}, {,n}, {n,} {n,m} repetition operators.
 1317     <expr> {n}    -- exactly n repetitions
 1318     <expr> {,n}   -- zero to n repetitions
 1319     <expr> {n,}   -- n or more repetitions
 1320     <expr> {n,m}  -- n to m repetitions
 1321  -Bug in binary search table in Aapl fixed. Fixes crashing on machines that
 1322   add to action tables that are implicitly shared among transitions.
 1323  -Tests using obsolete minimization algorithms are no longer built and run by
 1324   default.
 1325  -Added atoi and concurrent from examples to the test suite.
 1327 Ragel 2.1 - Sep 22, 2003
 1328 ========================
 1329  -Bug in priority comparison code fixed. Segfaulted on some input with many
 1330   embedded priorities.
 1331  -Added two new examples.
 1333 Ragel 2.0 - Sep 7, 2003
 1334 =======================
 1335  -Optional (?), One or More (+) and Kleene Star (*) operators changed from
 1336   prefix to postfix. Rationale is that postfix version is far more common in
 1337   regular expression implementations and will be more readily understood.
 1338  -All priority values attached to transitions are now accompanied by a name.
 1339   Transitions no longer have default priority values of zero assigned
 1340   to them. Only transitions that have different priority values assigned
 1341   to the same name influence the NFA-DFA conversion. This scheme reduces
 1342   side-effects of priorities.
 1343  -Removed the %! statement for unsetting pending out priorities. With
 1344   named priorities, it is not necessary to clear the priorities of a
 1345   machine with $0 %! because non-colliding names can be used to avoid
 1346   side-effects.
 1347  -Removed the clear keyword, which was for removing actions from a machine.
 1348   Not required functionality and it is non-intuitive to have a language
 1349   feature that undoes previous definitions.
 1350  -Removed the ^ modifier to repetition and concatenation operators. This
 1351   undocumented feature prevented out transitions and out priorities from being
 1352   transfered from final states to transitions leaving machines. Not required
 1353   functionality and complicates the language unnecessarily.
 1354  -Keyword 'func' changed to 'action' as a part of the phasing out of the term
 1355   'function' in favour of 'action'. Rationale is that the term 'function'
 1356   implies that the code is called like a C function, which is not necessarily
 1357   the case. The term 'action' is far more common in state machine compiler
 1358   implementations.
 1359  -Added the instantiation statement, which looks like a standard variable
 1360   assignment except := is used instead of =. Instantiations go into the
 1361   same graph dictionary as definitions. In the the future, instantiations
 1362   will be used as the target for gotos and calls in action code.
 1363  -The main graph should now be explicitly instantiated. If it is not,
 1364   a warning is issued.
 1365  -Or literal basic machines ([] outside of regular expressions) now support
 1366   negation and ranges. 
 1367  -C and C++ interfaces lowercased. In the C interface an underscore now
 1368   separates the fsm machine and the function name. Rationale is that lowercased
 1369   library and generated routines are more common.
 1370     C output:
 1371       int fsm_init( struct clang *fsm );
 1372       int fsm_execute( struct clang *fsm, char *data, int dlen );
 1373       int fsm_finish( struct clang *fsm );
 1374     C++ output:
 1375       int fsm::init( );
 1376       int fsm::execute( char *data, int dlen );
 1377       int fsm::finish( );
 1378  -Init, execute and finish all return -1 if the machine is in the error state
 1379   and can never accept, 0 if the machine is in a non-accepting state that has a
 1380   path to a final state and 1 if the machine is in an accepting state.
 1381  -Accept routine eliminated. Determining whether or not the machine accepts is
 1382   done by examining the return value of the finish routine.
 1383  -In C output, fsm structure is no longer a typedef, so referencing requires
 1384   the struct keyword. This is to stay in line with C language conventions.
 1385  -In C++ output, constructor is no longer written by ragel. As a consequence,
 1386   init routine is not called automatically. Allows constructor to be supplied
 1387   by user as well as the return value of init to be examined without calling it
 1388   twice.
 1389  -Static start state and private structures are taken out of C++ classes.
 1391 Ragel 1.5.4 - Jul 14, 2003
 1392 ==========================
 1393  -Workaround for building with bison 1.875, which produces an
 1394   optimization that doesn't build with newer version gcc.
 1396 Ragel 1.5.3 - Jul 10, 2003
 1397 ==========================
 1398  -Fixed building with versions of flex that recognize YY_NO_UNPUT.
 1399  -Fixed version numbers in ragel.spec file.
 1401 Ragel 1.5.2 - Jul 7, 2003
 1402 =========================
 1403  -Transition actions and out actions displayed in the graphviz output.
 1404  -Transitions on negative numbers handled in graphviz output.
 1405  -Warning generated when using bison 1.875 now squashed.
 1407 Ragel 1.5.1 - Jun 21, 2003
 1408 ==========================
 1409  -Bugs fixed: Don't delete the output objects when writing to standard out.
 1410   Copy mem into parser buffer with memcpy, not strcpy. Fixes buffer mem errror.
 1411  -Fixes for compiling with Sun WorkShop 6 compilers.
 1413 Ragel 1.5.0 - Jun 10, 2003
 1414 ==========================
 1415  -Line directives written to the output so that errors in the action code
 1416   are properly reported in the ragel input file.
 1417  -Simple graphviz dot file output format is supported. Shows states and
 1418   transitions. Does not yet show actions.
 1419  -Options -p and -f dropped in favour of -d output format.
 1420  -Added option -M for specifying the machine to dump with -d or the graph to
 1421   generate with -V.
 1422  -Error recovery implemented.
 1423  -Proper line and column number tracking implemented in the scanner.
 1424  -All action/function code is now embedded in the main Execute routine. Avoids
 1425   duplication of action code in the Finish routine and the need to call
 1426   ExecFuncs which resulted in huge code bloat. Will also allow actions to
 1427   modify cs when fsm goto, call and return is supported in action code.
 1428  -Fsm spec can have no statements, nothing will be generated.
 1429  -Bug fix: Don't accept ] as the opening of a .-. range a reg exp.
 1430  -Regular expression or set ranges (ie /[0-9]/) are now handled by the parser
 1431   and consequently must be well-formed. The following now generates a parser
 1432   error: /[+-]/ and must be rewritten as /[+\-]/. Also fixes a bug whereby ]
 1433   might be accepted as the opening of a .-. range causing /[0-9]-[0-9]/ to
 1434   parse incorrectly.
 1435  -\v, \f, and \r are now treated as whitespace in an fsm spec.
 1437 Ragel 1.4.1 - Nov 19, 2002
 1438 ==========================
 1439  -Compile fixes. The last release (integer alphabets) was so exciting
 1440   that usual portability checks got bypassed.
 1442 Ragel 1.4.0 - Nov 19, 2002
 1443 ==========================
 1444  -Arbitrary integer alphabets are now fully supported! A new language
 1445   construct:
 1446   'alphtype <type>' added for specifying the type of the alphabet. Default
 1447   is 'char'. Possible alphabet types are:
 1448        char, unsigned char, short, unsigned short, int, unsigned int
 1449  -Literal machines specified in decimal format can now be negative when the
 1450   alphabet is a signed type.
 1451  -Literal machines (strings, decimal and hex) have their values checked for
 1452   overflow/underflow against the size of the alphabet type.
 1453  -Table driven and goto driven output redesigned to support ranges. Table
 1454   driven uses a binary search for locating single characters and ranges. Goto
 1455   driven uses a switch statement for single characters and nested if blocks for
 1456   ranges.
 1457  -Switch driven output removed due to a lack of consistent advantages. Most of
 1458   the time the switch driven FSM is of no use because the goto FSM makes
 1459   smaller and faster code. Under certain circumstances it can produce smaller
 1460   code than a goto driven fsm and be almost as fast, but some sporadic case
 1461   does not warrant maintaining it.
 1462  -Many warnings changed to errors.
 1463  -Added option -p for printing the final fsm before minimization. This lets
 1464   priorities be seen. Priorties are all reset to 0 before minimization. The
 1465   exiting option -f prints the final fsm after minimization.
 1466  -Fixed a bug in the clang test and example that resulted in redundant actions
 1467   being executed.
 1469 Ragel 1.3.4 - Nov 6, 2002
 1470 =========================
 1471  -Fixes to Chapter 1 of the guide.
 1472  -Brought back the examples and made them current.
 1473  -MSVC is no longer supported for compiling windows binaries because its
 1474   support for the C++ standard is frustratingly inadequate, it will cost money
 1475   to upgrade if it ever gets better, and MinGW is a much better alternative.
 1476  -The build system now supports the --host= option for building ragel
 1477   for another system (used for cross compiling a windows binary with MinGW).
 1478  -Various design changes and fixes towards the goal of arbitrary integer
 1479   alphabets and the handling of larger state machines were made.
 1480  -The new shared vector class is now used for action lists in transitions and
 1481   states to reduce memory allocations.
 1482  -An avl tree is now used for the reduction of transitions and functions of an
 1483   fsm graph before making the final machine. The tree allows better scalability
 1484   and performance by not requiring consecutively larger heap allocations.
 1485  -Final stages in the separation of fsm graph code from action embedding and
 1486   priority assignment is complete. Makes the base graph leaner and easier to reuse
 1487   in other projects (like Keller).
 1489 Ragel 1.3.3 - Oct 22, 2002
 1490 ==========================
 1491  -More diagrams were added to section 1.7.1 of the user guide.
 1492  -FSM Graph code was reworked to spearate the regex/nfa/minimizaion graph
 1493   algorithms from the manipulation of state and transition properties.
 1494  -An rpm spec file from Cris Bailiff was added. This allows an rpm for ragel
 1495   to be built with the command 'rpm -ta ragel-x.x.x.tar.gz'
 1496  -Fixes to the build system and corresponding doc updates in the README.
 1497  -Removed autil and included the one needed source file directly in the top
 1498   level ragel directory.
 1499  -Fixed a bug that nullified the 20 times speedup in large compilations
 1500   claimed by the last version.
 1501  -Removed awk from the doc build (it was added with the last release -- though
 1502   not mentioned in the changelog).
 1503  -Install of man page was moved to the doc dir. The install also installs the
 1504   user guide to $(PREFIX)/share/doc/ragel/
 1506 Ragel 1.3.2 - Oct 16, 2002
 1507 ==========================
 1508  -Added option -v (or --version) to show version information.
 1509  -The subtract operator no longer removes transition data from the machine
 1510   being subtracted. This is left up to the user for the purpose of making it
 1511   possible to transfer transitions using subtract and also for speeding up the
 1512   subtract routine. Note that it is possible to explicitly clear transition
 1513   data before a doing a subtract.
 1514  -Rather severe typo bug fixed. Bug was related to transitions with higher
 1515   priorities taking precedence. A wrong ptr was being returned. It appears to
 1516   have worked most of the time becuase the old ptr was deleted and the new one
 1517   allocated immediatly after so the old ptr often pointed to the same space.
 1518   Just luck though.
 1519  -Bug in the removing of dead end paths was fixed. If the start state
 1520   has in transitions then those paths were not followed when finding states to
 1521   keep. Would result in non-dead end states being removed from the graph.
 1522  -In lists and in ranges are no longer maintained as a bst with the key as the
 1523   alphabet character and the value as a list of transitions coming in on that
 1524   char. There is one list for each of inList, inRange and inDefault. Now that
 1525   the required functionality of the graph is well known it is safe to remove
 1526   these lists to gain in speed and footprint. They shouldn't be needed.
 1527  -IsolateStartState() runs on modification of start data only if the start
 1528   state is not already isolated, which is now possible with the new in list
 1529   representation.
 1530  -Concat, Or and Star operators now use an approximation to
 1531   removeUnreachableStates that does not require a traversal of the entire
 1532   graph. This combined with an 'on-the-fly' management of final bits and final
 1533   state status results is a dramatic speed increase when compiling machines
 1534   that use those operators heavily. The strings2 test goes 20 times faster.
 1535  -Before the final minimization, after all fsm operations are complete,
 1536   priority data is reset which enables better minimization in cases where
 1537   priorities would otherwise separate similar states.
 1539 Ragel 1.3.1 - Oct 2, 2002
 1540 =========================
 1541  -Range transitions are now used to implement machines made with /[a-z]/ and
 1542   the .. operator as well as most of the builtin machines. The ranges are not
 1543   yet reflected in the output code, they are expanded as if they came from the
 1544   regular single transitions. This is one step closer to arbitrary integer
 1545   output.
 1546  -The builtin machine 'any' was added. It is equiv to the builtin extend,
 1547   matching any characters.
 1548  -The builtin machine 'cntrl' now includes newline.
 1549  -The builtin machine 'space' now includes newline.
 1550  -The builtin machine 'ascii' is now the range 0-127, not all characters.
 1551  -A man page was written.
 1552  -A proper user guide was started. Chapter 1: Specifying Ragel Programs
 1553   was written. It even has some diagrams :)
 1555 Ragel 1.3.0 - Sep 4, 2002
 1556 =========================
 1557  -NULL keyword no longer used in table output.
 1558  -Though not yet in use, underlying graph structure changed to support range
 1559   transitions. As a result, most of the code that walks transition lists is now
 1560   implemented with an iterator that hides the complexity of the transition
 1561   lists and ranges. Range transitions will be used to implement /[a-z]/ style
 1562   machines and machines made with the .. operator. Previously a single
 1563   transition would be used for each char in the range, which is very costly.
 1564   Ranges eliminate much of the space complexity and allow for the .. operator
 1565   to be used with very large (integer) alphabets.
 1566  -New minimization similar to Hopcroft's alg. It does not require n^2 space and
 1567   runs close to O(n*log(n)) (an exact analysis of the alg is very hard). It is
 1568   much better than the stable and approx minimization and obsoletes them both.
 1569   An exact implementation of Hopcroft's alg is desirable but not possible
 1570   because the ragel implementation does not assume a finite alphabet, which
 1571   Hopcroft's requires. Ragel will support arbitrary integer alphabets which
 1572   must be treated as an infinite set for implementation considerations.
 1573  -New option -m using above described minimization to replace all previous
 1574   minimization options. Old options sill work but are obsolete and not
 1575   advertised with -h.
 1576  -Bug fixed in goto style output. The error exit set the current state to 0,
 1577   which is actually a valid state. If the machine was entered again it would go
 1578   into the first state, very wrong. If the first state happened to be final then
 1579   an immediate finish would accept when in fact it should fail.
 1580  -Slightly better fsm minimization now capable due to clearing of the
 1581   transition ordering numbers just prior to minimization. 
 1583 Ragel 1.2.2 - May 25, 2002
 1584 ==========================
 1585  -Configuration option --prefix now works when installing.
 1586  -cc file extension changed to cpp for better portability.
 1587  -Unlink of output file upon error no longer happens, removes dependency on
 1588   unlink system command.
 1589  -All multiline strings removed: not standard c++.
 1590  -Awk build dependency removed.
 1591  -MSVC 6.0 added to the list of supported compilers (with some tweaking of
 1592   bison and flex output).
 1594 Ragel 1.2.1 - May 13, 2002
 1595 ==========================
 1596  -Automatic dependencies were fixed, they were not working correctly.
 1597  -Updated AUTHORS file to reflect contributors.
 1598  -Code is more C++ standards compliant: compiles with g++ 3.0
 1599  -Fixed bugs that only showed up in g++ 3.0
 1600  -Latest (unreleased) Aapl.
 1601  -Configuration script bails out if bison++ is installed. Ragel will not
 1602   compile with bison++ because it is coded in c++ and bison++ automatically
 1603   generates a c++ parser. Ragel uses a c-style bison parser.
 1605 Ragel 1.2.0 - May 3, 2002
 1606 =========================
 1607  -Underlying graph structure now supports default transitions. The result is
 1608   that a transition does not need to be made for each char of the alphabet
 1609   when making 'extend' or '/./' machines. Ragel compiles machines that
 1610   use the aforementioned primitives WAY faster.
 1611  -The ugly hacks needed to pick default transitions now go away due to
 1612   the graph supporting default transitions directly.
 1613  -If -e is given, but minimization is not turned on, print a warning.
 1614  -Makefiles use automatic dependencies.
 1616 Ragel 1.1.0 - Apr 15, 2002
 1617 ==========================
 1618  -Added goto fsm: much faster than any other fsm style.
 1619  -Default operator (if two machines are side by side with no operator
 1620   between them) is concatenation. First showed up in 1.0.4.
 1621  -The fsm machine no longer auotmatically builds the flat table for
 1622   transition indices. Instead it keeps the key,ptr pair. In tabcodegen
 1623   the flat table is produced. This way very large alphabets with sparse
 1624   transitions will not consume large amounts of mem. This is also in prep
 1625   for fsm graph getting a default transition.
 1626  -Generated code contains a statement explicitly stating that ragel fsms
 1627   are NOT covered by the GPL. Technically, Ragel copies part of itself
 1628   to the output to make the generic fsm execution routine (for table driven
 1629   fsms only) and so the output could be considered under the GPL. But this
 1630   code is very trivial and could easlily be rewritten. The actual fsm data
 1631   is subject to the copyright of the source. To promote the use of Ragel,
 1632   a special exception is made for the part of the output copied from Ragel:
 1633   it may be used without restriction.
 1634  -Much more elegant code generation scheme is employed. Code generation
 1635   class members need only put the 'codegen' keyword after their 'void' type
 1636   in order to be automatically registerd to handle macros of the same name.
 1637   An awk script recognises this keyword and generates an appropriate driver.
 1638  -Ragel gets a test suite.
 1639  -Postfunc and prefunc go away because they are not supported by non
 1640   loop-driven fsms (goto, switch) and present duplicate functionality. 
 1641   Universal funcs can be implemented by using $ operator.
 1642  -Automatic dependencies used in build system, no more make depend target.
 1643  -Code generation section in docs.
 1644  -Uses the latests aapl.
 1646 Ragel 1.0.5 - Mar 3, 2002
 1647 =========================
 1648  -Bugfix in SetErrorState that caused an assertion failure when compiling
 1649   simple machines that did not have full transition tables (and thus did
 1650   not show up on any example machines). Assertion failure did not occur
 1651   when using the switch statement code as ragel does not call SetErrorState
 1652   in that case.
 1653  -Fixed some missing includes, now compiles on redhat.
 1654  -Moved the FsmMachTrans Compare class out of FsmMachTrans. Some compilers
 1655   don't deal with nested classes in templates too well.
 1656  -Removed old unused BASEREF in fsmgraph and ragel now compiles using
 1657   egcs-2.91.66 and presumably SUNWspro. The baseref is no longer needed
 1658   because states do not support being elements in multiple lists. I would
 1659   rather be able to support more compilers than have this feature.
 1660  -Started a README with compilation notes. Started an AUTHORS file.
 1661  -Started the user documentation. Describes basic machines and operators.
 1663 Ragel 1.0.4 - Mar 1, 2002
 1664 =========================
 1665  -Ported to the version of Aapl just after 2.2.0 release. See 
 1666   http://www.ragel.ca/aapl/ for details on aapl.
 1667  -Fixed a bug in the clang example: the newline machine was not stared.
 1668  -Added explanations to the clang and mailbox examples. This should
 1669   help people that want to learn the lanuage as the manual is far from
 1670   complete.
 1672 Ragel 1.0.3 - Feb 2, 2002
 1673 =========================
 1674  -Added aapl to the ragel tree. No longer requires you to download
 1675   and build aapl separately. Should avoid discouraging impatient users
 1676   from compiling ragel.
 1677  -Added the examples to the ragel tree.
 1678  -Added configure script checks for bison and flex.
 1679  -Fixed makefile so as not to die with newer versions of bison that
 1680   write the header of the parser to a .hh file.
 1681  -Started ChangeLog file.
 1683 Ragel 1.0.2 - Jan 30, 2002
 1684 ==========================
 1685  -Bug fix in calculating highIndex for table based code. Was using
 1686   the length of out tranisition table rather than the value at the
 1687   end.
 1688  -If high/low index are at the limits, output a define in their place,
 1689   not the high/low values themselves so as not to cause compiler warnings.
 1690  -If the resulting machines don't have any indices or functions, then
 1691   omit the empty unrefereced static arrays so as not to cause compiler
 1692   warnings about unused static vars.
 1693  -Fixed variable sized indices support. The header cannot have any
 1694   reference to INDEX_TYPE as that info is not known at the time the header
 1695   data is written. Forces us to use a void * for pointers to indices. In
 1696   the c++ versions we are forced to make much of the data non-member
 1697   static data in the code portion for the same reason.
 1699 Ragel 1.0.1 - Jan 28, 2002
 1700 ==========================
 1701  -Exe name change from reglang to ragel.
 1702  -Added ftabcodegen output code style which uses a table for states and
 1703   transitions but uses a switch statement for the function execution.
 1704  -Reformatted options in usage dump to look better.
 1705  -Support escape sequences in [] sections of regular expressions.
 1707 Ragel 1.0 - Jan 25, 2002
 1708 ========================
 1709  -Initial release.