Next: , Previous: , Up: Top   [Contents][Index]

Introduction


Next: , Up: Introduction   [Contents][Index]

About this book

This manual is part of the ECL software system. It documents deviations of ECL from various standards ([see ANSI], [see AMOP],...), extensions, daily working process (compiling files, loading sources, creating programs, etc) and the internals of this implementation.

It is not intended as a source to learn Common Lisp. There are other tutorials and textbooks available in the Net which serve this purpose. The homepage of the Common-Lisp.net contains a good list of links of such teaching and learning material.

This book is structure into four parts:

User’s guide

We begin with [User's guide] which provides introductory material showing the user how to build and use ECL and some of its unique features. This part assumes some basic Common Lisp knowledge and is suggested as an entry point for a new users who want to start using Embeddable Common Lisp.

Developer’s guide

[Developer's guide] documents Embeddable Common Lisp implementation details. This part isn not meant for normal users but rather for the ECL developers and other people who want to contribute to Embeddable Common Lisp. This section is prone to change due to the dynamic nature of a software. Covered topics include source code structure, contributing guide, internal implementation details and many other topics relevant to the development process.

Standards

[Standards] documents all parts of the standard which are left as implementation specific or to which ECL doesn’t adhere. For instance, precision of floating point numbers, available character sets, actual input/output protocols, etc.

Section covers also C Reference as a description of ANSI Common-Lisp from the C/C++ programmer perspective and ANSI Dictionary for Common-Lisp constructs available from C/C++.

Extensions

[Extensions] introduces all features which are specific to ECL and which lay outside the standard. This includes configuring, building and installing ECL multiprocessing capabilities, graphics libraries, interfacing with the operating system, etc.


Next: , Previous: , Up: Introduction   [Contents][Index]

What is ECL

Common-Lisp is a general purpose programming language. It lays its roots in the LISP programming language [see LISP1.5] developed by John McCarthy in the 80s. Common-Lisp as we know it ANSI Common-Lisp is the result of an standarization process aimed at unifying the multiple lisp dialects that were born from that language.

Embeddable Common Lisp is an implementation of the Common-Lisp language. As such it derives from the implementation of the same name developed by Giuseppe Attardi, which itself was built using code from the Kyoto Common-Lisp [see Yasa:85]. History for the history of the code you are about to use.

Embeddable Common Lisp (ECL for short) uses standard C calling conventions for Lisp compiled functions, which allows C programs to easily call Lisp functions and vice versa. No foreign function interface is required: data can be exchanged between C and Lisp with no need for conversion.

ECL is based on a Common Runtime Support (CRS) which provides basic facilities for memory management, dynamic loading and dumping of binary images, support for multiple threads of execution. The CRS is built into a library that can be linked with the code of the application. ECL is modular: main modules are the program development tools (top level, debugger, trace, stepper), the compiler, and CLOS. A native implementation of CLOS is available in ECL. A runtime version of ECL can be built with just the modules which are required by the application.

The ECL compiler compiles from Lisp to C, and then invokes the C compiler to produce binaries. Additionally portable bytecode compiler is provided for machines which doesn’t have C compiler. While former releases of ECL adhere to the the reference of the language given in Common-Lisp: The Language II [see Steele90], the ECL is now compliant with X3J13 ANSI Common Lisp [see ANSI].


Next: , Previous: , Up: Introduction   [Contents][Index]

History

The ECL project is an implementation of the Common Lisp language inherits from many other previous projects, as shown in Figure 1. The oldest ancestor is the Kyoto Common Lisp, an implementation developed at the the Research Institute for Mathematical Sciences, Kyoto University [see Yasa:85]. This implementation was developed partially in C and partially in Common Lisp itself and featured a lisp to C translator.

figures/kcl-hierarchy

Figure 1: ECL’s family tree

The KCL implementation remained a propietary project for some time. During this time, William F. Schelter improved KCL in several areas and developed Austin Kyoto Common-Lisp (AKCL). However, those changes had to be distributed as patches over the propietary KCL implementation and it was not until much later that both KCL and AKCL became freely available and gave rise to the GNU Common Lisp project, GCL.

Around the 90’s, Giusseppe Attardi worked on the KCL and AKCL code basis to produce an implementation of Common Lisp that could be embedded in other C programs [see Attardi:95]. The result was an implementation sometimes known as ECL and sometimes as ECoLisp, which achieved rather good compliance to the informal specification of the language in CLTL2 [see Steele:90], and which run on a rather big number of platforms.

The ECL project stagnated a little bit in the coming years. In particular, certain dependencies such as object binary formats, word sizes and some C quirks made it difficult to port it to new platforms. Furthermore, ECL was not compliant with the ANSI specification, a goal that other Common Lisps were struggling to achieve.

This is where the ECLS or ECL-Spain project began. Juanjo García-Ripoll took the ECoLisp sources and worked on them, with some immediate goals in mind: increase portability, make the code 64-bit clean, make it able to build itself from scratch, without other implementation of Common Lisp and restore the ability to link ECL with other C programs.

Those goals were rather quickly achieved. ECL became ported to a number of platforms and with the years also compatibility with the ANSI specification became a more important goal. At some point the fork ECLS, with agreement of Prof. Attardi, took over the original ECL implementation and it became what it is nowadays, a community project.

In 2013 once again project got unmaintained. In 2015 Daniel Kochmański took the position of a maintainer with consent of Juanjo García-Ripoll.

The ECL project owes a lot to different people who have contributed in many different aspects, from pointing out bugs and incompatibilities of ECL with other programs and specifications, to actually solving these bugs and porting ECL to new platforms.

Current development of ECL is still driven by Daniel Kochmański with main focus on improving ANSI compliance and compatibility with the Common Lisp libraries ecosystem, fixing bugs, improving speed and the portability. The project homepage is located at https://common-lisp.net/project/ecl/.


Next: , Previous: , Up: Introduction   [Contents][Index]

Credits

The Embeddable Common Lisp project is an implementation of the Common-Lisp language that aims to comply with the ANSI Common-Lisp standard. The first ECL implementations were developed by Giuseppe Attardi’s who produced an interpreter and compiler fully conformat with the Common-Lisp as reported in Steele:84. ECL derives itself mostly from Kyoto Common-Lisp, an implementation developed at the Research Institute for Mathematical Sciences (RIMS), Kyoto University, with the cooperation of Nippon Data General Corporation. The main developers of Kyoto Common-Lisp were Taiichi Yuasa and Masami Hagiya, of the Research Institute for Mathematical Sciences, at Kyoto University.

We must thank Giuseppe Attardi, Yuasa and Hagiya and Juan Jose Garcia Ripoll for their wonderful work with preceding implementations and for putting them in the Public Domain under the GNU General Public License as published by the Free Software Foundation. Without them this product would have never been possible.

This document is an update of the original ECL documentation, which was based in part on the material in [see Yuasa:85]

The following people or organizations must be credited for support in the development of Kyoto Common-Lisp: Prof. Reiji Nakajima at RIMS, Kyoto University; Nippon Data General Corporation; Teruo Yabe; Toshiyasu Harada; Takashi Suzuki; Kibo Kurokawa; Data General Corporation; Richard Gabriel; Daniel Weinreb; Skef Wholey; Carl Hoffman; Naruhiko Kawamura; Takashi Sakuragawa; Akinori Yonezawa; Etsuya Shibayama; Hagiwara Laboratory; Shuji Doshita; Takashi Hattori.

William F. Schelter improved KCL in several areas and developed Austin Kyoto Common-Lisp (AKCL). Many ideas and code from AKCL have been incorporated in Embeddable Common Lisp.

The following is the partial list of contributors to ECL: Taiichi Yuasa and Masami Hagiya (KCL), William F. Schelter (Dynamic loader, conservative Gc), Giuseppe Attardi (Top-level, trace, stepper, compiler, CLOS, multithread), Marcus Daniels (Linux port) Cornelis van der Laan (FreeBSD port) David Rudloff (NeXT port) Dan Stanger, Don Cohen, and Brian Spilsbury.

We have to thank for the following pieces of software that have helped in the development of Embeddable Common Lisp

BRUNO HAIBLE

For the Cltl2-compliance test

PETER VAN EYNDE

For the ANSI-compliance test

SYMBOLIC’S INC.

For the ANSI-compliant LOOP macro.

The Embeddable Common Lisp project also owes a lot to the people who have tested this program and contributed with suggestions, error messages and documentation: Eric Marsden, Hannu Koivisto, Jeff Bowden and Yuto Hayamizu, Bo Yao and others whose name we may have omitted.


Previous: , Up: Introduction   [Contents][Index]

Copyrights

Copyright of ECL

ECL is distributed under the GNU LGPL, which allows for commercial uses of the software. A more precise description is given in the Copyright notice which is shipped with ECL.

---- BEGINNING OF COPYRIGHT FOR THE ECL CORE ENVIRONMENT ------------

Copyright (c) 2015, Daniel Kochmański
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

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 GNU Library General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

PLEASE NOTE THAT:

This license covers all of the ECL program except for the files
src/lsp/loop2.lsp       ; Symbolic's LOOP macro
src/lsp/pprint.lsp      ; CMUCL's pretty printer
src/lsp/format.lsp      ; CMUCL's format
and the directories
contrib/                ; User contributed extensions
examples/               ; Examples for the ECL usage
Look the precise copyright of these extensions in the corresponding
files.

Examples are licensed under: (SPDX-License-Identifier) BSD-2-Clause

Report bugs, comments, suggestions to the ecl mailing list:
ecl-devel@common-lisp.net.

---- END OF COPYRIGHT FOR THE ECL CORE ENVIRONMENT ------------------

Copyright of this manual

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, with the no Front-Cover Texts, and with no Back-Cover Texts. Exact text of the license is available at https://www.gnu.org/copyleft/fdl.html.


Previous: , Up: Introduction   [Contents][Index]