CodeBoost NEWS                                              (-*- Text -*-)
==============

Version 0.3.0:

  * Compiles with StrategoXT 0.9.5.

  * Works with autoconf 2.50+, automake 1.7+.

  * New autoxt based build system:  Stratego programs are now compiled to
    C code, which is then compiled and linked normally.  The (architecture
    independent) C files are included in the tarball distribution, so it is
    now possible to build CodeBoost without the Stratego compiler, as long
    as none of the Stratego source files are changed.  Furthermore, all
    Stratego source files have been renamed, and now use the .str extension
    (instead of .r).

  * Source tree moved to Subversion:

      https://svn.cs.uu.nl:12443/repos/codeboost/

  * More C++ language features supported: namespace, using (syntactic
    support only), enum, extern "C", hexadecimal literals, multi-line
    preprocessor directives.

  * Semantic analysis is much improved.

  * Added memoisation makes CodeBoost run 2-3 times faster.

  * AST changes:

    + New type representation:

      Old style used Type(q,n,d), where q was a list of qualifiers
      (signedness, constness, etc.), n was the type name, and d was the
      'declarator-part' of the type (e.g., 'pointer-to' or 'reference-to').

      The new style is defined inductively as follows:

	  type        := Type(cv-mod-type)
	  cv-mod-type := cv-type | mod-type | Array(expr, cv-mod-type)
	  cv-type     := Const(mod-type)
		       | Volatile(mod-type) 
		       | Const(Volatile(mod-type))
	  mod-type    := base-type
		       | Ptr(cv-mod-type)
		       | Ref(cv-mod-type)
	  base-type   := BaseType(name)
		       | FunType(list(type|Ellipsis), type)

      For example:

          int   (an integer) => Type(BaseType(IdName("int")))

          int*  (ptr to int) => Type(Ptr(BaseType(IdName("int"))))

          const int* (ptr to const int)
		=> Type(Ptr(Const(BaseType(IdName("int")))))

	  int (*)(const char*, int[5]) (ptr to function taking a pointer to
                                        a const char and an array of
					integers and returning int)
	        =>
          Type(Ptr(FunType([Type(Ptr(Const(BaseType(IdName("char"))))),
                            Type(Array(Int(5), BaseType(IdName("int"))))],
                           Type(BaseType(IdName("int"))))))


    + No more ManyDecl:

      Declarations of multiple variables in one statement is split into
      several consecutive declarations:

         int a, b, c;    ->  int a; int b; int c;

      This means that the ManyDecl constructor is gone, and VarDecl is the
      only constructor used for declaring variables.  For-statements needs
      special attention:

         for(int a,b; ...; ...) -> {int a; for(int b; ...; ...)}

      This means that the meaning of the program changes on non-compliant
      compilers where 'for' does not define its own scope.

    + [A utility (src/util/typeconv) is included in the Subversion
       repository to convert between old-style Type/ManyDecl, and the new
       style]
 
  * Literals are now const.
     
Version 0.2.3:

  * Compiles with StrategoXT 0.9

Version 0.2.2:

  * Improved C++ support:

    + Type comparison in overload resolution is more correct
 
    + Overload resolution support function pointer types and ellipsis

    + Function-style casts are supported

    + 'friend', 'delete' and 'new' are supported

    + Non-literal expressions and functions are supported as template
    arguments


  * Improved Sophus support:

    + Support for SGML function generation

    + Support for strange naming conventions

  * Mutification improvements:

    + Works with functions and operators in Root scope  (stub generation
    doesn't work yet, however)

    + Will no longer generate useless temporaries in function mutification

  * User-defined rule improvements:

    + New module (apply-user-rules) for efficiently applying topdown and
    bottomup rules

    + Support for sublist matching (for functions with variable number of
    arguments)

    + Simple support for conditions/where-clauses:  binding new
    meta-variables and finding the length of argument lists

    + Support for generic rules -- rules that are not tied to specific
    functions and operators (or even to specific function or operator
    names)

    + User-defined rules are now *much* faster

  * New compose extension for composition of functions with arbitrary
    arities

  * New map pattern extension (for Sophus) for automatically generating
    map-like functions with varying arities from a pattern (or template, in
    the non-C++ sense)

  * Performance improvement:  CodeBoost runs much faster (especially when
    using load/save)

  * Better regression testing

 * New transformations

   + Sophus-specific matrix specialisation. Pointwise algebraic operators on
   matrix structures can be specialised according to a compile-time
   defined layout.

   + Symbolic program derivation. Initial implementation of a derivation
   operator on the for D<f,1>(x,y,z) that derives the function f(x,y,z) on
   argument 1.

   + Tree dumping. To inspect the program at any point in the
   transformations, you can now insert the dump transformation that emits
   the tree to stderr.

 * Examples
  
   + examples/ is now populated by examples on which the different
   transformations can be applied. Some even have timing tests to show
   speedwise improvements.

Version 0.2.1: 

  * ASTs can be saved and reloaded

  * AST change

	FunDecl, ClsDecl and EnumDecl, when occurring as a declaration, are
	now wrapped in Decl(decl, sig), where sig is the canonical
	signature for that declaration -- all related declarations and
	definitions will have the same signature.  This makes it easy to
	relate the definition of a function to its declaration (and to any
	application).

	VarDecls in argument lists within a Sig should now have NoName and
	NoExpr as name and initialiser.  ``make-sig'' in sigs.r takes care
	of making a proper signature from a FunDecl.

  * New AST extensions: Map and Lambda

Version 0.2.0:

  * This is the first release capable of doing anything useful...