Announcement file, new version number and spell checking of the CHANGELOG file

Announcement of ECL v0.9h

Announcement of ECL v0.9i

=========================

ECL stands for Embeddable Common-Lisp. The ECL project aims to produce an

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

which produces libraries (static or dynamic) that can be called from C

programs. Furthermore, ECL can produce standalone executables from your lisp

code.

code and can itself be linked to your programs as a shared library.

ECL supports the operating systems Linux, FreeBSD, NetBSD, OpenBSD, Solaris (at

least v. 9), Microsoft Windows and OSX, running on top of the Intel, Sparc,

Notes for this release

======================

Apart from important bugs being fixed, this release makes slightly better use

of the Boehm-Weiser garbage collector, thereby reducing memory use. Typically,

in a linux/x86 box this can be as little as 6Mb of which 2.7Mb are shared

libraries (including both lisp and C libraries).

This version adds one port: OSX on Intel/x86. The port uses the latest version

of the Boehm-Weiser garbage collector and an unoptimized version of the GMP

library (because the developers refuse to port the Intel/x86 assembler code to

this platform).

Another highlight of this release are the improvements in the foreign function

interface. First of all, callbacks are now supported for all architectures

using compiled code. Second, we have new, nonportable code for dynamically

accessing C/C++ functions in shared libraries, as well as creating callbacks on

the fly. Due to the need for assembly code, this is currently supported on the

Intel-x86 architecture only, but can be extended to other ports.

Apart from that, this release contains mostly bug fixes. Some of them are very

important. For instance, ECL can now compiled code with constants that have no

printed representation, such as CLOS classes and objects, but also hash tables

and arrays with circular references.

Also of interests are the ASDF routines introduced by Michael Goffioul for

building unified FASL files, shared libraries and standalone executables up

from a single system definition file. For a simple example see

     ecls/examples/asdf/readme.lisp

ECL can also be built with support for strings and symbols with unicode

characters (patches by B. Spilsbury). However, since the reader still does not

understand external formats, there is some way until we can claim that ECL

supports unicode.

Finally, we have added a new platform to our list: OpenBSD. This port benefits

from the changes in ECL's own conservative garbage collector, which, at the

cost of being slightly slower, is the only one supported on this operating

system.

Changes since 0.9h

==================

ECL 0.9h

========

See file src/CHANGELOG.

* Platforms:

 - Ported to OpenBSD/x86. Might also work on other architectures.

* Errors fixed:

 - The garbage collection of FASL files had been deactivated by the use of

   high level routines (VECTOR-PUSH-EXTEND) to handle the vector of weak

   pointers to the files.

 - MULTIPLE-VALUE-SETQ must output only the primary value.

 - MAKE-CONDITION now accepts type specifiers such as '(AND SIMPLE-CONDITION

   TYPE-ERROR).

 - LOAD can now load code from streams which are not associated to files.

 - DISASSEMBLE now signals a TYPE-ERROR condition when the argument is neither

   an extended function designator nor a lambda expression.

 - The block name of a function does not involve the the forms in the lambda

   list: i.e. (LAMBDA-EXT F (&aux (X (RETURN-FROM F 2)))) is no longer valid.

 - Many of the STRING* functions (STRING=, STRING<, etc) were proclaimed to

   work only on strings, instead of string-designators.

 - The command line option "-s" does not take any arguments.

 - In ECL, all complex types are upgraded to (COMPLEX REAL). However, parts

   SUBTYPEP did not apply this.

 - When reading 1/0, the reader must signal a READER-ERROR, because it is

   a syntax error to have a denominator full of zeros (CLHS 2.2 end plus

   2.3.2.1.2).

 - When a DEFMETHOD form had an incongruent lambda list, an internal error

   prevented ECL from writing the proper error message.

 - SUBTYPEP formerly broken when handling (EQL #C(...))

 - Fixed several type propagations: for instance, the compiler assumed that

   SQRT of a real number is always real.

 - DECODE/ENCODE-UNIVERSAL-TIME now work with very big dates, although the

   accuracy for determining whether a time belongs to DAY-SAVING-TIME might

   depend on the implementation of the C library.

 - Most systems do not support dates before 1970 or after 2038. For guessing

   the daylight saving time property we shift the dates to equivalent years

   within this range.

* Design:

 - Simplified the structure of the frame stack, removing redundant fields.

 - Reworked the structure of the lexical environment to accelerate access to

   variables.

 - New hash routine, similar to SBCL's one, faster and leading to fewer

   collisions between similar strings.

 - Method combinations do not longer rely on a hash table of precomputed

   effective methods. That method required a structural analysis of the forms

   generated by the method combinations, which is plain slower than generating

   the effective method as either a closure (in most cases) or as bytecodes

   (for the most complex declarative forms).

 - CALL-NEXT-METHOD and NEXT-METHOD-P are now implemented in a simpler way,

   without relying on the code walker (which is a damm buggy piece of code).

 - Formerly, the body of methods was walked through, replacing slot access with

   the indices of the slots in the object structure. This is plain wrong

   because the structure of a class may change. Such aggressive optimizations

   may be reimplemented in a future in the compiler, but only when the user

   asks for them.

 - The code walker is no longer needed and has been removed from the core.

   It will be available in the contributed packages.

 - Possibility of configure --without-gmp when cross-compiling (there are no

   true bignums then, just long long int if possible; doesn't work with native

   compilation because compiler needs true bignums).

 - ECL's own conservative garbage collector works again.

 - It is possible now to execute lisp code from threads that have been created

   by external C applications. The functions

	ecl_import_current_thread(cl_object name, cl_object bindings)

   should be called to register the current thread with the lisp world, while

	ecl_release_current_thread()

   should be invoked before the current thread exits. However, in order to

   ensure that the garbage collector can handle these threads, these

   applications must be compiled and linked against ECL so that the

   appropiate replacements for pthread_create()/CreateThread() are used.

 - On some systems we are able to signal and trap floating point

   exceptions of the following kinds: overflow, underflow and division by zero.

   Trapping of these exceptions can be disabled with (SI::TRAP-FPE T NIL). In

   practice this means overflows in routines like EXP, EXPT, etc, are now

   detected.

* Visible changes:

 - The code for handling command line options has been redesigned. Now multiple

   -compile options are allowed; the -o/-c/-h/-data options have to come before

   the associated -compile; we introduce a new -rc option to force loading

   initialization files; errors during initialization are intercepted and cause

   ECL to abort.

 - Replacing GC_malloc with GC_malloc_ignore_offset() makes ECL use less

   memory. A 30% reduction observed when running the ANSI compatibility test

   suite.

 - Creating arrays with element type NIL now raises an error.

 - The DEFSYSTEM system definition facility v 3.4 is now distributed with ECL

   in the directory of external packages (contrib/defsystem).

 - The version of ASDF distributed with ECL supports building single FASL

   files, shared libraries and standalone executable files from a single

   definition file.

 - The test suites are now part of a separate project, ecls-test, that is only

   distributed via CVS from Sourceforge.

* Foreign function interface (FFI):

 - Foreign function return type is now correctly handled, when it is specified

   with a user-defined foreign type that is an alias for a primitive type

   (M. Goffioul)

 - C-INLINE forms which contain :CSTRING as argument are now automatically

   rewritten in terms of WITH-CSTRING. This way, the null terminated strings

   that are generated at run time will not be garbage collected.

 - There is a primitive implementation of run-time automatic generation of

   interfaces to C functions. This allows us to call functions in shared

   libraries without need of the compiler. The current implementation only

   works on the intel architecture with GCC, but should be easily extended.

   It can be turned on/off for individual compilations with variable

   SI::*USE-DFFI* (default is on if supported).

 - There is now a simple implementation of callbacks, with a syntax similar to

   that of CFFI:

	(ffi:defcallback foo :int ((a :int))

	   (1+ a))

 - On the intel x86 architecture we also have the possibility of creating

   callbacks dynamically, at run time, without the compiler.

;;; Local Variables: ***

;;; mode:text ***

* New platforms:

 - Patches in assembler code and GC headers to build ECL on Mac OSX/Intel

   contributed by Brad Beveridge. This port relies on the version of the

   GNU MP library shipped with DarwinPorts.

   contributed by Brad Beveridge.

 - ECL compiles and passes tests in OpenBSD/x86.

* Unicode support: (contributed by Brian Spilsbury)

 - Unicode strings (24-bits characters) are now supported as data structure,

   though they do not print and read properly.

   though they have no printed representation.

* Visible changes:

 - Compiled functions can have more than 64 required arguments.

 - Many functions have got now the prefix "ecl_" so as to avoid namespace

   collisions with C/C++ code.

   collisions with C/C++ code (still work to be done in this front).

 - Several functions with duplicate functionality (make_two_way_streams,

   make_string_output_stream_from_string, close_stream, etc) have been removed.

   constants. The only case where this fail is when the "unreadable" constant

   is part of a circular structure (contributed by Brian Spilsbury).

 - The second value of MACROEXPAND-1 is true whenever a macroexpansion

   happened; in other words, whenever an macro function was called. MACROEXPAND

   on the additionally checks whether the macroexpanded form is eq to the

   original one and complains of the infinite loop that results.

 - The second value of MACROEXPAND-1 is true whenever a macroexpansion happened

   or, in other words, whenever an macro function was called. MACROEXPAND

   additionally checks whether the macroexpanded form is eq to the original one

   and complains of the infinite loop that results.

 - Configuration flag --with-tcp defaults to true.

 - [Win32] Add a :SYSTEM key argument to C::BUILDER, used when building a program,

   to specify the type of executable. Possible values are :CONSOLE, to build a

   console program, and :WINDOWS, to build a Windows program. The second case makes

   only sense when the program contains some GUI (M. Goffioul).

 - [Win32] Add a :SYSTEM key argument to C::BUILDER, used when building a

   program, to specify the type of executable. Possible values are :CONSOLE, to

   build a console program, and :WINDOWS, to build a Windows program. The

   second case makes only sense when the program contains some GUI

   (M. Goffioul).

 - The compiler is slightly faster by avoiding use of EVAL.

 - A new defclass option, :OPTIMIZE-SLOT-ACCESS, which defaults to the value of

   CLOS:*OPTIMIZE-SLOT-ACCESS*, controls whether the slots accessors should

   address directly the values in the class or use SLOT-VALUE. It should be set

   to NIL when one intends to redefine the SLOT-*-USING-CLASS methods, and

   to T when trying to get the most of the speed.

   to NIL when one intends to redefine the SLOT-*-USING-CLASS methods, and to T

   when trying to get the most of the speed.

 - Implemented [FUNCALLABLE-]STANDARD-INSTANCE-ACCESS. They are synonyms for

   SI:INSTANCE-REF and are, as such, inlined and _very_ unsafe. Use with care.

	> (defclass foo (standard-class) ())

	> (defclass faa () () (:metaclass foo))

 - Callback functions are now 'static' so that the same names can be used

   in different files.

 - Callback functions are now C 'static' functions so that the same names can

   be used in different files.

 - New method for DOCUMENTATION to operate on slot-definition objects.

   any case, this collector is only intended for small setups and OpenBSD.

 - The compiler transformed &AUX variables into a LET* form. In doing so, all

   declarations were propageted to the body of the LET* form, even those for

   declarations were propagated to the body of the LET* form, even those for

   non-&AUX variables. This could lead to spurious warnings about IGNORE

   declarations.

#! /bin/sh

# From configure.in Revision.

# Guess values for system-dependent variables and create Makefiles.

# Generated by GNU Autoconf 2.59 for ecl 0.9h.

# Generated by GNU Autoconf 2.59 for ecl 0.9i.

#

# Copyright (C) 2003 Free Software Foundation, Inc.

# This configure script is free software; the Free Software Foundation

# Identity of this package.

PACKAGE_NAME='ecl'

PACKAGE_TARNAME='ecl'

PACKAGE_VERSION='0.9h'

PACKAGE_STRING='ecl 0.9h'

PACKAGE_VERSION='0.9i'

PACKAGE_STRING='ecl 0.9i'

PACKAGE_BUGREPORT=''

ac_unique_file="bare.lsp.in"

  # Omit some internal or obsolete options to make the list less imposing.

  # This message is too long to be a string in the A/UX 3.1 sh.

  cat <<_ACEOF

\`configure' configures ecl 0.9h to adapt to many kinds of systems.

\`configure' configures ecl 0.9i to adapt to many kinds of systems.

Usage: $0 [OPTION]... [VAR=VALUE]...

if test -n "$ac_init_help"; then

  case $ac_init_help in

     short | recursive ) echo "Configuration of ecl 0.9h:";;

     short | recursive ) echo "Configuration of ecl 0.9i:";;

   esac

  cat <<\_ACEOF

test -n "$ac_init_help" && exit 0

if $ac_init_version; then

  cat <<\_ACEOF

ecl configure 0.9h

ecl configure 0.9i

generated by GNU Autoconf 2.59

Copyright (C) 2003 Free Software Foundation, Inc.

This file contains any messages produced by compilers while

running configure, to aid debugging if configure makes a mistake.

It was created by ecl $as_me 0.9h, which was

It was created by ecl $as_me 0.9i, which was

generated by GNU Autoconf 2.59.  Invocation command line was

  $ $0 $@

} >&5

cat >&5 <<_CSEOF

This file was extended by ecl $as_me 0.9h, which was

This file was extended by ecl $as_me 0.9i, which was

generated by GNU Autoconf 2.59.  Invocation command line was

  CONFIG_FILES    = $CONFIG_FILES

cat >>$CONFIG_STATUS <<_ACEOF

ac_cs_version="\\

ecl config.status 0.9h

ecl config.status 0.9i

configured by $0, generated by GNU Autoconf 2.59,

  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"

dnl  Giuseppe Attardi 25.1.1994

dnl

AC_INIT([ecl],[0.9h],[])

AC_INIT([ecl],[0.9i],[])

AC_REVISION([$Revision$])

AC_CONFIG_SRCDIR([bare.lsp.in])

AC_CONFIG_AUX_DIR([${srcdir}/gmp])