README

Welcome to SICL.  It is meant to become a new implementation of Common
Lisp but with a difference.  For one thing, it is intentionally
divided into many implementation-independent modules that are written
in a totally or near-totally portable way, so as to allow other
implementations to incorporate these modules from SICL, rather than
having to maintain their own, perhaps implementation-specific
versions.  More information about this philosophy is available in the
Specification subdirectory. 

As of this writing, only a few modules are completely implemented, and
there are many partial ones.  You will find them in the Code
subdirectory.  We would like to start by distributing some big chunks
that could be useful for people experimenting with new
implementations, in particular the FORMAT function, the LOOP macro,
the READ function.

Each module M is organized so that the corresponding implementation
package (let's call it MP) uses the CL package except that it shadows
symbols from the CL package that it supplies itself, and also exports
at least those symbols.  Each module also has a corresponding test
package (let's call it TP) that uses the CL package, except for the
shadowed symbols of MP which are taken from MP instead.  That way, the
code in TP can be structured so that it looks like it is testing
ordinary Common Lisp functionality, except that it is really testing
functionality of MP.

If you are an implementor with an incomplete Common Lisp
implementation and you want to incorporate some module from SICL into
your implementation, or if you have a complete Common Lisp
implementation, but you want to replace an existing module with the
corresponding SICL module, you need to modify the package definition
of MP so that it doesn't shadow the symbols from the CL package.  That
way, the definitions of MP will just be added to your CL.

While the SICL modules can be added to an incomplete Common Lisp
implementation, they can not necessarily be built using such an
incomplete Common Lisp implementation.  We have made no attempt to
define a subset of Common Lisp that is enough to build each module.
To build the SICL implementation itself requires an existing Common
Lisp system, and it is entirely possible that every individual module
does as well.

If you want to contribute to SICL, you would either start working on a
new module, or improve an existing one.  Most of the existing modules
have a status.text file that describes what exists and what needs to
be done, how to run the tests etc.  If you want to start a new module,
it is best to copy the structures of existing modules.

In the Specification subdirectory, there is a document that gives some
hints about the goals of the system, and how these goals are to be
achieved.  The subdirectory Ideas are for ideas that might have to be
examined more thoroughly before being decided upon.  

We have included a copy of the lisp-unit unit testing framework in the
Lisp-Unit subdirectory, and we added an ASDF system definition for it
so make it easier to test the SICL modules.