[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Lisp Innards Wanted!

[Apologies to those who have seen this already, how could I have forgotten
the COMMON-LISP list!]

As part of my dissertation, I've been collecting info on the internal data
representations of various Lisp systems.  Lisp here is broadly defined as
any language ultimately based on Lisp 1.5, and includes Scheme.  What I'm
looking for is the grungiest of machine-level details on the layout of cons
cells, type discrimination schemes, memory organization, and storage recovery.
Moon's description of the Symbolics architecture in the January 87 Computer is
an excellent example, especially the pictures.  Not every single detail is
needed; just those that required conscious decisions by an implementor.  (For
instance, if arrays are tagged with a 0 to avoid masking, that is interesting,
but if it was only because "array" is the first type name in the dictionary,
that is not interesting.)  Implementations embedded in other Lisps (Scheme 84,
PCLS) are not of interest, but this does not exclude those written in other
high-level languages (as can be seen from the list below).

At present I have reasonably complete descriptions of the following systems,
mostly derived from published material, manuals, or source code:

        7090 Lisp 1.5
        M-460 Lisp
        Q-32 Lisp
	PDP-1 Lisp
        Lisp 1.6
        UCI Lisp
        MacLISP (PDP-10, Multics)
        Interlisp (VAX, PDP-10, -D)
        Cambridge LISP (IBM)
        Franz Lisp
        Spice Lisp
        S-1 Lisp
        Franz Extended Common Lisp
        MIT Scheme
        PC Scheme
	Lisp F3
        Kyoto Common Lisp

I have only sketchy or no data on the following systems:

	Cambridge Lisp (ST)
	Apollo Domain Lisp (the PSL deriv)
	Rutgers Lisp-20
	Rutgers DEC-20 Common Lisp
        Golden Common Lisp
        HP Common Lisp
	Pyramid Common Lisp
	Lucid Lisp

There are certainly others I've forgotten or simply don't know about - any
info on these is quite welcome!  Long-ago implementations are just as worth
knowing about as more recent ones.

Details received will go into my dissertation, and possibly into a separate
tech report; any contributor who wants one will get a copy when this work is
completed, perhaps in three months or so.  The dissertation itself is about
Lisp data structure design in general, and how it might be formalized.

Of course, all contributions will be properly credited, not to mention
greatly appreciated!

						stan shebs