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, no module is completely implemented, but 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 CL functionality, except that it is really testing
functionality of MP. 

If you are an implementor with an incomplete CL and you want to
incorporate some module from SICL into your implementation, or if you
have a complete CL 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
CL.  That way, the definitions of MP will just be added to your CL.

If you want to contribute to SICL, you would either start working on a
new module, or improve an existing one.  Each existing module has 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.