mirrors/ecl
1
Fork 0
mirror of https://gitlab.com/embeddable-common-lisp/ecl.git synced 2026-01-09 02:33:14 -08:00
Code Issues Projects Releases Packages Wiki Activity
ecl/src/CHANGELOG
jjgarcia 5440ae6b76 Limit the size of method hash tables.
2003-08-07 12:22:50 +00:00

1616 lines
58 KiB
Text
Raw Blame History

ECL-Spain v0.0
==============
* Removed all "break" from the configure script.
* Added latexinfo.sty to help producing the manual.
* src/configure.in: profile feature disable by default.
* Conversion to ANSI prototypes of all files in the library (c/)
directory. Two headers, external.h and lisp_external.h, to keep the
prototypes of C and LISP functions.
* Fixed lack of "extern" declaration for {short,long}float_zero and
lack of implementation.
* Fixed lack of "extern" declaration of r frame_stack, frs_limit and
frs_top. Actual implementation added in main.c.
* Fixed lack of "extern" declaration for Values in the THREADS case,
in vs.h
* Removed OFLAG as the standard is using CFLAGS
* Added test tree from CLISP
* Removed 'break's from configure.
* Grouped all keyword definitions in a single pool in the new file
all_keywords.c
* Grouped all symbol definitions in a single pool in the new file
all_symbols.c
* Removed all calls to register_root() for symbols from the
library. Instead the garbage collector uses the symbol/keyword
definition pools to mark these objects.
* parse_number() failed when GC was triggered. The reason was that
GC did only reallocate num.size limbs when it should actually move
num.alloc limbs. This has been solved in three steps
+ The GC uses num.alloc (= big_dim)
+ The allocator clears the bignum
+ The bignum data is only relocated when the pointer is valid,
that is, we assume that big_limbs may point to non
collectable memory.
* The allocator empties a region before returning it.
* All big_*() functions now get lisp objects as input, in order to
make the interface more abstract.
* Added #'nth-value
* Now big_alloc(), alloc_contblock() and alloc_relblock() fail when
passed a negative argument.
* Created a pool of three bignum registers. These registers may be
used to save consing, as the destination of mpz_* operations, as
follows
+ Perform a big_register?_get()
+ Perform elementary operations from the GMP library
+ Either discard the object, use big_register_copy() or use
big_register_normalize().
* Removed most preallocations of bignums, favoring the use of bignum
registers.
* In integer_quotient_remainder, if both operands are bignums and the
divisor is larger, a bignum with negative size was allocated. The
use of bignum registers fixes this problem.
* In parse_number() and parse_integer(), use the bignum registers to
store the intermediate result.
* Implementation of a new stream mode, smm_closed.
* Fresh streams from alloc_object() are smm_closed streams.
* In file.d: 1) input_stream_p, output_stream_p, stream_element_type,
readc_stream, unreadc_stream, writec_stream, flush_stream,
clear_input_stream, clear_output_stream, stream_at_end,
listen_stream, file_position, file_position_set, file_length,
file_column fail on closed streams. 2) close_stream and
Lopen_stream_p work on closed streams.
* In read.d, print.d: Lread_bytes and Lwrite_bytes which could have
tried to access a closed stream. Not a good fix, anyway.
* array.tst, hashlong.tst, eval20.tst, iofkts.tst, lists152.tst: added #+ECL.
* In pathname.d: coerce_to_pathname makes sense on closed streams.
* In print.d: print() did not output a trailing space.
* In read.d: #'read-char-no-hang now handles EOF and fails or returns
eof-value when appropiate.
* In format.c: Lformat formerly output a string for non-nil first
argument.
* In symbols.c, all_symbols.c, lisp_externals.h: implemented
*gensym-counter*
* In symbols.tst: placed (setq *gensym-counter*...) right before
creating the symbol --otherwise a spurious gensym is produced by the
interpreter.
* predlib.lsp: errata in subtypep caused failure for '(not ....) and
'(and ...) types.
* predlib.lsp: #'normalized-type now turns (integer a (b)) into
`(integer a ,(1- b)), producing an output which is suitable for
sub-interval-p.
* predlib.lsp: #'typep now rejects type specifiers that it doesn't
know about. For instance, '(symbol cons) is rejected.
* predlib.lsp: #'typep on '(MEMBER ...) now only outputs T or NIL.
* strings.tst: added #+ECL and now included in the test-suite.
* string.d: member_char() hangs when the character bag has some
non-character objects.
* string.d: nstring-{up,down}case now reject NIL as bound designator
when compiled in ANSI compatibility mode.
* characters.tst: added #+ECL and included in the test-suite.
* pack11.tst: the keyword :use from #'in-package needs a list, no
a single symbol. Added to the test.
* package.d: packages must be case sensitive. This implies changes in
find_package()
* package.d: #'package-name should also accept symbols and strings.
* package.d: #'unexport should ignore internal symbols.
* Makefile.in: makes tar file.
* in system.lsp: new syntax for defsystem, takes care of multiple
source directories and separate path for library.
* in {lsp,cmp,clos}/defsys.lsp.in: modified with new syntax.
* in load.d: build_symbol_table is now a C function invoked from the
initialization code and not exported to lisp.
* in cmpmain.lsp: new #'build-ecl function to build customized
executables. It generates the initialization code.
ECL v0.0b
=========
* in lsp/predlib.lsp: extended #'typep to classes.
* in cmp/cmpdefs.lsp: added types for all compiler structures.
* in clos/standard.lsp: redefine-class should be evaluated at compile
time.
* in clos/: fixed everything to allow generation of *.c files.
* in lsp/predlib.lsp: subclassp now exported from LISP package.
* in c/pathname.d:
+ now pathnames are constructed according to ANSI. We support
:ABSOLUTE, :RELATIVE, :UP and :WILD, and we require their use when
constructing pathnames.
+ All pathnames are considered relative except those which begin
with '/' or '~/'. The last case is expanded using the $HOME
environment variable.
+ pathnames are merged according to ANSI CL. If 'pathname' is a
relative directory, it is merged with 'default's directory, no
matter whether this one is relative or not.
+ tilde_expand() hidden as static -- it is far too low level.
+ current_dir() and getcwd() substitutes all uses of getwd().
+ fixed size buffers removed from most routines to avoid accidental
overflows. Use of current_dir() and siLstring_concatenate() prevents
this type of errors.
* in c/unixfsys.c:
+ truename() rewritten to detect only files and signal errors when
it finds directories.
+ Ltruename() now returns the number of output values.
+ Lrename_file() now outputs true names by checking the renamed file
after the operation.
+ string_match() and siLstring_match() provide SH-like patterns.
+ Ldirectory() only lists files and allows all wildcards that
siLstring_match() provides. The implementation dependent keyword,
:LIST-ALL, instructs Ldirectory() to list both files, directories
and special nodes such as devices, pipes, etc.
* in c/read.d:
+ Added Lsharp_P_reader() to read paths using #P.
+ Ldefault_dispatch_macro() outputs clearer error message.
* in lsp/defstruct.lsp,lsp/iolib.lsp: sharp-s-reader and
sharp-s-reader-si now ignore data when *read-suppress*.
* in lsp/module.lsp: #"" replaced with #P"".
* in c/lwp.d,c/big.c: per-thread allocation bignum registers.
* in c/Makefile.in,gmp/Makefile.in: make use of './' to avoid the need
of exporting PATH with a '.' inside.
* in c/print.d: Now paths are printed as #P.
* in Makefile.in: BUILDIR mispelled caused failure of installation.
ECLS v0.0c
==========
* in src/configure.in: make using CLOS the default.
* in gmp/Makefile.in,gmp/mpz/Makefile.in: fixed recursive error in
cleaning.
* in lsp/iolib.lsp,lsp/packlib.lsp: removed use of ". body" favoring
the use of "&rest body" because sys::expand-defmacro doesn't
understand it.
* in c/gbc.c: added gc marking of objects in lexical envs.
* in c/macros.c: define-macro now uses default values for last two
arguments when they are missing.
* in c/clos.c,c/package.d,c/print.d,c/read.d: added register_root() to
some variables.
* in lsp/builtin.lsp: removed make-instance on structure-metaclass,
since it does not exist.
* in lsp/predlib.lsp:
+ implemented sequence as a deftype
+ removed sequence from subtypep
+ built normalize-type to return multiple values
+ recoded subtypep & coerce to use multiple values from normalize-type
+ when using clos, deftype structure as STRUCTURE-OBJECT
* in c/let.c: save values in Fmultiple_value_bind before performing
the actual let_bind. This prevents losing data within a GC.
* Now a raw ecl_min file is built which uses no lisp compiled files,
to provide a tool for bootstraping ECL. This implies some changes
to avoid circular dependencies
+ src/c/Makefile.in creates an init_min.o when bootstraping
+ src/Makefile.in uses init_min.o,c/*.o and crs/*.o to create the
raw ECL which we will use to bootstrap.
+ c/init.c now loads *.lsp files when bootstraping
+ lsp/defmacro.lsp postpones definition of defmacro until
sys::expand-defmacro is defined
+ lsp/defmacro.lsp does not use 'defvar because it is not defined.
+ lsp/iolib.lsp,lsp/module.lsp,lsp/packlib.lsp now use &optional
instead of . in macros, as defmacro does not support '.'
+ clos/method.lsp: when :ecl-min, replace *safe-compile* with t
+ cmp/load.lsp: replace call to object-type with its result.
+ new src/config_min.lsp which performs booting.
* in cmp/cmpinline.lsp: inline-args adds a bogus arg when inlining
instance-ref. This problem only arised when *safe-compile*.
* in lsp/defmacro.lsp:
+ #'sys::destructure handles destructuring lambda lists
+ #'defmacro reimplemented using #'sys::destructure, which now
handles '.' arguments properly.
+ new #'destructuring-bind implemented using #'sys::destructure
* in c/unixfsys.c: sys::chdir now outputs original directory.
* in h/: lisp_external.h and unify.h were missing from CVS.
in c/: all_symbols.c and all_keywords.c were missing from CVS.
in contrib: ilisp removed, there are better versions around.
* new src/compile.lsp.in, lsp/defsys.lsp.in, clos/defsys.lsp.in,
cmp/defsys.lsp.in, plus changes in src/config.lsp.in,
src/configure.in and src/Makefile.in: now the C files are
compiled on-the fly usin the bare feet ecl_min program.
ECLS v0.0d
==========
* in clos/generic.lsp: implemented :method in #'defgeneric
* in lsp/predlib.lsp: extended #'typep to classes and made #'subclassp
public.
* New codeblock object which keeps all information about an object
file and its data. It replaces the old tagless structure and
introduces a new format for init_*() function when initializing an
object file.
* Moved compiler data into object files as C string. This implies
changes in the loader (load.d), in the data stream reader
(read_VV) and in the compiler (cmpwt.lsp,cmpmain.lsp,cmptop.lsp)
which nows generates a different boot code for compiled lisp files.
* in cmp/cmpmain.lsp: new #'make-library joins several object files
into an *.a file, adding a new object file which initializes them
all and exports an init_*() routine.
* cmp/cmpmain.lsp: compiler-pass2 now upcases init_* names to avoid
name clashes with lisp code.
* in src/util/system.lsp: new :LIBRARY target which uses
compiler::make-library to produce *.a libraries up from CLOS, LSP
and CMP subdirectories.
* in src/c/Makefile.in: now a library libecls.a is built up from
all object files except cinit*.o
* in src/Makefile.in, src/compile.lsp: ecl_min is built up only from
the core C library, while ecl is built with this core and all
required libraries liblsp.a, libcmp.a, libclos.a, etc, plus
config.o. To help in this compile.lsp is used to build all required
libraries.
* load.d: siLbuild_symbol_table no longer removes ecl.sym
* in c/main.c,c/cinit.c,c/load.d: removed system_directory C variable.
The lisp variable *system-directory* is used instead and points to
the system files (headers, libraries, initialization code). Default
value for this one is assigned during the configuration phase and
defaults to @libdir@
* in cmp/cmpmain.lsp: <ecl.h> header is no longer copied onto the
compiled code, but #inlined from the system directory.
* in c/package.d, c/assignment.c, c/macros.c, c/toplevel.c,
h/object.h: new function #'sys::package-lock locks a package and
subsequents redefefinitions of functions/macros produce a warning.
* config.lsp moved to lsp/config.lsp and compiled into interpreter.
* in Makefile.in, src/Makefile.in: primitive installation method,
which stores $(bindir)/ecl, $(mandir)/man.1, $(libdir)/ecl.sym,
$(libdir)/help.doc and $(libdir)/h/ecl.h
ECLS v0.0e
==========
* Support for FreeBSD >= 4.0 using ELF.
* Defined ANSI and #+ansi by default, except in number_atan(), which
needs fixing.
* in package.d: lisp package renamed to common-lisp with nicknames
"lisp" and "cl", and user package renamed to common-lisp-user with
nicknames "cl-user" and "user".
* in export.d: common-lisp-user, cl, cl-user, common-lisp added to
export list of common-lisp package.
* in defsys.lsp: ansi.lsp, loop.lsp and defpackage.lsp incorporated.
* in package.d: shadow did not shadow already interned objects.
* in toplevel.c: added :execute, :compile-toplevel and :load-toplevel
to eval-when.
* in list.d: fixed #'last adding optional argument
* in src/util/system.lsp: new syntax which allows separate directory
for library.
* src/config.lsp.in moved to src/lsp/config.lsp.in and incorporated
into liblsp.a
* in cmp/cmpmain.lsp: new #'build-ecl to build customized executables.
{lsp,cmp,clos}/defsys.lsp.in updated accordingly.
* in src/Makefile.in: new build process relying entirely on lisp and
defsystem to build executables.
* in print.d: when *print-escape* is nil, pathnames are written as
addresses -- now the namestring is output.
* in predicate.c: functionp = 't on symbols bound to functions.
* in src/Makefile.in: strip executables.
* in lsp/seq.lsp: #'make-sequence was broken due to new #'normalize-type.
* in lsp/predlib.lsp: #'coerce was broken due to new #'normalize-type.
Plus a quick hack to handle 'LIST properly.
* in cmp/cmpmain.lsp: #'build-ecl now also strips symbols using
"rsym", which gets installed into @libdir@
* Simplified the set of headers. Now there is a ecls.h for base code
and ecls-cmp.h for lisp compiled code, both sharing the rest of
headers (stacks.h, object.h, etc), to simplify maintenance.
ECLS v0.0g
==========
* Binding stack, invocation history stack and frame stack predate now
ordinary memory as a first step for future resizable stacks.
* Built in C strings are better handled now: they can contain \000 and
make use of \n,\t,\\, and of special characters in octal notation.
* Final problems with documentation solved. #'si::help no longer hangs
and the database is now properly generated (in v0.0e only a few
entries got in).
* New online manual in texinfo format gets installed.
* Support for character attributes removed, including #'char-bit,
#'char-font, #'make-character, #'string-char-p and 'string-char
type. Instead, the whole chapter of the ANSI spec is implemented
with types character = base-char > standard-char and extended-char
being an empty type.
* Initialization of functions grouped in a single file all_functions.c.
* Full ANSI compliance for CHARACTER and STRING sections of the spec.
* (type-of nil) now returns 'NULL instead of 'SYMBOL.
* Different hierarchy of tags in object.h saves some space & time.
* Open-coded caar, cadr, etc, are faster & smaller.
* In old garbage collector, flag *IGNORE-MAXIMUM-PAGES* turned into
function #'si:ignore-maximum-pages
* Added support for Boehm-Weiser garbage collector with flag
--enable-boehm.
* Removed support for relocatable blocks of memory from original
garbage collector. Unified allocation interface with alloc(),
alloc_align(), dealloc() and the alloc_atomic() and
alloc_atomic_align() variants.
ECLS v0.0h
==========
* big_bitp() was broken due to the use of wrong limb sizes. Furthermore,
it did not consider the case of negative bignums.
* gmp-3.1 takes the place of the original gmp-1.
* Now it is possible to link ECLS with a local copy of the GMP library,
avoiding to compile and install the copy that comes with it.
* New C functions floor1, floor2, ceiling1, ceiling2, truncate1,
truncate2, round1, round2 which correspond to #'floor, #'ceiling,
#'truncate and #'round with one or two arguments, but which are only
used internally. Lfloor, Lceiling and Ltruncate implemented using
them.
* Rewritten many routines optimizing and removing or completing type
checks. For instance, make_complex(),
number_{plus,minus,times,divide}(), integer_divide(), log_op(), etc.
* At cost of some speed, the interpreter (i.e. not compiled code)
keeps track of all called functions for better error signaling.
* Some failed type checks are now restartable in most cases in which
it is safe. This allows the user to dynamically supply a different
value
> (make-list 'a :initial-element 'b)
Correctable error: A is not of type (INTEGER 0 *).
Signalled by MAKE-LIST.
If continued: Enter new value.
;;; Warning: Clearing input from *debug-io*
Broken at MAKE-LIST.
>> :b
Backtrace: > MAKE-LIST
>> :continue
Enter new value> 10
(B B B B B B B B B B)
>
The jump to the debugger may be suppressed by binding *break-enable*
to nil.
> (setq *break-enable* nil)
NIL
> (make-list 'a :initial-element 'b)
Correctable error: A is not of type (INTEGER 0 *).
Signalled by MAKE-LIST.
Aborting:
>
* Support for logical pathnames. The syntax for logical pathnames is
[hostname:][;][directory-item;][name][.type]
and the syntax for physical pathnames is extended to
[device:][[//hostname]/][directory-item/][name][.type]
where device defaults to "file". Pathname translation and matching
is also implemented, although wildcard expansion is not maximal
and works more like "sh" than like "regexp".
* New set of C types which includes: cl_object for all lisp objects,
cl_fixnum for an integer large enough to hold a fixnum, cl_index for
an unsigned integer large enough to index an array, cl_hashkey for
hashing and cl_type for all type tags.
* New macros LISTP(), ATOM(), CONSP(), SYMBOLP() optimize type checks
within the library code and within automatically generated C
compiled code.
* Errors fixed:
+ Removed non-standard keyword argument :staticp from #'make-array
and #'make-vector.
+ A fixnum is no longer a valid string designator.
+ #'butlast and #'nbutlast now work with dotted lists.
+ Inlined #'tan now produces the right code.
+ A fixnum cannot be coerced to a character.
+ Character bags of type vector would produce erroneous results.
+ #'equalp would fail to compare complex numbers
+ #'char now only accepts strings
+ in pathnames, namestrings, etc, symbols are not implicitely
coerced to strings.
* The Common-Lisp reader has been reworked to allow an unlimited
number of #= and ## references in circular structures. Besides, this
also fixes the accidental deactivation of the #=/## readers in ECLS
v0.0g :(
* Errors detected but not yet fixed throught all bit manipulating
functions: they fail to fake two's complement convention for
negative bignums.
* Big change of names in structure members: ht.ht_size -> hash.size,
etc. Less redundant and more expressive.
* Packages are now stored in a list. The link in the package object
has been removed. We make sure this list is garbage collected by
applying "register_root()" on it. Garbage collection of package
objects is now moved into the mark_object() routine.
ECLS 0.0i
=========
* Replaced hashing function with a crc32.
* Packages now use standard hashes for storing symbols. This seems
to reduce the amount of wasted memory at now speed cost. Besides,
future improvements to hashes will get in packages as well.
* The interpreter is now capable of passing the whole suite of tests.
Just issue "make ecls_min_test" from within build/test directory.
* Errors can be ignored by setting si:*ignore-errors* to true. If this
happens, a (throw si:*ignore-errors-tag* 'ERROR) is thrown. Hence
a useful construct for testing is
(defmacro with-ignored-errors (&rest forms)
`(catch si::*ignore-errors-tag*
(let ((si::*ignore-errors* t)) ,@forms)))
* Improvements to the "dpp" preprocessor that generates code for the
core library:
+ All C code is now run by the preprocessor.
+ Simplified #line staments in the output make files more readable.
+ It now exits with value != 0 when errors occurr, which means
makefiles now stop when the *.d file has errors.
+ It accepts more flexible input as tokens. No need of [`] character,
use parenthesis instead; function names may contain packages
as in "si::unwind"
+ It does not generate #define/#undefine pragma, but uses variables
instead.
* Errors fixed:
+ #'mapcan and #'mapcon failed to handle dotted lists.
+ Inlined short-float/long-float values were truncated to ints.
+ declaim's effects are now visible at compile time.
+ proclaim causes no effect at compile time.
+ declarations cannot arise as the result of a macro expansion.
* CL package unpolluted:
+ 'system, '*break-enable* and others now rest in the 'system package.
+ function #'proclamation removed
* New macro expanders help the compiler to produce the right code for
(do ((s "asbc") c (i 0 (1+ i)))
((= i 3) c)
(declare (type character c))
(setq c (char s i)))
Formerly, C would be initialized with "char_code(Cnil)" which is
probably not what the user wanted.
* IN-PACKAGE is now a macro and DEFPACKAGE now expands to a shorter
expression with the help of an internal function SI:%DEFPACKAGE.
* Evaluation of (LAMBDA (..) ...) expressions now conses less when in
an empty lexical environment.
* The system now uses a different protocol for returning values.
+ If a lisp function returns one single value, the C function
outputs that value directly and sets NValues=1.
+ If N values are output, the function, sets NValues=N; it sets
VALUES(1..N-1) to the N-1 last values and outputs the first one.
* The code walker in PCL now avoids macroexpanding DOTIMES, DOLIST,
WHEN and UNLESS. This gives smaller/faster code in the interpreter.
ECLS 0.1a
=========
* Brand new interpreter based on a byte compiler. This implies major
changes to CLOS, the code walker and to the compiler.
* Export COMPILE-FILE-PATHNAME.
* Gabriel's benchmark incorporated to the source tree.
* Ported to NetBSD.
* Added support for SYMBOL-MACROLET in the interpreter.
* New lisp object for loaded binary files. This helps in garbage
collection of FASL objects and serves as a base for DLL support.
* Fixed documentation and doc/help.lsp.
* Fixed benchmark, which now output results in right order.
* SETF revised. Now it, and all accessors are implemented as macros
with no special support from the interpreter.
ECLS 0.2
========
* Due to human errors, the bytecompiler shipped with 0.1a was not the
finished version. In 0.1b we shipped a more polished files. Some of
the errors which are fixed are
+ Produce the right code for TAGBODY inside closures
+ Activate compiler for SYMBOL-MACROLET
+ Allow non-keyword symbols as lambda-list-keywords
+ Allow more than one :ALLOW-OTHER-KEYS to be supplied, but
discard other than the first one
+ Process declarations in FLET/LABELS forms
* Fixed the C compiler routines for TAGBODY: it would produce wrong
code when jumping out of a closure.
* Rewrite the error system using KMP's condition system, CLOS and a
rudimentary interface to the toplevel.
* Enclosing the bytecompiler in an UNWIND-PROTECT ensures that the
status of the compiler and of the interpreter is always consistent.
* Port and incorporate Peter Van Eynde's test suite for ANSI
compliance.
* Replace features ECL/ECL-MIN with ECLS and ECLS-MIN.
* Add simple-program-error and simple-control-error to the hierarchy
of conditions, and try to ensure that all routines in libecls.a
signal the right type of condition.
* Define COMPLEMENT and CONTINOUSLY.
* Fix #'= between bignums.
* NIL is no longer valid as the first of a pair of bounding index
designators, i.e. (nstring-upcase "aa" :start nil :end nil) causes
an error.
ECLS 0.3
========
* Errors fixed:
- The dynamic linker in eval.d (link_call) truncated addresses
larger than MOST_POSITIVE_FIXNUM.
- The routine that outputs addresses as hexadecimal numbers, and
which is used in print-unreadable, would only output the first
digit.
- Make sure that the proclamations in Gabriel's benchmark are
evaluated at compile time, too.
- Fix the native compiler and the bytecodes compiler so that when
they finds LOCALLY, MACROLET or SYMBOL-MACROLET at the top level,
it processes their bodies as top level forms as well. For
instance, this now works:
(LOCALLY (EVAL-WHEN (:COMPILE-TOPLEVEL) (PRINT "HELLO")))
* Add name mangling to ECLS:
- In the preprocessed files (*.d) @package::symbol can be used to
refer to a lisp function, while @'package::symbol can be used to
refer to a lisp symbol. The preprocessor translates these names
into valid C names.
- Function SI::MANGLE-NAME returns the C name for a lisp symbol
or function, and tells whether that symbol has been defined as
external C function already.
- A new proclamation
(proclaim '(si::c-export-fname union))
advises the lisp->C translator to produce a C function with
mangle named (clLunion in this case), that can be directly called
from other translated files and from user written code.
* Visible changes and ANSI compatibility:
- Remove variable si::*system-directory* and use logical hostname
"SYS:" instead.
- Remove *EVALHOOK*, *APPLYHOOK*, #'EVALHOOK and #'APPLYHOOK, which
make little sense when working in a early compilation environment.
- Stepper removed until we figure out how to implement this using
the bytecodes.
- The library function eval() now accepts an environment as a third
parameter. On top of this function, SI:EVAL-WITH-ENV, evaluates
a form on a given environment.
- New accessor ROW-MAJOR-AREF.
* System design and portability:
- Code has been revised so that it works in environments where stack
grows upwards, as well as in environments where the parameters to
a function cannot be accessed as an array and only va_list/va_arg
work.
- Implement loading of object files using the native "dlopen"
function which is present in most operating systems. Support for
"dld" has been dropped and the whole of the CRS library has been
removed
- Remove use of alloca() when printing circular structures.
ECLS 0.4
=========
* Errors fixed:
- Fixnum product would overflow: (* 65536 32768) => negative number.
- Bit fiddling operations with negative fixnums now work (i.e.
LOGAND, LOGOR, LOGBITP, etc).
- When a PRINT-OBJECT method prints a circular structure which is itself
in another circular structure, the stack that keeps temporary data
may get deleted.
- Format clause "~<" now accepts any number of text segments.
- Format clause "~E" should not add spurious zeros past the decimal
dot. I.e. (format nil "~13,6,2,7E" 3.14159) should output "
3141590.E-06", not "3141590.0E-06". Similar problem happened to
"~F", which added a traling zero even when number of decimal
positions was specified as zero.
* System design and portability:
- Ported to Debian Linux PPC and Cygwin.
- Small changes allow a static build of the executable in platforms
where either dlopen() does not work, or ld does not allow
undefined symbols in libraries.
- Remove unportable code of the type "va_list d = cs".
- Simplify gathering of &rest and &key arguments in compiled code.
- Make the interpreter stack public, with variables and functions
prefixed with "cl_stack*".
- Remove the Invocation History Stack, and implement it as a "linked
list" of frame records on top of the interpreter stack. This
avoids previous size limitations.
- Compile code onto the interpreter stack instead of using a stack
of its own.
- Use the interpreter stack to simplify the implementations of the
printer and of the formater.
* Visible changes and ANSI compatibility:
- MAKE-PATHNAME now accepts all combinations denoted by ANSI. Namely,
(MAKE-PATHNAME :directory :wild), etc.
- :UNSPECIFIC is only allowed in pathname's version and in a logical
pathname's device.
- MSDOS style namestrings, such as "c:/my/path/to/this/file.txt" and
"//c/my/path/to/this/file.txt" finally work. Beware that these
paths are also allowed under Unix, even though they cause errors
when trying to access files. Besides (EQUALP #P"c:/foo/file.txt"
#P"//c/path/file.txt") => NIL
- (DECLARE (OPTIMIZE DEBUG)) is ignored, but no warning is printed.
- Implemented WITH-STANDARD-IO-SYNTAX.
ECLS 0.5
========
* Errors fixed:
- libclos.a should be installed together with libecls.a and liblsp.a
- PROBE-FILE would not translate logical pathnames before checking for
file existence.
- In unsafe mode, inlining AREF lead to bogus code.
- The order of evaluation of arguments in a PSETQ was not respected.
- The compiler would not restore the value of a special variable which
is used in MULTIPLE-VALUE-BIND.
- The compiler produced wrong code for CATCH forms in which the tag
is not constant.
- The compiler produced wrong code for RETURN-FROM forms inside an
UNWIND-PROTECT.
- Deftype BIT-VECTOR would not expand to a vector type.
* System design and portability:
- Remove function_entry_table.
- Each compiled file has an entry point whose name is either
init_CODE() or another name based on the name of the source file.
The algorithm for computing these names has been slightly changed
so that the entry points of ECLS's own library do not conflict with
user defined entry points.
* Visible changes and ANSI compatibility:
- The value of *package* is correctly set and restored while loading
compiled code. This way, 'ecls -eval "(print *package*)"' produces
the expected result #<"COMMON-LISP-USER" package>
- COMPILE-FILE now outputs three values.
- The value of si::*keep-definitions* determines whether the
interpreter keeps the source of defined functions, for later use
with COMPILE and DISASSEMBLE. For instance,
> (set si::*keep-definitions* t)
> (defun foo (x) (1+ x))
> (compile 'foo)
> (foo 2)
3
> (compile 'foo)
;;; Error ....
These definitions are lost once the function is compiled, hence
the second error message.
- Reader macro '#,' has been dropped. LOAD-TIME-VALUE added to both
the interpreter and the compiler.
- New, undocumented implementation of documentation strings which
uses hash tables instead of property lists. The global variable
si::*keep-documentation* determines whether documentation strings
are stored in memory. It is possible to dump documentation strings
to a help file.
- New interface for building standalone programs and libraries, based
on the functions C:BUILD-ECLS, C:BUILD-STATIC-LIBRARY and
C:BUILD-SHARED-LIBRARY, all of which accept similar parameters,
:PROLOGUE-CODE, :EPILOGE-CODE, :LISP-FILES, and :LD-FLAGS. Exhaustive
documentation with examples included in the Developer's Guide.
- Symbolic's update of the MIT LOOP macro imported.
- A LET/LET* form in which the initializers for a variable have not
the expected type produce a warning, but the code is accepted. For
instance (LET (V) (DECLARE (TYPE FIXNUM V)) (SETQ V 1)) now
compiles.
- (SETF name), where name is a symbol, is now a valid function name in all
contexts. It is accepted by DEFUN, FUNCTION, FBOUNDP, FMAKUNBOUND, etc,
and it can be the on the function position in any form.
- New specialized arrays for (UNSIGNED-BYTE 8) and (SIGNED-BYTE 8).
ECL 0.6
=======
* Supported platforms:
- ECL now compiles and runs in static mode under MacOSX.
* Errors fixed:
- Code for handling :IMPORT-FROM in DEFPACKAGE was bogus
- The arguments of GENSYM should not be remembered by ECLS. The
current behaviour was wrong:
> (gensym)
#:G36
> (gensym "F")
#:F37
> (gensym)
#:F38
* System design:
- Function SI:NANI has been removed. Its purpose was to provide an
object which could not be printed or readed so that it could be
used to mark unbound slots in classes. Now the function SI:UNBOUND
performs the same task.
- Mathematical functions which deal with matisas, exponents, etc,
now make use of the ISO-C99 facilities which are almost
everywhere.
- Global function pointer output_ch_fun and read_ch_fun
disappear. Now the differences between ordinary streams and CLOS
streams are handled in file.d. Optimizations for synonym streams
also disappear from read.d and print.d.
- All information used by FORMAT is kept in stack-allocated
structures. Now FORMAT is reentrant and can be safely called from
within PRINT-OBJECT.
- Most symbols belonging to the LISP package and to the C core, are
kept in a single array, "cl_symbols". The translator "dpp" and the
routine SI::MANGLE-NAME, output the right name for any symbol
which is in this array.
- ECL relies fully on the Boehm-Weiser garbage collector
(v. 6.1). The old garbage collector is known to reclaim too much
data, resulting in heap corruption. Help is welcome on this field.
- The headers of the Boehm-Weiser garbage collector are installed
together with ECL.
* Visible changes and ANSI compatibility:
- New configuration flag --with-clos-streams, enables the user to
define CLOS objects which behave as lisp streams. Such object must
have the following methods defined: STREAM-INPUT-P,
STREAM-OUTPUT-P, STREAM-READ-CHAR, STREAM-UNREAD-CHAR,
STREAM-LISTEN, STREAM-CLEAR-INPUT, STREAM-WRITE-CHAR,
STREAM-CLEAR-OUTPUT, STREAM-FORCE-OUTPUT, STREAM-CLOSE.
- LOAD accepts now a stream as input parameter. However, in this
case it only tolerates lisp source files, not compiled files or
libraries. For example, (LOAD (OPEN "foo.lsp")) is equivalent
to (LOAD "foo.lsp").
- ECL now uses a hashtable to store objects when *PRINT-CIRCLE* is
on. This hashtable is not cleared when calling PRINT-OBJECT, so
that circularities are also detected inside these methods.
- *PRINT-CIRCLE* defaults to NIL.
ECL 0.7
=======
* Errors fixed:
- When installing, ECL would not build all required directories.
- Symbol BUILD-PROGRAM should be exported from package C.
- In compiled code UNWIND-PROTECT would procted also the exit form,
resulting in an infinite loop when the exit form fails.
* System design:
- Global variables READsuppress, READdefault_float_format,
READtable, and READbase have been removed. The corresponding
special variables are used instead.
- No need for function read_object_recursive(), since read_object()
is equivalent to it.
- Changed the algorithm of the list reader. A dot which is not
escaped is read as a symbol SI::. which is recognized by
LEFT-PARENTHESIS-READER. This avoids using global variables
"in_list_flag" and "dot_flag".
- The calling conventions have been changed. SI::C-ARGUMENTS-LIMIT
and LAMBDA-PARAMETERS-LIMIT are both 64. Up to C-ARGUMENTS-LIMIT
may be passed to a function using C calling conventions. If the
function is to retrieve more arguments, (for instance through a
&rest variable), this can be done, but then the arguments have to
be pushed on the lisp stack. This method allows us to raise the
CALL-ARGUMENTS-LIMIT up to MOST-POSITIVE-FIXNUM. From a users
point of view, there is no visible change, excep the fact that a
function may receive more arguments.
- The function apply() has been replaced with cl_apply_from_stack().
The former took a pointer to the list of arguments. The latter
assumes that the last "narg" elements on the lisp stack are the
arguments of the function.
* Visible changes:
- New functions SI:SAFE-EVAL and cl_safe_eval() allow the user to
evaluate code with errors without jumping into the
debugger. Useful when embedding ECL in other programs.
- New function SI:OPEN-UNIX-SOCKET-STREAM creates a two-way stream
attached to a unix socked (Unix sockets are pipes which programs
from the same computer may use to communicate with each other, and
they are either anonymous (not supported by ECL) or associated to
a file of the filesystem).
- New function SI:LOOKUP-HOST-ENTRY encompasses the C calls
gethostbyname() and gethostbyaddress() and it is used to guess the
address, aliases and hostname of a machine in the Internet (Currently
we only support AF_INET protocol).
* ANSI compatibility:
- READ and READ-PRESERVING-WHITESPACE behave the same when
RECURSIVE-P is NIL. Furthermore, EOF is detected when EOF-ERROR-P
is true, regardless of the value of RECURSIVE-P.
ECL 0.8
=======
* Errors fixed:
- SI::BC-DISASSEMBLE would not use Lisp streams for output.
- The compiler forgets to define a block when compiling a LAMBDA-BLOCK
form, such as #'(lambda-block f (x) ...) This results in errors when
defining some methods (Pointed out by Hannu Koivisto).
- Fix error in UNWIND-PROTECT forms: the destination frame nlj_fr has to be
saved, because it may be overwritten by a BLOCK or TAGBODY inside
the normal exit form.
- An empty directory now matches against a :wildcard-directory.
- FILENAME-NAMESTRING now works.
* System design:
- Setting a (DECLARE (SI::C-LOCAL)) inside a function, we advise the
compiler to make it local to an object file and do not export it
for general use outside this file, neither as C code nor in Lisp.
- New function cl_defvar() implements DEFVAR.
- Global variable si::*cblock* keeps a pointer to the descriptor of the
library being loaded (on systems which support DLLs).
- In compiled TAGBODY forms, tags are replaced with numbers, so that
compiled code takes less space.
- Implement Invocation History Stack as a chain of stack-allocated
records.
- Added a new virtual host "HOME:".
- Global variable preserving_whitespace removed. By default,
read_object() and other routines preserve whitespaces, and only
READ gets read of the trailing whitespace when required to do so.
- Global variable detect_eos_flag removed. read_object() always
returns OBJNULL when EOF is met. It is up to the calling routine
to handle this.
- Global variable escape_flag removed. A local variable is enough.
- Global variable delimiter_char removed. A new local function
read_object_with_delimiter(), which reads up to a certain
delimiting char is used instead.
- Two separate functions SI::PROCESS-LAMBDA & SI::PROCESS-LAMBDA-LIST to
parse functions and general lambda lists. The code has been improved,
it is now smaller, and it is also used in DESTRUCTURING-BIND and
DEFMACRO (defmacro.lsp).
- DO and DO* have now different macroexpansions, with less gotos;
which leads to smaller C code.
* Visible changes:
- The C counterparts of the Lisp functions have now the prefix
cl_*. For instance, LIST-LENGTH is named cl_list_length(). There
are two types of functions. Those who take a fixed number of
arguments, are just called using C calling conventions:
cl_object form = c_string_to_object("(1 2 3 4)");
cl_object l = cl_list_length(form);
But there are functions which take a variable number of arguments:
in this case, the first argument must be the total number of
arguments. For instance
cl_object form = cl_read(0);
or
cl_object form = cl_read(1, Cnil);
- Renamed functions MF() and MM() to cl_def_c_function(),
cl_def_c_function_va() and cl_def_c_macro_va(). Removed
make_function() and make_si_function(), which had a more limited
purpose. The *_va() functions take as argument a C function with
prototype
cl_object (*function)(int narg, ...)
which means that the function should accept any number of
arguments and signal an error when the number is incorrect. The
functions without *_va() suffix, take as argument a C function
with prototype
cl_object (*function)()
and an integer "narg" denoting the number of arguments that this
function actually receives.
- Within the debugger, users are now able to evaluate expressions using the
lexical environment of the functions being debugged. Sample session:
> (defun foo (x) (cos x))
FOO
> (foo 'a)
A is not of type NUMBER.
Broken at COS.
>> :b
Backtrace: COS > foo > eval
>> :p
Broken at FOO.
>> :v
Block names: FOO.
Local variables:
X: A
>> (return-from foo (cos 2.0))
-0.4161468
- DISASSEMBLE can now either disassemble the bytecodes of an interpreted
function, or translate a lisp expression into C and show the result.
- New program "ecl-config" outputs either the flags compile ("ecl-config -c")
or to link ("ecl-config -l") a program using the ECL library.
- In compiled code, constants which are EQUALP are merged; that is, they
become EQ at run time.
- cl_special_form_p() renamed to cl_special_operator_p().
- If a wrong number of arguments is passed to a function, the name of
the function is mentioned in the error message, whenever possible.
- The tests for the type and size of cl_fixnum have been
grouped. FIXNUM_BITS and CHAR_BIT do not rely now on "char" being
8-bit large.
- All configuration settings are now grouped in config.h. This file
has two parts, and the second one, containing flags which are only
needed during the build process, is deleted when installing ECL.
- File critical.h merged into lwp.h.
* ANSI compatibility:
- DEFINE-SYMBOL-MACRO finally implemented.
- Added a WITH-COMPILATION-UNIT which does nothing.
- Added function ENSURE-DIRECTORIES-EXIST.
- CODE-CHAR would reject negative numbers.
- Remove si::*inhibit-macro-special*. When a special operator is
redefined as a macro, preserve the special nature of the
operator. Complain when user tries to redefine a special operator
as a function.
ECLS 0.9
========
* Errors fixed:
- The PCL relied on the compiler to optimize certain method
combinations. However, the native compiler is not always present,
and therefore it is safer to use interpreted functions instead.
- The compiler had wrong type information about CHAR-NAME &
NAME-CHAR.
- DOTIMES fails with negative bignums and floats.
- LOAD-TIME-VALUE should be a special operator.
- COPY-SYMBOL fails with uninterned symbols.
- GENSYM and GENTEMP failed if the suffix becomes a bignum.
- COMPILE has to generate libraries with different names for each
function. Otherwise, when compiling a second function, the
dlopen() loader will not load the library because it thinks it has
it already in memory.
- When a compound form consists only of a string, this string should
not be interpreted as a documentation string, but as a form.
- SYMBOL-MACROLET definitions were ignored by GET-SETF-EXPANSION.
- DESTRUCTURING-BIND fails to interpret &WHOLE arguments.
- The compiler might get into an infinite loop when dealing with
compiler-macros.
- When the functions/macros in a DLL are no longer used, and the
garbage collector notices this, the library is properly deallocated.
- BIT-* fails when the input is made of arrays with rank <> 1.
- A few leaks from ECL's original garbage collector have been
fixed. Thus, the option "--disable-boehm" at configuration time is
again active.
- When returning from a function, the values are stored in the
VALUES() array. This process has to be "atomic", in the sense that
no lisp function (cl_*, si_*, bytecodes) may be called, because
they also try to overwrite these values. This requirement was not
accomplished by the previous inliner.
- CCASE forms would output no value.
- Tags in TAGBODY should be compared with EQL so that a bignums may
tags (Two bignums which are EQL may be not EQ!).
- Various errors in STRING-TRIM* and *CAPITALIZE.
- Wrong type information about NAME-CHAR, CHAR-NAME and DIGIT-CHAR
lead to compilation errors.
- DEFPACKAGE would ignore the value of :INTERN and, would replace
empty :USE statements with (:USE "CL").
- :CONC-NAME alone is not interpreted as a lack of prefix in
structures. Furthermore, when no prefix is given, the package of
the slot name is not honored.
- MAP-INTO did not recognize strings and bit-vectors as vectors.
- In WITH-PACKAGE-ITERATOR, only symbols which are accessible in the
current package should be output, and the accesibility type returned
should correspond to that of FIND-SYMBOL.
- The expansion of DO/DO* would not enclose the body in a TAGBODY.
- SLOT-EXISTS-P outputted OBJNULL when the slot did not exist.
* Errors of the interpreter:
- CASE should use EQL to compare objects, not EQ.
- Empty PROGN and implicit PROGNs (LAMBDA, etc) should output NIL
instead of (VALUES). Similarly, a CASE with no matching clause
should also output NIL.
- A NIL in the keys position of a CASE clause can never match
anything: (CASE () (NIL 'A) (T 'B)) => B
- SETQ can only output one value
- User could not have a keyword variable with name ALLOW-OTHER-KEYS,
as in (LAMBDA (&KEY ALLOW-OTHER-KEYS) (PRINT ALLOW-OTHER-KEYS)).
- Excesive arguments to NOT or NULL were not detected.
- Under some circumstances, FUNCALL would not signal an error when
a symbol naming a macro is passed as a first argument.
- When &ALLOW-OTHER-KEYS was present in the lambda list, any
occurrence of :ALLOW-OTHER-KEYS is ignored.
* Visible changes:
- No "Bye" message in QUIT.
- Function definitions from the interpreter are now remembered by
default. This means you can now type
(DEFUN MY-FUNCTION (X) (COS X))
and later on
(COMPILE 'MY-FUNCTION)
If you want to save memory, use this to forget these definitions
(SETQ SI::*KEEP-DEFINITIONS* NIL)
- New function SI:MKSTEMP creates an totally new empty file by
appending a 6-characters prefix to a template supplied by the
user.
- COMPILE now creates all temporary files in the directory pointed
to by the environment variable TMPDIR (Or /tmp if none). It also
uses MKSTEMP to produce unique file names, and solve the problem
that dlopen() cannot reload two libraries with the same name.
- The interpreter now detects syntax errors in function calls: such
as in (setq a ("foo")).
- Functions remf(), remprop() and putprop() removed. Use si_rem_f,
cl_remprop and cl_putprop instead.
- A small optimization allows the compiler to produce smaller code
when two functions share the same keywords (Like FIND, POSITION,
etc).
* ANSI compatibility:
- WITH-HASH-TABLE-ITERATOR implemented.
- In DEFGENERIC, only SPACE and SPEED declarations were allowed.
- The bytecodes compiler did not contemplate the possibility of
a lambda list with &key and no keyword variables.
- In MAKE-PATHNAME, values which are supplied (even if NIL), are not
overwritten by the :DEFAULTS. For instance, (MAKE-PATHNAME :TYPE
NIL :DEFAULTS "FOO.LISP") => #P"FOO"
- INVOKE-DEBUGGER now uses the value of *DEBUGGER-HOOK*.
- Implemented LEAST-*-NORMALIZED-*-FLOAT.
- WITH-PACKAGE-ITERATOR implemented. LOOP clauses which iterate over
the symbols of a package now work. Furthermore, LOOP... FOR
PRESENT-SYMBOL... now iterates both over internal and external
symbols, just to be conformant with other implementations.
- COMPILE should output three values: the function itself, plus two
flags indicating the existence of errors.
- CONSTANTP takes two arguments, the second being an environment.
- Implemented FUNCTION-LAMBDA-EXPRESSION (Replaces non-standard
SI::COMPILED-FUNCTION-SOURCE).
- Right evaluation order enforced in PUSH, PUSHNEW, PSETQ.
- In FUNCALL, the interpreter evaluated the function form *after*
the arguments.
- (SETF #:GXXX), where #:GXXX is any uninterned symbol, should be a
valid function name.
- Symbol GC moved from the COMMON-LISP package, to SI and CL-USER.
- DELETE-PACKAGE turns a package into an illegal object. Thus, if a
reference to the package is around, this may cause problems.
- *CASE and *TYPECASE now use condition & restarts for signaling errors.
- Restarts may be associated to conditions. WITH-CONDITION-RESTART
implemented.
- *COMPILE-FILE-{PATHNAME,TRUENAME}* defined and used.
- All package function now signal errors of type
PACKAGE-ERROR. Also, when trying to operate on a locked package
(See SI::PACKAGE-LOCK), a correctable error is signaled.
- Errors in LOOP macro are signaled as PROGRAM-ERROR.
- When a LOOP has a NAMED sentence, no enclosing NIL block is
produced. Furthermore, the blocks always surround the whole of the
code, so that (LOOP FOR A IN (RETURN :GOOD)) works.
- Character names ("Return", "Tab", etc) now have the right case.
- CHAR/= and CHAR-NOT-EQUAL require at least one character.
- Implemented *PRINT-READABLY*, and the condition PRINT-NOT-READABLY.
- Implemented type EXTENDED-CHAR.
- Property lists are no longer used to store vital
information. Things like SETF expansions, DEFTYPEs, etc, are now
stored and retrieved using SI::{GET,PUT,REM}-SYSPROP. The current
implementation is based on a hash table, which means that some
symbols may not be garbage collected.
- New condition types PARSE-ERROR, SIMPLE-READER-ERROR and READER-ERROR. The
errors from the reader correspond to this later type.
- LOOP macro now accepts LOOP-FOR-BY forms, and it better supports
destructuring (Thanks to the CMUCL team for maintaining a reasonably
portable LOOP!).
- SLOT-UNBOUND now effectively signals an UNBOUND-SLOT condition.
- In structure constructors, lambda variables should not have the
name of slot names. This avoids problems with slots that whose
name is also a special variable or a constant.
- MAKE-SEQUENCE, CONCATENATE, etc (All sequence functions), now
recognize more sequence types and also signal errors when the type
denotes a length and the sequence does not match it.
- COERCE recognizes more types, and also signals an error in most
cases in which the output does not match the required type (For
instance, (COERCE 1 '(INTEGER 2 3)).
- Implemented ARRAY-DISPLACEMENT.
- BOA-constructors for structures should now work as expected (Among
other things, they now support &KEY arguments).
- DELETE and REMOVE now accept negative values of :COUNT.
- SHADOW should work with strings/lists of strings, instead of only
with symbols.
- STRUCTURE-OBJECT is now a STRUCTURE-CLASS.
- DELETE-PACKAGE and MAKE-PACKAGE now signal the right type of errors.
- When a handler refuses to process a condition, the remaining
handlers are processed.
- Both the compiler and the interpreter now properly handle function
names of the form (SETF fname). Instead of creating an uninterened
a symbol with the name "SETF fname", the function definition is
stored directly as a property list.
- In destructuring lambda lists, &WHOLE may be accompanied by a
destructuring form.
- In DEF{CLASS,CONDITION}, arguments to the :INITFORM option, or to
the :DEFAULT-INITARGS option, are now properly evaluated in the
lexical environment corresponding to the DEF{CLASS,CONDITION} form.
- Structures may now have :TYPE (VECTOR BIT), (VECTOR CHARACTER),
etc. That sequence type is used, rather than the general one
(VECTOR T). (:TYPE option from slots is not used, though).
ECLS 0.9b
=========
* Supported platforms:
- Solaris 32 bits.
- Linux/Alpha 64 bits.
* Errors fixed:
- DPP now properly handles &allow_other_keys.
- NIL could not be the name of a slot in a struct.
- (/ 0 0) should signal an error.
- FORMAT control ~C now works as expected.
- (SETF DOCUMENTATION) did not work on classes.
- The option :DOCUMENTATION produced an error in DEFINE-CONDITION.
- ENSURE-DIRECTORIES-EXIST was broken.
- EQL specializers were compared to the arguments using EQ instead
of EQL.
- Method hash tables could grow indefinitely. Now they are limited
to 512 elements.
* System design:
- The bytecodes compiler now works with character arrays. Bytecodes
are thus 8 bits large, while their arguments are 16 bits large.
Lisp objects referenced in the code are kept in a separate array
to simplify garbage collection. This strategy limits the size of
bytecode objects to about 32000 bytes and about 32000 constants,
but reduces the use of memory by about 25%.
- Macros are implemented in C as functions with two arguments.
Argument checking is thus left to funcall() and apply(), saving
space.
- AND, OR and WHEN are now just macros, without any special
treatment in the bytecodes compiler.
- To support a large number of arguments, when a function receives
more than 64 values they get stored in the stack of the lisp
interpreter, and general purpose routines are used to handle
them (cl_va_list, cl_va_arg, etc). Now, for functions which can
only receive up to 32 values (i.e. functions without &rest,
&key, and thess than 32 arguments including optionals), ECL
avoids using this overhead by using directly va_list and va_arg.
* Visible changes:
- New special form C-INLINE, allows inserting C/C++ code in any
place where a lisp form is allowed.
- New lisp object type, t_foreign, for user-allocated or "foreign"
data; plus routines to simulate the UFFI foreign functions
interface.
- New function SI::FILE-KIND (based on lstat() and stat()) returns
either :DIRECTORY, :FILE, :LINK, :SPECIAL, or NIL (= Non
existent), for a given file name.
- Bytecode-compiled functions now print as
#<bytecompiled-function... just to remark that, according to ANSI,
these functions are not interpreted (i.e. there are no run-time
dependencies on macros left).
- Formerly, the process of inlining a call to a function would be
done only once the C code is written. For instance, if the
compiler found
(FUNCALL (LAMBDA (X) (COS X)) 1.0)
it would only decide to do the inlining during the second phase of
the compilation process. That meant extremely complicated and easy
to break code in the compiler. The new engine does the inlining of
these forms during the first phase, in which Lisp is translated to
an intermediate representation. For instance, the previous form
is translated to
(LET ((X 1.0)) (COS X))
and here optimizations are much easier.
- The optimizers for the MAPCAR, MAPCAN, etc, were broken. They will
be replaced with compiler macro functions, which are easier to
maintain.
- CLEAR-INPUT now works with interactive streams (*STANDARD-INPUT, etc).
- On systems which support it, LISTEN-STREAM is now implemented
using select(). This means it now works on sockets as well.
- LOAD now accepts a fourth keyword argument, :SEARCH-LIST, which
is a list of directories where LOAD should try to find the file.
The value of SEARCH-LIST defaults to SI::*LOAD-SEARCH-LIST*. If
the file is not found using SEARCH-LIST, then the current
directory is tried.
- Two implementations of FORMAT are supplied: the old one written in
C and a port of the code in CMUCL. The last one is selected with
the flag --with-cmuformat.
- ECL extension AUTOLOAD implemented. An example
(autoload "sys:cmp" 'compile 'compile-file 'disassemble)
* ANSI compatibility:
- DIRECTORY now understands :WILD, :UP, :WILD-INFERIORS, and, as an
extension, other masks within the pathname ("/foo*/**/d*d.l?sp").
It also accepts and ignores all keyword arguments.
- LOAD no longer binds *STANDARD-INPUT* to the file being read. That
was wrong, AFAIK.
- An important problem in DEFSTRUCT has been solved: when :CONC-NAME
is NIL, it may happen that a second definition of a function
overwrites the reader of a slot. For instance
(defstruct (foo (:conc-name nil)) slot-a)
followed by
(defstruct (faa (:include foo) (:conc-name nil)))
would produce an accessor SLOT-A which only works for structures
of type FAA:
(SLOT-A (MAKE-FAA)) => NIL
(SLOT-A (MAKE-FOO)) => Error
- The set of valid keyword arguments for a method depends on the
applicable methods for each specific call. Thus, the associated
LAMBDA forms need not check the consistency of arguments
themselves, and may be declared with &allow-other-keys. With the
new code, this is valid:
(defmethod foo (&key b) ...)
(defmethod foo :after (&key x) ...)
but an invalid call (FOO :C 2) is undetected.
- All streams have from now on element type (UNSIGNED-BYTE 8).
READ-CHAR and WRITE-CHAR work on any stream, though, as do
READ-BYTE and WRITE-BYTE.
- READ/WRITE-SEQUENCE implemented.
- OPEN now accepts the parameter :EXTERNAL-FORMAT, which can only be
:DEFAULT, as ECL does not support the notion of external formats
(all streams have element type (UNSIGNED-BYTE 8)).
- Method combinations are now fully supported.
- DEFGENERIC now accepts the :METHOD-COMBINATION and :METHOD options.
- The initialization and finalization protocol from the AMOP have
been almost fully implemented. Still missing are the class
redefinition and instance obsolence protocols.
- FORMATTER has been implemented, and ERROR/CERROR now accept as
"datum" the functions produced by FORMATTER.
TODO:
=====
* Selectively remove spices from read.d and object.h
* Implement memory collection based on mmap()
* Improve the garbage collector using kernel information about dirty
pages.
* Improve fixnum_times.
* #'unread-char does not fail when the character differs from the
original one.
* vector-push-extend may succeed even if the vector is not
adjustable. Should we be more strict?
* should we relax ASSOC? (See lists156.tst)
* boost setf and generalized places -- the current implementation is
extremely faulty with respect to the standards.
* expand parse_namestring() to accept scaped strings, spaces, etc.
* Remove most property lists from standard symbols.
* Make the version with Boehm's GC and the version without it binary
compatible.
;;; Local Variables: ***
;;; mode:text ***
;;; fill-column:70 ***
;;; End: ***
Reference in a new issue View git blame Copy permalink