
3.9.0
=====

* Prerelease of the 4.0.0 that will be R6RS compliant.

* The doc directory temporary removed from distrib.
  The old docs obsolete and new is not ready.

* Simple R6RS-like library manager implemented.
  "load" function removed (use "import" syntax instead).

* the ksi module system removed in a favour of new R6RS library system.

* `psyntax.ss' that implemented 'syntax-case' in older revisions of the ksi, was removed.
  As a result, only core syntax evaluated by ksi.
  And ksi core is not a R6RS core :-(

* '(gensym)' generate (almost) unique symbol names.
  As a part of generated symbol name used a 'session_id' that is initialized at startup.
  So, each ksi invocation has its own 'session_id'.
  This can help (in a future) to hardly optimize the scheme code evaluation 
  Now the 'session_id' is initialized with random bits converted to readable string.

* the "do" syntax, "delay" syntax and "force" function was removed from the ksi core.

* the 'struct Ksi_Environ' and companions was rewriten almost completly.
  Now the environment has the name, the export list
  and the hashtab that maps the symbol to the value 
  A value can be a plain value (the symbol is a variable) or a syntax value.
  If a symbol is bound to a syntax value, it can not be defined, assigned or
  used in any other case except in a intented syntax form 
  As a special case, if a symbol is bound to a syntax value and the value is a procedure,
  the procedure is applyed to the form before evaluating it.
  (Look at 'ksi_defsyntax()' and 'ksi_compile()' for details).
  This mechanics is intended for low-level macros (as "define-macro!")
  and derived forms such as 'cond', 'case', etc.
  The normal sanitary macro system planned ;-).

* All packed-in-the-pointer objects was removed.
  Such objects as 'ksi_nil', 'ksi_false' and so on,
  are implemented as a pointers to a memory location
  that allocated when initializing the ksi library.
  Do not be suprized the error if you use its before calling `ksi_init()'.

* The 'struct Ksi_Char' (added) is internal representation of a character now.
 (first step to unicode).

* the GMP library used for exact arithmetics now.
  As a result, the ksi supports the exact rational numbers now.

* The short integers was removed.  Bignums are the only exact numbers now.
  And predefined constans 'ksi_zero', 'ksi_one', etc was removed too.
  (Use 'ksi_long2num()' in C code)

* A flonum has real and imag part always, and so, a flonum is a complex number now.
  But 'real?' returns #t if imaginary part is zero
  and 'number->string' do not print "+0.0i" if imaginary part is zero.
  (This is not what R6RS requires but alas, it is the ksi)

* balanced comments are writen within "#| |#" construct now
  (not with "#! !#" as in the previous revisions of the ksi).
  The sequence "#!<identifier>" used for the reader directives now.
  In addition, to support the scheme scripts, the sequence "#! " (note whitespace)
  and "#!/" in the very begin of a file supposed as a one-line comment.

* Reader now case-sensitive by default, as required R6RS.
 Use the "#!fold-case" directive to switch the reader to the case-insensitive mode,
 and "#!no-fold-case" to switch to the case-sensitive mode back.

* By default, the reader parses postfix keyword notation, such as "key:".
 "#!keyword-prefix" switches the reader to prefix mode, such as ":key",
 and "#!keyword-postfix" switches the reader back to postfix mode.
 
* By default, the reader do not parses the old ksi keyword notation, such as "#:key".
 Use the "#!keyword-sharp" directive to switch the old mode on,
 and "#!no-keyword-sharp" to switch off.

* "#!r6rs" directive switches the reader to the R6RS mode,
  and "#!ksi" directive switches the reader to the default mode back.

 In the r6rs mode:
   -- the keywords are not parsed at all;
   -- any sequence that starts with digit, '+', '-', '.', tried to be parsed as a number
      and, if cannot, exception raised.
      Otherwice the sequence is parsed as a symbol.

 In the ksi mode:
   --  the keywords are parsed;
   --  any sequence, that starts with digit, or '+', '-', '.' folowed by digit,
       tried to be parsed as a number and, if cannot, exception raised.
       Otherwice the sequence is parsed as a symbol.

 So, the sequence like '+x' is parsed as symbol in the ksi mode, but raise exception in the r6rs mode.

 Note that in the previous revisions of the ksi, any sequence,
 that cannot be parsed as a number, was considered as a symbol (never exception raised).


3.5.1
=====

* bugfixes

* (Windows) ksi dll name has version info now.


3.5.0
=====

* code refactoring

3.4.3
=====

* garbage collector is removed from distribution.
  It is supposed atready installed in the system.

3.4.2
=====

* fixed bug with division bignum by shortnum

3.4.1
=====

* removed unused files

* fixed bug that course fail on solaris

3.4.0
=====

* Chars and strings are compared using collation ordering.

* Implemented change-class.

* Interface to readline library removed from ksi library.
  It now in interp/ksi.c

* Async event rewritten.  Now you can use you own event manager.

* C interface for primitives rewritten (see ksi_prim.h).

* Bugfixes

3.3.3
=====

* Procedure `use-module' can be called with a list in NAME argument.
  In this case, definition of module is loaded from file with
  name constructed from all but last elements of the list and the
  string "modules".  This file loaded with `load' procedure.
  And after loading this file, usual module search performed.
  Name of the module is contained in the last element of the list.
  
  Example:
	; load module `bar' that defined in file "app/foo/modules"
	(use-module '(app foo bar))

	; load module `baz' that defined in file "/usr/share/ksi/modules"
	(use-module '("" usr share ksi baz))


3.3.2
=====

* New Scheme primitive `write-block'.
 
* New Scheme primitive `sleep'.
 
* Signal SIGINT is not now restarted.
  So user can type Ctrl-C to interrupt system call.


3.3.1
=====

* Buffixes


3.3.0
=====

* New C macros KSI_CONS2 ... KSI_CONS9 that are like KSI_LIST1 ... KSI_LIST9
  but make improper list.

* New Scheme primitives `ksi:gcollections', `ksi:gc-set-size!',
  `ksi:gc-size', `ksi:gc-free'.

* Structure of `struct Ksi_Port' and `struct Ksi_Port_Tag' changed
  (see "ksi-lib" document).

* File and socket ports rewritten.

* More proper tail recursion with call/cc.

* New C function `ksi_aprintf' that formats output in heap allocated
  buffer and returns result.

* New Scheme primitive `printf' (see "ksi-lang" document).

* C functions `ksi_malloc_atomic' and `ksi_malloc_large_data'
  replaced with one `ksi_malloc_data'.


3.2.5
=====

* Bugfixes


3.2.4
=====

* Socket in nonblocking mode now send pending data in background.

* Implemented more correct algorithm to find and handle ready events.

* Event now has new parameter `result'.
  It can be gotten by the `event-result' procedure and
  filled with return value of event-handler or exception that thrown
  from the event-handler.

* The executable ksi now accept command line option `-L dir'.
  By that option you can add directory in search load list.

* Module record now worked.

* Procedure `set-errlog-priority!' renamed to simply `errlog-priority'.


3.2.3
=====

* Procedure `open-client-socket' set nonblocking mode on socket
 (if requested by argument) before connecting, allowing async connection

* Procedure `accept-connection' now take 1 argument

* New procedure `set-nonblocking-mode' set nonblocking mode on socket.

* string-append: can append chars as strings

   (string-append "he" #\- "he") ==> "he-he"

* Startup initialization changed (see docs)


3.2.2
=====

* Async events implemented (see documentation).

* Socket ports rewritten and documented.

* letrec bindings rearranged while compiled to allow expressions like

  (letrec ((a (b))
           (b (lambda () ...)))
    a)

* New procedure `port-ready?' that checks port for write readiness.

* Procedures `cpu-time', `eval-time' and `real-time' now return
  time in seconds, not milliseconds.

* New primitive procedure `make-exn' added.  This procedure
  creates special object that indicates the error condition.

* Error handling changed.  Now throwing exception and error signaling
  has the really same semantics.
  So expressions

    (error "the error message")

  and

    (throw '#error (make-exn 'misc (void) "the error message"))

  have the same result.

* Error handling changed.  The error handlers (installed with
  `set-error-handler' scheme procedure or with `ksi_set_error_handler'
  ksi-library "C" function) called only if the error exception is not
  catch'ed by the some sort of `catch' expression.

* Simple error logging added.
  Example:

  ; Write error and warning messages into the file "log-file"
  (open-errlog errlog/warning "log-file")

  ; For module `some-name' write info messages too
  (set-errlog-priority! 'some-name errlog/info)

  ; Write info message for module `some-name' 
  (errlog 'some-name errlog/info "info from some-name module")

  ; This message is not be written
  (errlog 'another-name errlog/info "info from another-name module")

* "C" functions `ksi_apply_with_catch', `ksi_eval_with_catch' and so on,
  now return the exn object if error occur.
  (Was: In case of error that functions return meaningless `ksi_void'
  value).


3.2.1
=====

* Simple typed exceptions.

* Some bug fixes.

3.2.0
=====

* Functions `ksi_num2int' and `ksi_int2num' works now with long's.
  New functions `ksi_num2uint' and `ksi_uint2num' added that works with
  unsigned long's.  Functions `ksi_num2long', `ksi_long2num', `ksi_num2ulong'
  and `ksi_ulong2num' works now with signed and unsigned long long's.

* New primitive procedures `strftime', `localtime', `gmtime' and `mktime'
  that implement the corresponding `libc' functions.

* Under MSWIN searching of the initialazing files changed.
  The initialization files are searched first in
  the directory where `ksi.dll' is resides, then in the parent directory,
  then in the directory where executable resides,
  and last in the parent directory of the executable.

* New syntax `and-let*' that implements SRFI-2.

* New procedure `module-repl'.  This procedure is useful for module
  debugging.  It starts new repl in the argument module environment.

  Example:
    ksi> (use-module list-lib)
    ksi> (module-repl list-lib)
    list-lib> ; now you can eval expr's in the `list-lib' module environment

* In procedure `substring' last argument now optional (defaulted to
  length of the string).

* New procedures `foldl' and `foldr' that implement usual functional
  list operators `fold-left' and `fold-right'.

* Procedure `has-suffix?' is renamed to `file-name-has-suffix?'.

* New installed script `ksi-compile' that can be used for compiling
  source scheme code to ksi byte-code.

* New installed script `ksi-config' that can be used for building
  applications with ksi library.

  Example compilation:
    cc -c $(CFLAGS) `ksi-config --compile` file.c

  Example linking:
    cc -o prog $(LDFLAGS) $(OBJS) $(LIBS) `ksi-config --link`

* New module `command-line' that implements sh-like command line parsing.

* New module `list-lib' that implements SRFI-1 list library.

* New syntax `receive' that implements SRFI-8.

* The `export' and other clauses of `define-module' syntax
  may be placed in any order.
  (Was: `export' clause should be the first clause).

* Parameterized modules.

  Example:
	(define-module (example-module plus)
	  (export add)
	  (begin (define (add x y) (plus x y))))

	(use-module (example-module +)    "m1:")
	(use-module (example-module list) "m2:")

	(m1:add 1 2)		==> 3
	(m2:add 1 2)		==> (1 2)


* `use-module' can now accept optional argument `prefix'.
   This prefix used to rename the exported variables.
  
  Example:
	(use-module 'getopt "getopt:")

   Now, if the module `getopt' exports the variable `get-option',
   it can be referred under name `getopt:get-option'.

* Semantics of `equal?' is extended.
  It now can compare closures and circular lists.

  Example:
	(define (f1 a b) (+ a b))
	(define (f2 x y) (+ x y))	
	(equal? f1 f2)				==> #t
	
	(define c1 (circular-list 1 2 3))
	(define c2 (circular-list 1 2 3))
	(define c3 (list 1 2 3))
	(equal? c1 c2)				==> #t
	(equal? c1 c3)				==> #f

3.1.5
=====

* Added simple `help' procedure in interactive repl.
  You should provide documentation strings for lambda expressions
  to display meaningful help.

* Many changes in evaluator.  Now interpreter 1.5-2 times faster.

* Arguments of "C" functions `ksi_reg_prim', `ksi_reg_unit' and `ksi_defun'
  changed.  The argument `module_name' removed (it's meaningless).
  If you use that functions, you need change your code and recompile.
	
* In the `struct Ksi_Obj' the type of field `itag' changed
  from `int' to `unsigned'.  Some compilers generate more efficient code
  in such a case.  You may do the same changes in your code, but it is
  not required, because on most architectures `int' and `unsigned' in that
  situation is practically the same.

* New "C" public function: ksi_clear_vtab.
  It removes all elements from the argument hash-table.


3.1.4
=====

* Ksi language documentation (ksi-lang.texi) is up to date.

* New syntax `with-slots' added.

* New pretty-printer.

* In `define-class' the `#:metaclass' option placement changed.
  Now all `define-class', `define-generic' and `define-method'
  has similar syntax.

* Ksi now can be compiled under Visual C.

* "C" function `ksi_gcollect' now returns zero if no more garbage
  to collect and nonzero otherwise.  You can check the return value
  of `ksi_gcollect' to determine the need of the succedent calls.
  If it returns zero, your wait loop (if it calls `ksi_gcollect')
  may sleep to allow your processor become cold.


3.1.3
=====

* "C" function `ksi_gcollect' now takes argument that indicates
  what type of garbage collection to perform -- full or partial.
  It is reasonable to call `ksi_gcollect(0)' in a wait loop.

* New "C" public function: ksi_call_with_dynamic_context.

* New "C" public functions: ksi_disable_gc, ksi_enable_gc.
  They completely disable/enable gc.
  
* New "C" public functions: ksi_gc_protect, ksi_gc_unprotect.
  They protect/unprotect object from garbage collecting.

* Under MSWIN32 char & string function make use of Windows API for
  testing/conversion the case of chars.
  So functions such as `char-upper-case?' and `char-upcase' can properly
  work with national letters (but only with ANSI codepage).

* More correct work with "winsock.dll" under MS Windows.


3.1.2
=====

* As usual, some bug fixes.

* Internal representation of dumped objects changed.
  So, format of `*.ko' files changed again.

* Vectors that constructed by quote syntax, now considered as
  constants, and cannot be modified with `vector-set!'.

* `ksi_dump' and `ksi_undump' can now work with big objects --
  strings, vectors and bignums who's length is more than 0x1fff.

* Simple interface to BSD sockets implemented.
  That interface should be considered very expiremental.

* The "C" functions `ksi_defun' and `ksi_reg_prim' now return
  the new created procedure.

* Added new public "C" function `ksi_get_arg'.

* `slot-ref' and `slot-set!' can now accept integer as slot name.
  In this case they bypass normal slot name resolution, and
  directly take the slot with that number.

* New "C" function `ksi_obj2name' added.  It works like `ksi_obj2str',
  but uses `display' instead of `write' and prints lists and vectors
  without parens.  It can be used to convert Scheme object into
  the nice "C" string that may be printed as a title of something.

* Initialization of ksi library slightly changed.
  If you does not use the ksi as embeddable language in your application,
  it does not touch you.

* Escape procedure of `call/cc' can now accept any number of arguments
  to communicate with `call-with-values', as specified in R5RS.

* Changed internal implementation of klos classes.
  If you aren't the implementor of your own metaclasses,
  it does not touch you.

* Bug fixed with inherited slots that have class allocation.
  Such slots are allocated in each new class, instead of
  sharing its states with superclass.

* New generic function added -- `slot-unbound' and `slot-missing'.
  They now called (instead of signaling an error) when getting value
  of unbound slot and getting/setting not existing slot.
  Standard methods of that generic functions, as in past, signals an error,
  but now that behavior may be redefined in the user metaclasses.

* Semantic of the `catch' changed.
  Handler of the catch expression has now only two arguments,
  and so it can't restart the continuation of the throw expression.
  The old semantic of the `catch' is now available via the new
  `catch-with-retry' expression.


3.1.1
=====

* New module `z' added.  It provides a simple interface to zlib compression
  library.  Only reading/writing gzip'ed files implemented.

* Again, format of `fast-load' files changed.

* Changed searching of init directory under MSDOS/MSWIN to be more MS'ish.

* New module `html' added.
  It can be used in a simple cgi-scripts to generate a html forms.
  Only GET method implemented now.

* Procedure `getenv' can be called now without arguments.
  In this case it returns association list of all environment variables.

* New `fluid-let' syntax added.


3.1.0
=====

* some bug fixes and speedups.

* Syntax of `define-generic' changed.
  Now syntaxes of `define-generic' and `define-method' are very similar.
  You can now supply body of method for the generic function
  in `define-generic' expression.

* Format of `fast-load' files changed.
  New version is not compatible with old.

* New primitive procedures: mkdir, rmdir

* Reader recognizes new notation for keywords `#:|keyword-name|'.
  Keyword names in such notation may contain non standart
  characters (spaces, upper case letters and so on).
  Note that this notation similar to corresponding symbol
  notation `#|symbol-name|'.

3.0.2
=====

* Macros KSI_INT_P, KSI_MK_INT and KSI_INT_COD are renamed to
  KSI_SINT_P, KSI_MK_SINT and KSI_SINT_COD to reflex the fact
  that they operatate on small integers.

* Creating and loading of ``fast-load'' files.
  By this, startup time of ksi interpreter is very reduced.

* New primitives: opendir, readdir, closedir, getcwd, rename-file, stat.

* Reader now recognizes escape sequence `\a' in strings.

* Many bugs fixes.


3.0.1
=====

* While read-eval-print loop, result of expression that evaled
  into the `unspecified' value is not printed.

* Strict R5RS complex number parsing. 

* Loading is performed in the environment of module that calls
  the function `load' not in the environment of current module.
  
* Prompt are changed while reading lists, strings and vectors
  from tty port.

* Fixed bug with division of floating number by integer.
