mirrors/ecl
1
Fork 0
mirror of https://gitlab.com/embeddable-common-lisp/ecl.git synced 2026-01-01 07:10:34 -08:00
Code Issues Projects Releases Packages Wiki Activity

Remove webpages from standard distribution

Browse source
This commit is contained in:
jgarcia 2007-12-31 18:26:31 +00:00
parent 1f9a5ecfa8
commit 4aa721e34c
10 changed files with 6 additions and 778 deletions
Download patch file Download diff file Expand all files Collapse all files

344
src/CHANGELOG
View file

@ -1,343 +1,11 @@
ECL 0.9j-p1:
============
ECL 0.9k:
=========
* Fixes with respect 0.9j
* Visible changes:
- Added a disambiguation prefix that allows an executable to have the same
name as one of the object files that are used to create it.
- Fixed examples/threads/import.c to ensure that the GC_pthread is used.
- Fixed the code for inspecting the generic function hash table
(Ralph Campbell)
- Added fixes for the Boehm-Weiser garbage collector under Mac OS X
Leopard/PPC (Aleix Conchillo)
* New platforms:
- Support for GNU/kFreeBSD and Mac OS X Leopard.
- ECL has additionally been ported to GNU/Hurd (Pierre Thierry) and
HP NonStop S-Series (Craig McDaniel)
* New features:
- ECL now has POSIX condition variables when built with threads. Moreover,
locks can be now recursive or non-recursive, that is, the kind that signals
an error when tried to grabed twice from the same thread (Dan Corkill).
- SBCL's SERVE-EVENT package has been ported to ECL by Steve Smith.
- New commands, :RESTART, :R1, :R2, etc, allow invoking restarts (contributed
by Chui Tey).
- Interpreted functions can now be disassembled in the debugger. The commands
are :D and :DISASSEMBLE.
- New (private) function EXT::FUNCTION-LAMBDA-LIST, returns the lambda list of
a function whenever it was recorded.
- Implemented finalization on the lisp level. Only available for the Boehm
Weiser GC. Finalizers are closures which can be attached to objects
using SI:SET-FINALIZER and SI:GET-FINALIZER. Only one closure per
object is allowed.
- [Win32] Command-line arguments are now available for programs compiled with
:SYSTEM set to :WINDOWS (M. Goffioul)
- MAPCAR, MAPLIST, MAPC, MAPL, MAPCAN, MAPCON have now compiler macro functions
which create equivalent inlined forms.
- Support for C "long double" as lisp long-double datatype (originated from
a patch by Lars Brinkhoff). Still missing compiler support for unboxed
long double types.
- TIME outputs information about consed bytes and calls to the garbage
collector.
- MAKE-ARRAY accepts a foreign pointer as an argument to :DISPLACED-TO That
creates a lisp array on top of the foreign data and can be used to directly
scan C strings, or unboxed arrays of numbers.
- DFFI works now on AMD64 or Intel EMT64 (DFFI stands for Dynamical Foreign
Function Interface and it is the component that allows ECL call directly
C functions and create C callbacks without the C compiler being around).
(initial code by M. Goffioul)
- Using version 6.8 of the Boehm-Weiser garbage collector.
- Using version 4.2.1 of the GMP library.
- Random number generator based on the Mersenne-Twister algorithm (Based on
code contributed by Roy Zywina).
- GET-INTERNAL-RUN/REAL-TIME now have a better resolution of microseconds
when the platform allows it.
* Bugs fixed:
- The Windows installer works again.
- Local C variables are now always marked as volatile if the function code
uses setjmp/longjmp. Detection of this cases is also more accurate.
- COMPILE-FILE-PATHNAME accepts the same keyword arguments as COMPILE-FILE.
- COMPILER-LET is not standard and belongs in the EXT package. However, it had
not been imported into the compiler and thus it did not work at all.
- Remove ancient, bogus optimizers for: ASH, LDB.
- MINGW's compiler is broken: it does not accept directories with trailing
slashes as an argument to "-I". We include a hack in cmpmain.lsp for that.
- Streamp signals an error for Gray streams.
- ENOUGH-NAMESTRING provided too large directory names (Contributed by Tim S)
- ADJUST-ARRAY accepted a fill-pointer even for arrays that did not have any.
- Instead of using SHORT-FLOAT and LONG-FLOAT as basic floating point types,
we use SINGLE-FLOAT and DOUBLE-FLOAT now. The names of the C functions have
changed accordingly (Contributed by Lars Brinkhoff).
- There was a problem with the variable capture when creating accessors
methods for classes.
- [Win32] Processes are now correctly listed with MP:ALL-PROCESSES (M. Goffioul)
- DIRECTORY behaves more according to people's expectations
(DIRECTORY "*/") => List all directories in current path
(DIRECTORY "*.*") => List all files in current path
This means you need to make two calls to DIRECTORY to get all the content of
it, but it allows you to select whether you want to list files or
not. Furthermore, the paths returned by DIRECTORY are more or less
guaranteed to match the mask -- the exception are links, for whose the
truename is returned.
- [Win32] DIRECTORY did not take the drive letter into account.
- [Win32] si_trap_fpe is now exported by ecl.dll
- Instead of sharing a single string buffer (cl_env.token), ECL now has a pool
of small strings which can be used for temporary operations. This fixes a
number of problems with the reader.
- DIRECTORY would always match NIL entries, independent of the mask. Now, the
following two statements differ:
(directory "foo*") => ("foo")
(directory "foo*.*") => ("foo" "foo.log")
- The code in contrib/sockets.lisp was not compatible with C++ because of
multiple implicit pointer conversions, and additionally it had some pointer
miscalculations.
- GET-INTERNAL-REAL-TIME now works on Windows with 1/60s precision
(contributed by Dustin Long)
- When :INITFORM was a constant variable but not self evaluating (i.e. not T,
NIL, or a keyword), it was not processed properly
(defclass a () ((a :initform most-positive-fixnum)))
(slot-value (make-instance a) 'a) => most-positive-fixnum
- The namestring "." was improperly parsed as having file type "".
- Now the file type is determined by the last dot in the name.
(pathname-type "foo.mpq.txt") => "txt"
- When iterating over a hash table we now check that the argument is really a
hash table.
- *COMPILE-VERBOSE* and *COMPILE-PRINT* now also have effect when compiling
isolated lambda forms using COMPILE. Additionally, these variables are
defined even without the compiler loaded.
- DESCRIBE was not prepare for the number range types returned by TYPE-OF.
- In OS X, ECL can now load shared libraries (Extension *.dylib) thanks
to using dlopen() instead of the obsolete NSLinkModule() function.
- (CONCATENATE 'STRING ...) does no longer have an ad-hoc limit in the number
of strings.
- Reader for #( did not always read the last parenthesis, what lead to a warning:
> #3(1 2 3)
#(1 2 3)
> ;;; Warning: Ignoring an unmatched right parenthesis.
- RANDOM no longer overflows when the input is a bignum that does not fit in a
double-float.
- MAKE-PATHNAME should remove all occurrences of single dots "." in physical
pathnames and does not interpret the directory component :BACK properly.
- ENOUGH-NAMESTRING did not simplify a pathname when it had the same directory
as the default pathname.
- Some toplevel forms with closures caused the compiler to abort, for example
(let ((data '(a b)))
(flet ((get-it ()
(second data)))
(defun print-it-1 ()
(print (get-it)))))
- COPY-READTABLE did not copy entries when supplied a second argument.
- When expanding tilde pathnames, as in "~/bin/foo", the device is also
taken into account. So if HOME=c:/jjgarcia, the previous path becomes
"c:/jjgarcia/bin/foo"
- If the homedir component contains a tilde itself, ECL entered an infinite
loop when expanding the pathname
- Now it should be possible to load the same FASL files multiple times,
even if previous instances have not completely garbage collected.
- SI:MKSTEMP now works on Windows for more than 26 temporary file names
(Dustin Long)
- There was no builtin type for loaded libraries.
- EXT:RUN-PROGRAM has now a keyword argument :WAIT, which defaults to T and
which determines whether the function should wait for the process to finish
before returning.
* Unicode:
- MAKE-STRING only allowed :ELEMENT-TYPE to be one of CHARACTER, BASE-CHAR, or
STANDARD-CHAR.
- The FFI will signal a type error when converting extended characters to
the C types "char" or "unsigned char".
- Unicode support for ALPHA-CHAR-P, ALPHANUMERICP, CHAR-UPCASE, CHAR-DOWNCASE,
etc, based on the ISO C99 library functions for wide characters.
- Following functions fixed to work with Unicode strings: EQUAL, EQUALP,
PARSE-INTEGER, STRING-TRIM, STRING-LEFT-TRIM, STRING-RIGHT-TRIM,
COPY-STRUCTURE, SHADOW.
- Most functions dealing with sequences (REMOVE, DELETE, etc) would
output a STRING even if the input was a BASE-STRING.
- TYPE-OF did not recognized EXTENDED-CHARs.
- Type BASE-STRING and STRING were defined as equivalent.
- Pathnames now allow extended strings in the names. Errors are signalled,
however, when a file name contains illegal characters. UTF-8 encoding
of file names is not supported.
* Other visible changes:
- New conditional feature, PREFIXED-API, signals that the internal C functions
now have a common prefix, "ecl_".
- The interpreter now makes an attempt at showing the offending form
when a syntax error happens.
> (progn (setq a 1) (setq b) (setq c 2))
In form
(SETQ B)
Syntax error: list with too few elements or improperly terminated.
Broken at SI:EVAL-WITH-ENV.No restarts available.
Broken at SI::BREAK-WHERE.
- The documentation shipped with ECL was outdated. To enforce moving on
to the new manual, the build and installation process now ignores anything
inside src/doc.
- LOAD no longer defaults to loading a file as binary if the file type is
different from FAS or FASL. Use either SI:LOAD-BINARY or configure the
variable SI:*LOAD-HOOKS* accordingly to load FASL files with unusual
extensions.
- EXT:PROCESS-COMMAND-ARGS now allows for a default rule.
- Variable EXT:*HELP-MESSAGE* and EXT:+DEFAULT-COMMAND-ARG-RULES+ exported.
- C:BUILD-PROGRAM now uses a unique prefix for the initialization function,
init_ECL_PROGRAM, to avoid collisions when both the program and a component
have the same name:
(C:BUILD-PROGRAM "ls" :lisp-files '("ls.o"))
- FFI:CLINES is no longer restricted to appear as a toplevel form. The
following code is thus valid:
(defun c-sin (x)
(ffi:clines "#include <math.h>")
(ffi:c-inline (x) (:double) :double "sin(#0)" :one-liner t))
- Minimized the number of headers included by ecl/ecl.h. In particular,
stdio.h, inittypes.h and pthread.h are no longer used.
- When a compiler finds a literal standard object, the load and initialization
forms it generates are now closer to the first reference to the object. This
allows to have, in the same file, a class definition and a constant which
is an object of that class.
- Support for hierarchical package names, as in Allegro Common-Lisp.
- The debugger now prints a list of available restarts.
- Added restarts to the errors signaled by several functions: SIN, COS, EXP,
EXPT, TAN, TANH, SINH, COSH, LOG, ATAN, RATIONAL, NUMERATOR, DENOMINATOR,
FLOOR, CEILING, ROUND, TRUNCATE, FLOAT-PRECISION, FLOAT-SIGN, DECODE-FLOAT,
SCALE-FLOAT, FLOAT-RADIX, FLOAT-DIGITS, INTEGER-DECODE-FLOAT, REALPART,
IMAGPART, COMPLEX, etc
- DIGIT-CHAR-P and DIGIT-CHAR will signal an error if the radix is not an
integer value between 2 and 36, both included.
- The slot accessors for structures with type VECTOR or LIST now rely on
the standard function ELT, instead of si:list-nth and si:rplaca-nthcdr.
- TYPE-OF returns expanded types for arrays. For instance,
(ARRAY CHARACTER (12)) instead of (STRING 12).
- C functions which disappear: si_set_compiled_function_name(),
si_extended_string_concatenate(), assert_type_string(),
assert_type_character(), assert_type_symbol(), make_symbol(),
parse_number(), parse_integer(), adjust_displaced().
- Lisp functions which disappear: si:set-compiled-function-name,
si:extended-string-concatenate, si:list-nth, si:rplaca-nthcdr.
- New C functions: ecl_stream_to_handle(), ecl_base_char_code(),
ecl_type_error(), ecl_check_cl_type(), ecl_check_type_string(),
ecl_fixnum_in_range(), ecl_stringp(), ecl_parse_number(),
ecl_parse_integer(), ecl_char(), ecl_char_set(), ecl_base_char_p().
- New Lisp functions: si:wrong-type-argument.
- Functions renamed: backup_fopen() -> ecl_backup_fopen() char_code() ->
ecl_char_code(), cl_log1() -> ecl_log1(), cl_log2() -> ecl_log2(),
NUMBER_TYPE() -> ECL_NUMBER_TYPE_P().
- Additionally, most functions have got now the prefix "ecl_"
- LOAD-FOREIGN-LIBRARY accepts an additional keyword argument :SYSTEM-LIBRARY
which, when true, tells ECL to link object files against the system version
of that library instead of directly referencing the shared library: i.e. use
linker flag -lmylib instead of libmylib.so (Brian Spilsbury)
- When compiling lisp files, ECL now creates different entry functions
depending on the file type. FASL, library and object files get a function
with the prefix {init_fas, init_lib, init_} prepended to the file name.
This solves the problem of a shared library having the same name as one
of the components it is made of.
- C:BUILDER searches the ASDF module list for libraries. (Thanks to F.R. Rideau)
- In Windows, CLX is no longer built by default: use "nmake ECL_CLX=1".
- ECL now uses standard Unix paths for installation: assuming prefix=/usr, the
shared library libecl.so is typically installed in /usr/lib/, the C header
files under /usr/include/ecl and all remaining data and FASL files under
/usr/lib/ecl.
* Contributed code:
- New examples: cmdline/ls.lsp, ffi/uffi.lsp, ffi/cffi.lsp
- The documentation is slowly disappearing form this source tree, as there
is a different tree (ecl-doc) which contains the XML sources for a more
complete manual.
;;; Local Variables: ***
;;; mode:text ***

27
src/doc/benchmark.in.html
View file

@ -1,27 +0,0 @@
<h2>Benchmark</h2>
Benchmarks should be taken with a grain of salt. <a
href="http://ecls.sourceforge.net">ECL</a> does not aim to compete with any
commercial or open source implementation. The purpose of these benchmarks are,
thus, to show the progress of <a href="http://ecls.sourceforge.net">ECL</a>
itself from version to version.
<p>It also serves to show how well other implementations perform: CLISPc, which
is based on bytecodes, is astonishingly fast, compared to other bytecodes
implementations (ECLi, CMUCLi) and to native code implementations (ECLc,
CMUCLc).
<p>All benchmarks are executed one after another. The benchmark currently shows
just mean execution times in seconds, using English decimal point (0.03 = 3/100
seconds). This means that performance of garbage collectors has a deep impact
in these numbers.
<p>It would be nice to collect some other information, such as memory use and
garbage collector timings, but that is beyond my reach for now. Help is always
welcome.
<p>Finally, I have decided to distribute Gabriel's benchmarks together with <a
href="http://ecls.sourceforge.net">ECL</a>. The reason is that this code seems
to belong to public domain and I had to perform several changes in order to let
it run with different implementations. To recreate the benchmark just get in
<tt>build/gabriel/</tt> and type <tt>make</tt>.

28
src/doc/cvs.in.html
View file

@ -1,28 +0,0 @@
<h2>CVS repository</h2>
<p>Beginning on March, ECL partially moved to the common-lisp.net
server. If you keep up to date with the latest improvements and fixes of
the ECL environment, you can use CVS to pull the latest sources from
there.
<p>If you have a modern version of the CVS program, such as the one
shipped with Mingw or with any Linux distribution, the command to get
the development sources is
<pre>
# ADDRESS=anonymous@common-lisp.net:/project/ecl/cvsroot
# cvs -z3 -d :pserver:anonymous:$ADDRESS co ecl
</pre>
<p>Additionally you can test ECL with Paul Dietz's ANSI test
suite. For that you need to download some additional files using
<pre>
# cvs -z3 -d :pserver:anonymous:$ADDRESS co ecl-test
</pre>
<p>Typing <tt>make</tt> from the top of the <tt>ecl-test</tt>
directory will download the latest version of the test suite and run
it using the version of ECL which is available on your machine.
<h2>Browsing CVS</h2>
<p>Additionally you can browse the ECL source code and download
tarballs using <a
href="http://common-lisp.net/cgi-bin/viewcvs.cgi/?root=ecl">this address</a>.

4
src/doc/download.in.html
View file

@ -1,4 +0,0 @@
<h2>Downloading</h2>
<p>You can always get the latest source-code release at
<a href="http://www.sourceforge.net/projects/ecls">the project page</a>.</p>

12
src/doc/end
View file

@ -1,12 +0,0 @@
<!-- End text -->
<p>&nbsp;</p>
</td>
</tr>
</table>
<table width="100%" align="center">
<tr><td bgcolor="#EEEEEE" align="right">
<h1><font color="#EEEEEE"><a href="http://sourceforge.net"><img src="http://sourceforge.net/sflogo.php?group_id=30335" width="88" height="31" border="0" alt="SourceForge Logo"</a></font></h1>
</td></tr>
</table>
</body>
</html>

116
src/doc/goals.in.html
View file

@ -1,116 +0,0 @@
<h2>Introduction</h2>
<a href="http://ecls.sourceforge.net">ECL</a> stands for <em>Embeddable
Common-Lisp "Spain"</em>, and I usually read it as "e-klos". It is a an
implementation of the <a href="http://www.lisp.org">Common-Lisp language</a>
which aims to comply to the <a
href="http://www.lisp.org/HyperSpec/FrontMatter/index.html">ANSI X3J13</a>
definition of the language.
<p><a href="http://ecls.sourceforge.net">ECL</a> combines a bytecodes
compiler/interpreter and a translator to C. The first one is specially suited
for prototyping and debugging. The second one produces fast code that can be
dynamically loaded into the interpreter or statically linked to build
standalone executables.
<p><a href="http://ecls.sourceforge.net">ECL</a> is distributed under the <a
href="#copyright">GNU Library General Public License (GNU LGPL)</a>.
<h2>ECL vs other implementations</h2>
<p><a href="http://ecls.sourceforge.net">ECL</a> is not a brand new
product. It has evolved from the EcoLisp implementation by Giuseppe Attardi
which in turn was based on the Kyoto Common-Lisp implementation done by Taiichi
Yuasa and Masami Hagiya, with contributions from several people. Nevertheless
the program has been seriously modified and the current code base bears little
resemblance to the previous implementations and the author of those
implementations should not be blamed for the faults of <a
href="http://ecls.sourceforge.net">ECL</a>.
<p>I have received several questions concerning why I work on ECL
instead of improving GCL. The main reason for this is the simplicity
of the code base. The EcoLisp implementation on which ECL is based
already was Cltl2 compliant. It had low level support for CLOS, a LOOP
package, DEFPACKAGE and the code in general was much more readable and
easier to maintain. It would be a huge task to get all these
improvements back and the code I put into ECL back into GCL.</p>
<h2>Project goals</h2>
<ul>
<li><b>To produce a free implementation of Common-Lisp.</b>
<p><a href="http://ecls.sourceforge.net">ECL</a> is released under the LGPL or
GNU Library General Public Licence (See <a
href="license.html">Copyright</a>). This means that <a
href="http://ecls.sourceforge.net">ECL</a> can be used in commercial projects
while keeping the implementation free.
<li><b>Compliance to the latest ANSI spec.</b>
<p><a href="http://ecls.sourceforge.net">ECL</a> is already rather standards
compliant. <a href="http://ecls.sourceforge.net">ECL</a> was born as a fork
from the ECL (Eco-Common-Lisp by Giusepe Attardi) which conformed to Cltl2
("Common-Lisp the Language 2"), but which was shipped with some ANSI
compatibility extensions. Currently the worst parts with respect to ANSI are
the LOOP package and parts of CLOS.
<li><b>Small code size.</b>
<p><a href="http://ecls.sourceforge.net">ECL</a> is made of a runtime library
and an interpreter. The interpreter itself is small, at most three files of C
code. Once the lisp environment is booted, it takes about 1Mb of code (although
currently it is a bit more due to debuggin issues in the interpreter). If the
whole of <a href="http://ecls.sourceforge.net">ECL</a> is compiled from lisp
to C, the resulting program is 1.5Mb. Nevertheless, there is room for
improvement in this area.
<li><b>Embedability.</b>
<p><a href="http://ecls.sourceforge.net">ECL</a> is shipped as a
library that can be linked against arbitrary C programs. Arbitrary
C/C++ code can be linked against <a
href="http://ecls.sourceforge.net">ECL</a>, either statically or at
runtime.
<li><b>Portability to arbitrary environments.</b>
<p><a href="http://ecls.sourceforge.net">ECL</a> is currently supported in
<ul>
<li>Linux on Intel, PowerPC, Alpha and Opteron</li>
<li>FreeBSD on Intel</li>
<li>NetBSD on Intel and Alpha</li>
<li>Microsoft Windows</li>
<li>MacOSX (currently broken)</li>
</ul>
Most of the code is portable and clean from issues like endianness and
word size (<a href="http://ecls.sourceforge.net">ECL</a> works on 64
bit architectures). The parts which change from operating system to
operating system are about the filesystem, sockets, signals and the
allocation of big chunks of memory, but in all it is well below 1000
lines.
<li><b>Compilation via an ANSI C compiler.</b>
<p><a href="http://ecls.sourceforge.net">ECL</a> can translate lisp code to C
code that can be dynamically loaded or linked to the runtime to produce a
standalone executable. Currently this process relies on GCC as a target
platform, but work is in progress to remove GCC dependencies.
<li><b>Better garbage collection.</b>
<p>As of this release the ECL fully relies on the Boehm-Weiser Garbage
Collector. This increases the memory requirements of <a
href="http://ecls.sourceforge.net">ECL</a> with respect to the old
garbage collector, but the whole environment results faster and more robust.
<li><b>Improve the compiler: more agressive inlining, better operations among
numbers and unboxed arrays of complex numbers.</b>
<p><a href="http://ecls.sourceforge.net">ECL</a> currently can inline all
operations that involve fixnums, characters and floating point
numbers. However, the type inferencer is not very powerful and therefore some
operations are not inlined because the compiler cannot actually tell the types
of the arguments and of the output.
</ul>

37
src/doc/head
View file

@ -1,37 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
<html>
<head>
<title>ECL - a Common-Lisp implementation</title>
<meta http-equiv="Content-Type" content="text/html"/>
</head>
<body bgcolor="#000000">
<table width="100%" align="center">
<tr><td bgcolor="#EEEEEE" align="center">
<h1><a href="http://sourceforge.net/projects/ecls">ECL</a></h1>
</td></tr>
</table>
</p>
<table width="100%" cellpadding="5" align="center">
<tr>
<td width="20%" bgcolor="#DDDDDD" valign="top">
<table align="center" valign="top">
<tr><td><a href="index.html"><b>Home page</b></a></td></tr>
<tr><td><a href="http://sourceforge.net/projects/ecls"><b>Project</b></a></td></tr>
<tr><td><a href="news.html"><b>Latest release</b></a></td></tr>
<tr><td><a href="install.html"><b>Installing</b></a></td></tr>
<tr><td><a href="license.html"><b>License</b></a></td></tr>
<tr><td><a href="new-manual/"><b>Documentation</b></a></td></tr>
<tr><td><a href="clx/index.html"><b>CLX manual</b></a></td></tr>
<tr><td><a href="benchmark.html"><b>Benchmarks</b></a></td></tr>
<tr><td><a href="download.html"><b>Distribution</b></a></td></tr>
<tr><td><a href="http://common-lisp.net/cgi-bin/viewcvs.cgi/?cvsroot=ecl"><b>Browse CVS</b></a></td></tr>
<tr><td><a href="cvs.html"><b>Checkout CVS</b></a></td></tr>
<tr><td><a href="http://lists.sourceforge.net/mailman/listinfo/ecls-list"><b>Mailing list</b></a></td></tr>
<tr><td><a href="http://ecls.wiki.sourceforge.net/"><b>Wiki</b></a></td></tr>
<tr><td><a href="http://sourceforge.net/export/rss2_projnews.php?group_id=30035&amp;rss_fulltext=1">
<b>News</b><IMG src="http://images.sourceforge.net/images/xml.png" border="0" alt="RSS Feed Available" width="36" height="14"></a>
</table>
<td width="7"></td>
<td width="100%" bgcolor="#FFFFFF" valign="top">
<!-- Begin text -->

41
src/doc/index.in.html
View file

@ -1,41 +0,0 @@
<h2>What is ECL</h2>
<a href="http://ecls.sourceforge.net">ECL</a> stands for <em>Embeddable
Common-Lisp</em>. The <a href="http://ecls.sourceforge.net">ECL</a> project is
an effort to modernize Giuseppe Attardi's ECL environment to produce an
implementation of the <a href="http://www.lisp.org">Common-Lisp language</a>
which complies to the <a
href="http://www.lisp.org/HyperSpec/FrontMatter/index.html">ANSI X3J13</a>
definition of the language.
<p>The current ECL implementation features:</p>
<ul>
<li>A bytecodes compiler and interpreter.</li>
<li>A translator to C.</li>
<li>A UFFI-compatible interface to C code.</li>
<li>A dynamic loader.</li>
<li>The possibility to build standalone executables and DLLs.</li>
<li>The Common-Lisp Object System (CLOS).</li>
<li>Conditions and restarts for handling errors.</li>
<li>Sockets as ordinary streams.</li>
<li>The Gnu Multiprecision library for fast bignum operations.</li>
<li>A simple conservative mark & sweep garbage collector.</li>
<li>The Boehm-Weiser garbage collector.</li>
</ul>
<p>ECL supports the operating systems Linux, FreeBSD, NetBSD, Solaris,
Windows, running on top of the Intel, Sparc, Alpha and PowerPC
processors.Porting to other architectures should be rather easy.</p>
<h2>The author</h2>
The original version was written by Giuseppe Attardi.
The current maintainer of <a href="http://ecls.sourceforge.net">ECLS</a> is
<a href="http://juanjose.garciaripoll.googlepages.com">Juan Jose Garcia
Ripoll</a>, who can be reached at the ECLS mailing list.
<p>We seek volunteers willing to test or improve the
implementation. We accept both code and constructive critics, so feel
free to share your toughts at the mailing list.
<h2>Latest news</h2>

113
src/doc/install.in.html
View file

@ -1,113 +0,0 @@
<h2>Installation</h2>
<p>You should read the <a href="#configure">Autoconf based configuration</a>
if you use ECL on a unix-like platform, such as
<ul>
<li>Linux, NetBSD, FreeBSD, Solaris 9
<li>Mac OSX (See <a href="#osx">below</a>)
<li>Cygwin or Mingw32 on Windows.
</ul>
<p>If you want to compile ECL using Microsoft C++ you should read <a
href="#msvc">the appropiate section</a>.
<p>For OSX you should also read a section which specifies <a href="#osx">how
to build</a> ECL for different versions of the operating system.
<p>If you want to cross-compile ECL, there is also <a href="#cross">a
chapter</a> on how to pre-configure, write down a configuration file
and finish the compilation.
<h3><a name="configure">Autoconf based configuration</a></h3>
<ul>
<li>Unpack the tar file
<pre>
gunzip -c ecl.tgz | tar xf -
</pre>
<li>Run the configuration file.
<pre>
cd ecl-@PACKAGE_VERSION@
./configure
</pre>
The previous step creates a directory with the name <b>build</b>, and
stores a bunch of makefiles in it. <b>Note:</b> If you are building
under Solaris 9, you should rather use
<pre>
./configure --enable-slow-config --with-system-gmp=no
</pre>
because otherwise ECL will fail to detect the 64-bit capabilities of
the operating system.
<li>Use GNU make to begin building ECL
<pre>
make
</pre>
<li>If you want to test the fresh new executable before installing,
you can do it. You should invoke ECL from withing the build directory
using the "-dir ./" argument to advice it about the right place to
find header files, libraries, etc
<pre>
$ ./configure --prefix=$HOME
[...]
$ cd build
$ make
[...]
$ ./ecl -dir ./
</pre>
<li>Install it in the preconfigured location
<pre>
make install
</pre>
</ul>
<h3><a name="msvc">Microsoft C++</a></h3>
<p>If you have a commercial version of Microsoft Visual Studio, the
steps are simple:
<ul>
<li>Change to the <tt>msvc</tt> directory.
<li>Run <tt>nmake</tt> to build ECL.
<li>Run <tt>nmake flatinstall prefix=d:\Software\ECL</tt> where the
<tt>prefix</tt> is the directory where you want to install ECL.
<li>Optionally, if you want to build a self-installing executable, you can install <a href="http://nsis.sourceforge.net">NSIS</a>
and run <tt>nmake windows-nsi</tt>.
</ul>
<p>If you want to build ECL using the free Microsoft Visual C++
Toolkit 2003, you should follow these before building ECL:
<ul>
<li> Download and install <a href="http://msdn.microsoft.com/visualc/vctoolkit2003/">Microsoft Visual C++ Toolkit</a>.
<li> Download and install the <a href="http://www.microsoft.com/msdownload/platformsdk/sdkupdate/">Microsoft Platform SDK</a>
<li> Download NMAKE and install. There is an old version in <a href="http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe">Microsoft's download page</a>.
<li> Download and install the .NET Framework SDK. Copy the files msvcrt.lib an msvcrtd.lib from this toolkit to the directory where the Visual C++ Toolkit keeps it libraries. Afterwards you can uninstall the .NET SDK.
<li> Make sure that
<ul>
<li><tt>%PATH%</tt> includes the directories <tt>bin</tt> of both the C++ Toolkit, NMAKE and the SDK.
<li><tt>%INCLUDE%</tt> includes the directories <tt>include</tt> of both the C++ Toolkit and the SDK.
<li><tt>%LIB%</tt>includes the directories <tt>lib</tt> of both the C++ Toolkit and the SDK.
</ul>
</ul>
<h3><a name="osx">Mac OSX</a></h3>
<p>ECL now compiles with GCC 4.0. You need not specify any particular
options. But if you still experience some strange behaviour, try
compiling with a previous version of the compiler before reporting the
bug.
<p>For compiling with GCC 3.3 (shipped with XCode >= 2) you
must instruct <tt>configure</tt> to use a different compiler, as in
<pre>
$ CC=gcc-3.3 ./configure --prefix=/opt/local
</pre>
<h3><a name="cross">Cross compiling ECL</a></h3>
[To be written]

62
src/doc/license.in.html
View file

@ -1,62 +0,0 @@
<pre>
_______________________________________________________________________________
Copyright (c) 2000, Juan Jose Garcia Ripoll
Copyright (c) 1990, 1991, 1993 Giuseppe Attardi
Copyright (c) 1984 Taiichi Yuasa and Masami Hagiya
All Rights Reserved
_______________________________________________________________________________
Summary:
Permission is granted to use, copy, modify this program,
EXCEPT that the copyright notice must be reproduced on copies, and
credit should be given to the authors where it is due.
WE MAKE NO WARRANTY AND ACCEPT NO LIABILITY FOR THIS PROGRAM.
In detail:
1. Permission to use, copy, modify this software and its documentation
for any purpose is hereby granted without fee, provided that
- the above copyright notice appears in all copies,
- both that copyright notice and this permission notice appears in
supporting documentation, and that
- you cause modified files to carry prominent notices stating that
you changed the files and the date of any change.
2. Please notify us if you are going to sell this software or its
documentation for profit.
3. WE DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
WE BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
Additionally:
ECL is free software; you can redistribute it and/or modify it
under the terms of the GNU Library General Public License as published
by the Free Software Foundation; either version 2 of the License, or
(at your option) any later version; see file 'Copying'.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Library General Public License for more details.
You should have received a copy of the <a href="http://www.fsf.org/copyleft/lgpl.html">GNU Library General Public License</a>
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Please reporting bugs, comments, suggestions at
ECL Mailing list
ecls-list@lists.sourceforge.net
or directly to the maintainer
Juan Jose Garcia Ripoll
http://juanjose.garciaripoll.googlepages.com
</pre>