| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
|
|
From Kozachuk Oleksandr <oleksandr@kozachuk.info> in private mail.
|
|
|
|
|
|
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.12.3:
===========
* Visible changes:
- When converting rationals to floats, ECL now rounds instead of using the
routine in GMP, which truncates.
- LOAD open streams in buffered mode. It does not cause any significant
performance increase except in broken network filesystems that lack
buffering such as some implementations of NFS.
ECL 9.12.2:
===========
* Bugs fixed:
- RANDOM broken on 64-bits architectures.
- The debugger now shows the package names of inspected variables.
- The code in CLX that dealt with interrupts had become outdated.
* Other changes:
- Methods now show up in the debugger with their original name.
- Enlarged the string buffers used for reading and parsing lisp data.
ECL 9.12.1:
===========
* Platform support:
- Support for Itanium.
- Support for Solaris and SunStudio compiler.
- Support for Microsoft Visual Studio C++ 10 beta.
- Support for Cygwin.
* Visible changes:
- New function EXT:ARRAY-RAW-DATA returns a non-adjustable vector of type
(UNSIGNED-BYTE 8) with the content of an array. The returned array overlaps
with the original, so any change on one will affect the other.
- LOAD works on special files (/dev/null and the like).
- New command line option --version outputs the version number preceded
by the implementation name ("ECL 9.11.1" in this particular release).
- MULTIPLE-VALUE-BIND is optimally replaced with a LET form when the number
of variables is 1.
- ECL now accepts Windows' UNC pathnames.
(with-open-file (s #P"//JUANJO-IMAC/Public Folder/index.html"
:direction :input)
(loop for l = (read-line s nil nil)
while l
do (princ l)))
- The default memory limits are increased up to 512Mb for 32 bit images and
4Gb for 64-bits systems.
- The bignums generated by RANDOM did not contain enough random bits.
* Bugs fixed:
- In single-threaded builds, ECL did not properly restore the signal mask
before jumping out of a signal handler.
- Floating point exceptions were sometimes ignored, leading to infinite loops.
- A new configuration flag is added, --with-dffi. This flag allows
deactivating the foreign function interface when the compiler does not
support inline assembly with the GCC syntax and libffi is not available.
- In a multithreaded ECL, when handling a Ctr-C/SIGINT asynchronous interrupt,
the CONTINUE restart was not always available.
- In cygwin, LOAD was unable to load and execute binary files.
- In cygwin, FASL files can not lack a file extension, because dlopen()
then looks for a file ending in ".dll" and fails.
- In cygwin, files that are dlopen'ed must have executable permissions.
- ECL ignored the IGNORABLE declaration.
- The IGNORE/IGNORABLE declarations accept (but ignore) arguments of the
for (FUNCTION function-name).
- SUBTYPEP caused a SIGSEGV when the input was a not finalized class.
- Due to the SUBTYPEP bug, ECL could not compile DEFMETHOD forms whose
arguments referenced non-finalized classes
- When supplied an error value, (EXT:SAFE-EVAL form env &optional err-value)
never returned the output of the evaluated form.
- FIND-SYMBOL accepted string designators instead of just strings, as
mandated by the ANSI specification.
- APPEND copied also the last argument.
- (LOG #C(x x)) now produces a better result when x == 0
- (ATAN #C(0.0 1.0)) no longer produces an infinite recursion.
- Solved a hard to hit bug in DEFCLASS's routine for detecting collisions in
slot names
- LOG and LOG1P did not work properly with NaNs under linux.
- ECL had problems combining #. and #n=/#n# reader macros.
- FDEFINITION and SYMBOL-FUNCTION caused an incorrect error condition when
acting on NIL.
- The optimizer for TYPEP did not work when passed three arguments.
* Clos:
- CLOS:SET-FUNCALLABLE-INSTANCE-FUNCTION broke the value if SI:INSTANCE-SIG,
preventing any further access to the instance slots.
- The optimized slot accessors check that the instances are up to date.
- The use of MAKE-INSTANCES-OBSOLETE now forces UPDATE-INSTANCE-FOR-REDEFINED-CLASS
to be invoked even if the slots did not change.
- ENSURE-GENERIC-FUNCTION-USING-CLASS does not provide a default method class.
* Sockets:
- The socket option TCP_NODELAY option has been fixed: it was improperly using
the socket interface SOL_SOCKET instead of IPPROTO_TCP (Chun Tian)
- sockopt-linger and (setf sockopt-linger) now work as they should, using
the struct linger argument (M. Mondor)
* ASDF:
- ASDF:MAKE-BUILD now accepts also a :PROLOGUE-CODE argument with code to
be executed before all lisp files are run.
- C:BUILDER's argument :PROLOGUE-CODE can now be a lisp form. In the case of
standalone programs the prologue code is always executed after cl_boot() has
been invoked.
- QUIT did not work from standalone executables created with neither ASDF
nor with C:BUILDER.
|
|
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 changes the buildlink3.mk files to use an include guard for the
recursive include. The use of BUILDLINK_DEPTH, BUILDLINK_DEPENDS,
BUILDLINK_PACKAGES and BUILDLINK_ORDER is handled by a single new
variable BUILDLINK_TREE. Each buildlink3.mk file adds a pair of
enter/exit marker, which can be used to reconstruct the tree and
to determine first level includes. Avoiding := for large variables
(BUILDLINK_ORDER) speeds up parse time as += has linear complexity.
The include guard reduces system time by avoiding reading files over and
over again. For complex packages this reduces both %user and %sys time to
half of the former time.
|
|
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.
|
