GRAMMATICA VERSION INFORMATION
==============================

Version 1.4 (2003-08-27):
-------------------------

    o Added Apache Ant task
      An Apache Ant task has been added to the distribution. See the 
      reference manual for details on how to use it. (Bug #3620)

    o Added support for retrieving all tokens
      The Tokenizer class now supports enabling a useTokenList 
      feature, that will link all tokens in a double-linked list. 
      This can be used to access whitespace and comment tokens, 
      although otherwise ignored by the parser. By default this 
      feature is off, to avoid potetial garbage collection problems 
      when parsing large files. (Bug #3605)

    o Removed API documentation for unsupported API
      Java API documentation for the unsupported API:s in Grammatica 
      is no longer created or distributed. (Bug #4969)

    o Corrected a null pointer error in --profile
      When using --profile a null pointer exception was thrown during 
      the parsing of the file. This was due to the analyzer being set 
      to null, something that has now been made impossible. (Bug 
      #4967)


Version 1.3 (2003-07-27):
-------------------------

    o Added C# API documentation
      C# API documentation has now been added to the release 
      documentation. The build file uses CppDoc to generate the HTML 
      documents. (Bug #3612)

    o Added source code examples to documentation
      Some examples of Java source code for creating a parser has 
      been added to the reference manual. (Bug #4093)

    o Improved and clarified the Analyzer API
      The Analyzer class API has been clarified by improving the 
      generated comments slightly and by adding a getChildValues() 
      method. (Bug #4181)

    o Corrected generation of C# analyzer classes
      The generation of C# analyzer classes was completely broken in 
      all previous releases, due to missing keywords and erroneous 
      casing of method names. Tests have now been added to verify the 
      generated analyzers. This was only an issue in the C# code 
      generation, as the Java version has been tested continuously. 
      (Bugs #4416 and #4498)


Version 1.2 (2003-06-10):
-------------------------

    o Added profiling for grammars
      A new action --profile has been added that prints out the 
      statistics from a profiling run of the grammar. This is useful 
      for improving the grammar and parsing speed. (Bug #3936)

    o Improved tokenizer performance
      The tokenizer performance has been much improved for string 
      tokens. The speed improvement is about 100% on average, meaning 
      that the tokenizer will use half the time for most input and 
      grammars. (Bug #3603)

    o Improved the parse tree output on error
      The parse tree was previously only printed when a file could be 
      parsed correctly. Now the parse tree is printed until the first 
      syntax error is found. (Bug #3930)

    o Improved error message for missing '%' character
      When missing the final '%' character in the grammar file, the 
      error message printed was not logical. This has been improved 
      by printing an 'unterminated directive' error instead. (Bug 
      #3931)

    o Improved the reference manual
      The reference manual has been improved to the point where it is 
      considered finished. There is still room for much improvement, 
      however, and such fixes will added in later versions. (Bug 
      #3598)

    o Corrected unexpected token error messages
      In some circumstances the unexpected token error messages 
      didn't list all possible tokens. This only ocurred for 
      productions containing alternatives with ambiguities that were 
      resolved with one alternative being set as the default. This 
      has now been corrected, which should also improve the error 
      recovery in these cases. (Bug #3929)


Version 1.1 (2003-05-26):
-------------------------

    o Added automatic error recovery
      Automatic error recovery is now always attempted without any 
      changes to the grammar. Unfortunately the parser library API 
      had to be changed a bit to make this possible. (Bug #3601)

    o Added debug printout of the interpreted grammar
      A new action --debug has been added that prints out the 
      internal representation of the grammar. This is useful for 
      debugging, as it also prints the look-ahead token sets 
      calculated. (Bug #3692)

    o Improved speed of the look-ahead calculation
      Calculating look-ahead sequences longer than four (4) tokens, 
      could be very slow in previous versions. This was due to the 
      algorithm being used. A new algorithm has now been implemented, 
      speeding up the process and allowing calculation of look-aheads 
      of at least 10 tokens length. (Bug #3674)

    o Corrected stack overflow in regular expressions
      Regular expressions containing reluctant quantifiers (such as 
      '*?') caused stack overflow errors when matching long input 
      strings (about 4096 characters). This has now been fixed in 
      both the C# and Java versions, and new automatic test cases 
      have been added. (Bug #3632)

    o Corrected failing regular expression match
      Tokens with regular expression patterns sometimes didn't find a 
      proper match. This only occured for expressions containing 
      quantifiers ('*', '+', '*?' and '+?'), and only extremely 
      seldom due to a failure to reset previous matches. This was 
      only ever an issue in the Java version, where it has now been 
      fixed. (Bug #3653)


Version 1.0 (2003-05-14):
-------------------------

    o Improved grammar error reporting
      Error messages printed by Grammatica have been much improved in 
      various ways. First, the exception traces are no longer printed 
      by default. Secondly, the faulting line is printed on many 
      errors (as done by javac). Thirdly, ambiguity errors are now 
      reported with a list of conflicting tokens, making them easier 
      to understand.

    o Corrected parse tree analyzer child handling
      A bug in the base Analyzer class caused the child() methods not 
      to be called when processing a parse tree after creation (both 
      for C# & Java). When analyzing through callbacks things did 
      work as expected, though.


Version 0.4 (2003-05-08):
-------------------------

    o Added creation of C# parsers (for .NET)
      The parser runtime library has been ported to C#, so it is now 
      possible to generate parsers for .NET languages. A C# parser 
      output has also been added to the main program.

    o Added unit tests for generated parsers
      Validation of the parsers generated for both C# and Java has 
      been automated in unit tests. A bug in the previous release was 
      detected through these tests (see below).

    o Added a first draft reference manual
      A first short reference manual has been added to the 
      documentation. The reference manual is generated to HTML from 
      XML just as the release notes.

    o Corrected parse exception creation bug
      When creating a parse exception, the LL(k) parser in some 
      situations caused a NullPointerException. This has now been 
      corrected.


Version 0.3 (2003-05-04):
-------------------------

    o Created XML generated documentation
      The release documentation is now available in both text and 
      HTML format. Both formats are generated with XSLT from a single 
      source.

    o Added look-ahead loop detection
      The look-ahead calculation now detects grammar loops and all 
      grammar ambiguities. It should no longer be possible to cause 
      infinite loops with a malformed grammar.

    o Added ambiguity resolution inside alternatives
      Some ambiguities inside productions couldn't previously be 
      resolved by the LL(k) parser. Productions like ["one"] "one" 
      "two" contain an ambiguity between the first element and the 
      second, but it is not inherent. This is now handled correctly 
      by adding look-ahead sets for individual production elements.

    o Added expected tokens to parse errors
      The parse error exceptions now contains a list of the expected 
      tokens for the unexpected token errors.

    o Added automatic unit tests for the parser
      A JUnit class testing the LL(k) parser has been added. These 
      tests are executed upon every build to verify the integrity of 
      the parser.


Version 0.2 (2003-04-20):
-------------------------

    o Addition of an internal regular expression library
      This improves tokenizer performance by at least 100% compared 
      to using the GNU RegExp library.

    o Addition of an analyzer framework with parser callbacks
      A code generator has also been added to create default methods 
      for all tokens and productions in the grammar.

    o Major refactorings of the tokenizer and parser classes
      Various other classes have also been improved to simplify 
      future feature additions.


Version 0.1 (2003-03-29):
-------------------------

    o Initial release
      The first alpha release. This version was only available to a 
      limited audience.


_____________________________________________________________________

Grammatica 1.4 (2003-08-27). See http://www.nongnu.org/grammatica for
more information.

Copyright (c) 2003 Per Cederberg. Permission is granted to copy this 
document verbatim in any medium, provided that this copyright notice 
is left intact.
