[back]
12 Jun 2010, version 2.8.2

  Support for Windows DLL programming (see -da and -dx options).

  Also added -k option for package name.  The name is just embedded in
  the include guard.  So now can have multiple files with the same
  name (in different directories of course) in the same project.

  And fixed a problem with Windows filename parsing.  In earlier
  versions if you passed for example "..\..\src\file.lzz" to Lzz it
  would think "..\..\src\file" is the base name, the filename without
  the extension and path.  So the include guard looked a little funny
  (LZZ______src_file).  

28 Sep 2008, version 2.8.0

  It's been 5 years, but still maintaining the code (and using lzz
  almost every day!:) Just a few bug fixes:

  1) Fixed bug with captured code in macros.  This used to cause an assert:

       #define INSTANTIATE() N <X> & f <Y> ();
       INSTANTIATE()

     Had a problem if more than one BLOCK (or captured code) was in a
     macro.  Was indexing BLOCKs by file location in a map, but in a case
     like this both have the same location (where the macro is expanded).

  2) In the following example

       class X
       {
         template <> class A <int>
         {
           void f ()
           {
           }
         }
       }

     used to be generating 'template<>' before the member function
     definition of the nested class template.  This was not correct.

  Also some minor fixes to compile with g++ 4.2.3:

  1) #including assert.h in util_GetTempDir.lzz.

  2) Added missing const qualifier in a char* definition in
     conf_Config.lzz.

  Also added an explicit destructor to FileStat in gram_FileStat.lzz,
  as this was causing an undefined external on Mac OS X (just for an
  optimized build).

2 Nov 2003

  Functions are declared in context and defined at the end of the
  file. So functions can appear in any order, and their bodies can
  refer to types or objects declared later.

  All code can be preprocessed (option -e).  This permits you to
  define fuctions entirely using macros.

  Class declaration in class defintion introduces a type, so name
  can be used without "typename" in member function return type:

    template <class T>
    class A
    {
      class B;
      B f () { ... }
    }

  version 2.6.0

18 May 2003

  Integer and floating litearals are initially lexed as pp-number
  tokens.  pp-number tokens are converted to int and floating literals
  when fed to the parser.  Previously this would have failed ('123E'
  not a valid floating literal):

    #define F(X,Y) X ## Y
    F (A,123E)

  Function declarations, if neither static nor in an unnamed
  namespace, are output to the header file.  If you want them in the
  source file, include the appropriate header file instead.

  version 2.5.2

29 Apr 2003

  Version 2.5.0 writes data first to temporary files.  On some
  machines a file would not be created properly.  Using string
  streams.

  version 2.5.1

26 Apr 2003

  Support for linkage specifications.

  Function declarations now output to header file if not extern.
  Need to use 'extern' if intent is to declare in source file.
  'static' and function declarations within an unnamed namespace
  are output to source file, as always.

  version 2.5.0

23 Feb 2003

  Source file #includes the inline file at the top of the file, just
  after #including the header file, instead of at the bottom of file.
  This way the inline file cannot depend on declarations (or later
  #includes) in the source file (a common mistake when
  LZZ_ENABLE_INLINE is not defined).

  Lexer fixes:

    '02468' lexed as octal literal (with warning) 

    '02468.0' lexed as float literal, not octal literal followed
     by float literal.

  version 2.4.1

11 Jan 2003

  Added support for 'long long int' and 'unsigned long long int' types.

  version 2.4.0

27 Nov 2002

  Qualified local type in template class definition prefixed with
  'typename' in return type of function definition:

    template <class T>
    class A
    {
      typedef int T;
      T boo () { }
    }

  Definition of boo is

    typename A <T>::T boo () { }

  Opening brace of function body is indented to same column as in
  Lzz file.  (Cuts down on noise from style-checking tools.)

  version 2.3.6

19 Sep 2002

  Fixed another bug introduced in version 2: member definitions
  of explicitly specialized classes are not now preceded by 'template <>'.

  version 2.3.5

7 Sep 2002

  Universal characters not translated at character-reading stage,
  instead they now correctly translated during lexing of tokens.  So,
  invalid-looking universal characters in comments are OK.

  Lzz no longer hangs on missing #if before a #else, #elif or a #end.

  version 2.3.4

14 Aug 2002

  Member types in return types of member function definitions do not
  have to be qualified.  For example:

    class A
    {
      Enum E { e = 0 }
      E foo () { }
      E * (* baz ()) (int i) { }
      template <class T> class B { }
      B <T> spud () { }
    }

  Template parameters of nested template declarations now printed
  correctly.

  version 2.3.0

10 Aug 2002

  Variadic macro support.  g++ extensions also supported (named
  variable parameter and ## after comma in replacement list).

  Missing support for template friend function declarations and
  template friend function definitions in version 2.  Now fixed.

  version 2.2.0

5 Aug 2002

  New syntax error recover command: able to move some number of
  tokens after some number of tokens to the right.

  Option -ver added.  Prints the version number.

  Bug fixed with preprocessor # operator: \ characters now prefixed
  with \ in string and character literals.  Also spacing is now
  correct in resulting string literal.  Preprocessor now passes
  examples in section 16.3.5 of the Standard.

  version 2.1.0

1 Aug 2002

  Major rewrite.

  Code is preprocessed before it is parsed (except function bodies,
  expressions and template args).

  Lazy classes and lazy functors (and template versions) are now fully
  supported.

  Using latest Basil (parser generator).  Method parser uses to
  recover from syntax errors is configured at runtime with -r option.

  Options are shorter.

  Options -prefix and -keep-path removed.  Option -x provides better
  alternative.

  Option -macro removed.  Preprocessor provides better alternative.

  Option -tmpl-asis removed.  Compilers should support class template
  declarations defined outside of class body.

  Options -v added to print the values of the options.  Help text now
  shorter and easier to read.

  Output files are not created if any fatal error is encountered.

  version 2.0.0

26 Mar 2002

  Better code capture: nesting and terminating characters are ignored
  in string and character constants and in comments.  Previously
  context was not considered.
 
  version 1.5.3

23 Mar 2002

  If not generating an inline file, $inl blocks are output to the
  header file.

  If not generating a template file, $tpl blocks are output to the
  header file.

  If not generating a template inline file, $tnl blocks are output to
  the header file.

  version 1.5.2

13 Mar 2002

  Help text easier to read, more consistent with basil and basilsim.
  Both -h and -help recognized.

  version 1.5.1

10 Mar 2002

  Lazy functors.  This 

    void Foo (A & a, B b; C c) const : FooBase (b)
    {
    }
 
  is the same as

    struct Foo : FooBase
    {
       A & a;
       Foo (A & a, B b) : FooBase (b), a (a) { }
       void operator () (C c) const { }
    }
 
  Lazy constructors.  This

    struct Bar (A & a, B b) : BarBase (b)
    {
    }

  is the same as

    struct Bar : public BarBase
    {
      A & a;
      Bar (A & a, B b) : BarBase (b), a (a) { }
    }

  Lazy functors and lazy constructors are used by basil.  At the
  moment they are somewhat limited:

    o They can only appear in namespace scope (not inside classes)
    
    o access specifiers (and virtual) on base classes aren't supported

    o lazy template functors aren't supported, that is you can't do this

        template <class T>
        void Foo (A & a; C c) const
        {
        }

      however this is supported

        template <class T>
        struct Bar (A & a, B b) : BarBase (b)
        {
        }

  These limitations will be fixed in the next major version.

  The '-out-dir' option is also new.

  version 1.5

27 May 2001

  $pragma directives to create (or not create) inline,
  template, or template inline files.

  qualified non-template function definitions not declared in header
  file

  version 1.4

24 May 2001

  first expression in direct initializer can be enclosed within a
  redundant set of parenthesis instead of using _dinit

  -macro option

  version 1.3

10 May 2001

  warn on member functions with pure specifier that are not virtual

  warn on namespace functions that are pure virtual or virtual

  options can be specified in the environment variable LZZ_OPTIONS,
  leading '-' optional

  all bool options are off by default

  -help shows usage and options (and current values)

  version 1.2

30 Apr 2001

  member objects with initializers must be static

  version 1.1

26 Apr 2001

  version 1.0
[back]