Changes in DyALog 1.11.3

	* Added -dev option when using dyacc (the auto-detect -dev
          mechanism for dyacc does not seem to work correctly in some
          situations)

	* Changes subsuming policy for TAG post-substitution
          continuation. There are now subsumed by default. Should soon
          add some user option for more flexibility.

	* Fixed bugs in subsumption checking on dereferencable terms
          such as fset terms.

	* Small modif im Ma2asm for darwin/intel

	* Fixed bug in modulation for tig adjunctions.

	* Non cycling indirect forest parts no longer require 
	  the #x or #x{ ... } notation. This notation is only required
	  for non empty cycling indirect parts.

Changes in DyALog 1.11.2

	* Somes fixes to allow compilation with gcc-4.1.0

Change in DyALog 1.11.1

       * Prelimary port to MacOS intel (*86-darwin) which has induced
         a model change for Ma2Asm (and possible consequences for
         linux x86 !)

Change in DyALog 1.11.0

      * Many fixes to allow compilation with gcc-4.0.0 and with
      reduced warning.


      * Added preliminary handling of a skip action during parsing, with the
	possibility to leave traces in the derivation forest.

	A skip predicate may be installed with the directive
	:-skipper(my_skip_predicate)
	where my_skip_predicate(Left,Token,Right) :- ...

	The skip predicate is used prior scanning, anchoring and coanchoring.

Change in DyALog 1.10.7

      * Preliminary support to customize TAG substitution via the
        directive :-tag_custom_subst(Custom_Pred).

	The original TAG subst application may be protected via
	'$protect'(Node) to avoid endless recursions !

	For instance, one can write:

	:-tag_custom_subst(my_subst_handler).

	my_subst_handler(P,Left,Right,N) :-
	      format('Trying ~w ~w ~w\n',[P,Left,Right,N]),
	      tag_phrase( '$protect'(id=N at P), Left, Right ),
	      format('Found ~w ~w ~w\n',[P,Left,Right,N]),
	      true
	      .

        The possibility to customize TAG substitution should be
        generalized to other kinds of applications (such as
        adjunction).

        * completed support for the use of metacalls to write stuff
          like '$answers'(NT) where NT may stand for any predicte or
          non-terminal (depending on the context). A predicate or
          non-terminal can be accessed through metacalls only it is
          has been declared with the directive public/1 (that accepts
          the '*default*' value)

	* fixed a few bugs and features relative to the use of finite sets.

Change in DyALog 1.10.6

      * Updated support to start and compile new projects with DyALog
        (see dyalog-config and dyalog-template)

      * Regexp-like operators like kleene-star (@*) and interleaving
        (##) now available for TAGs. Guarded nodes are also available
        (guard{ goal => G, true => Cond1, fail => Cond2 }). Added
        notion of coanchor nodes (<=> Cat).

      * improved -verbose_tag mode for reading TAG derivation forest
        (** NOT BACKWARD COMPATIBLE **)

      * Preliminary support for meta-predicates in TAG/TIGs and DCGs
        ($call and $answers)

      * Fixes of several pbs related to regexp-like operators

      * Improved support for TIGs

Change in DyALog 1.10.5

       * Modified support predicates for verbose traces in TAG
         derivation forests. This modication is NOT backward
         compatible.

Change in DyALog 1.10.4

       * Improved support for RCG 

       * Updated support for shared forest browsing and extraction

Change in DyALog 1.10.3

       * Prelimary support to mix TAG and TIG (Tree Insertion
         Grammars, a restricted form of TAG). Compiler option -analyze
         tag2tig identifies auxiliary trees which are left or right
         TIG and output compiler directives. 

	 Multiple adjunction used for TIG

       * Prelimary support for interleaving in DCG using construction
         (A ## B). Non-terminals and terminals in A and B are then
         freely interleaved, preserving respective order whithin A and
         B.

	 For instance ("a","b" ## "x") covers "abx" "axb" and "xab"

	 Nested interleaving is supported.

       * Kleene operator now allowed in DCG productions, using
	notation G @* or X^G @* (to bound variables in X in each
	occurrence of G). See Tests/kleene.dcg for an example.

       * Added file 'dyalog.pc' to be used with pkg-config as an
         alternative for dyalog-config

       * Finite Set are no longer limited to 29 elements (but still to
         255) and should now be more robust

       * Autoloading (option -autoload) have been completed for DCG,
         TAG and TIG. Autoloading is used to filter out
         lexicalized/anchored productions/trees whose lexicals/anchors
         are not present in the input string.

Change in DyALog 1.10.2

       * Improved pretty-printing with library file format.pl. In
         particular, possibility of indented printing with ~Q

       * Improved handling of '$answers'/1 for light_tabular predicates

       * Added negation operator ~ in finite sets (e.g. letter[~ [a,e,i,o,u,y]])

Change in DyALog 1.10.1

        * Added preliminary support for installing predicates in
        modules. Directive :-module(Module) set default namespace to
        Module for all predicates. Directive
        :-import{module=>Module,preds=>Preds} may be used
        to import predicates from Module.
        * Added preliminary support for namespaces and modules using
	module!name notation. Feature term functors and Finite Set
	functor now belong to specific namespaces.
	* Directive :-end_require to stop reading a file in require mode.
	* Toplevel used to implement term_expand/2, dcg_term_expand/6 and bmg_term_expand/10
	* Added preliminary support for floats
	* Added script 'dyalog-template' to start new project with DyALog
	* More robust script 'dyalog-config'
	* Updated to automake-1.6.2 and autoconf-2.53
	* Boehm GC code is now used as an extern package
	http://www.hpl.hp.com/personal/Hans_Boehm/gc/gcinterface.html
	* Added toplevel to DyALog (dyalog -a -toplevel)
	* Default loader conditions added for DCG and RCG
	* Loading conditions only used in conjunction with option -autoload
	* added directive light_tabular/1 for tabulated predicates that are not "cyclic",
	  i.e. no call for P subsumes one of its descendant calls
        * added support for left corner for DCG with compiler
	directive lc/1 (use left-corner for a predicate) and option -analyze lc (to build the
        left corner relation)

Change in DyALog 1.10.0

	* Terms and objects skeletons are no longer built during
	initialization but when needed.

	* Objects corresponding to clauses may be loaded on condition
	using syntax '$loader'(Cond,Clause). 

	* A TAG tree is loaded on condition that the input string
	provides potential values for the anchor and lexical nodes of the tree.

	* A better wrapping scheme is used to compile TAG adjunction
	nodes, in order to save space and compilation time.

	* Added options -pg and -g to dyacc for profiling and
	debugging (similar to C options -pg and -g)

Change in DyALog 1.9.1

	* litterals in clause body may be labelled to get a better
display of forests. The binary labelling operetor may be specified
using directive :-tagop/1.

	* scanning by be done using some user-defined predicate using
directive :-scanner/1.

	* fixed a few bugs (reading number, lexing long comments, path
traversal, ...).

Change in DyALog 1.9.0

	* Preliminary implementation of Range Concatenation Grammars (RCG) (rcg.pl)
        The implementation is not optimal (need for constraints) but
	should be sufficient to play with RCG.

        * Added mechanism to handle Regression Suites (Tests/) A full
	list of tests has still to be established.

Change in DyALog 1.8.2

	* fixed bugs in Runtime files raising compilation problems
with gcc on Redhat 7.* (one of them is maybe a pb of gcc)
	* fixed bugs in relation with BMG (dcg.pl and bmg.pl)
	* fixed bugs in relation with modulation (reader.pl)

Change in DyALog 1.8.1

	* fixed bugs in relation with infinite terms.

Change in DyALog 1.8.0

	* Preliminary implementation of infinite terms, using a
	special kind of deref terms based on predicate '$LOOP'/3. Bugs
	are expected !

	* Changed low-level parameters of DyALog, namely the tags used
	for the various kinds of terms (integers, chars,
	...). Previous programs should be recompiled.

Change in DyALog 1.7.3

	* Last version before introducing infinite terms

Change in DyALog 1.7.2

	* Removed arbitrary compilation limits on the number of
strings and longs.

	* Changed notation for finite set from f{a,b,c} to f[a,b,c] to
avoid conflict on f{} if f is both a feature functor and a fset
functor. The old notation remains valid for backward compatibility.

Change in DyALog 1.7.1

	* Tiny modifications for compilation on Sparc Solaris (tentative)

Change in DyALog 1.7.0

	* Enriched DyALog mini assembler and updated it for SPARC.

	* Many deep modifications of the Compiler part (simpler
handling of alternatives, wrapping of tabular predicates, ...).

	* More efficient handling of Garbage Collection (for terms).

Change in DyALog 1.6.0

	* Changed to a lighter and faster tabulation scheme for
TAGs. It is theoretically worst but faster in practive. Still a few
details to check.

	* Use more efficient C functions to help the compiler. Still
other functions to write. 

Change in DyALog 1.5.0

	* First implementation of a foreign interface to C through
'$interface'. More details in Compiler/foreign.pl

	* Syntax extension of the Modulation Mode Templates to allow
lists such as [+|-].

Change in DyALog 1.4.4

	* Updated Boehm Gc package to version 5.0
	
Change in DyALog 1.4.3

	* Added option -verbose_tag to the compiler to get mmore
verbose TAG forests

Change in DyALog 1.4.1

	* Completed extensions for the TAGs to handle tree families
and anchors (note that the library file 'tag_generic.pl' is required).

Change in DyALog 1.4.0

	* Add predicate find 'std_prolog' (subclass of
	'rec_prolog'). They have still some limitations but are very
	close from traditionnal prolog predicates. Their main
	advantage is that last call optimisation is possible with them.

	* Some extensions of TAGs (still under developpment)

Change in DyALog 1.3.0

	* Fixed many bugs for TAGs
	* Changed internal mechanisms to handle continuations (now using closures)
	* Better representation of forests (for TAGs and for Prolog parts)
	* Reduced size of variable tupples in continuations

Change in DyALog 1.2.0:

	* First port for Sparc SunOS4

Change in DyALog 1.1.2:

	* Extended the parser to accept multiple occurence of a same
	feature in a feature terms: the values are unified at parse
	time.

Change in DyALog 1.1.1:

	* Fix a small bug in Runtime/parser.c
	* Fix a few bugs relative to the use of Typed Feature Structures

Change in DyALog 1.1:

	* Many small changes
	* Extension of the compiler to handle Tree Adjoining Grammars
(TAGs)

Change in DyALog 1.0:

	* First official release of DyALog (no longer based on Scheme
to C compiler Bigloo).