Embeddable Common-Lisp

File Release Notes and Changelog

Release Name: 9.4.0

Notes:
This release is the first one with a new design of ECL, which includes changes
in the way streams are implemented, support for full Unicode character set,
safety against interrupts and serious performance improvements.

Known issues:

+ Threads and Unicode currently do not work in the Windows port.

Patch release 9.4.1
===================

* Bugs fixed:

 - Symbol NIL was not exported from the GRAY package.

 - GRAY:STREAM-PEEK-CHAR was not used at all by ECL.


Changes:
* Streams:

 - ECL has now a new and more easily extensible implementation of streams, based
   on C structures with a method dispatch table. Apart from code reuse and better
   maintainability, this allows a more sensible design of read/write-sequence.

 - *STANDARD-INPUT*, *{STANDARD,ERROR,TRACE}-OUTPUT* are no longer synonyms to
   *TERMINAL-IO* but directly the input or output streams associated to stdin,
   stdout and stderr.

 - Internally, ECL allows to work with POSIX file descriptors directly, without
   using C streams.

 - POSIX files and C streams now support different external formats. ECL
   understands right now :UTF-8, :UCS-2 (bigendian), :UCS-4 (bigendian),
   :LATIN-1 and :ISO-8859-1. If built _without_ support for Unicode, only the
   last two are available.

 - Readtables now include entries for extended characters.

 - When a string is read, if the characters are base-char, the string is read
   as a base-string.

 - ECL supports external formats. They may be a symbol, denoting the encoding
   or an encoding option, an association table between bytes and unicode codes
   or a list of these. Some valid symbols are :DEFAULT, :LATIN-1, :ISO-8859-1,
   :UTF-8, :UCS-{2,4}{,BE,LE}, :US-ASCII :CR, :LF, :CRLF, :BIG-ENDIAN and
   :LITTLE-ENDIAN.

 - The external format options :BIG-ENDIAN or :LITTLE-ENDIAN also affect the
   behavior of READ-BYTE and WRITE-BYTE. Default value is :BIG-ENDIAN.

 - The interpretation of newline characters defaults to CRLF in Windows and
   LF elsewhere.

 - ECL accepts :UNSPECIFIC as a valid pathname type component.

* Bugs fixed:

 - (FLOOR X X), (CEILING X X), etc, might return a second value which is a
   signed zero if X is a float with a negative sign.

 - (SXHASH -0.0) != (SXHASH 0.0)

 - (UNREAD-CHAR c) did not decrease the file position accordingly.

 - FILE-STRING-LENGTH only works with file streams, for which it returns
   the right value, and with Gray streams, which output NIL.

 - When ECL is built with --enable-unicode, it uses its own database for
   Unicode properties instead of tolower, toupper, etc (Based on code
   from SBCL)

 - A bug in the binary file loaded prevented loading a recompiled file.

 - READ-DELIMITED-LIST interpreted the value of :RECURSIVEP the wrong way.

 - A trivial bug in the compiler prevented ECL from considering many
   unsafe inlined forms for AREF, (SETF AREF) and many other functions.

 - A bug in the bytecodes compiler prevented ECL's debugger from inspecting the
   stack when there were local functions.

 - Fixed problems with C/C++ forward declarations of static arrays in compiled
   code that prevented ECL from building with a C++ compiler.

 - The CLX module now adds itself to *MODULES* and also requires SOCKETS
   automatically on startup.

* AMOP:

 - In DEFCLASS, the :TYPE of slots was ignored.

 - ECL now sets the proper value for the SLOT-DEFINITION-INITFUNCTION and
   SLOT-DEFINITION-INITFORM of each effective and direct slot definition.

 - The canonicalized default arguments list now contains functions instead
   of the forms to be evaluated.

 - With null safety settings, the slot accessors for structures with
   specialized vector types were not properly compiled.

 - DEFSTRUCT :INCLUDE did not work with read only slots.

 - EXT:SETENV now ensures that strings are null terminated.

 - For high safety settings, ECL produces a CHECK-TYPE for each declaration
   at the beginning of a function. If the declaration has a function type,
   these checks were wrong, for TYPEP cannot take an arbitrary function type
   as argument.

* Visible changes:

 - New function (EXT:HEAP-SIZE &optional NEW-MAX-HEAP-SIZE) can change the      
   memory limits.

 - LOG does not overflow on bignums (LOG (ASH 1 128) 2) => 128

 - Instead of internally using the format (ARRAY T), Unicode strings are
   now stored using an (ARRAY (SIGNED-BYTE 32)). This saves memory on
   systems with 64-bit pointers.

 - Faster calling conventions for function objects, generic functions, symbols
   and interpreted bytecodes, reduce time by 50% in best cases.

 - New, more efficient bytecodes for parsing the function lambda list, instead
   of using a common function.

 - ECL provides macros that define specialized integer types (ecl_uint8_t,
   ecl_int32_t, ... up to ecl_int64_t). These macros can be used to check for
   support of these specialized types in arrays and in compilers. There are
   also companion functions or macros, ecl_make_[u]int*_t and ecl_to_[u]int*_t
   that respectively convert to and from Lisp integers.

 - New specialized array types for signed and unsigned integers with 8, 16, 32
   and 64 bits. They depend on the existence of the ecl_[u]int*_t macros
   mentioned before.

 - Two new constants, a C macro ECL_VERSION_NUMBER, and Lisp constant
   EXT:+ECL-VERSION-NUMBER+, allow determining the version of ECL with
   a greater granurality. The constant is a decimal number, yymmaa,
   matching the ECL versioning scheme.

 - The function EXT:EVAL-WITH-ENV can be used to bytecompile a lisp form for
   later evaluation. The bytecompiled form is compiled like a toplevel form,
   so that EVAL-WHEN understands :COMPILE-TOPLEVEL and :LOAD-TOPLEVEL
	(funcall (si::eval-with-env '(cos 1.0) nil nil nil nil))
   This new feature is used by the module BYTECMP to implement a bytecodes
   compiler that does not need the C compiler to be around.