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 avaiable. 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.
    
* Pending changes since 15.3.7
** API changes

   - There is no "uffi" nickname for "ffi" package - we piggyback on
     cffi-uffi-compat (ours uffi wasn't uffi version 2.0 compatible and
     there were problems with dependencies on uffi - it wasn't a system)

   - CLOS has new nickname "MOP"

   - ext:run-program :error argument can be freshly created separate stream
     if provided with :stream keyword, structure process has new field
     holding that stream (suprisingly named "error")

   - methods can be specilized on both single- and double-float (added
     built-in class for them)

** Enchantments:

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

   - Update libffi to version 3.2.1

   - Update asdf to version 3.1.4

   - Update bdwgc to version 7.4.2

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

   - Dead code removals, untiabifying sources

   - 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 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 work
     now conformingly)

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

   - Format float bug, when width and fdigits aren't set, but k is

   - `logical-pathname-translations' throws an error if logical pathname
     wasn't defined yet. Until now it non-conformingly returned nil

   - Other minor tweaks

* 15.3.7 changes since 15.2.21  
** Issues fixed:
   
   - DEFUN functions not defined as toplevel forms were also directly
     referenced 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.
     
** Enchantments
   
   - autoconf scripts are rewritten to support version 2.69 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 EXT: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.
    
* Changes since 12.7.1
  
  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: ***