From: Juanjo
Subject: [ANN] ECL 0.9f released
Date: 
Message-ID: <1116683278.483319.114740@g44g2000cwa.googlegroups.com>
Announcement of ECL v0.9f
=========================

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 allows to produce libraries (static or dynamic) that can be
called from C
programs. Furthermore, ECL can produce standalone executables from your
lisp
code.

ECL supports the operating systems Linux, FreeBSD, NetBSD, Solaris,
Microsoft
Windows and OSX, running on top of the Intel, Sparc, Alpha and PowerPC
processors. Porting to other architectures should be rather easy.

ECL is currently hosted at SourceForge. The home page of the project is
http://ecls.sourceforge.net, and in it you will find source code
releases, a
CVS tree and an up to date documentation.

Notes for this release
======================

The highlights of these release are the two new contributed modules: a
port of
the ASDF system definition, and a port of SBCL's socket libraries,
including
TCP and unix sockets and, only on Windows, named pipes.

ECL 0.9f
========

* Platforms:

 - Cygwin support has been fixed and it now supports DLLs (M.
Goffioul).

* Errors fixed:

 - The reader macros for lists, ##, #C, #P and #' did not behave as
expected
   when *read-suppress* = t.

 - No comments were allowed between the last list element and the
parenthesis
   in a dotted lists. In other words, this:
	(1 . 2 ;; just a comment
	)
   produced an error.

 - All strings in a pathname must be valid C strings, with a null
terminating
   character and no fill pointer.

 - "+nan" is no longer parsed as a number.

 - Where available, ECL now uses _setjmp/_longjmp for control
structures. These
   functions are faster, as they do not save signals.

 - (EXPT 10.0l0 308) failed because the routine EXPT computed too many
powers
   of 10.0l0, some of which (in particular 10^512) were not required
and
   overflowed the machine accuracy.

 - make_stream_from_fd() did not accept smm_io.

 - Fixed the optimizer for slot access, which now only operates if the
   variables have been declared of type STANDARD-OBJECT.

 - Pipes are now opened in character mode (M. Pasternacki)

 - (DOCUMENTATION 'F 'FUNCTION) did not work with generic functions.

 - ADJUST-ARRAY did not work with strings.

 - DEFMACRO admits again lambda lists of the form (a . b).

 - EXPT failed when the exponent was a complex number equal to zero.

 - Setting the property lists of the symbol NIL no longer breaks ECL.

 - Fixed (documentation) and (setf documentation) behaviour. (M.
Pasternacki)

* Compiler errors:

 - In compiled code, discarded (VALUES ...) forms did not trigger all
the
   required unwinding forms, so that (TAGBODY (CATCH 'FOO (VALUES 0)))
produced
   wrong code.

 - In compiled code, the init-form for keyword and optional arguments
could
   reference the variable that it was going to initialize, as in
	(LAMBDA (&OPTIONAL (FOO (1+ FOO))) ...)

 - Globals declared with DEFPARAMETER toplevel forms were not
recognized by
   the compiler as special variables.

 - The code for handling closure variables has been changed and now
encloses
   the whole of the function in a C block.

 - Values of MOST-POSTIVE-LONG-FLOAT, and similar constants, are now
taken from
   the float.h header, instead of referencing the lisp variables
themselves.

 - A typo made the check for proper tail recursion always succeed.

* Foreign function interface (FFI):

 - ext:c-uint-max and ext:c-ulong-max did not have the right bignum
value.

 - C-INLINE forms now can output multiple values. For instance
	> (compile nil '(lambda (x)
			  (ffi::c-inline (x) (:int) (values :int :int)
				 ·@·@(return 0)=#0+2; @(return 1)=#0+3;")))
	[...]
	#<compiled-function 0815b318>
	NIL
	NIL
	> (funcall * 2)
	4
	5

 - C-INLINE forms are now understood by the walker in clos/walk.lsp

 - DEFENTRY, DEFCBODY and DEFLA have been reimplemented. The current
status
   of the FFI is now better described in the documentation, with a
reference
   to the UFFI package for further details.

* Visible changes:

 - Boehm-Weiser garbage collector v 6.4

 - GNU MP library v 4.1.4

 - Multithreaded ECL now in Windows, either with Microsoft VC++
   or Mingw32 (M. Goffioul).

 - Improvements in the efficiency of macro readers for #a() and #()

 - When supplied an :INITIAL-CONTENTS, MAKE-ARRAY now uses a more
efficient
   algorithm.

 - Optimized some routines that iterate over sequences: SOME, EVERY,
   NOTANY, NOTEVERY (M. Goffioul)

 - A new global variable SI::*EXIT-HOOKS* is used to store closures
that
   will be invoked when exiting ECL by cl_shutdown().

 - Slight rewrite of configuration help.

 - Configure option --with-clos-streams now defaults to true.

 - When closing a composite stream, all references to its elements are
now erased.

 - Backquote forms are now translated into lists containing the macros
   EXT:QUASIQUOTE, EXT:UNQUOTE, EXT:UNQUOTE-SPLICE and
EXT:UNQUOTE-NSPLICE.
   At evaluation/compilation time, the macroexpander for QUASIQUOTE
transforms
   the tree into the appropiate lisp expression. Otherwise, the print
   representation is preserved:
	(format nil '`(foo ,@a)) => "`(foo ,@a)"

 - Our implementation of CLOS streams now builds on the Gray streams
proposal
   except for the generic functions CLOSE, STREAM-ELEMENT-TYPE,
INPUT-STREAM-P,
   OUTPUT-STREAM-P and OPEN-STREAM-P. We rather keep these as normal
functions
   that call the user extensible EXT:STREAM-{CLOSE, ELT-TYPE, INPUT-P,
   OUTPUT-P, OPEN-P}. Care has been taken to ensure compatibility with
previous
   versions of ECL.

 - The configuration and build process have been cleaned, making it
closer to
   GNU guidelines and improving things like naming of variables. The
flags
   --with-system-{gmp,boehm} now take an optional argument which can be
"auto",
   for automatic detection of the libraries (M. Pasternacki).

 - By default, the size of binary streams is rounded to a multiple of
8. If you
   want other behavior, pass :USE-HEADER-P T to the function OPEN.

 - ECL now accepts a double dash, '--', as a command line option.
Anything
   after the double dash is interpreted as a lisp command.

 - Bytecode functions can now be printed readably as #Y(...). The
appropiate
   reader macro has been also implemented (M. Pasternacki)

 - *ERROR-OUTPUT* is now properly set to the C error stream.

 - EXT:RUN-PROCESS can now duplicate the *STANDARD-OUTPUT* and
*ERROR-OUTPUT*
   even if they are not the files set at the beginning of the process
	> (let ((*standard-output* (open "foo.txt" :direction :output
					  :if-does-not-exist :create :if-exists :supersede)))
	      (ext:run-program "echo" '("hola!") :output t))
	#<two-way stream 0868a708>
	> (si::system "cat foo.txt")
	hola!
	0

* ANSI Compatibility:

 - DEFSETF forms are enclosed in a block with the name of the accessor.

 - When supplied a compiled function as second argument, COMPILE
returns
   this function. And also when the function is interpreted but we have
   lost its original definition.

 - Now an error is signaled for unmatched parenthesis as in "(1 2 3))".
   The only exception is in the toplevel, where only a warning is
issued.

 - The stream argument for DESCRIBE-OBJECT is now a required one,
instead of
   an optional.

 - When *PRINT-READABLY*=T, vectors just print as arrays.

 - When used as macro characters, upper and lowercase letters share the
same
   dispatcher, so that if the user defines a dispatcher for #f, it is
   automagically set for #F and viceversa.

* MOP Compatibility:

 - We have implemented the *-SLOT-DEFINITION classes, as well as the
protocol
   for computing effective slot definitions from direct ones, and the
methods
   DIRECT/EFFECTIVE-SLOT-DEFINITION-CLASS. (Position field in slot-def.
objects
   still missing).

 - CLASS-PROTOTYPE is now only a reader.

* Contributed modules:

 - MIT test unit rt.lisp is now available as #p"sys:rt"

 - SBCL sockets have been ported to unix (J. Stecklina) and to windows
   (M. Goffioul) and are built when using the configuration option
--with-tcp.
   Both INET and Unix sockets are implemented. Under windows Unix
sockets are
   simulated the cygwin way (i.e. creating a file with the address and
port
   of a INET socket), and we also offer the possibility of creating
named
   pipes.

 - SBCL's implementation of PROVIDE/REQUIRE is now in ECL. By default,
modules
   are searched in the #P"SYS:" path, but you can add your own
searching
   functions to *module-provider-functions*. (J. Stecklina)

 - ASDF is now provided together with ECL. Hopefully, in a near future
we will
   be able to customize it to produce shared libraries out of
definition files.

From: Rainer Joswig
Subject: Re: [ANN] ECL 0.9f released
Date: 
Message-ID: <joswig-7180C6.17275221052005@news-europe.giganews.com>
In article <························@g44g2000cwa.googlegroups.com>,
 "Juanjo" <····@arrakis.es> wrote:

> Announcement of ECL v0.9f
> =========================
> 
> 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 allows to produce libraries (static or dynamic) that can be
> called from C
> programs. Furthermore, ECL can produce standalone executables from your
> lisp
> code.
> 
> ECL supports the operating systems Linux, FreeBSD, NetBSD, Solaris,
> Microsoft
> Windows and OSX, running on top of the Intel, Sparc, Alpha and PowerPC
> processors. Porting to other architectures should be rather easy.

It definitely does not run on my PowerMac G5 running Mac OS X 10.4.1.

On what OSX box should it run?

The error is here:


if [ -f CROSS-COMPILER ]; then \
        touch ecl_min; \
else \
        gcc  -o ecl_min cinit.o c/all_symbols.o -L./ libeclmin.a -leclgmp -leclgc  -lm ;\
fi
sed -e 's,@······@,/usr/local/lib/ecl,g' < compile.pre > compile.lsp
ln -s /Lisp/CL-Implementations/ecl-0.9f/src/cmp/sysfun.lsp ./
if [ -f CROSS-COMPILER ]; then \
        ./CROSS-COMPILER < compile.lsp; \
else \
        ./ecl_min < compile.lsp; \
fi
;*** Lisp core booted ****
ECL (Embeddable Common Lisp)  16384 pages

> #<"SI" package>
> 
Unrecoverable error: 
Lisp initialization error.

make[1]: *** [ecl] Error 134
make: *** [all] Error 2
[RJG5:/Lisp/CL-Implementations/ecl-0.9f] joswig%
From: Juanjo
Subject: Re: ECL 0.9f released
Date: 
Message-ID: <1116764521.551115.240470@g43g2000cwa.googlegroups.com>
Well, I just report what users say. There are users in the mailing list
using MacOSX which have provided patches for making ECL run on this
platform. I cannot test it because I lack an Apple machine myself.

Juanjo
From: John Connors
Subject: Re: [ANN] ECL 0.9f released
Date: 
Message-ID: <d6np4v$dd7$1@newsg2.svr.pol.co.uk>
Stefan Ram wrote:

> "Juanjo" <····@arrakis.es> writes:
> 
>>TCP and unix sockets and, only on Windows, named pipes.
>>ECL 0.9f
>>* Platforms:
> 
> 
>   Thank you! There is a precompiled "ecl-0.9d.exe" for Windows
>   available, but its "(disassemble *)" seems to produce
>   assembler instead of C (C-code generation as being
>   described in "doc/ecldev/Inspecting-generated-C-code.html").
> 
>   Compiling ECL 0.9f myself is not easy for me, because it seems
>   I do not need only Mingw32, but also several tools, like
>   autoconf. I would have to figure out, which tools, have to
>   find them, install them, configure them, and so. Therefore, I
>   would appreciate it, if a precompiled version for Windows
>   would become available one day. It does not have to be a
>   self-installing executeable, a zip-file with the neccessary
>   files also might suffice.
> 

It's not as bad as it looks: the tools come in the Msys package
that come with mingw : http://mingw.sourceforge.net/msys.shtml

I did find that the makeinfo that came with this didn't work so well
with ECLS and downloaded the texinfo package that came with the
gnu-win32 utlilties http://gnuwin32.sourceforge.net/. This was with a
recent CVS, and not 0.9f, so it may be fixed.

Once it's all installed it's pretty much the same as any autoconf'd
package:- configure ; make ; make install. Not hard at all.


-- 
Cyborg Animation Programmer
http://yagc.blogspot.com
http://badbyteblues.blogspot.com
From: Juanjo
Subject: Re: ECL 0.9f released
Date: 
Message-ID: <1116764669.806840.165740@o13g2000cwo.googlegroups.com>
I have a student that uses DevCPP.

You can also install the development enviroment without mingw, then
install the official mingw distribution, inlcuding the msys development
enviroment and instruct DevCPP the location of mingw.

I find this better, because it is easier to update mingw.

Juanjo