# $LastChangedDate: 2002-08-30 13:20:30 +0200 (Fri, 30 Aug 2002) $ $Rev: 710 $

0.0.4, Aug 28 2002
  - gyacc fixed, extended and renamed to gontyacc
  - compiler/language changes
    * it now uses gontyacc generated parser, which makes it less error-prone
      and easier to extend, which in turn results in:
    * no parser rules for dangling else, it's checked later
    * there is no stmt_expr anymore, { 2+2; } won't give you parse error,
      but typechecker warning
    * however there are some special expression (only structure expression
      at the moment) that cannot be used as stmt, nor argument for binary
      operator etc, which allows:
    * structure expression can be now written without (), i.e. {x = 3, y = 4}
      instead of ({x = 3, y = 4}). Old syntax is still allowed (it's simply
      {}-expression in parentheses, as any expression can be)
    * new switches -Wunused-value and -Wunused-retval
    * export_as fixed: one must not declare functions defined with export_as
      in interface, they are however generated with Ksi::Public. I guess we
      could allow declaration with = "...".
    * major syntax change: in short y/[]/()/. Tuple type is now *(int, int),
      tuple expression (1, 2), union expression Foo(x, y, z) etc. [] can
      be now used to construct list expressions and patterns, instead of 
      Cons/Nil.
    * -B is now alias for -prefix
    * type inference improved a lot, it is now full strength polimorphic
      Milner's ,,W'' algorithm. Hopefully lots of bugs has been fixed, and
      less introduced ;-)
    * fixed problems with Ksi structures being output several times for
      different type aliases of the same base type in code generator, which
      caused Ksi to fail on some gontc output
    * fixed problems with `type foo;' in .gi and `typedef int foo;' in .g
    * () is now expression of type void
    * void can be now used as type parameter
    * fixed checks of variable initialization after endless loop
    * new, hopefully faster, ksi writer
  - library changes
    * List::t moved to Std::list, i.e. one now need to write <int>list and 
      Cons[1, Nil], not <int>List::t and List::Cons[1, List::Nil]. Functions
      for list manipulation stay in List though.
    * new functions: Hacks::same_ptrs(), Hashtbl::prime_around()
    * rewritten Ptrhash to use regular ints instead of ASCII ints in strings,
      which caused crash (GC...) *sigh*. On the good side -- it's much faster
      now.
    * fixed bugs in Hashtbl::remove_all()
    * new modules Unionfind and Fifo.
    * massive changes in Std:
      + aliases: Std::{int,float}_of_string, Std::string_of_{int,float}
        for  Std::itoa(), Std::atof() etc. Std::puts() for Std::print_string()
      + new functions: Std::ignore(), Std::string_of_bool(),
        Std::bool_of_string(), Std::partial{,2}(), Std::read_string() 
	(read one word of input)
      + - <'a>ref type with Std::ref_{get,set}()
      + Std::Exit exception removed
      + changed Std::read_{int,float}() to read just one word, not entire 
        line, and convert it  
      + comments (descriptions of all functions)

0.0.3, Aug 26 2002
  - updated gont.vim
  - added gyacc tool for making interfaces to bison/yacc generated parsers
  - compiler/language changes
    + fixed --version output
    + "'c'" is now value of type char, however it's implemented as call to
      function in Std. Don't how to resolve this correctly, probably
      `char' type will be added to the language.
    + "_" is allowed instead of type in few places, namely:
        * in variable definitions (like "_ x = List::map(foobar, lst);")
        * in lambda expression formal parameters and return type (example:
	  "List::map(fun _ (_ x) (x * 2), lst)")
        * if all variables have type "_", then lambda expression can be
          written without them: "fun _ (_ x, _ y) (...)" -> "fun (x, y) (...)"
      When "_" is used instead of type, it's inferred. However inference 
      algorithm will fail in cycles in more complicated cases so beware,
      experimental, Berzerkeley quality software, etc :) But it's cool! ;-)
  - library changes:
    + removed Std::{invalid_argument,fail_with}() (they don't seem to be useful)
    + Std::{at_exit,exit,abort}() moved to Sys
    + new function Sys::shell()

0.0.2, Aug 25 2002
  - make install should now work, prefixes should be right
  - configure script added (note that it has nothing to do with autoconf)
  - updated documentation for current state of compiler
  - compiler changes
    + handle variables with extern_c properly
    + added -Ftime-report knob, it also reports memory usage
    + this three optimizations makes generated code ~30% faster, due to ~30%
      less allocations:
      * not all local functions will have closure now
      * if function have no closure its lambda expression can be static
      * if type constructor (union field) takes no arguments it can be
        made static
    + one will now get linking error upon try to link .o, instead of .xgo
    + code around bison bug (?) in handling locations for empty lhs in rules,
      fixes problems with Ksi ICE-ing sometime on `for (;;) {}'
  - library changes
    + removed chunked allocator
    + use GC_malloc_many() instead (if it's available), this gives next 20%
      performance boost, memory usage is also limited
    + exception stack has been rewritten to use continues memory chunks;
      however for testing application it causes more precise garbage 
      collection (memory usage 8M -> 6M) and thus increase running time,
      it can be disabled at compile time.
  - language changes:
    + case guards and fall-through on empty case bodies, i.e.:
	switch qux {
	case Foo[x, y]: if (y > 0) return x; else return 2; 
	case Bar[x]:	return x;
	case Foo[_, _]: return 2;
	case Baz:	return 2;
	}
      can be now:
	switch qux {
	case Foo[x, y] if (y > 0): 
	case Bar[x]: 		return x;
	case Foo[_, _]: 
	case Baz:		return 2;
	}
    + allow string literals concatenation
	
  - new library functions:
    + Sys::dump_allocator_statistics()

0.0.1, Aug 23 2002
  - new library modules
    + Ptrhash (hash from anything to anything. First anything is hashed
      based upon its address)
    + Bitvector (arrays of bools, although it needs to be reimplemented)
  - new library functions
    + List::{iter,map}2()
    + {Array,Hashtbl}::copy()
    + Hashtbl::{remove{,_all},length}()
    + Sys::{times,clk_tck}()
    + Xml::save_to_file{,_indented}()
  - library changes
    + Stdio::fputs() won't choke on "" anymore
    + String::concat("", List::Nil) won't choke either
    + added simple chunked allocator for memory/speed tradeoffs, environment
      variable GONT_ALLOCATOR_CHUNK_SIZE is searched for amount of bytes
      to be allocated at once
  - compiler changes
    + compiler has been entirely rewritten in Gont instead of OCaml, it is
      now bootstraped from .ksi and .c files distributed along
    + therefore there are zillions of user visible changes, including, but
      not limited to:
      * no need to prototype globals symbols (types, functions, variables)
        anymore
      * void f(string, int x) { ... } allowed instead of void f(string
        unused, int x) { ... }
      * better error messages about unification failures (union and structs
        are not expanded)
      * pattern variables are now read-only
      * pattern variables can be used in local functions
      * better debugger support, but 1/ it needs more work, especially 
        patching Ksi and GDB will be required, 2/ it needs latest Ksi 
	(pre55) to work
      * as compiler compiles itself bootstrap comparison is performed
      
pre22, Aug 12 2002
  - new modules
    + Xml (wrapper for libxml-2)
    + Stack (mutable stack (implemented as list for now))
    + Hashtbl
    + Hacks (contains unsafe functions)
  - new functions
    + Std::abort()
    + gont_id(), gont_hash_string()
    + String::hash() (alias to gont_hash_string())
    + List::rev(), List::nil(), List::cons(), List::exists(), List::find()
    + global symbols Stdio::std{in,out,err}
    + Stdio::{input,output}_* family of functions for serialization
    + String::{contains,index}_str{,_from} and String::split
    + String::{lower,upper}case_char(), String::{,un}capitalize()
    + Array::resize()
  - library changes
    + allow spaces before in Int64::of_string
    + always bzero memory after obtaining it from GC, it doesn't seem to do so
    + fixed Stdio::fputs to use fwrite(), not fputs()
    + added Stdio::fwrite alias for Stdio::fputs
    + fixed String::blit and String::concat
  - compiler changes
    + bugfix: non-function symbols from other modules weren't usable
    + added -ldopt compiler option working in both linker and archiver
      modes; options from -ldopt when making archives are saved for
      link time
    + allow \t, \" and \' escape sequences
    + optimize calls to external functions not to use closures
    + don't generate (return (modify (result) ...)) in functions
      returning void
    + added '!' operator
    + fixed chini of try blocks
    + use ksi version 1
    + use hopefully non-cyclic data for created structures hash table
      (numerous hacks here :<)
    + fixed prototyping current function
    + bugfix: let with multiple assignments were broken badly
    + remove .go file if compilation didn't succeed
    + fixed bug with structure allocation (all structures were assigned 4 
      bytes of memory, sigh!)
    + != on strings was working like ==
    + in [x, y] = [1, 2] x and y *are* initialized
    + fixed issue with try/with and return in case ...
    + fixed try {} with code generation; is some cases pop_try_block() wasn't 
      called
	  
pre21, Jun ?? 2002
  - added && and || operators
  - added char type and String module
  - new Stdio module
  - new Sys module (just argv inside for now)
  - new Array module
  - allowed stmts, not only blocks in let ... in bindings
  - several fixes for abstract types
  - changed internal formal of string to be faster
  - some fixes in ciface
  - less restrictive rules for {} in 'if else'

pre20, May 27 2002
  - added -ciface switch to dump C header for given gont module
  - new syntax for lambda expressions:
      - fun t (t1 n1, ...) { ... }
      - fun t (t1 n1, ...) (...)
    - and function types:
      - *t (t1 [n1], ...)
      - *(t (t1 [n1], ...))
    - old syntax fun ... -> ... is ... removed
    - old syntax *(....) -> ... removed
  - interfacing with C is now easier:
      c_foo.c:
        void gont_foo_bar(int, struct gont_string *) { ... }
      foo.gi
        void foo(int, string) = "gont_foo_bar";
  - added Int64 module with basic operations on 64 bit numbers
  - some bugfixes (abstract types, named types equality)

pre19, Feb ?? 2002 
[really released in at May 27 2002, but there was no changes since Feb 2002]
  - implemented assignment to structure field
  - relaxed rules about putting [] after union expressions and union patterns
  - relaxed rules about superfluous semicolons at the toplevel, they are
    now allowed everywhere
  - .go files are now generated:
      - no need to export_as "main" anymore
      - section init { ... } code is executed upon initialization of
        module
      - section fini { ... } -- go figure :)
      - one needs now to link .go files (not .o as before)
      - exceptions should work
  - documentation: added Unix manpage for gontc, FAQ and Manual (mainly
    from c2gont.tex, that is now removed)
  - OptStruct is now properly checked if it's not null
  - +., *. etc are removed, +, *, / and - are now used by both ints and
    floats. + can be also used to concatenate strings.
  - fixed pattern matching to work on strings
  - ==, <= etc now supported on strings
  - Stdc module removed
  - std library extended, Std module now contains most of what it is
    supposed to contain, except file i/o
  NOTE: ksi-pre48 is required

pre18, Feb 20 2002
  - implemented structures (but no pattern-matching on structures yet)
  - garbage collector is now linked in (if you have it)
  - runtime environment is now correctly split into libraries
  - Std and Stdc modules are now open at the beginning of each compilation
    unit
  - Gonttree interface-only module introduced
  - got rid of symbol class (replaced by record)
  - much fixes in interface compilation, and modules in general
  - several interface files can be now stored in one archive file
  - break & continue, labeled loops
  - ++/--
  - int a, b, c, d; is now possible
  - other bugfixes :)
  - exceptions are in parser and parts of compiler already, but 
    *THEY DOESN'T WORK*
  NOTE: ksi-pre46 is required!
  
pre17, Feb 12 2002
  - let stmt
  - pattern exhaustive checks
  - variable initialization checks
  - cleanups and bugfixes, as usual
  
pre14, Jan 28 2002
  - unions
  - polymorphic unions
  - pattern matching
  - so many bugfixes, I can't count them all ;)
  
pre13, Dec 03 2001
  - type_walk wasn't properly walk down through the type term recursively,
    fixed.
  - yet another fix to polymorphic functions, in 'a f('a x) { ... } 'a ain't 
    polymorphic variable.
  - added tests script in t/, now we are able to produce some nice tests
    that should fail, should output something and so on.
  - fixed print_string() to write to fd 1 (stdout) instead of fd 0 (stdin).

pre12, Nov 29 2001
  (from now on we start very detailed changelogs)
  - more comments
  - made ksi_stmt always return expression of Ksi.Void type -- hence 
    conversion for Ksi.Cond (aka Gontutil.If) is not required anymore
  - catch Invalid_argument errors from map2 in typechecking, convert them
    to human readable messages
  - semicolons are required after function prototype and global variables
    again... I guess there are not needed, but parser is unable to split
    declarations then :<
  - hacker.tex update -- added coding style section
  - t/* compiles
  - added few fixes for polymorphic functions, however they are still 
    broken... :<

pre11, Nov 27 2001
  - made it compile

pre10, Nov 27 2001
  - total rewrite of typesystem
  - added copyright note to each source file

pre8, Nov 24 2001
  - docs translated to LaTeX

pre7, Nov 22 2001
  - some initial work on structures, unions and tuples, they will be all
    considered subtypes on the content basis, not the name
  - now we produce line number information for debugger
  
pre6, Nov 21 2001
  - fixed string and floats handling, it is possible that they will work
    now :)

pre4, Nov 21 2001
  - README file updated, items added:
    - info about differences between Gont and Caml, SML and Popcorn
    - example about closures
    - chapter about datatypes representation, and more about passing 
      conventions
  - new bug and optimization possibility added to TODO

pre3, Nov 20 2001
  - runtime rewritten to C
  - added exceptions support basics to runtime
  - added proposed COPYRIGHT
  - makefile/mkdist cleanups
