* 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, OSX, Android and iOS, 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.

  - Before issuing =make check= on the package package developer has to
    install ECL on the preferred destination (specified with "--prefix"
    parameter given to configure script).

* Pending changes since 21.2.1
* 21.2.1 changes since 20.4.24
** Announcement
Dear Community,

We are announcing a new stable ECL release which fixes a number of bugs
from the previous release. Changes made include amongst others

- working generational and precise garbage collector modes
- support for using precompiled headers to improve compilation speed
- the bytecompiler correctly implements the ANSI specification for load
  time forms of literal objects in compiled files
- fixes for encoding issues when reading in the output of the MSVC compiler
- issues preventing ECL from compiling on Xcode 12 and running on ARM64
  versions of Mac OS have been rectified

More detailed information can be obtained from the CHANGELOG file and git
commit logs. We'd like to thank all people who contributed to this release.
Some of them are listed here (without any particular order): Paul Ruetz,
Karsten Poeck, Eric Timmons, Vladimir Sedach, Dima Pasechnik, Matthias
Köppe, Yuri Lensky, Tobias Hansen, Pritam Baral, Marius Gerbershagen and
Daniel Kochmański.

This release is available for download in a form of a source code archive
(we do not ship prebuilt binaries):

- [ECL 21.2.1 tarball archive](https://common-lisp.net/project/ecl/static/files/release/ecl-21.2.1.tgz)
- [The ECL Manual](https://common-lisp.net/project/ecl/static/manual/)

Happy Hacking,
The ECL Developers

** Enhancements
- less cryptic names in backtraces of C-compiled functions
- ECL can now use precompiled headers to speed up compilation. Use ~(setq
  c::*use-precompiled-headers* t)~ to enable this feature
** Issues fixed
- the generational and precise garbage collector modes work again
- ~serve-event~ extension may be used simultaneously from different threads now
- several Unicode issues have been fixed thanks to Vladimir Sedach
- encoding issues when reading in the output of the MSVC compiler have been fixed
- inlining of a local function which closes over a variable no longer leads
  to miscompilations if a variable with the same name exists at the point
  where the function is inlined
- the bytecompiler handles load time forms from literal objects correctly
  with regards to the evaluation order and to multiple occurrences of the same
  literal object in a single file
- the ECL_C_COMPATIBLE_VARIADIC_DISPATCH option needed for running on Apple
  ARM64 devices is automatically enabled when ECL is compiled for such a
  device, allowing ECL to run on ARM64 Mac OS without any special compile
  flags
** API changes
- a condition ~ext:timeout~ is defined
* 20.4.24 changes since 16.1.3
** Announcement
Dear Community,

After more than three years of development, we are proud to announce a new
ECL release having the version tag `20.4.24`. During that time many
important improvements have been made including bug fixes, stability
enhancements and new features. Changes include but are not limited to:

- package local nicknames support
- atomic operations support
- specialized representations of complex float types
- a port to the iOS platform
- fixes for weak hash tables and weak pointers
- fixes for race conditions in the ECL internals
- hash table extensions (synchronization and custom test functions)
- better MOP conformance and improved meta-stability
- improvements to the manual

For more information please read the file CHANGELOG which is located in the
source code, and browse commits. We'd like to thank all people who made
this release possible by contributions of code, documentation, issue
reports, testing and others. Some of them are listed here (without any
particular order): Paul Ruetz, Karsten Poeck, Vadim Penzin, Roger Sen, Stas
Boukarev, Michael Fox, Erik Bray, Bo Yao, Jeremy Cooper, Florian Margaine,
Fabrizio Fabbri, Tomek Kurcz, Kris Katterjohn, Marcin Kolenda, Zhang Yuguo,
Sébastien Villemot, Moritz Petersen, Marius Gerbershagen and Daniel
Kochmański. We'd also like to thank the company Rigetti Computing for
sponsoring the work on specialized complex float representations.

We have another important announcement we'd like to make. Embeddable
Common-Lisp project has now two maintainers: Daniel Kochmański and Marius
Gerbershagen. After numerous contributions from Marius I've proposed him
this responsibility and to my rejoice he has accepted it. That reflects our
community growth.

This release is available for download in a form of a source code archive
(we do not ship prebuilt binaries):

- [ECL 20.4.24 tarball archive](https://common-lisp.net/project/ecl/static/files/release/ecl-20.4.24.tgz)
- [The ECL Manual](https://common-lisp.net/project/ecl/static/manual/)

Happy Hacking,  
The ECL Developers

** Enhancements
- iOS support thanks to the help of P. Ruetz and gitlab user Whimse
- hash-table may now have a custom equivalence predicate
- ~make-load-form-with-slots~ works for structs even if slot names are not interned
- ~ext:weak-pointer-value~ returns two values (value and its presence)
- specialized complex float types based on C99 complex numbers have been
  added, together with corresponding specialized array element types.
- support for atomic operations added with an interface similar to SBCL.
  Currently (SBCL 1.4.12), it differs in the following points:
  - the set of supported places is slightly different
  - ~atomic-incf/decf~ always implement modular arithmetic with respect to
    the width of a fixnum, instead of a width of 64 bits as for some places
    in SBCL.
  - Functions such as ~(cas foo)~ analogous to ~(setf foo)~ are not allowed
    in ECL.
  - The arguments of ~defcas~ are consistent with the short form of
    ~defsetf~ in contrast to SBCL, where they are different.
  - compare-and-swap expansions can be removed with ~remcas~
- experimental support for serializing Lisp objects in compiled files
  directly instead of using the reader for faster loading of .fas files
  (configure option ~--enable-serialization~).
- improvements to C backtrace interface. Compile with CFLAGS+="-rdynamic"
  ./configure ... (Unix) or nmake ECL_USE_DBGHELP=yes ... (MSVC) to take
  full advantage of this feature.
- better handling of fifo files (see man 7 fifo)
- unicode names are always linked for unicode builds (~--with-unicode-names~ removed)
- numerous bytecodes compiler enhancements
- ~ext:run-program~: process streams may be virtual streams (for instance
  ~*standard-output*~ in slime, or a string-output-stream)
- ~ext:run-program~: environ argument defaults to ~:default~, when NIL
  passed empty environment is used
- compiler: when gcc fails ecl prints the failing command output
- ASDF has been updated to 3.1.8.8
- The Boehm-Demers-Weiser garbage collector has been updated to version 7.6.8
- libffi has been updated to version 3.3
- package local nicknames has been implemented (after SBCL)
- hash table extensions are documented in newdoc
- various cleanups performed in the compiler
- compiler is less verbose by default now
- ~ext:run-program~ has been rewritten (almost) from scratch
- improved documentation of operating system interface (newdoc)
- example of parsing arguments in standalone executable (newdoc)
- example of using shared libraries from C world (newdoc)
- reduced =format= directive tables size
- simplified ~atan2~ implementation by using c99 equivalent - now we
  produce correct output for signed zeros, infinities and nans.
- configure script supports new options =--with-libgc-prefix=,
  =--with-libgc-incdir= and =--with-libgc-libdir= (these flags work the
  same as flags for =libffi= and =libgmp=)
** Issues fixed
- issues with type system revealed by sbcl bootstrapping are gone
- classes are not defined at compilation time
- weak hashtables mishandled weak values when keys were present
- gethash on weak hashtables returned the pointer instead of the value
- maphash on weak hashtables mapped over pointers instead of the values
- initarg caches are now invalidated when new methods are defined. Problem
  found and fixed by Alexander Wood.
- ECL allocated too much space in lisp stack. Instead of the specified size
  x in bytes, ECL allocated roughly x^2/p where p is defined in
  LISP_PAGESIZE (2048 by default). If you're setting the value of
  ECL_OPT_LISP_STACK_SIZE, please check whether you really have
  set a high enough value.
- ~block/return-from~ fixed (didn't work across some closure boundaries)
- ~mp:semaphore-signal~ fixed (race when count was > 1)
- Multiple native threads issues fixed
- ASDF systems like foo/base and bar/base doesn't have conflicts in bundles
- interactive input stream in ext:run-program on Windows
- removed race condition between waitpid and sigchld handler on UNIX
- buildsystem parallel builds work (i.e make -j999)
- ECL builds on consoles with unusual encodings on Windows (i.e cp936)
** API changes
- ~LISP~ and ~USER~ package nicknames to ~COMMON-LISP~ and
  ~COMMON-LISP-USER~ are removed
- make-hash-table accepts a new keyword argument ~:hashing-function~
- no-op ~--enable-asmapply~ configure option has been removed
- ~profile~ and ~rt~ contribs are now deprecated and disabled by default
- thread-local variable support has been removed (~--with___thread~)
- deprecated configure option ~--enable-opcode8~ has been removed
- mk-defsystem is not build by default (enable by ~--with-defsystem=yes~)
- asdf:make-build accepts ~:init-name~ argument for libraries
this allows specifying human-memorable initialization function name to call
in C code
- package local nicknames protocol (documented in newdoc)
- make-hash-table accepts ~:synchronize~ flag for thread safe variant. New
  predicate ~ext:hash-table-synchronized-p~ implemented
- make-hash-table ~:weakness~ argument new variant ~:key-or-value~
  implemented
- No more explicit option in ~main.d~ to trap SIGCHLD asynchronously
- Zombie processes are cleaned in ~external-process~ finalizer. If process
  is still referenced in the memory, it's programmer duty to call wait.
- The ECL_OPT_SIGALTSTACK_SIZE option has been removed, because it had no
  effect.
- Non-standard package nicknames (USER for COMMON-LISP-USER and LISP for
  COMMON-LISP) have been removed.
* 16.1.3 changes since 16.1.2
** Announcement
Dear Community,

After almost a year of development we are proud to present a new release of
ECL tagged with version =16.1.3=. All changes are backward compatible
fixing bugs and other issues, implementing new interfaces and cleaning up
the code base.

ECL manual has been updated in a few places. Work on a new documentation is
still pending. It is still incomplete, but you may check see it here:
https://common-lisp.net/project/ecl/static/ecldoc/.

Before this release we have performed extensive tests on various platforms
(Linux, FreeBSD, OpenBSD, NetBSD, OSX, Windows MSVC, Windows MinGW, Windows
Cygwin, Android and Haiku). For details please consult
https://gitlab.com/embeddable-common-lisp/ecl/issues/307. Extra attention
has been paid to Windows testing to improve that platform support.

Best regards,
ECL Development Team

** API changes
- Added better interface for package-locks.

  Introduced functions:
  =ext:package-locked-p package=
  =ext:lock-package package=
  =ext:unlock-package package=
  =ext:without-package-locks=
  =ext:with-unlocked-package=

  To use these functions user has to require the module
  #+BEGIN_SRC lisp
    (require '#:package-locks)
  #+END_SRC

  =defpackage= accepts new option =lock= to allow locking package on
  creation:

  #+BEGIN_SRC lisp
    (defpackage foo (:lock t))
  #+END_SRC

- =mp:holding-lock-p=: introduce new function for multiprocessing. Function
  verifies if lock is hold by the thread which calls the function. Usage:
  =(mp:holding-lock-p my-lock)=.

- =make-random-state=: fix problem with simple-vectors. The correct
  initialization types for =make-random-state= are: =(OR RANDOM-STATE
  FIXNUM (MEMBER T NIL))=.

  Initializing a random state with an appropriate array (element type and
  arity dependent on platform) is also possible.

- =ext:random-state-array=: new extension for random-states. Usage:
  =(ext:random-state-array random-state)=.

- =ext:terminate-process=: new extension for external processes. Usage:
  =(ext:terminate-process process)= with a second, optional boolean
  argument whenever termination should be forced or not.

** Enhancements
- Implemented =CDR-7=.
  https://common-lisp.net/project/cdr/document/7/index.html

- implemented CDRs: =CDR-1=, =CDR-5=, =CDR-14=. Both =CDR-1= and =CDR-5=
  were already implemented, CDR-14 made us to list them in =*features*=
  (https://common-lisp.net/project/cdr/document/14/index.html).

- if ECL is build with =--with-cxx= option, =:CXX-CORE= is present in
  =*features*=.

- deprecated configure option =--with-local-gmp= has been removed - use
  =--enable-gmp= (defaults to auto).

- configure options has been revised.

- ASDF has been upgraded to version 3.1.7.26 (with a few patches scheduled
  for 3.2.0).

- bundled CLX has been purged. Lately I've fixed ECL support on portable
  CLX maintained by sharplispers on https://github.com/sharplispers/clx
  (available via QuickLisp).

- initial port for the Haiku platform. The port is done by Kacper Kasper's
  work, one of Haiku developers. Threads are not supported yet.

- refactored ECL internal tests framework. Tests in =src/tests= are now
  asdf-loadable (with =load-source-op=) and divided into test suites. =make
  check= target runs all regression and feature tests which aren't supposed
  to fail.

- removed 15000 lines of obsolete code. Files not included in the
  buildsystem but lingering in the codebase or options failing to
  build. All info is added in the new documentation in the section "Removed
  interfaces".

- improved man page and help output. Man page now contains up-to-date list
  of flags, as well as explanation of flag's behavior.

- deprecated long flags with one dash, added two-dash version. Flags that
  aren't one-character, but start with one dash (e.g. =-eval=) are now
  deprecated; long version =--eval= was added instead.

- indented C/C++ code to follow emacs's gnu C style.  This is a first step
  towards coding standards in the documentation. Additionally all in the
  src/c/ directory are listed in the appropraite documentation section
  (new-doc).

- refactored =list_current_directory in unixfsys.d=. Function was
  obfuscated with ifdefs with non-even pairs of =#\{= and =#\}=.

** Issues fixed
- ECL signals floating point exceptions in top-level console.

- =mp:rwlock= is treated as built-in class (previously process crashed if
  =class-of= was called on such object).

- ECL builds now succesfully with =--with-ieee-fp=no= option.

- =ext:file-stream-fd=: doesn't cause an internal-error if called with
  something not being a =file-stream= (signals a =SIMPLE-TYPE-ERROR=
  condtition).

- =stable-sort=: bugfix and improvement in speed. Adapted from SBCL by
  Diogo Franco.

- typep: accept =*= type specifier as abbreviation of =T= as described in
  =2.4.3 Type Specifiers= of the specification.

- MOP: fix problemes when redefining non-standard and anonymous
  classes. Bugs identified and fixed by Pascal Costanza.

- =getcwd=: fix issue with too long pathname. This fixes the regression,
  which crashed ECL at start when pathname exceeded 128 characters limit.

- =make-random-state=: fix a problem with simple-vectors. Until now =#$=
  reader macro accepted simple vectors as an argument, what lead to bugs if
  vector didn't match specific requirements like the element type or the
  arity. Now we sanitize this.

- =make-load-form=: provide implementation for random-state objects.

- thread fix on msvc: on windows importing thread was closing the thread
  handler so the thread wakeup wasn't working because the handler is not
  more valid.

- import thread wasn't set upping a proper environment: on some case the
  thread was mistakenly thinking that the thread was already registered.

- =ECL_HANDLER_CASE= and =ECL_RESTART_CASE= didn't work as expected. Bug
  identified and fixed by Vadim Penzin.

* 16.1.2 changes since 16.0.0

** API changes

   - =si:do-defsetf= accepts optional parameter stores.\\
     New lambda-list:\\
     =(access-fn function &optional (stores-no 1))=.\\
     This change is backward compatible.

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

   - Added back removed C interfaces\\
     =ecl_import_current_thread=\\
     =ecl_release_current_thread=

   - When =cl-truename= encounters a broken symlink, it returns its path
     instead of signalling a file-error

   - Deprecated variables has been removed
     =c::*suppress-compiler-warnings*=, =c::*suppress-compiler-notes*=

   - Random state might be initialized by a random seed (truncated to
     32bit value) or by a precomputed array.

     Latter is designed to allow reading back the printed random state
     (when printed readably), not as an array to initialize the random
     state.

   - C99 supporting compiler is mandatory for C backend.

   - =COMPILER::*CC_IS_CXX*=: New variable to switch the output extension of
     emitted compiler code to ".cxx" when configured with "--with-c++". This
     eliminates compiler warnings that compiling C++ with a ".c" extension is
     deprecated; this is seen mostly with Clang++.

   - =GRAY:CLOSE= isn't specialized on =T= to preserve compatibility with some
     libraries.

** Enhancements:

   - Added code walker (present in =*features*= as =:walker=)

   - Testing framework initial cleanup

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

   - Annotations are added at runtime (better integration with SLIME)

   - Mersenne-Twister RNG has new 64 bit implementation for appropriate
     machines

   - Add sockets implementation for the android platform

   - Add android build target (official android support)

   - Added Clang-specific pragmas to disable return type, unused value and
     excessive parentheses warnings, which are fairly harmless, but annoying
     and clutter user output.

** Issues fixed:

   - =si:open-unix-socket-stream= accepts both string and base-string
     (automatic coercion is performed)

   - Long form of =DEFSETF= accepts multiple-values as a store forms:

     #+BEGIN_SRC lisp
       (defsetf gah (x) (y z) `(list ,x ,y ,z))
       (setf (gah 3) (values 3 4))
     #+END_SRC

   - Building with single-threaded boehm works if ECL threads are disabled

   - Using labels works with sharp-S-reader

     #+BEGIN_SRC lisp
       (read-from-string
        "(#1=\"Hello\" #S(sharp-s-reader.1.example-struct :A #1#))")
     #+END_SRC

   - Generated C code works well with IEEE 754 infinities
     (regression tests created)

   - User-defined heap sizes can now exceed the size of a fixnum on 32-bit

   - The heap size limit was intended to be 1GB on 32-bit or 4GB on 64-bit
     but inconsistency between =ECL_FIXNUM_BITS= and =FIXNUM_BITS= in the code
     prevented the heap to grow for 64-bit.  This now occurs, and a few
     other less visible bugs were fixed by restoring consistency to
     =ECL_FIXNUM_BITS=.

   - =EXT:EXTERNAL-PROCESS-WAIT= potential race condition fix

   - Building with object files not created by ECL works (CFFI wrappers)

   - Regression regarding initialization of build by ECL libraries from
     external code fixed. Static and shared libraries initialization
     funcitons has predetermined name while object files has randomized
     names.

   - Random state initial state generation was buggy and insecure (entropy
     from urandom was rejected)

   - Fix =listen= on streams when =FILE_CNT= isn't available (use read instad
     of fread)

   - =FIND= compiled with C compiler didn't respect =START= nor =END=
     arguments. Compiler macro is fixed now and should work as expected

   - =compute-applicable-methods-using-classes= bugfix

* 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: ***
