| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
Changes since 16.0.0
* API changes
- si:do-setf accepts optional parameter stores. New lambda-list:
(access-fn function &optional (stores `(,(gensym))))
This change is backward compatible.
- New MP functions:
mp:with-rwlock
mp:try-get-semaphore (non-blocking)
mp:mailbox-try-read (non-blocking)
mp:mailbox-try-send (non-blocking)
- Added back removed C interfaces
ecl_import_current_thread
ecl_release_current_thread
- When cl-truename encounters a broken symlink, it returns its path
instead of signalling a file-error
- Deprecated variables has been removed
c::*suppress-compiler-warnings*, c::*suppress-compiler-notes*
- Random state might be initialized by a random seed (truncated to
32bit value) or by a precomputed array.
Latter is designed to allow reading back the printed random state
(when printed readably), not as an array to initialize the random
state.
- C99 supporting compiler is mandatory for C backend.
- COMPILER::*cc_is_cxx*: New variable to switch the output extension of
emitted compiler code to ".cxx" when configured with "--with-c++". This
eliminates compiler warnings that compiling C++ with a ".c" extension is
deprecated; this is seen mostly with Clang++.
- Added Clang-specific pragmas to disable return type, unused value and
excessive parentheses warnings, which are fairly harmless, but annoying
and clutter user output.
- GRAY:CLOSE isn't specialized on T to preserve compatibility with some
libraries.
* Enhancements:
- Added code walker (present as *feature* :walker)
- Testing framework cleanup
- Format fallbacks to prin1 if infinity or NaN are passed to it
- Annotations are added at runtime (better integration with SLIME)
- Mersenne-Twister RNG has new 64 bit implementation for appropriate
machines
- Add sockets implementation for android platform
- Add android build target (official android support)
* Issues fixed:
- si:open-unix-socket-stream accepts both string and base-string
(automatic coercion is performed)
- Long form of DEFSETF accepts multiple-values as a store forms:
(defsetf gah (x) (y z) `(list ,x ,y ,z))
(setf (gah 3) (values 3 4))
- Building with single-threaded boehm works if ECL threads are disabled
- Using labels works with sharp-S-reader
(read-from-string
"(#1=\"Hello\" #S(sharp-s-reader.1.example-struct :A #1#))")
- Generated C code works well with IEEE 754 infinities
(regression tests created)
- User-defined heap sizes can now exceed the size of a fixnum on 32-bit
- The heap size limit was intended to be 1GB on 32-bit or 4GB on 64-bit
but inconsistency between ECL_FIXNUM_BITS and FIXNUM_BITS in the code
prevented the heap to grow for 64-bit. This now occurs, and a few
other less visible bugs were fixed by restoring consistency to
ECL_FIXNUM_BITS.
- EXT:EXTERNAL-PROCESS-WAIT potential race condition fix
- Building with object files not created by ECL works (CFFI wrappers)
- Regression regarding initialization of build by ECL libraries from
external code fixed. Static and shared libraries initialization
funcitons has predetermined name while object files has randomized
names.
- Random state initial state generation was buggy and insecure (entropy
from urandom was rejected)
- Fix `listen' on streams when FILE_CNT isn't available (use read instad
of fread)
- `FIND' compiled with C compiler didn't respect `START' nor `END'
arguments. Compiler macro is fixed now and should work as expected
- `compute-applicable-methods-using-classes` bugfix
|
|
ECL 12.7.1:
===========
* Bugs fixed:
- The implementation of locks and condition variables based on POSIX threads
was not safe under interrupts. It has all been reimplemented using atomic
userspace operations plus a new wait queue.
- :CDECL was not accepted as an FFI declaration due to a typo.
- REMOVE-METHOD and FIND-METHOD were not generic functions.
- MAKE-LOAD-FORM's methods for standard-object, structure-object and
condition did not signal an error).
* Visible changes:
- ECL builds with support for threads by default (where available).
- DIRECTORY no longer complains when it finds an inexistent directory
component: it simply returns NIL as the list of pathnames.
- CASE now complains when the OTHERWISE/T clause is not the last one.
- Instead of issuing an error, LOOP now only produces a STYLE-WARNING
when iteration forms appear at the wrong place, as in (LOOP WHILE ...)
followed by some assignment.
- EXT:MKDIR no longer accepts pathnames as inputs to avoid problems with
pathnames that contain name or type components.
- ENSURE-DIRECTORIES-EXIST accepts the keyword argument :MODE which is
passed to MKDIR.
- In EXT:RUN-PROGRAM the child process is delayed until the parent has created
the process structure and stored the process id in it. Formerly we had race
conditions due to the child exiting before the parent was able to call
sigwait().
- Where available, ECL now defines the constants EXT:+SIGRTMIN+ and
EXT:+SIGRTMAX+, as well as EXT:+SIGRT0+ through EXT:+RTMINn+ where n =
SIGRTMAX - SIGRTMIN Those signals can be then trapped.
- The interrupt handler for floating point exceptions does not care about
the value of EXT:*INTERRUPTS-ENABLED* or similar mechanisms because such
interrupt has to be treated as an error, not as something optional. The
same applies to other evil signals, such as SIGSEGV or SIGBUS.
- New functions (EXT:GET-INTERRUPT-HANDLER code) and
(EXT:SET-INTERRUPT-HANDLER code function-designator) allow the user to
customize how these interrupts are caught. SET-INTERRUPT-HANDLER runs an
implicit EXT:CATCH-SIGNAL.
- ECL now exports the symbols FFI:C-INT-MAX, FFI:C-INT-MIN, FFI:C-LONG-MAX,
etc, which correspond to the POSIX C constants INT_MAX, INT_MIN, LONG_MAX,
and similar ones.
- APROPOS-LIST no longer returns duplicate symbols.
- The ABORT restart is now bound on every new thread (except the main one,
where either the user or the toplevel must take care of that).
* Windows:
- ECL guesses whether the input / output / error streams are consoles. If
so, it sets up a special type of stream that copes with the deficiencies
of read()/write() and similar functions on consoles -- namely that they
may read or write a larger number of bytes than demanded because they
translate the input/output to and from the corresponding codepage.
(EXPERIMENTAL)
- ECL detects the codepage that the console is using and applies it as
the appropriate external format (with :CRLF convention).
- ECL's console stream signals EOF when Ctrl-Z is detected.
* Metaobject protocol:
- Implemented CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSES.
- COMPUTE-APPLICABLE-METHODS and CLOS:COMPUTE-EFFECTIVE-METHOD are now
generic functions.
- Implemented and used in the core: VALIDATE-SUPERCLASSES
- UPDATE-DEPENDENT, MAP-DEPENDENTS and related functions have been fixed. They
are now invoked by REMOVE-METHOD and REINITIALIZE-INSTANCE, when acting on
generic functions, standard classes, etc.
- (SETF CLASS-NAME) is now implemented using REINITIALIZE-INSTANCE.
- ENSURE-CLASS-USING-CLASS now registers the class with
FIND-CLASS. ENSURE-CLASS relies on E-C-U-C doing that.
- EXTRACT-LAMBDA-LIST and EXTRACT-SPECIALIZER-NAMES implemented.
- CLOS:GENERIC-FUNCTION-DECLARATIONS and slot CLOS:DECLARATIONS are now
implemented (even if not used by ECL itself).
- Implemented the class CLOS:METAOBJECT
- Implemented SPECIALIZER and EQL-SPECIALIZER, together with
ADD-DIRECT-METHOD, REMOVE-DIRECT-METHOD, SPECIALIZER-DIRECT-METHODS,
SPECIALIZER-DIRECT-GENERIC-FUNCTIONS and EQL-SPECIALIZER-OBJECT. ECL now
uses these objects internally for method dispatch.
- DEFMETHOD now relies on MAKE-METHOD-LAMBDA to create the appropriate
function.
- Implemented COMPUTE-DISCRIMINATING-FUNCTION.
- ECL's discriminating functions use COMPUTE-APPLICABLE-METHODS-USING-CLASSES
on those classes in which the user may redefine or extend the
method. Elsewhere, ECL relies on the internal equivalent of
COMPUTE-APPLICABLE-METHODS, which _always_ memoizes results.
- When reinitializing a class instance, ECL would not remove the class from
its former superclasses.
- The method combination slot of a generic function is now precomputed by
using FIND-METHOD-COMBINATION in SHARED-INITIALIZE.
- METHOD-COMBINATION is now a class with slots and it is used by ECL for
computing effective methods.
- The MOP and CL classes and metaclasses do not contain any slot whose name
is exported by any of the CL or CL-USER packages.
|
|
ECL 12.2.1:
===========
* Bugs fixed:
- Fixed several dozens of typos.
- ENSURE-DIRECTORIES-EXIST did not work properly with logical pathnames.
- EXT:SET-LIMIT with option EXT:FRAME-STACK corrupted the frame stack.
- The array of boot-time symbols is fixed and independent of the features
that are compiled in. This is essential for cross-compilation and also
for sharing C code among different builds.
- Fixed externalization of bytecodes with literals that need MAKE-LOAD-FORM.
- When parsing a floating point number at least one digit should be
present. ECL parsed +.e0 as +0.0e0, instead of as a symbol.
- For OS X Lion we need a newer version of the garbage collector. Since the
maintainers' advise is that we use the unstable tree, we have made a copy
and use it _only_ for this port (src/gc-unstable).
* Visible changes:
- When printing error messages, the condition type is shown (M. Mondor)
- SI:TOP-LEVEL, when invoked without arguments, does not process the
command line.
- The command line used by EXT:PROCESS-COMMAND-ARGS is now by default
the one stored in *COMMAND-ARGS*, and this may be "cleared" by the
user.
- SOCKET-MAKE-STREAM now accepts an :ELEMENT-TYPE argument.
- When --enable-rpath is used in combination with --with-gmp-prefix, then the
path of the GMP library is hardcoded into ECL. If the remaining libraries
(GC, libffi) are in a similar location this will make ECL work without
further flags, and without modifying LD_LIBRARY_PATH or DYLD_LIBRARY_PATH.
- All arguments after the '--' command line option are stored in a global
variable, ext:*unprocessed-ecl-command-args*.
- In the rules passed to ext:process-command-args, :stop now implies that all
remaining arguments including the current one are collected and passed to
the rule code. An example of use of this option
;; Collect all arguments _after_ the command line option --
("--" 1 (setf ext:*unprocessed-ecl-command-args* (rest 1)) :stop)
;; Collect all arguments including the first unknown one
("*DEFAULTS*" 1 (setf ext:*unprocessed-ecl-command-args* 1) :stop)
- ECL will always build, by default, with support for Unicode strings.
- EXT:GETENV coerces its input argument to type BASE-STRING.
- The garbage collector would reset the counters on every call to
SI:GC-STATS. This made nested TIME calls not to work, as the statistics of
the inner call would spoil those of the outer one. This has been fixed.
- ECL implements CDR 6 (ext:*inspector-hook*) as described in
http://cdr.eurolisp.org/document/6/index.html
- ECL implements CDR 5 (Sub-interval Numerical Types) as described in
http://cdr.eurolisp.org/document/5/index.html
- ECL ships libffi together with its source tree, much like GMP and GC.
- On POSIX platforms ECL traps SIGCHLD and uses it to update the status of
external processes.
- DIRECTORY accepts the keyword argument :RESOLVE-SYMLINKS.
- Compiling files now generates C headers with the extension "eclh". This
is done to avoid accidentally generating header files with the same name
as those in the C library. Take for instance, float.lsp -> float.h.
- ECL no longer relies on "git" being installed to gather the git commit id
and setting (ext:lisp-implementation-vcs-id).
- When building shared and statically linked libraries, ECL creates an
extra function that performs two tasks: initializing ECL if it wasn't done
before, and initializing the library. This can be used to create standalone
libraries to be linked with other programs. The name of the function typically
begins with main_dll or main_lib but it is output by ECL on screen.
- Hash tables do no longer have implicit locking. All complex structures in
ECL (arrays, hash tables, objects) should be dealt with sufficient care on
the user side, just as in other programming languages, making use of
WITH-LOCK and similar facilities.
- In OPEN the default format is :UTF-8 for Unicode builds and :LATIN-1 for
others, and the stream element type is always CHARACTER by default.
- Function read_VV is renamed to ecl_init_module()
- Initialization of random number generator is done using only 16 bytes from
/dev/urandom (Phillip Marek).
- Each thread keeps a copy of the process sigmask (POSIX) and it is inherited
by children thread. The sigmask can be manipulated by the function
EXT:CATCH-SIGNAL which has the signature
(ext:catch-signal signal-code action &key process)
The ACTION is one of :IGNORE, :DEFAULT, :CATCH, determining what ECL does
when it receives the signal, or it can be :MASK/:UNMASK to determine whether
the process is blocking the signal or not. The optional argument :PROCESS
only applies to :MASK/:UNMASK and it can be the current process, some
process that has not been activated or any other value (indicating that
the function has a global effect, as sigprocmask).
- Allocate executable memory using libffi instead of using just the
Boehm-Weiser garbage collector.
- In bytecodes.h, deactivate the threaded interpreter when using the LLVM
compiler. The problem is that llvm-gcc disguises itself as GCC but it is
not capable of properly compiling the jump table.
- Implemented SEQUENCE-STREAMs, which are input/output streams defined on some
specialized array type. The functions to create them are
(ext:make-sequence-input-stream vector &key :start :end :external-format)
(ext:make-sequence-output-stream vector &key :external-format)
* If the array is a string, it is a character stream.
- When no external format is supplied, it defaults to the usual encoding
and the stream behaves like a string stream.
- When an external format is supplied, each character in the string
is interpreted as a single byte and used for that external format.
* If the array is specialized over integers and EXTERNAL-FORMAT is NIL
the stream is a binary stream.
* Otherwise, it is a binary string but READ/WRITE-CHAR may be used on it.
Reading and writing does not preserve the original word size of the array
but rather threads the array as a collection of bytes (octets), writing
sequentially over it. Thus, if you use encodings such as UCS2 and UCS4, make
sure that you choose the right endianness to match the shape of the array.
- DELETE-FILE works on empty directories.
- In DIRECTORY, :RESOLVE-SYMLINKS defaults to T.
- Added POSIX function (EXT:CHMOD filename mode)
- ECL's compiler is now less verbose and hides performance notes, as well as
invocations of the C compiler. This can be modfied by changing the type
specifier in c:*suppress-compiler-messages*.
- Hash tables can now be printed readably when *READ-EVAL* is true. This is
done using two new functions, EXT:HASH-TABLE-CONTENT and
EXT:HASH-TABLE-FILL.
- When a compiler macro fails, ECL simply ignores the errors and
continues. This is more to the spirit of the compiler macros, as explained
here http://lists.common-lisp.net/pipermail/pro/2011-December/000675.html
- INLINE declarations now actually cause the function to be inlined. If
the function is also proclaimed as INLINE, ECL will store a copy of its
definition for later use _in other files_. Otherwise INLINE declarations
remain local to the file being processed.
- ECL now implements weak hash tables. They are built as ordinary hash tables
with an extra argument, :WEAKNESS, which may be :KEY, :VALUE,
:KEY-AND-VALUE, or NIL, for the default behavior. The status of the hash
table is returned by EXT:HASH-TABLE-WEAKNESS. Note that these associations
are no substitute for proper management of resources, as the time of
collection can not be guaranteed.
- In pathnames, ".." is translated to :UP, not :BACK.
- ECL introduces two special forms, EXT:CHECKED-VALUE and EXT:TRULY-THE, which
have the same syntax as THE, but in the first case lead to a type assertion
at low safety levels and in the second case lead to an unchecked
declaration. By default THE maps to EXT:CHECKED-VALUE (as in SBCL), but this
may be controlled globally using the declaration/proclamation
EXT:THE-IS-CHECKED.
- Unicode strings were not properly saved in C compiled code.
|
|
Requested by Matthew Mondor, who contributed description of changes.
Since 10.4.1, changes were made in the following areas:
- Better cross-compile support, including with C++ compilers
- FFI from interpreted code now requires libffi
- Compiler now shipped as a single FASL file, cmp.fas
- Various fixes, notably in handling of:
LIST/LIST*, foreign arrays and structures, optimization annotations,
pathnames (logical pathnames and case), RENAME-FILE, READ,
the debugger, ANSI CL function declarations, DECLAIM, DEFMACRO,
EXPT, ASDF, rational math
- Performance optimizations in the following areas:
SETF expansions, AREF/ASET, unboxing, sequence functions, LOOP,
ASSERT, use of long-long and long-double where possible,
reworked compilation policies, EXT:MAKE-FOREIGN-DATA-FROM-ARRAY
- Other new features:
EXT:WITH-BACKEND
See http://ecls.cvs.sourceforge.net/viewvc/ecls/ecl/src/CHANGELOG?revision=1.793
for more details, or src/CHANGELOG in the source.
|
|
ECL 10.4.1:
===========
* Bugs fixed:
- Fixed offset problems in READ/WRITE-SEQUENCE.
- In multithreaded ECL, the signal servicing thread was not created
due to a stale debug statement.
- The tool 'ecl-config' contained unsubstituted values, such as @LDRPATH@
because these variablesls had been renamed in the autoconf file.
- The reimplementation of DIRECTORY introduced a bug in pathnames with ending
double wildcars, such as "/foo/**/".
- EXT:SAFE-EVAL (or cl_safe_eval in C) would attempt to start the debugger
when an error was signaled.
- The logical hostname EXT: did not have a pathname translation relative to
that of SRC:
- After loading the compiler, the COMMON-LISP package was left unlocked
against changes.
- ECL can build again itself using a C++ compiler (--with-cxx thus works).
- ecl_make_file_stream_from_fd() did not set the right mode in the stream
structure.
- ECL did not understand type declarations that involved symbol macros.
- (SETF STREAM-EXTERNAL-FORMAT) inserted the wrong format type in some cases.
* Visible changes:
- The source location annotator records the original pathnames instead of
truenames. This allows Slime to find out the ECL sources even if they
have been moved.
- The signal servicing thread now carries the name SI:SIGNAL-SERVICING, which
is different from the name of the threads that are created to actually
handle those signals. Users should avoid killing SI:SIGNAL-SERVICING.
- FFI:CLINES admits the notation @lisp-object, just like FFI:C-INLINE. The
result is that @lisp-object gets replaced with a pointer to the given
lisp object, created at run time.
- Gray streams implement a new generic function, GRAY:STREAM-FILE-DESCRIPTOR
which is used by SERVE-EVENT to gather the C file descriptor or Windows
handle used to wait on input from the device.
- ECL restores the habit of installing manual pages for ecl and ecl-config.
- We have removed the obsolete versions of the documentation files. The
up to date documentation now lives in a separate source repository,
as explained in http://ecls.sourceforge.net/download.html
- The encoding :DEFAULT implies looking up in the special variable
EXT:*DEFAULT-EXTERNAL-FORMAT* the actual value of the encoding, which may be
a known one, or :pass-through.
- LOAD now accepts the keyword argument :EXTERNAL-FORMAT
* ASDF:
- ECL's contributed modules and ECL's compiler can now be used in standalone
programs, for they are now stored both in FASL form and as statically linked
libraries.
- ASDF:MAKE-BUILD takes a new keyword argument, :MOVE-HERE, that allows moving
the files that ASDF creates to the current directory. :MOVE-HERE can be the
boolean value T, in which case the files are output at ./asdf-output/ or a
pathname designator with the actual destination.
- ASDF:MAKE-BUILD admits a new type, :BINARY, which creates a standalone
system (*.asd) accompanied by two binary files, statically linked library
(.a or .lib), and a FASL (*.fasb). This can be used, to replace existing
systems with precompiled ones.
|
|
ECL 10.3.1:
===========
This release has three important focuses: performance improvements in various
fronts (garbage collection and hash tables), extending the run-process function
and important fixes to let ECL work better with Slime. To quote one lisper
ECL "this feels like a real Lisp implementation now"
* Bugs fixed:
- DIRECTORY used stat() also on files that did not match the directory masks.
- The syntax for matching strings in DIRECTORY is now the same as in
PATHNAME-MATCH-P. Formerly there were small differences, such as DIRECTORY
understanding characters #\? and #\\ and PATHNAME-MATCH-P not.
- Standalone executables do not require the existence of the ECLDIR directory
to start up -- it may be required, though, for working Unicode because the
encodings are stored there.
- PROCESS-JOIN was exported from the wrong package.
- PROCESS-JOIN failed when invoked with a thread that was in the process of
being set up.
- The output values of a process or thread are now collected in the process
object and returned by PROCESS-JOIN.
- ECL's interrupt servicing thread could not be shut down.
- When compiling LET forms, ECL emitted warnings about removal of variables
even when they were declared IGNORABLE.
- An internal variable MP:*ALLOW-WITH-INTERRUPTS* was not declared special.
- The compiler now understands function type proclamations with &OPTIONAL
values.
- The compiler now accepts THE special forms with a VALUES type.
- If file A.lsp explicitely loads B.lsp to use a package that is only defined
in B, then ECL signaled an error in the compiled version of A even after
this one had required B.lsp.
- ECL accepts FTYPE proclamations for SETF-functions.
- On platforms where a stack overflow does not trigger a SIGSEGV, ECL was
unable to recover from the overflow. Now it jumps to the outermost
protection frame (typically the toplevel).
- Socket streams are now two-way streams. This solves a problem with certain
platforms (OS X) where a C stream can not be used to read and write
simultaneously by two different threads.
- TRUENAME and PROBE-FILE were not thread safe.
* Visible changes:
- Hash tables now use hand-coded specialized loops for EQ, EQL, EQUAL, EQUALP
and package types, achieving a reduction of about 30% time in lookups.
- A new function EXT:ENVIRON returns the list of strings that makes up the
process environment. This is the equivalent of POSIX (char **environ)
and Windows' GetEnvironmentStrings.
- EXT:RUN-PROGRAM now accepts a keyword argument, :ENVIRON, with a list of
strings used to configure the environment of the child process. For instance
'("PWD=/home" "PATH=/usr/bin")
- EXT:RUN-PROGRAM returns as third value an EXT:EXTERNAL-PROCESS structure,
which supports the queries EXT:EXTERNAL-PROCESS-{PID,INPUT,OUTPUT,STATUS},
following CCL's conventions.
- The new function EXT:EXTERNAL-PROCESS-WAIT can be used to wait indefinitely
for termination of a process or simply to query its status.
- ECL implements a new garbage collector marking mode which at the overhead of
one word per object achieves precise marking of heap objects, reducing
accidental data retention and improving the time spent in garbage
collection. This mode is only available when using --enable-boehm=system at
configuration time.
- ECL now ships with ASDF version 1.604
- The variables C:*USER-CC-FLAGS* and C:*USER-LD-FLAGS* are lists of strings
which can used to change the behavior of the C compiler and the
linker. Note, however, that the flags that ECL uses may take priority.
- In the C code we are beginning to use GCC's attributes (__attribute__) and
branch annotation (__builtin_expect). This decreases the size of code that
checks for errors and improves performance.
- When printing compiler notes, instead of printing the macroexpanded form,
ECL now prints the toplevel form, as follows
;;; Warning: in file src:lsp;autoload.lsp.NEWEST, position 1178 and top form
;;; (DEFMACRO WITH-COMPILATION-UNIT (OPTIONS &REST BODY) ...)
;;; The variable OPTIONS is not used.
- ECL now implements EXT:*INVOKE-DEBUGGER-HOOK*, which works like *DEBUGGER-HOOK*
but is also observed by BREAK. (SBCL extension adopted by ECL)
- The UFFI interface now supports C99 types, such as :int8-t, :uint32-t, etc,
but only when the corresponding types do exist in the underlying C environment.
- SOCKET-MAKE-STREAM defaults :BUFFERING to :FULL and allows three new keyword
arguments, :INPUT, :OUTPUT and :EXTERNAL-FORMAT, as in SBCL.
- COMPILE-FILE admits the keyword argument :EXTERNAL-FORMAT.
- A new function EXT:ALL-ENCODINGS lists all encondings known to ECL.
- Improved readability of compiler messages.
- SERVE-EVENT now allows time resolution of less than one second.
- The PROFILE package now has an alias, SB-PROFILE.
- ECL now stores the location of its source files in a logical hostname,
"SRC:", which points to the directory where Announcement is located.
- When building ECL, if "etags" is installed, a file TAGS is created which
contains references to the location of all C functions. This file can be
used to locate functions from the core library in Slime, using M-.
- Documentation files now allow for annotation of arbitrary symbols,
based on a key and a sub-key which are both symbols.
- New function EXT:FUNCTION-LAMBDA-LIST which currently only works with
functions from the core ECL library, generic functions and interpreted
functions.
- The debugger now is capable of showing the special variable bindings
from a function, as well as the restarts newly bound by that function.
- When using git, a new function EXT:LISP-IMPLEMENTATION-VCS-ID returns a
unique identifier denoting the last commit. This can be used to discriminate
between unstable releases and remove stale FASL files.
- COMPILE-FILE admits two new keyword arguments, :SOURCE-TRUENAME and
:SOURCE-OFFSET which can be used to change the value returned by
EXT:COMPILED-FUNCTION-FILE when acting on compiled functions.
|
|
ECL 9.10.2:
===========
* Bugs fixed:
- Fixed typo in src/c/unixint.d that affected single-threaded builds
- The GMP library did not build in OS X Snow Leopard in 64-bits mode.
- The package MP is needed also in single-threaded versions (for fake
mp:with-lock, which is used in CLX).
- In CLX, there were a couple of typos in the code related to locks and ECL.
These typos only revealed in multithreaded builds of the CLX library.
- In Linux there is a problem with handlers for SIGFPE being totally ignored
by the system. The problem seems to be solved by avoiding the use of
feenableexcept() and restricting to C99 exception tests. That is bad because
we can not reliably and cheaply detect underflow exceptions.
- Under OS X, --enable-rpath works again. It was broken for about a year
due to my misunderstanding of how -install_name works and the differences
between that and -rpath.
ECL 9.10.1:
===========
* Configuration flags:
- The option --enable-slow-config is now always on in Solaris and it does not
take more time than an ordinary build using --with-system-gmp=no
- A new compiler macro ECL_NO_LEGACY can be defined to remove all deprecated
macros and functions. Have a look at the end of src/h/external.h to see
what functions are deprecated on each release -- typically they are functions
that have been renamed with one of the prefixes, ecl_, cl_, si_, ext_ or _ecl.
- Under OS X, you can use the environment variable ABI to select between
32-bits (ABI=32) or 64-bits pointers (ABI=64).
* Bignums:
- When embedded, ECL may coexist with code that uses the GMP library in
different ways, and sometimes that code may use different memory allocation
routines. In order to solve this problem ECL introduces a new option,
ECL_OPT_SET_GMP_MEMORY_FUNCTIONS, which determines whether GMP will use the
Boehm-Weiser garbage collector to allocate memory or not.
- The previous change also implies that ECL must do all bignum computations
using GMP-allocated numbers that are then automatically freed. More
precisely, this is done using big_register[0-2]_get() and
big_register_normalize() everywhere and operating destructively on those
numbers. These functions have been made aware of the fact that GMP may
use other allocation routines and always call mpz_clear() to free memory.
- The internal functions dealing with bignums have been renamed with the usual
prefix "_ecl", and some of them have been turned into macros. Do not use
those functions if possible.
- Bignums are now allocated as a compact IMMUTABLE unit that combines the lisp
object and the data for the GMP integer itself. Since it can be now
allocated as an atomic (i.e. pointerless) region of memory, the garbage
collector has to work less for marking and collecting them.
- The function ecl_alloc_simple_vector() also creates arrays as a compact unit
with pointerfree memory whenever possible.
- The functions cl_alloc_simple_{base,extended}_string() now carry the prefix
ecl_ instead of cl_, and they are simple aliases for ecl_alloc_simple_vector.
- ECL now implements weak pointers. The interface is
(ext:make-weak-pointer value) => weak-pointer
(ext:weak-pointer-value weak-pointer) => value
and it defines a new built-in type, EXT:WEAK-POINTER
- When running in multithreaded mode, the streams for *terminal-io*,
*standard-input* and *standard-output* are created using non-locking
C pipes, instead of locking C streams. This is essential to allow background
threads gain control of the console.
* Native threads:
- ECL now implements WITHOUT-INTERRUPTS and WITH-INTERRUPTS similarly to SBCL.
It creates three local macros, ALLOW-WITH-INTERRUPTS and
WITH-LOCAL-INTERRUPTS, and an additional one WITH-RESTORED-INTERRUPTS,
which executes the forms with the value of interrupts of the forms that
surround WITHOUT-INTERRUPTS.
- Symbol SI:*INTERRUPT-DISABLE* changes name to SI:*INTERRUPTS-DISABLED*.
- New function MP:PROCESS-JOIN, waits for a thread to terminate (J.C.Beaudoin)
For this to work, threads are always created in a joinable state, and they
only detach themselves when exiting and no process is waiting.
- EXT:QUIT now has a different definition
(ext:quit &optional (exit-code 0) (kill-all-threads nil))
The first difference is that QUIT will execute all unwind-protect forms
that surrounds the form that caused the exit. The second one is that we
can explicitely kill all threads and wait for them to exit before exiting.
- Two new functions MP:PROCESS-SUSPEND and MP:PROCESS-RESUME allow suspending
and resuming a thread.
- The C function ecl_import_current_thread() now automatically registers the
thread with the garbage collector. You should use ecl_release_current_thread()
before the thread exits, for consistency.
- Due to the change in ecl_import_current_thread(), ECL now needs a slightly
more modern version of the Boehm-Weiser garbage collector. Hence, even if you
try to enforce --enable-boehm=system, you may find that ECL ignores the
pre-installed library in favor of the one shipped with it.
* Bugs fixed:
- WITH-LOCK might run into a race condition when the lock acquisition process
was interrupted.
- The following functions are now interrupt safe: MP:MAKE-LOCK.
- The use of GIVEUP-LOCK in WITH-LOCK is now protected against interrupts.
- Forms in toplevel EVAL-WHEN or PROGN statements did not have a proper value
of bytecodes.definition, causing the debugger to enter an infinite chain
of errors
- In Solaris 8 ECL failed because it did not find inttypes.h
- When signbit() is not available, ECL now looks for existence of copysign.
* Signals and environment:
- The toplevel now allows handling multiple processes in the same console.
Two new commands, :w and :s, allow reading the list of processes waiting for
grabbing the console and switching to that given process.
- ECL now has a signal handling thread running in the background. When
Ctrl-C or Ctrl-Break is pressed or the process gets a SIGINT signal, then
a separate thread is spawned for handling that event. This thread typically
enters the debugger, allowing either to continue or to interrupt specific
processes.
* Packages:
- The package hash tables are not destructively extended, but rather a new
hash table is created when we need more room. ecl_sethash() now returns
the pointer to the possibly reallocated hashtable.
- ECL now follows the SBCL model, by which there is a global lock for
destructive package operations (INTERN, EXPORT, etc), but not for
query only operations (FIND-SYMBOL, PACKAGE-USE-LIST), etc.
* Windows:
- The latest version of Visual Studio introduced a number of automatically
generated files (*.implib, *.manifest, *.expdef) which are not used at
all by ECL, but which were also not deleted, causing the temporary
directory to be filled with garbage.
- FASLs created by COMPILE and LOAD in the directory for temporary files are
now properly deleted before exiting ECL.
- ECL now embeds the manifest file in the generated executables and shared
libraries.
* Other errors:
- Extended strings (i.e. strings with characters that are not base-characters)
were not identified as valid documentation strings by the interpreter.
|
|
* Bugs fixed:
- si_{set,get}_finalizer were not exported from ecl.dll and thus the library
TRIVIAL-GARBAGE failed to build in Windows
- The MSVC port did not define @ECL_LDRPATH@ and failed to build ecl.dll
- The sequence functions did not understand the newest specialized array types.
* Visible changes:
- The configuration flag --with-__thread now defaults to NO because many
platforms do not support it and GCC does not complain, making reliable
detection impossible.
- For further compatibility with SBCL, ECL now supports two additional
buffer types :FULL and :LINE which are compatible with :FULLY-BUFFERED
and :LINE-BUFFERED (Thanks to Matthew Mondor)
- The sockets library can now be loaded using either (REQUIRE 'SOCKETS)
or (REQUIRE 'SB-BSD-SOCKETS).
|
|
Changes since previous packaged version (8.12.0) include half year
of very active development:
- The dynamic FFI is now implemented using libffi.
- Support of UNICODE.
- Multithreading (provided Boehm-GC built with threads support).
- Command line flags to control the different memory limits:
--heap-size, --lisp-stack, --frame-stack and --c-stack.
- The stack size is now measured in bytes, not in lisp words.
- The out of memory error (ext:storage-exhausted) can now be recovered.
By default a correctable error is signaled and the user is given the
chance to increase the heap size.
- Better compiler, optimizer, debugger.
- Improved handling of compiler errors.
- New and more easily extensible implementation of streams.
- *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.
- Improved numerics.
- Read-only readtables.
- Numerous bug fixes.
|
|
|
|
This release is the last one before a major redesign of ECL,
which will affect issues like Unicode streams and handling of
interrupts.
Most notable changes since 0.9l include:
- new versioning scheme, based on <year>.<month>.<patchlevel>;
- compiler error, warning, notes and messages handling;
- float point number exceptions handling;
- signals handling;
- improvements to help file;
- improvements to operating system interface;
- CLX 0.7.3;
- many bug fixes.
|
|
ECL stands for Embeddable Common-Lisp. The ECL project is an effort to
modernize Giuseppe Attardi's ECL environment to produce an implementation of
the Common-Lisp language which complies to the ANSI X3J13 definition of the
language.
|
