mirrors/ecl
1
Fork 0
mirror of https://gitlab.com/embeddable-common-lisp/ecl.git synced 2026-01-04 00:11:37 -08:00
Code Issues Projects Releases Packages Wiki Activity

Final version of the announcement for the release 0.9h

Browse source
This commit is contained in:
jjgarcia 2005-11-16 10:07:57 +00:00
parent a85a00784c
commit dc576ca1a2
1 changed files with 138 additions and 128 deletions
Download patch file Download diff file Expand all files Collapse all files

266
ANNOUNCEMENT
View file

@ -1,4 +1,4 @@
Announcement of ECL v0.9f
Announcement of ECL v0.9h
=========================
ECL stands for Embeddable Common-Lisp. The ECL project aims to produce an
@ -10,182 +10,192 @@ 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 (at least
v. 9), Microsoft Windows and OSX (including 10.4.2), running on top of the
Intel, Sparc, Alpha and PowerPC processors. Porting to other architectures
should be rather easy.
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,
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.
CVS tree and some useful documentation.
Notes for this release
======================
This release includes many bug fixes, as well as performance improvements. A
noticeable speed up happens at boot time, due to changes in the implementation
of SUBTYPEP, which make type comparisons much faster.
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).
We have also introduced several bug fixes which seem to make ECL more friendly
towards GCC 4.0 At least this means ECL now builds on my iBook without
additional configuration flags. Please report if you experience any
difficulties.
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.
ECL 0.9g
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
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.
ECL 0.9h
========
* Platforms:
- Fixed the broken port for MacOSX. It should work with any release >= 10.2
- Based on version 6.5 of Boehm-Weiser garbage collector, which fixes some
problems related to the OSX port.
- The latest version of Mingw32's GCC is broken. It silently ignores pathnames
which end in '/'. The include options in ECL have been modified to take
this into account but this intrinsic bug of Mingw might influence ECL's
behavior in some other unexpected ways.
- The configuration in Solaris should now proceed with the flag
--enable-slow-conf.
* Foreign function interface (FFI):
- Added nickname UFFI for FFI package; functions ALLOCATE-FOREIGN-STRING,
WITH-FOREIGN-STRING, WITH-FOREIGN-STRINGS, and FOREIGN-STRING-LENGTH are now
exported. (M. Pasternacki)
- Ecl now accepts :CSTRING UFFI primitive type. (M. Pasternacki)
- DEF-FOREIGN-VAR rewritten to make variables visible from other files and to
dereference also arrays and pointers. (M. Pasternacki)
- When creating a C-STRING, characters after the fill pointer are discarded,
according to people's expectations.
* Compiler changes:
- Generated C functions now have readable names corresponding to appropriate
Lisp function names (M. Pasternacki)
- ECL now compiles with the free Microsoft Visual C++ Toolkit
2003. Instructions are provided on how to do it.
- Unless SI:*KEEP-DOCUMENTATION* = NIL, the documentation of functions is
stored in the compiled files.
- COMPILE-FILE now honors the value of :OUTPUT-FILE given by the user, even if
they do no have the usual extension (.fas). Furthermore, LOAD will now try
to load files with strange extensions (.fas, .fasl, etc) as binary files and
only if this fails, use the source-file loader.
- .LSP/.LISP are now recognized lisp source extensions.
- We now provide inline expansions for all logical operators.
- We have changed the syntax both for function proclamantions and for inline
expansions in sysfun.lsp Additionally, the checks for functions having side
effects have been improved and inline expansions are now stored with a
special-purpose structure INLINE-INFO.
- Ported to OpenBSD/x86. Might also work on other architectures.
* Errors fixed:
- Now .o files compiled with :SYSTEM-P T with dash in filename load
correctly. (M. Pasternacki)
- 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.
- Incorrectly loaded files are now unloaded without falling into infinite
loop. (M. Pasternacki)
- MULTIPLE-VALUE-SETQ must output only the primary value.
- When ECASE or CTYPECASE signal a TYPE-EROR the TYPE-ERROR-DATUM is the value
that originated the error.
- MAKE-CONDITION now accepts type specifiers such as '(AND SIMPLE-CONDITION
TYPE-ERROR).
- FDEFINITION did not signal a type error when passed things like '(SETF A B).
- LOAD can now load code from streams which are not associated to files.
- FUNCTION-LAMBDA-EXPRESSION does not fail, but does nothing useful, when
passed a generic function.
- DISASSEMBLE now signals a TYPE-ERROR condition when the argument is neither
an extended function designator nor a lambda expression.
- Trying to execute an instance object that is not a generic function does no
longer crashes ECL.
- 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.
- When signalling a READER-ERROR, the field reader-error-stream was not bound.
- Many of the STRING* functions (STRING=, STRING<, etc) were proclaimed to
work only on strings, instead of string-designators.
- The random number generator assumed 32-bit integers.
- The command line option "-s" does not take any arguments.
- ext:run-program looks into *standard-input/output* and *error-output* for handle
duplication also under Win32.
- In ECL, all complex types are upgraded to (COMPLEX REAL). However, parts
SUBTYPEP did not apply this.
- FEtype_error_index() had format arguments in wrong order (M. Goffioul).
- 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).
- In the LOOP macro, variables are initialized with values of their type, no
longer producing code like (LET ((C NIL)) (DECLARE (CHARACTER C)) ...)
- When a DEFMETHOD form had an incongruent lambda list, an internal error
prevented ECL from writing the proper error message.
- The compiler now advertises itself with PROVIDE so that issuing (REQUIRE
'CMP) twice does not cause the compiler to be loaded twice.
- SUBTYPEP formerly broken when handling (EQL #C(...))
- Fix error message of interpreted FFI:CLINES form (M. Goffioul).
- Fixed several type propagations: for instance, the compiler assumed that
SQRT of a real number is always real.
- Remove obsolete C::BUILD-ECL documentation (M. Goffioul).
- 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.
- The conversion from ratio to float works now even if the numerator/denominator
are themselves too large to fit a float.
- 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.
- Fixnums and short-floats were compared using the "float" C type. This led to
loss of precision and caused
(= (1+ (ceiling (rational -3.781832e7))) -3.781832e7) => T
* Design:
- Keyword arguments in a type defined with DEFTYPE, for which a default value
is not given, default to '*. Also the DEFTYPE form are enclosed in a block
with the name of the type.
- Simplified the structure of the frame stack, removing redundant fields.
- The syntax of #\: can now be changed.
- Reworked the structure of the lexical environment to accelerate access to
variables.
- Adjusting displaced bit-vectors failed to take the displace-offset into
account.
- New hash routine, similar to SBCL's one, faster and leading to fewer
collisions between similar strings.
- Variable SI::*GC-VERBOSE* controls whether ECL emits messages when FASL
libraries are garbage colleced.
- 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).
- Values of EQL specializers are now evaluated in the lexical environment
in which the DEFMETHOD is enclosed. This makes it now possible to write
(defmethod foo (x) (defmethod bar ((f (eql x)))))
- 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).
- Fixes in the C code to comply with gcc 4.0.
- 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.
* ANSI compatibility:
- The code walker is no longer needed and has been removed from the core.
It will be available in the contributed packages.
- Several functions that signaled type-errors did not set the right values
on the field TYPE-ERROR-EXPECTED-TYPE. We now use the following types:
* valid function names => (SATISFIES EXT:VALID-FUNCTION-NAME-P)
* proper list => PROPER-LIST = (OR (CONS T PROPER-LIST) NULL)
* positive fixnum => (INTEGER 0 MOST-POSITIVE-FIXNUM)
* nonnegative integer => (INTEGER 0 *)
* index in a seq => (INTEGER 0 L) where L is (1- (length sequence))
- 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).
- (COMPLEX *) is now recognized as valid type identifier by subtypep.
- ECL's own conservative garbage collector works again.
- TYPE-OF now returns more precise type names, so that if (TYPE-OF x) = t1 and
(TYPEP x t2) = T then (SUBTYPEP t1 t2) = T.
- 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.
- MAKE-PATHNAME now signals ordinary errors when the arguments do not have
the required type, but signals a file error when it finds something like
a wrong directory (i.e. '(:ABSOLUTE :UP)).
- 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.
- Pathnames which contain :BACK in the directory, now print as unreadable
objects, instead of signaling an error when printing.
* Visible changes:
- Declaration names cannot be used to define new type names and viceversa.
- 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.
- #\Space has constituent trait "invalid".
- Replacing GC_malloc with GC_malloc_ignore_offset() makes ECL use less
memory. A 30% reduction observed when running the ANSI compatibility test
suite.
- DEFINE-SETF-EXPANDER encloses the form in an implicit block with the name of
the SETF function.
- Creating arrays with element type NIL now raises an error.
* New features:
- The DEFSYSTEM system definition facility v 3.4 is now distributed with ECL
in the directory of external packages (contrib/defsystem).
- Added function si:rmdir (M. Pasternacki)
- The version of ASDF distributed with ECL supports building single FASL
files, shared libraries and standalone executable files from a single
definition file.
- There are now specialized arrays for 32 or 64 bits data, depending on the
size of words in the platform.
- 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 ***