Log message:
Update to ECL 13.5.1

ECL 13.5.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.

Log message:
Update to ECL 12.12.1

Changes since last release
==========================

Some highlights of this release are:

* Lots of bugs fixed.

* The MOP has been fixed to work with the upcoming release of
  Closer-MOP

* ECL now produces a much more readable C code, with indentation and
  more explicit declarations of variables.

Known issues
============

* Cygwin's library is still broken: fork/exec fails to reload the
  cygwin library, or ECL's compiled libraries in a completely random
  fashion. For this reason we recommend using ext:system instead of
  ext:run-program in that platform.

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

Log message:
Drop superfluous PKG_DESTDIR_SUPPORT, "user-destdir" is default these days.

Log message:
recursive bump from libffi shlib major bump
(additionaly, reset PKGREVISION of qt4-* sub packages from base qt4 update)

Log message:
lang/ecl: Teach it about DragonFly

Add DragonFly to the configure script.
Patch for configure and aclocal.m4 will be sent to SourceForge.

Log message:
Move debug into separate options.
Requested by Matthew Mondor.

Log message:
Update to ECL 12.7.1

ECL 12.7.1:
===========

* Bugs fixed:

 - The implementation of locks and condition variables based on POSIX threads
   was not safe under interrupts. It has all been reimplemented using atomic
   userspace operations plus a new wait queue.

 - :CDECL was not accepted as an FFI declaration due to a typo.

 - REMOVE-METHOD and FIND-METHOD were not generic functions.

 - MAKE-LOAD-FORM's methods for standard-object, structure-object and
   condition did not signal an error).

* Visible changes:

 - ECL builds with support for threads by default (where available).

 - DIRECTORY no longer complains when it finds an inexistent directory
   component: it simply returns NIL as the list of pathnames.

 - CASE now complains when the OTHERWISE/T clause is not the last one.

 - Instead of issuing an error, LOOP now only produces a STYLE-WARNING
   when iteration forms appear at the wrong place, as in (LOOP WHILE ...)
   followed by some assignment.

 - EXT:MKDIR no longer accepts pathnames as inputs to avoid problems with
   pathnames that contain name or type components.

 - ENSURE-DIRECTORIES-EXIST accepts the keyword argument :MODE which is
   passed to MKDIR.

 - In EXT:RUN-PROGRAM the child process is delayed until the parent has created
   the process structure and stored the process id in it. Formerly we had race
   conditions due to the child exiting before the parent was able to call
   sigwait().

 - Where available, ECL now defines the constants EXT:+SIGRTMIN+ and
   EXT:+SIGRTMAX+, as well as EXT:+SIGRT0+ through EXT:+RTMINn+ where n =
   SIGRTMAX - SIGRTMIN Those signals can be then trapped.

 - The interrupt handler for floating point exceptions does not care about
   the value of EXT:*INTERRUPTS-ENABLED* or similar mechanisms because such
   interrupt has to be treated as an error, not as something optional. The
   same applies to other evil signals, such as SIGSEGV or SIGBUS.

 - New functions (EXT:GET-INTERRUPT-HANDLER code) and
   (EXT:SET-INTERRUPT-HANDLER code function-designator) allow the user to
   customize how these interrupts are caught. SET-INTERRUPT-HANDLER runs an
   implicit EXT:CATCH-SIGNAL.

 - ECL now exports the symbols FFI:C-INT-MAX, FFI:C-INT-MIN, FFI:C-LONG-MAX,
   etc, which correspond to the POSIX C constants INT_MAX, INT_MIN, LONG_MAX,
   and similar ones.

 - APROPOS-LIST no longer returns duplicate symbols.

 - The ABORT restart is now bound on every new thread (except the main one,
   where either the user or the toplevel must take care of that).

* Windows:

 - ECL guesses whether the input / output / error streams are consoles. If
   so, it sets up a special type of stream that copes with the deficiencies
   of read()/write() and similar functions on consoles -- namely that they
   may read or write a larger number of bytes than demanded because they
   translate the input/output to and from the corresponding codepage.
   (EXPERIMENTAL)

 - ECL detects the codepage that the console is using and applies it as
   the appropriate external format (with :CRLF convention).

 - ECL's console stream signals EOF when Ctrl-Z is detected.

* Metaobject protocol:

 - Implemented CLOS:COMPUTE-APPLICABLE-METHODS-USING-CLASSES.

 - COMPUTE-APPLICABLE-METHODS and CLOS:COMPUTE-EFFECTIVE-METHOD are now
   generic functions.

 - Implemented and used in the core: VALIDATE-SUPERCLASSES

 - UPDATE-DEPENDENT, MAP-DEPENDENTS and related functions have been fixed. They
   are now invoked by REMOVE-METHOD and REINITIALIZE-INSTANCE, when acting on
   generic functions, standard classes, etc.

 - (SETF CLASS-NAME) is now implemented using REINITIALIZE-INSTANCE.

 - ENSURE-CLASS-USING-CLASS now registers the class with
   FIND-CLASS. ENSURE-CLASS relies on E-C-U-C doing that.

 - EXTRACT-LAMBDA-LIST and EXTRACT-SPECIALIZER-NAMES implemented.

 - CLOS:GENERIC-FUNCTION-DECLARATIONS and slot CLOS:DECLARATIONS are now
   implemented (even if not used by ECL itself).

 - Implemented the class CLOS:METAOBJECT

 - Implemented SPECIALIZER and EQL-SPECIALIZER, together with
   ADD-DIRECT-METHOD, REMOVE-DIRECT-METHOD, SPECIALIZER-DIRECT-METHODS,
   SPECIALIZER-DIRECT-GENERIC-FUNCTIONS and EQL-SPECIALIZER-OBJECT. ECL now
   uses these objects internally for method dispatch.

 - DEFMETHOD now relies on MAKE-METHOD-LAMBDA to create the appropriate
   function.

 - Implemented COMPUTE-DISCRIMINATING-FUNCTION.

 - ECL's discriminating functions use COMPUTE-APPLICABLE-METHODS-USING-CLASSES
   on those classes in which the user may redefine or extend the
   method. Elsewhere, ECL relies on the internal equivalent of
   COMPUTE-APPLICABLE-METHODS, which _always_ memoizes results.

 - When reinitializing a class instance, ECL would not remove the class from
   its former superclasses.

 - The method combination slot of a generic function is now precomputed by
   using FIND-METHOD-COMBINATION in SHARED-INITIALIZE.

 - METHOD-COMBINATION is now a class with slots and it is used by ECL for
   computing effective methods.

 - The MOP and CL classes and metaclasses do not contain any slot whose name
   is exported by any of the CL or CL-USER packages.

Log message:
Update to ECL 12.2.1

ECL 12.2.1:
===========

* Bugs fixed:

 - Fixed several dozens of typos.

 - ENSURE-DIRECTORIES-EXIST did not work properly with logical pathnames.

 - EXT:SET-LIMIT with option EXT:FRAME-STACK corrupted the frame stack.

 - The array of boot-time symbols is fixed and independent of the features
   that are compiled in. This is essential for cross-compilation and also
   for sharing C code among different builds.

 - Fixed externalization of bytecodes with literals that need MAKE-LOAD-FORM.

 - When parsing a floating point number at least one digit should be
   present. ECL parsed +.e0 as +0.0e0, instead of as a symbol.

 - For OS X Lion we need a newer version of the garbage collector. Since the
   maintainers' advise is that we use the unstable tree, we have made a copy
   and use it _only_ for this port (src/gc-unstable).

* Visible changes:

 - When printing error messages, the condition type is shown (M. Mondor)

 - SI:TOP-LEVEL, when invoked without arguments, does not process the
   command line.

 - The command line used by EXT:PROCESS-COMMAND-ARGS is now by default
   the one stored in *COMMAND-ARGS*, and this may be "cleared" by the
   user.

 - SOCKET-MAKE-STREAM now accepts an :ELEMENT-TYPE argument.

 - When --enable-rpath is used in combination with --with-gmp-prefix, then the
   path of the GMP library is hardcoded into ECL. If the remaining libraries
   (GC, libffi) are in a similar location this will make ECL work without
   further flags, and without modifying LD_LIBRARY_PATH or DYLD_LIBRARY_PATH.

 - All arguments after the '--' command line option are stored in a global
   variable, ext:*unprocessed-ecl-command-args*.

 - In the rules passed to ext:process-command-args, :stop now implies that all
   remaining arguments including the current one are collected and passed to
   the rule code. An example of use of this option
      ;; Collect all arguments _after_ the command line option --
      ("--" 1 (setf ext:*unprocessed-ecl-command-args* (rest 1)) :stop)
      ;; Collect all arguments including the first unknown one
      ("*DEFAULTS*" 1 (setf ext:*unprocessed-ecl-command-args* 1) :stop)

 - ECL will always build, by default, with support for Unicode strings.

 - EXT:GETENV coerces its input argument to type BASE-STRING.

 - The garbage collector would reset the counters on every call to
   SI:GC-STATS. This made nested TIME calls not to work, as the statistics of
   the inner call would spoil those of the outer one. This has been fixed.

 - ECL implements CDR 6 (ext:*inspector-hook*) as described in
   http://cdr.eurolisp.org/document/6/index.html

 - ECL implements CDR 5 (Sub-interval Numerical Types) as described in
   http://cdr.eurolisp.org/document/5/index.html

 - ECL ships libffi together with its source tree, much like GMP and GC.

 - On POSIX platforms ECL traps SIGCHLD and uses it to update the status of
   external processes.

 - DIRECTORY accepts the keyword argument :RESOLVE-SYMLINKS.

 - Compiling files now generates C headers with the extension "eclh". This
   is done to avoid accidentally generating header files with the same name
   as those in the C library. Take for instance, float.lsp -> float.h.

 - ECL no longer relies on "git" being installed to gather the git \ 
commit id
   and setting (ext:lisp-implementation-vcs-id).

 - When building shared and statically linked libraries, ECL creates an
   extra function that performs two tasks: initializing ECL if it wasn't done
   before, and initializing the library. This can be used to create standalone
   libraries to be linked with other programs. The name of the function typically
   begins with main_dll or main_lib but it is output by ECL on screen.

 - Hash tables do no longer have implicit locking. All complex structures in
   ECL (arrays, hash tables, objects) should be dealt with sufficient care on
   the user side, just as in other programming languages, making use of
   WITH-LOCK and similar facilities.

 - In OPEN the default format is :UTF-8 for Unicode builds and :LATIN-1 for
   others, and the stream element type is always CHARACTER by default.

 - Function read_VV is renamed to ecl_init_module()

 - Initialization of random number generator is done using only 16 bytes from
   /dev/urandom (Phillip Marek).

 - Each thread keeps a copy of the process sigmask (POSIX) and it is inherited
   by children thread. The sigmask can be manipulated by the function
   EXT:CATCH-SIGNAL which has the signature
	(ext:catch-signal signal-code action &key process)
   The ACTION is one of :IGNORE, :DEFAULT, :CATCH, determining what ECL does
   when it receives the signal, or it can be :MASK/:UNMASK to determine whether
   the process is blocking the signal or not. The optional argument :PROCESS
   only applies to :MASK/:UNMASK and it can be the current process, some
   process that has not been activated or any other value (indicating that
   the function has a global effect, as sigprocmask).

 - Allocate executable memory using libffi instead of using just the
   Boehm-Weiser garbage collector.

 - In bytecodes.h, deactivate the threaded interpreter when using the LLVM
   compiler. The problem is that llvm-gcc disguises itself as GCC but it is
   not capable of properly compiling the jump table.

 - Implemented SEQUENCE-STREAMs, which are input/output streams defined on some
   specialized array type. The functions to create them are
     (ext:make-sequence-input-stream vector &key :start :end :external-format)
     (ext:make-sequence-output-stream vector &key :external-format)
        * If the array is a string, it is a character stream.
          - When no external format is supplied, it defaults to the usual encoding
            and the stream behaves like a string stream.
          - When an external format is supplied, each character in the string
            is interpreted as a single byte and used for that external format.
        * If the array is specialized over integers and EXTERNAL-FORMAT is NIL
          the stream is a binary stream.
        * Otherwise, it is a binary string but READ/WRITE-CHAR may be used on it.
   Reading and writing does not preserve the original word size of the array
   but rather threads the array as a collection of bytes (octets), writing
   sequentially over it. Thus, if you use encodings such as UCS2 and UCS4, make
   sure that you choose the right endianness to match the shape of the array.

 - DELETE-FILE works on empty directories.

 - In DIRECTORY, :RESOLVE-SYMLINKS defaults to T.

 - Added POSIX function (EXT:CHMOD filename mode)

 - ECL's compiler is now less verbose and hides performance notes, as well as
   invocations of the C compiler. This can be modfied by changing the type
   specifier in c:*suppress-compiler-messages*.

 - Hash tables can now be printed readably when *READ-EVAL* is true. This is
   done using two new functions, EXT:HASH-TABLE-CONTENT and
   EXT:HASH-TABLE-FILL.

 - When a compiler macro fails, ECL simply ignores the errors and
   continues. This is more to the spirit of the compiler macros, as explained
   here http://lists.common-lisp.net/pipermail/pro/2011-December/000675.html

 - INLINE declarations now actually cause the function to be inlined. If
   the function is also proclaimed as INLINE, ECL will store a copy of its
   definition for later use _in other files_. Otherwise INLINE declarations
   remain local to the file being processed.

 - ECL now implements weak hash tables. They are built as ordinary hash tables
   with an extra argument, :WEAKNESS, which may be :KEY, :VALUE,
   :KEY-AND-VALUE, or NIL, for the default behavior. The status of the hash
   table is returned by EXT:HASH-TABLE-WEAKNESS. Note that these associations
   are no substitute for proper management of resources, as the time of
   collection can not be guaranteed.

 - In pathnames, ".." is translated to :UP, not :BACK.

 - ECL introduces two special forms, EXT:CHECKED-VALUE and EXT:TRULY-THE, which
   have the same syntax as THE, but in the first case lead to a type assertion
   at low safety levels and in the second case lead to an unchecked
   declaration. By default THE maps to EXT:CHECKED-VALUE (as in SBCL), but this
   may be controlled globally using the declaration/proclamation
   EXT:THE-IS-CHECKED.

 - Unicode strings were not properly saved in C compiled code.

Log message:
Set BUILDLINK_ABI_DEPENDS correctly (with +=, not ?=)
It turns out there were a lot of these.

Log message:
Fix build on SunOS.