User visible changes for ksi scheme interpreter.
************************************************

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.
