ecl/CHANGELOG

* Announcement of ECL
  
  ECL stands for Embeddable Common-Lisp. The ECL project aims to
  produce an implementation of the Common-Lisp language which complies
  to the ANSI X3J13 definition of the language.
  
  The term embeddable refers to the fact that ECL includes a lisp to C
  compiler, which produces libraries (static or dynamic) that can be
  called from C programs. Furthermore, ECL can produce standalone
  executables from your lisp code and can itself be linked to your
  programs as a shared library.
  
  ECL supports the operating systems Linux, FreeBSD, NetBSD, OpenBSD,
  Solaris (at least v. 9), Microsoft Windows and OSX, running on top of
  the Intel, Sparc, Alpha, ARM and PowerPC processors.  Porting to other
  architectures should be rather easy.
  
* Known issues

  - In Windows ECL comes with bytecodes compiler by default, because C
    compilers are normally not available. Unfortunately several libraries
    out there are not prepared for this.  If you plan to use quicklisp and
    have a C compiler accessible to ECL, you may use
    (ext:install-c-compiler) to switch back to the Lisp-to-C compiler.

  - In order to test package programmer has to install ECL on desired
    destination (specified with "--prefix" parameter given to configure
    script).
    
* Pending changes since 16.0.0
** API changes

   - New MP functions:
     mp:with-rwlock
     mp:try-get-semaphore (non-blocking)
     mp:mailbox-try-read  (non-blocking)
     mp:mailbox-try-send  (non-blocking)

** Enhancements:

   - Added code walker (present as *feature* :walker)

   - Testing framework cleanup

   - Format fallbacks to prin1 if infinity or NaN are passed to it

** Issues fixed:

   - 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#))")

* 16.0.0 changes since 15.3.7
** API changes

   - There is no UFFI nickname for FFI package - we piggyback on
     cffi-uffi-compat for UFFI dependent systems (our UFFI wasn't version
     2.0 compatible and there were problems with ADSF dependencies on
     UFFI - it wasn't a system)

   - CLOS has the new nickname "MOP"

   - The new ext:run-program :error argument can automatically create a
     separate stream if provided with the :stream keyword.
     The external-process structure also has a new field to hold that
     stream.

   - ext:run-program accepts new arguments - :if-input-does-not-exist,
     :if-error-exists and :external-format

   - ext:system no longer binds *standard-input* and *standard-output* and
     now ignores input and output (use ext:run-program for more control)

   - methods can be specialized on both single-float and double-float
     (built-in classes were added for them)

   - LET/FLET/LABELS will signal error if parameter of the same name will
     appear multiple times

   - lambda lists with repeated required parameter name are considered
     invalid

   - deprecated configure options "--with-system-boehm=x" and
     "--enable-slow-config" removed

** Enhancements:

   - Verification if manual is up-to-date, providing corrections for
     outdated parts

   - Documentation is now included in the main repository under the
     toplevel directory `doc'

   - Update libffi to version 3.2.1

   - Update asdf to version 3.1.5.4

   - Update Boehm-Demers-Weiser garbage collector to version 7.4.2

   - Pathname string-parts internal representation is now character, not
     base-char

   - Dead code removal, tabulators were replaced by spaces

   - Better quality of generated code (explicit casting when necessary)
  
** Issues fixed:

   - Various fixes of bogus declarations

   - Remove deprecated GC calls

   - ROTATEF, SHIFTF, PSETF reworked to conform to the ANSI standard.
     Places were handled improperly in regard of multiple values.

   - Improved unicode support in character handling

   - Format handles floats and exponentials correctly (major format rework)

   - Stack limits refinements and cleanup, inconsistency and bug fixes

   - Duplicate large block deallocation with GMP 6.0.0a fixed

   - ECL builds on OpenBSD with threads enabled

   - Closures put in mapcar work as expected in both compiled and
     interpreted code

   - Improved readtable-case handling (:invert and character literals now
     conform)

   - Library initialization functions have unique names - no risk of
     clashing symbol names in object files

   - Format float bug fixed, when width and fdigits were not set, but k
     was

   - `logical-pathname-translations' now throws an error if logical
     pathname wasn't defined yet, to conform with ANSI (it used to return
     NIL)

   - Wildcards in logical pathname translations are replaced correctly

   - Regression testing framework and unit tests cleanup

   - deftype ANSI conformity fix (deftype accepts macro labda-lists)

   - ECL built with MSVC doesn't crash when Control-C is pressed

   - Other minor tweaks

* 15.3.7 changes since 15.2.21  
** Issues fixed:
   
   - DEFUN functions not defined as toplevel forms were also directly
     referenced by other code in the same file.
     
   - STABLE-SORT works as desired (bogus optimization for strings
     fixed).
     
   - broken --with-sse=yes configure flag works once again.
     
** Enhancements:
   
   - autoconf scripts are rewritten to support version 2.69 stack.
     
   - stack direction is now correctly determined, fixing gcc 5.x builds.
     
   - compilation of ECL under MSVC (2008/2010/2012) even with custom
     code pages.
     
   - In compiled code it is possible to declare variables to have a C
     type such as in (declare (:double a)) and then the variable is
     enforced to be unboxed to such type.
     
   - New form FFI:C-PROGN used to interleave C statements with lisp
     code, where the lisp code may refer to any number of
     variables. Example:
     #+BEGIN_SRC lisp
       (lambda (i)
         (let* ((limit i)
                (iterator 0))
           (declare (:int limit iterator))
           (ffi:c-progn (limit iterator)
                        "for (#1 = 0; #1 < #0; #1++) {"
                        (print iterator)
                        "}")))
     #+END_SRC
     
* 15.2.21 changes since 13.5.1
  
  - Features coverity scan model, ffi-unload-module implementation,
    probably more.
    
  - Build system enhancements, parallel builds, fixes,
    simplifications, cleanups, maintenance.  minor cleanup,
    maintenance.
    
  - Numerous fixes.
    
* 13.5.1 changes since 12.7.1

** Visible changes:

 - ECL now reports #+UNIX for all compatible systems, including *BSD ones.

** Compiler fixes:

 - Minor readability improvements in the C code.

 - MULTIPLE-VALUE-BIND compiles using MULTIPLE-VALUE-SETQ and now both are
   better optimized, generating simpler C code.

 - The type checking routine for LOGAND was producing spurious warnings.

 - (LDB (BYTE ...) ...) no longer conses a BYTE object.

 - Added optimizations for MASK-FIELD, DPB, DEPOSIT-FIELD, LDB-TEST and LDB.

 - CONSTANT-VALUE-P and friends now use the (compiler) environment.

 - No optional type check generated for constant values.

 - Declare the temporary variables in DEFMACRO/DESTRUCTURING-BIND as IGNORABLE

 - ECL now accepts WHILE/IF before FOR/AS, a construct that is not ANSI
   An example: (LOOP FOR I IN LIST WHILE (SOME-TEST I) FOR X = (F I) ... )

** Common Lisp fixes:

 - CONSTANTP now performs a bit more work, macroexpanding forms.

 - ENSURE-DIRECTORIES-EXIST ignores the host and device from the original
   pathname when creating the directories.

 - In FORMAT, printing of floating point numbers could lead to an infinite loop.

 - ROUND, FLOOR, CEILING and TRUNCATE have been reorganized and work faster with
   rational numbers.

 - (CONCATENATE 'SIMPLE-BASE-STRING ...) returned an ordinary string.

 - MAKE-ARRAY did not terminate strings with #\Null (needed internally by the C
   code).

 - (SETF DOCUMENTATION) did not operate on functions because the function object
   documentation had precedence over the annotation.

 - Added the whole Unicode character database to the C library. This means ECL
   can now interpret all Unicode character names properly, and print them as
   well. ECL now also recognizes all ASCII control-character abbreviations

 - Print integers using upcase letters for radix > 10

 - New functions RATIOP, {SINGLE,SHORT,DOUBLE,LONG}-FLOAT-P help avoid consing
   in TYPEP

 - HASH-TABLE-COUNT did not work with weak hashes: it did not update the count
   of live cells (Note, however, that this function is by definition not
   reliable, just a hint, since a garbage collection may happen while the count
   is being computed)

 - ECL no longer uses :READ-ONLY declarations in the SETF expansions because
   there is code out there that modifies the values variables.

 - PROGV can now 'unbind' variables when the list of variables is longer than
   the list of values.

** CLOS:

 - Added built in classes FIXNUM and BIGNUM.

 - Eliminated code for accessing slots that was no longer used. Removed also
   redundant code.

 - Updating a class (due to a change in metaclass) now forces updating its
   children

 - UPDATE-INSTANCE-FOR-REDEFINED-CLASS received an alist instead of a
   propertly-list as last argument

 - PRINT-OBJECT did not have a working default for built in classes.

** Extensions:

 - SYSTEM must use the POSIX shell, which usually lives in /bin/sh.

 - CLX now uses recursive locks.

 - ASDF upgraded to version 2.32, including the ASDF-BUNDLE facility, which
   supersedes ECL's own implementation of precompiled libraries.

 - MAKE-INSTANCE, SHARED-INITIALIZE, REINITIALIZE-INSTANCE now work on
   structures as well.

* 12.7.1 changes
  
  Some highlights of this release are:
  
  - ECL now ships with the whole of the Unicode names database,
    optimally compressed using constant C tables. This means ECL now
    recognizes all valid Unicode (and ASCII) names for the whole range
    of characters, and can print them as well.
    
  - ECL has changed the way it stores compiled data in the C files, so
    that it works around the limit of 65k characters per string.
    
  - ECL now builds with Microsoft Visual Studio C++ 2012.
    
  - We bend the knee and accepted WHILE/IF statements intertwined with
    FOR/AS, though this is still not valid ANSI Common Lisp.

* Settings    
;;; Local Variables: ***
;;; mode:org ***
;;; fill-column:75 ***
;;; End: ***