ecl/ANNOUNCEMENT

Announcement of ECL v0.9f
=========================

ECL stands for Embeddable Common-Lisp. The ECL project aims to produce an
implementation of the Common-Lisp language which complies to the ANSI X3J13
definition of the language.

The term embeddable refers to the fact that ECL includes a lisp to C compiler,
which allows to produce libraries (static or dynamic) that can be called from C
programs. Furthermore, ECL can produce standalone executables from your lisp
code.

ECL supports the operating systems Linux, FreeBSD, NetBSD, Solaris, Microsoft
Windows and OSX, running on top of the Intel, Sparc, Alpha and PowerPC
processors. Porting to other architectures should be rather easy.

ECL is currently hosted at SourceForge. The home page of the project is
http://ecls.sourceforge.net, and in it you will find source code releases, a
CVS tree and an up to date documentation.

Notes for this release
======================

The highlights of these release are the two new contributed modules: a port of
the ASDF system definition, and a port of SBCL's socket libraries, including
TCP and unix sockets and, only on Windows, named pipes.

ECL 0.9f
========

* Platforms:

 - Cygwin support has been fixed and it now supports DLLs (M. Goffioul).

* Errors fixed:

 - The reader macros for lists, ##, #C, #P and #' did not behave as expected
   when *read-suppress* = t.

 - No comments were allowed between the last list element and the parenthesis
   in a dotted lists. In other words, this:
	(1 . 2 ;; just a comment
	)
   produced an error.

 - All strings in a pathname must be valid C strings, with a null terminating
   character and no fill pointer.

 - "+nan" is no longer parsed as a number.

 - Where available, ECL now uses _setjmp/_longjmp for control structures. These
   functions are faster, as they do not save signals.

 - (EXPT 10.0l0 308) failed because the routine EXPT computed too many powers
   of 10.0l0, some of which (in particular 10^512) were not required and
   overflowed the machine accuracy.

 - make_stream_from_fd() did not accept smm_io.

 - Fixed the optimizer for slot access, which now only operates if the
   variables have been declared of type STANDARD-OBJECT.

 - Pipes are now opened in character mode (M. Pasternacki)

 - (DOCUMENTATION 'F 'FUNCTION) did not work with generic functions.

 - ADJUST-ARRAY did not work with strings.

 - DEFMACRO admits again lambda lists of the form (a . b).

 - EXPT failed when the exponent was a complex number equal to zero.

 - Setting the property lists of the symbol NIL no longer breaks ECL.

 - Fixed (documentation) and (setf documentation) behaviour. (M. Pasternacki)

* Compiler errors:

 - In compiled code, discarded (VALUES ...) forms did not trigger all the
   required unwinding forms, so that (TAGBODY (CATCH 'FOO (VALUES 0))) produced
   wrong code.

 - In compiled code, the init-form for keyword and optional arguments could
   reference the variable that it was going to initialize, as in
	(LAMBDA (&OPTIONAL (FOO (1+ FOO))) ...)

 - Globals declared with DEFPARAMETER toplevel forms were not recognized by
   the compiler as special variables.

 - The code for handling closure variables has been changed and now encloses
   the whole of the function in a C block.

 - Values of MOST-POSTIVE-LONG-FLOAT, and similar constants, are now taken from
   the float.h header, instead of referencing the lisp variables themselves.

 - A typo made the check for proper tail recursion always succeed.

* Foreign function interface (FFI):

 - ext:c-uint-max and ext:c-ulong-max did not have the right bignum value.

 - C-INLINE forms now can output multiple values. For instance
	> (compile nil '(lambda (x)
			  (ffi::c-inline (x) (:int) (values :int :int)
				 "@;@(return 0)=#0+2; @(return 1)=#0+3;")))
	[...]
	#<compiled-function 0815b318>
	NIL
	NIL
	> (funcall * 2)
	4
	5

 - C-INLINE forms are now understood by the walker in clos/walk.lsp

 - DEFENTRY, DEFCBODY and DEFLA have been reimplemented. The current status
   of the FFI is now better described in the documentation, with a reference
   to the UFFI package for further details.

* Visible changes:

 - Boehm-Weiser garbage collector v 6.4

 - GNU MP library v 4.1.4

 - Multithreaded ECL now in Windows, either with Microsoft VC++
   or Mingw32 (M. Goffioul).

 - Improvements in the efficiency of macro readers for #a() and #()

 - When supplied an :INITIAL-CONTENTS, MAKE-ARRAY now uses a more efficient
   algorithm.

 - Optimized some routines that iterate over sequences: SOME, EVERY,
   NOTANY, NOTEVERY (M. Goffioul)

 - A new global variable SI::*EXIT-HOOKS* is used to store closures that
   will be invoked when exiting ECL by cl_shutdown().

 - Slight rewrite of configuration help.

 - Configure option --with-clos-streams now defaults to true.

 - When closing a composite stream, all references to its elements are now erased.

 - Backquote forms are now translated into lists containing the macros
   EXT:QUASIQUOTE, EXT:UNQUOTE, EXT:UNQUOTE-SPLICE and EXT:UNQUOTE-NSPLICE.
   At evaluation/compilation time, the macroexpander for QUASIQUOTE transforms
   the tree into the appropiate lisp expression. Otherwise, the print
   representation is preserved:
	(format nil '`(foo ,@a)) => "`(foo ,@a)"

 - Our implementation of CLOS streams now builds on the Gray streams proposal
   except for the generic functions CLOSE, STREAM-ELEMENT-TYPE, INPUT-STREAM-P,
   OUTPUT-STREAM-P and OPEN-STREAM-P. We rather keep these as normal functions
   that call the user extensible EXT:STREAM-{CLOSE, ELT-TYPE, INPUT-P,
   OUTPUT-P, OPEN-P}. Care has been taken to ensure compatibility with previous
   versions of ECL.

 - The configuration and build process have been cleaned, making it closer to
   GNU guidelines and improving things like naming of variables. The flags
   --with-system-{gmp,boehm} now take an optional argument which can be "auto",
   for automatic detection of the libraries (M. Pasternacki).

 - By default, the size of binary streams is rounded to a multiple of 8. If you
   want other behavior, pass :USE-HEADER-P T to the function OPEN.

 - ECL now accepts a double dash, '--', as a command line option. Anything
   after the double dash is interpreted as a lisp command.

 - Bytecode functions can now be printed readably as #Y(...). The appropiate
   reader macro has been also implemented (M. Pasternacki)

 - *ERROR-OUTPUT* is now properly set to the C error stream.

 - EXT:RUN-PROCESS can now duplicate the *STANDARD-OUTPUT* and *ERROR-OUTPUT*
   even if they are not the files set at the beginning of the process
	> (let ((*standard-output* (open "foo.txt" :direction :output
					  :if-does-not-exist :create :if-exists :supersede)))
	      (ext:run-program "echo" '("hola!") :output t))
	#<two-way stream 0868a708>
	> (si::system "cat foo.txt")
	hola!
	0

* ANSI Compatibility:

 - DEFSETF forms are enclosed in a block with the name of the accessor.

 - When supplied a compiled function as second argument, COMPILE returns
   this function. And also when the function is interpreted but we have
   lost its original definition.

 - Now an error is signaled for unmatched parenthesis as in "(1 2 3))".
   The only exception is in the toplevel, where only a warning is issued.

 - The stream argument for DESCRIBE-OBJECT is now a required one, instead of
   an optional.

 - When *PRINT-READABLY*=T, vectors just print as arrays.

 - When used as macro characters, upper and lowercase letters share the same
   dispatcher, so that if the user defines a dispatcher for #f, it is
   automagically set for #F and viceversa.

* MOP Compatibility:

 - We have implemented the *-SLOT-DEFINITION classes, as well as the protocol
   for computing effective slot definitions from direct ones, and the methods
   DIRECT/EFFECTIVE-SLOT-DEFINITION-CLASS. (Position field in slot-def. objects
   still missing).

 - CLASS-PROTOTYPE is now only a reader.

* Contributed modules:

 - MIT test unit rt.lisp is now available as #p"sys:rt"

 - SBCL sockets have been ported to unix (J. Stecklina) and to windows
   (M. Goffioul) and are built when using the configuration option --with-tcp.
   Both INET and Unix sockets are implemented. Under windows Unix sockets are
   simulated the cygwin way (i.e. creating a file with the address and port
   of a INET socket), and we also offer the possibility of creating named
   pipes.

 - SBCL's implementation of PROVIDE/REQUIRE is now in ECL. By default, modules
   are searched in the #P"SYS:" path, but you can add your own searching
   functions to *module-provider-functions*. (J. Stecklina)

 - ASDF is now provided together with ECL. Hopefully, in a near future we will
   be able to customize it to produce shared libraries out of definition files.

;;; Local Variables: ***
;;; mode:text ***
;;; fill-column:79 ***
;;; End: ***