<doc>
  <head>
    <title>Grammatica Version Information</title>
  </head>

  <body>

    <h1>Version <param name="version"/> (<param name="date"/>):</h1>

    <list>
      <item>
        <title>License modified to revised BSD</title>
        <text>The license agreement for this library has been changed
        to revised BSD license. This change was made to avoid any confusion
        related to usage in commercial (closed source) applications.</text>
      </item>

      <item>
        <title>Fixed minor API issues for reusing parsers</title>
        <text>The <code>Parser.reset</code> method is now available
        in a new flavor that allows replacing the <code>Analyzer</code>
        being used. Also the <code>Tokenizer</code> now disposes the
        input buffer and references to parsed tokens already when the
        end of file is encountered.</text>
      </item>
    </list>


    <h1>Version 1.5 (2009-03-07):</h1>

    <list>
      <item>
        <title>License modified to GNU LGPL version 3</title>
        <text>The license agreement for this library has been changed
        to <a href="http://www.gnu.org/licenses/lgpl.html">GNU LGPL,
        version 3</a>. This change was made for compatibility reasons
        and most users will remain unaffected.</text>
      </item>

      <item>
        <title>Added Visual Basic.NET code generation</title>
        <text>A Visual Basic.NET source code generator has been
        contributed by Adrian Moore. It uses the same run-time library
        (DLL) as the C# .NET version. <ref bug="8199"/></text>
      </item>

      <item>
        <title>Added support for case-insensitive parsing</title>
        <text>A <code>CASESENSITIVE</code> grammar declaration has
        been added to make it possible to parse in case-insensitive
        mode. By default all parsing is case-sensitive. Thanks to
        Adrian Moore for providing a partial implementation.
        <ref bug="5060"/></text>
      </item>

      <item>
        <title>Added support for reusing parsers and tokenizers</title>
        <text>A <code>reset()</code> method has been added to both the
        Parser and the Tokenizer classes, allowing to reuse a parser
        with a new input stream. By reusing a single parser and
        tokenizer for various input files speed and memory gains can
        be made, especially for complex grammars.
        <ref bug="4500"/></text>
      </item>

      <item>
        <title>Added factory methods for creating various objects</title>
        <text>New factory methods for creating tokens, productions,
        tokenizers and analyzers have been added. These can be overridden
        in subclasses to provide more specific classes if desired.</text>
      </item>

      <item>
        <title>Improved the tokenizer processing speed</title>
        <text>The tokenizer speed has been improved by using a custom
        DFA implementation for regular expressions. The tokenization
        phase now runs some 20-30% faster in the general case.
        <ref bug="3603"/> &amp; <ref bug="8202"/></text>
      </item>

      <item>
        <title>Changed to use native Java regular expressions</title>
        <text>Since the built-in regular expression library is not used
        as frequently after the implementation of DFA regular expression
        handling, the native Java regular expression classes are now
        used. This implies improved support for advanced regular
        expression syntax (at a performance penalty).
        <ref bug="3597"/> &amp; <ref bug="17189"/></text>
      </item>

      <item>
        <title>Changed .NET parser namespace for C# 2.0</title>
        <text>The C# parser namespace has been modified from
        <code>PerCederberg.Grammatica.Parser</code> to
        <code>PerCederberg.Grammatica.Runtime</code> due to the new
        C# 2.0 compiler strictness. <ref bug="14302"/></text>
      </item>

      <item>
        <title>Changed .NET parser API for better integration</title>
        <text>The .NET parser API has been modified for almost all
        classes, introducing properties and indices instead of getter
        and setter methods. The old methods have been deprecated, but
        are still available to avoid breaking existing applications.
        <ref bug="8693" /></text>
      </item>

      <item>
        <title>Changed built-in regular expression API subtly</title>
        <text>Due to fixes required to be able to reuse tokenizers,
        the built-in regular expression class API had to be changed
        subtly. In essence, all the methods can now throw IOException
        which breaks a Java compile. <ref bug="4500"/></text>
      </item>

      <item>
        <title>Fixed possible divide by zero in profiling</title>
        <text>When profiling grammars with small input files, the time
        measured could previously be zero (0). This caused a division
        by zero exception when calculating the number of tokens parsed
        per second. <ref bug="7998"/></text>
      </item>

      <item>
        <title>Fixed parse error on some grammar comments</title>
        <text>Grammar comments ending with "**/" previously caused a
        parse error. The comment token regular expression has now been
        corrected to fix this. <ref bug="12767"/></text>
      </item>

      <item>
        <title>Fixed premature EOF reported in some cases</title>
        <text>The tokenizer previously assumed EOF had been encountered
        when a full look-ahead buffer couldn't be read. Thanks to 
        Jeremy M Stone for finding this. <ref bug="23818"/></text>
      </item>

      <item>
        <title>Fixed token match priority to use the grammar order</title>
        <text>String tokens were previously always checked and considered
        first, unless a regular expression token matched more characters.
        This has now been changed to depend on the grammar file ordering
        instead. <ref bug="13009"/></text>
      </item>
    </list>


    <h1>Version 1.4 (2003-08-27):</h1>

    <list>
      <item>
        <title>Added Apache Ant task</title>
        <text>An Apache Ant task has been added to the distribution.
        See the reference manual for details on how to use it. 
        <ref bug="3620"/></text>
      </item>

      <item>
        <title>Added support for retrieving all tokens</title>
        <text>The <code>Tokenizer</code> class now supports enabling 
        a <code>useTokenList</code> 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. 
        <ref bug="3605"/></text>
      </item>

      <item>
        <title>Removed API documentation for unsupported API</title>
        <text>Java API documentation for the unsupported API:s in 
        Grammatica is no longer created or distributed. 
        <ref bug="4969"/></text>
      </item>

      <item>
        <title>Corrected a null pointer error in <code>--profile</code></title>
        <text>When using <code>--profile</code> 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. <ref bug="4967"/></text>
      </item>
    </list>


    <h1>Version 1.3 (2003-07-27):</h1>

    <list>
      <item>
        <title>Added C# API documentation</title>
        <text>C# API documentation has now been added to the 
        release documentation. The build file uses CppDoc to
        generate the HTML documents. <ref bug="3612"/></text>
      </item>
      
      <item>
        <title>Added source code examples to documentation</title>
        <text>Some examples of Java source code for creating a
        parser has been added to the reference manual. 
        <ref bug="4093"/></text>
      </item>

      <item>
        <title>Improved and clarified the Analyzer API</title>
        <text>The Analyzer class API has been clarified by improving
        the generated comments slightly and by adding a 
        <code>getChildValues()</code> method. <ref bug="4181"/></text>
      </item>

      <item>
        <title>Corrected generation of C# analyzer classes</title>
        <text>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. <ref bug="4416"/> &amp; <ref bug="4498"/></text>
      </item>
	</list>


    <h1>Version 1.2 (2003-06-10):</h1>

    <list>
      <item>
        <title>Added profiling for grammars</title>
        <text>A new action <code>--profile</code> 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. <ref bug="3936"/></text>
      </item>

      <item>
        <title>Improved tokenizer performance</title>
        <text>The tokenizer performance has been much improved for
        string tokens. The tokenization speed is now about twice as fast
        (on average), meaning that the tokenizer will use half as much
        time for most input and grammars. <ref bug="3603"/></text>
      </item>
      
      <item>
        <title>Improved the parse tree output on error</title>
        <text>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.
        <ref bug="3930"/></text>
      </item>

      <item>
        <title>Improved error message for missing '%' character</title>
        <text>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. <ref bug="3931"/></text>
      </item>

      <item>
        <title>Improved the reference manual</title>
        <text>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. <ref bug="3598"/></text>
      </item>

      <item>
        <title>Corrected unexpected token error messages</title>
        <text>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. <ref bug="3929"/></text>
      </item>
    </list>


    <h1>Version 1.1 (2003-05-26):</h1>

    <list>
      <item>
        <title>Added automatic error recovery</title>
        <text>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. 
        <ref bug="3601"/></text>
      </item>

      <item>
        <title>Added debug printout of the interpreted grammar</title>
        <text>A new action <code>--debug</code> 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. <ref bug="3692"/></text>
      </item>

      <item>
        <title>Improved speed of the look-ahead calculation</title>
        <text>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.
        <ref bug="3674"/></text>
      </item>
    
      <item>
        <title>Corrected stack overflow in regular expressions</title>
        <text>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.
        <ref bug="3632"/></text>
      </item>

      <item>
        <title>Corrected failing regular expression match</title>
        <text>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. <ref bug="3653"/></text>
      </item>
    </list>


    <h1>Version 1.0 (2003-05-14):</h1>

    <list>
      <item>
        <title>Improved grammar error reporting</title>
        <text>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.</text>
      </item>

      <item>
        <title>Corrected parse tree analyzer child handling</title>
        <text>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# &amp; Java). When analyzing through 
        callbacks things did work as expected, though.</text>
      </item>
    </list>


    <h1>Version 0.4 (2003-05-08):</h1>

    <list>
      <item>
        <title>Added creation of C# parsers (for .NET)</title>
        <text>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.</text>
      </item>
  
      <item>
        <title>Added unit tests for generated parsers</title>
        <text>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).</text>
      </item>

      <item>
        <title>Added a first draft reference manual</title>
        <text>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.</text>
      </item>

      <item>
        <title>Corrected parse exception creation bug</title>
        <text>When creating a parse exception, the LL(k) parser in
        some situations caused a NullPointerException. This has now
        been corrected.</text>
      </item>
	</list>


    <h1>Version 0.3 (2003-05-04):</h1>
    
    <list>
      <item>
        <title>Created XML generated documentation</title>
        <text>The release documentation is now available in both text
        and HTML format. Both formats are generated with XSLT from a
        single source.</text>
      </item>

      <item>
        <title>Added look-ahead loop detection</title>
        <text>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.</text>
      </item>
      
      <item>
        <title>Added ambiguity resolution inside alternatives</title>
        <text>Some ambiguities inside productions couldn't previously 
        be resolved by the LL(k) parser. Productions like
        <code>["one"] "one" "two"</code> 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.</text>
      </item>
  
      <item>
        <title>Added expected tokens to parse errors</title>
        <text>The parse error exceptions now contains a list of the
        expected tokens for the unexpected token errors.</text>
      </item>

      <item>
        <title>Added automatic unit tests for the parser</title>
        <text>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.</text>
      </item>
    </list>    


    <h1>Version 0.2 (2003-04-20):</h1>

    <list>
      <item>
        <title>Addition of an internal regular expression library</title>
        <text>This improves tokenizer performance by at least 100% 
        compared to using the GNU RegExp library.</text>
      </item>

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

      <item>
        <title>Major refactorings of the tokenizer and parser classes</title>
        <text>Various other classes have also been improved to simplify 
        future feature additions.</text>
      </item>
    </list>


    <h1>Version 0.1 (2003-03-29):</h1>

    <list>
      <item>
        <title>Initial release</title>
        <text>The first alpha release. This version was only available
        to a limited audience.</text>
      </item>
    </list>

  </body>
</doc>
