version 2.5:
 - %rule has been replaced by a new rules() construct in Gom. This new
   construct ensures that rules are always applied, even when manipuling a term
   using the Java API.
 - Gom supports various theories for lists. A list can now be normalized wrt.
   associative and neutral element axioms (AU), as well as
   associative-commutative (AC) or AC with neutral element (ACU).
 - Gom supports terms with pointers to manipulate graph structures.
 - Tom has a new compiler based on constraint solving.
 - Tom supports matching for list-operators whose domain is equal to the codomain.
   This corresponds to associative matching with neutral element (AU).
   An interesting variant for flattened lists (FL) has also been developed. 
 - Tom supports any combination of patterns, anti-patterns, and list-operators
   are fully supported, even with anti-patterns.
 - The new strategy library sl allows access to more context information, such
   as the root of the term to which the strategy is applied
 
version 2.4:
 - the eclipse plugin is back, for eclipse version 3.2

 - in the %match construct, the sort of the subject is now optional. Its is
   automatically inferred from the patterns when possible. In addition, a
   subject is no longer restricted to a variable. Constructors and function
   calls can be used.

 - Gom generates congruence strategies and offers new functionalities, such as
   the length of a list.

 - !: a new construct that can be used to denote anti-patterns. Tom support
   anti-patterns under syntactic and list-operators, but not yet in XML.

 - the strategy library has been extended such that strategy expressions can be
   matched, like any other term. A strategy can now take another strategy in
   argument. The mu-expansion is performed on strategies defined using
   %strategy.

 - a support for Java bytecode analysis and transformation has been added

version 2.3:
 - a new generator of abstract data types has been introduced: Gom.
   Its syntax is compatible with the syntax of Vas.
   Gom is more expressive than Vas by allowing the definition of Hooks.
   This ensure that an action is executed each time a constructor is built. In
   practice, this allows to compute canonical forms.
   In addition, Gom generate more compact code and is more efficient than Vas.

 - %strategy: a new construct that helps to defines strategies. When
   using %strategy, it is no longer necessary to define inner-classes.
   In addition, a Tom mapping is automatically generated.

- %[...]%: a new construct that helps to write backends. The text
   between %[ and ]% is no interpreted, therefore the string
   s=%[print("hello\n")]% corresponds to s="print(\"hello\\n\")"

 - the documentation has been improved. The four documents (reference, guide,
   tutorial, and cookbook) have been merged into one: manual

 - new organization
    * tom
    *  |--- engine
    *  |      |--- adt               (datatype definitions)
    *  |      |--- backend
    *  |      |--- checker
    *  |      |--- compiler
    *  |      |--- exception
    *  |      |--- optimizer
    *  |      |--- parser
    *  |      |--- starter
    *  |      |--- tools
    *  |      |--- verifier
    *  |      |--- xml
    *  |--- library
    *  |--- platform

version 2.2:
  - this version is not 100% compatible with version 2.1.
    see User Guide, section migration, for details.
  - %typelist and %typearray have been removed: use %typeterm instead
  - access functions (get_head, get_tail, etc.) have to be defined in %oplist
    and %oparray
  - fixed a completeness bug in array version of list-matching
  - a new optimizer has been developed (-O2): this improves pattern matching
    efficiency
  - backquote notation can be used in make(...) { ... }

version 2.1:
  - introduced %vas syntax
  - new parser based on ANTLR
  - new internal architecture based on plugins
  - new library for defining traversal strategies
  - fixed two major bugs, related to completeness, in list-matching
  - several bug fixed
  - new library organization
    * tom
    *  |--- library
    *  |        |--- adt               (datatype definitions)
    *  |        |--- mapping           (predefined mapping)
    *  |               |--- adt        (generated mapping)
    *  |        |--- plugin            (platform tools)
    *  |        |--- set               (to handle sets)
    *  |        |--- strategy
    *  |               |--- concurrent (to support parallel strategy)
    *  |        |--- traversal         (generic traversal)
    *  |        |--- xml               (xml tools)
    *  |
    *  |--- platform                   (the Tom Plugin Platform, known as Tom server)
    *           |--- adt

version 2.0:
  - support for Caml
  - introduced several predefined mappings
  - added an optimizer which performs inlining and improves the
    efficiency of the generated code
  - support for builtin char and builtin string (seen as list of
    char)
  - a better XML support (backquote notation, anonymous nodes)
  - re-designed kernel compiler (with better algorithms)
  - re-designed list-matching
  - annoted variables and non-linear variable are compiled into constraints
  - syntactic patterns are no longer abstracted, but compiled in list-matching
  - several bugs fixed (improved the sortAttributeList method, major
    bug in the Type Expander)
  - removed %typeint, %typedouble and %typestring (use predefined mapping instead)

version 1.5:
  - ported jtom to new version of apigen
  - new TomChecker and simpler regression test infrastructure
  - added disjunction of HeadSymbol
  - XML syntax corresponds to implicit notation
  - implicit and explicit XML lists are allowed
  - unamed lists are allowed
  - sort attribute names by alphabetic order
  - new XML parser
  - fix undetected error
  - optimization in matching: do not assign UnamedVariable when
    they are not annotated
  - fix a bug in linearization of annoted variables
  - allow UnamedVariable and UnamedVariableStar in list-matching
  - allow annoted variables in list-matching

version 1.4:
  - fix the ^M problem under windows
  - user defined labels a are allowed in patterns
  - complex paths allowed in %include constructs

version 1.3:
  - %typein and %typedouble added
  - runtime/strategies added to stable
  - builtin strings supported in back-quoted terms
  - start debugger development
  - allow is_fsym for list and array operators

version 1.2:
  - beginning of documentation: Tom user manual
  - improved debugging facilities
  - traversal facilities added in jtom.runtime
  - disjunction of patterns supported
  - integer in backQuotedTerm supported
  - matching and equality conditions supported in rewrite rules
  - several bugs fixed

version 1.1:
  - new debugging facilities:
    Tom source and the generated code are now synchronized
  - backquote support for typelist and typearray
    make_add renamed into make_insert (for oplist)
    make_add renamed into make_append (for oparray)
  - non-linear patterns supported
  - builtin-integers supported
  - tutorial

version 1.0:
  - new stable version based on ApiGen
  - efficiency bottleneck found
  - import option added: path extension for includes
  - noDeclaration flags added: do not generate declarations

version 0.7:
  - bootstrap with ApiGen (6 types)

version 0.6:
  - use a cache to improve the generator
  - backquote mechanism introduced

version 0.5:
  - front-end improved by adding a type checker.
