%% Oh Emacs, this is a -*- Makefile -*-, so give me tabs.
\documentclass{article}
\usepackage{axiom}
\begin{document}
\title{\$SPAD/src/interp Makefile}
\author{Timothy Daly \and Gabriel Dos~Reis}
\maketitle
\begin{abstract}
\end{abstract}
\eject
\tableofcontents
\eject
\begin{verbatim}

IMPORTANT: all source file names in this Makefile must be lowercase
  This is for cross-platform compatibility and also makes getting
  them into Lisp much easier at the Makefile level.

\end{verbatim}

\section{The Environment}

We define 3 directories for this build. The first is
{\bf MID} which is where we will put the compiled intermediates.

Since we support separate build tree we are phasing out the old
directory structure and move everything to the current direstory.

The interpreter files are usually written in {\bf boot} \cite{2}.
There are two dialects of {\bf boot}: the old one and a newer one (shoe).
Shoe (new boot) files will be compiled in a {\bf BOOTSYS} image (to
translate from {\bf boot} to Common Lisp.  The old boot files
will be compiled in a {\bf DEPSYS} image.


The dvi files will be generated from the pamphlet files in the
final ship \File{doc/src/} directory. Since they are system independent
but machine generated and part of the final ship they will exist
in the \File{\$(axiom_target_docdir)/src/interp/} directory.

<<environment>>=
DOC=$(axiom_target_docdir)/src/interp
BOOK=$(axiom_target_docdir)

# Command to translate Boot to Common Lisp
BOOT_TO_LISP = \
	$(axiom_build_document) --tag=boot --mode=translate \
		--use=$(BOOTSYS) $<

# Command to translate Common Lisp to native object code
COMPILE_LISP = \
	$(axiom_build_document) --tag=lisp --mode=compile \
		--output=$@ --use=$(DEPSYS) $<
@

In order to minimize the size of the Axiom image at load time
we put some of the compiled files into a separate directory
that will be autoloaded on demand. This directory of code
will be shipped with the final system and so it belongs in
the {\bf \$SPAD/mnt} subtree.
<<environment>>=
AUTO=$(axiom_targetdir)/autoload

autoload_objects =

@

We need a raw lisp image that we can use as a base to construct
the other images. This is called {\bf LISPSYS} and is
system-dependent and machine-generated.
It belongs in the {\bf \$SPAD/obj} subtree.
<<environment>>=
LISPSYS= $(axiom_build_bindir)/lisp

@

Most of the interpreter is written in {\bf boot} \cite{2}.
Thus we need a program to translate {\bf boot} to Common
Lisp. The translator for shoe (new boot) is called the {\bf BOOTSYS}
image (because the
translator is written in {\bf boot} and needs to translate
itself to bootstrap the system). This image is assumed to
have been built by a previous step in the make process.
<<environment>>=
BOOTSYS= $(axiom_build_bindir)/bootsys

@

The old boot is translated using {\bf DEPSYS} image.

Also some of the Common Lisp code we compile uses macros which
are assumed to be available at compile time. The {\bf DEPSYS}
image is created to contain the compile time environment
and saved. We pipe compile commands into this environment
to compile from Common Lisp to machine dependent code.
%
<<environment>>=
DEPSYS=	$(axiom_build_bindir)/depsys

depsys_lisp_noncompiled_sources += sys-pkg.lisp nocompil.lisp \
	ncompil.lisp bookvol5.lisp util.lisp

depsys_lisp_compiled_sources += parsing.lisp metalex.lisp bootlex.lisp \
	newaux.lisp preparse.lisp def.lisp metameta.lisp \
	fnewmeta.lisp

depsys_lisp_sources = $(depsys_lisp_noncompiled_sources) \
			$(depsys_lisp_compiled_sources)

@

The {\bf DEP} variable contains the list of files that
will be loaded into {\bf DEPSYS}. Notice that these files
are loaded in interpreted form. We are not concerned about
the compile time performance so we can use interpreted code.
We do, however, care about the macros as these will be
expanded in later compiles. All macros are assumed to be
in this list of files.
<<environment>>=
DEP=	vmlisp.lisp	ggreater.lisp	\
	hash.lisp	bootfuns.lisp	\
	union.lisp	nlib.lisp	\
	macros.lisp	comp.lisp	\
	spaderror.lisp	debug.lisp	\
	spad.lisp	bits.lisp	\
	setq.lisp	property.lisp	\
	foam_l.lisp      \
	axext_l.lisp

depsys_lisp_macro_sources = vmlisp.lisp ggreater.lisp hash.lisp \
	bootfuns.lisp union.lisp nlib.lisp macros.lisp	\
	comp.lisp spaderror.lisp debug.lisp \
	spad.lisp bits.lisp setq.lisp property.lisp \
	foam_l.lisp axext_l.lisp

depsys_lisp_noncompiled_sources += $(depsys_lisp_macro_sources)
depsys_lisp_SOURCES = $(addsuffix .pamphlet, $(depsys_lisp_sources))
@

Once we've compile all of the Common Lisp files we fire up
a clean lisp image called {\bf LOADSYS}, load all of the
final executable code and save it out as {\bf SAVESYS}.
The {\bf SAVESYS} image is copied to the [[$(axiom_target_bindir)]]
subdirectory and becomes the axiom executable image.
<<environment>>=
LOADSYS= $(axiom_build_bindir)/lisp$(EXEEXT)
SAVESYS= $(axiom_build_bindir)/interpsys$(EXEEXT)
AXIOMSYS= $(axiom_target_bindir)/AXIOMsys$(EXEEXT)

@

These are the files that need to be compiled (in {\bf BOOTSYS}),
loaded into a clean lisp image ({\bf LOADSYS}) and saved as
a runnable Axiom interpreter ({\bf SAVESYS}) usually named
{\bf interpsys}. Most of these files
are translated from {\bf boot} to Common Lisp and then
compiled. There are two exceptions, {\bf bootfuns.lisp}
and {\bf setq.lisp}. The {\bf bootfuns.lisp} \cite{3} file
contains forward references for {\bf boot} code. The {\bf setq.lisp}
file contains constant initialization code which gains nothing
by being compiled.

The value of the variable [[AXIOMsys_boot_sources]] is the (currently
partial) list of Boot source files that make up the interpreter.
Similarly, the value of the variable [[AXIOMsys_compiled_lisp_sources]]
is the list of Common Lisp source files that are compiled into
the interpreter.  Notice that some of these files are loaded (\eg{},
interpreted) in [[depsys]].

<<environment>>=
OBJS=	vmlisp.$(FASLEXT)	hash.$(FASLEXT)	\
	bootfuns.lisp	macros.$(FASLEXT)	\
	setq.lisp	\
	astr.$(FASLEXT)	bits.$(FASLEXT)	\
	alql.$(FASLEXT)	buildom.$(FASLEXT)	\
	cattable.$(FASLEXT)				\
	cformat.$(FASLEXT)	cfuns.$(FASLEXT)	\
	clam.$(FASLEXT)	clammed.$(FASLEXT)	\
	comp.$(FASLEXT)	\
	compat.$(FASLEXT)	compress.$(FASLEXT)	\
	cparse.$(FASLEXT)	cstream.$(FASLEXT)	\
	database.$(FASLEXT)	\
	debug.$(FASLEXT)	dq.$(FASLEXT)		\
	fname.$(FASLEXT)	format.$(FASLEXT)	\
	g-boot.$(FASLEXT)	g-cndata.$(FASLEXT)	\
	g-error.$(FASLEXT)	g-opt.$(FASLEXT)	\
	g-timer.$(FASLEXT)	g-util.$(FASLEXT)	\
	ggreater.$(FASLEXT)				\
	hypertex.$(FASLEXT)	i-analy.$(FASLEXT)	\
	i-code.$(FASLEXT)	i-coerce.$(FASLEXT)	\
	i-coerfn.$(FASLEXT)	i-eval.$(FASLEXT)	\
	i-funsel.$(FASLEXT)	bookvol5.$(FASLEXT)	\
	i-intern.$(FASLEXT)	i-map.$(FASLEXT)	\
	i-output.$(FASLEXT)	i-resolv.$(FASLEXT)	\
	i-spec1.$(FASLEXT)				\
	i-spec2.$(FASLEXT)	i-syscmd.$(FASLEXT)	\
	i-toplev.$(FASLEXT)	i-util.$(FASLEXT)	\
	incl.$(FASLEXT)	int-top.$(FASLEXT)	\
	lisplib.$(FASLEXT)	macex.$(FASLEXT)	\
	match.$(FASLEXT)				\
	monitor.$(FASLEXT)	msg.$(FASLEXT)		\
	msgdb.$(FASLEXT)	nci.$(FASLEXT)		\
	newaux.$(FASLEXT)	newfort.$(FASLEXT)	\
	nlib.$(FASLEXT)	nrunfast.$(FASLEXT)	\
	nrungo.$(FASLEXT)	nrunopt.$(FASLEXT)	\
	nruntime.$(FASLEXT)	osyscmd.$(FASLEXT)	\
	packtran.$(FASLEXT)	pathname.$(FASLEXT)	\
	pf2sex.$(FASLEXT)	pile.$(FASLEXT)	\
	posit.$(FASLEXT)	property.lisp	\
	ptrees.$(FASLEXT)	ptrop.$(FASLEXT)	\
	record.$(FASLEXT)				\
	rulesets.$(FASLEXT)	\
	scan.$(FASLEXT)	serror.$(FASLEXT)	\
	server.$(FASLEXT)				\
	setvars.$(FASLEXT)	\
	sfsfun-l.$(FASLEXT)	sfsfun.$(FASLEXT)	\
	simpbool.$(FASLEXT)	slam.$(FASLEXT)	\
	sockio.$(FASLEXT)	spad.$(FASLEXT)	\
	spaderror.$(FASLEXT)				\
	template.$(FASLEXT)	termrw.$(FASLEXT)	\
	trace.$(FASLEXT)	\
	union.$(FASLEXT)       daase.$(FASLEXT)  	\
	fortcall.$(FASLEXT)

AXIOMsys_noncompiled_lisp_sources = bootfuns.lisp nocompil.lisp \
	property.lisp setq.lisp

AXIOMsys_compiled_lisp_sources = bits.lisp \
	bootlex.lisp cfuns.lisp comp.lisp construc.lisp daase.lisp \
	debug.lisp def.lisp fname.lisp fnewmeta.lisp ggreater.lisp \
	hash.lisp macros.lisp metalex.lisp monitor.lisp newaux.lisp \
	nlib.lisp nspadaux.lisp parsing.lisp \
	patches.lisp preparse.lisp \
	sockio.lisp spad.lisp spaderror.lisp \
	union.lisp util.lisp vmlisp.lisp obey.lisp \
	nci.lisp sfsfun-l.lisp \
	axext_l.lisp foam_l.lisp

AXIOMsys_boot_sources = astr.boot alql.boot buildom.boot cattable.boot \
	cformat.boot clam.boot clammed.boot compat.boot compress.boot \
	cparse.boot cstream.boot database.boot dq.boot format.boot \
	g-boot.boot g-cndata.boot g-error.boot g-opt.boot g-timer.boot \
	g-util.boot hypertex.boot i-analy.boot i-code.boot i-coerce.boot \
	i-coerfn.boot i-eval.boot i-funsel.boot i-intern.boot i-map.boot \
	i-output.boot i-resolv.boot i-spec1.boot i-spec2.boot \
	i-syscmd.boot i-toplev.boot i-util.boot incl.boot int-top.boot \
	lisplib.boot macex.boot match.boot msg.boot \
	msgdb.boot newfort.boot nrunfast.boot nrungo.boot nrunopt.boot \
	nruntime.boot osyscmd.boot packtran.boot pathname.boot \
	pf2sex.boot pile.boot posit.boot ptrees.boot ptrop.boot \
	record.boot rulesets.boot scan.boot serror.boot server.boot \
	setvars.boot sfsfun.boot simpbool.boot slam.boot template.boot \
	termrw.boot trace.boot fortcall.boot
@

Before we save the {\bf SAVESYS} image we need to run some
initialization code. These files perform initialization
for various parts of the system. The {\bf patches.lisp} \cite{5}
file contains last-minute changes to various functions and
constants.
<<environment>>=
INOBJS=	varini.$(FASLEXT)	parini.$(FASLEXT)	\
	setvart.$(FASLEXT)	\
        interop.$(FASLEXT)     \
        patches.$(FASLEXT)

@

Certain functions do not need to be in the running system.
If the running image never calls the compiler or does not
use the hypertex browser we will never call the functions
in these files. The code that calls these functions in the
running system will autoload the appropriate files the
first time they are called. Loading the files overwrites
the autoload function call and re-calls the function.
Any subsequent calls will run the compiled code.

The {\bf OPOBJS} list contains files from the old parser. The use of
``old'' is something of a subtle concept as there were several
generations of ``old'' and all meaning of the term is lost.

Notice that the object file [[def.$(FASLEXT)]] appears on both the
[[OPBJS]] and [[TRANOBJS]] lists.  In normal situation, parsing
precedes translation; consequently the file [[def]] is loaded by the
parser, so that it does not need to be reloaded by the translator.
However, it may theoretically be that a translation could happen without
prior parsing (in case someone types in a parse tree for SPAD code).
Consequently, it must be ensured that [[def.]] is still loaded in that
configuration.  In the long term, the autoload machinery need
rethinking.

<<environment>>=
# These are autloaded old parser files
OPOBJS=	${AUTO}/parsing.$(FASLEXT)	${AUTO}/bootlex.$(FASLEXT)	\
        ${AUTO}/def.$(FASLEXT)	\
	${AUTO}/fnewmeta.$(FASLEXT)	${AUTO}/metalex.$(FASLEXT)	\
	${AUTO}/metameta.$(FASLEXT)	\
	${AUTO}/parse.$(FASLEXT)	${AUTO}/postpar.$(FASLEXT)	\
	${AUTO}/preparse.$(FASLEXT)

autoload_objects += $(OPBJS)
@

The {\bf OCOBJS} list contains files from the old compiler. Again,
``old'' is meaningless. These files should probably be autoloaded.
<<environment>>=
OCOBJS=	${AUTO}/apply.$(FASLEXT)	${AUTO}/c-doc.$(FASLEXT)	\
	${AUTO}/c-util.$(FASLEXT)	${AUTO}/profile.$(FASLEXT)	\
	${AUTO}/category.$(FASLEXT)	${AUTO}/compiler.$(FASLEXT)	\
	${AUTO}/define.$(FASLEXT)	${AUTO}/functor.$(FASLEXT)	\
	${AUTO}/info.$(FASLEXT)	${AUTO}/iterator.$(FASLEXT)	\
	${AUTO}/modemap.$(FASLEXT)	${AUTO}/nruncomp.$(FASLEXT)	\
	${AUTO}/package.$(FASLEXT)	${AUTO}/htcheck.$(FASLEXT)

autoload_objects += $(OCOBJS)

@

The {\bf BROBJS} list contains files only used by the hypertex
browser. These files should probably be autoloaded.
<<environment>>=
BROBJS=	${AUTO}/bc-matrix.$(FASLEXT)				\
	${AUTO}/bc-misc.$(FASLEXT)	${AUTO}/bc-solve.$(FASLEXT)	\
	${AUTO}/bc-util.$(FASLEXT)				\
	${AUTO}/ht-util.$(FASLEXT)	${AUTO}/htsetvar.$(FASLEXT)	\
	${AUTO}/ht-root.$(FASLEXT)	\
	${AUTO}/br-con.$(FASLEXT)	\
	${AUTO}/br-data.$(FASLEXT)	${AUTO}/showimp.$(FASLEXT)    \
	${AUTO}/br-op1.$(FASLEXT)	${AUTO}/br-op2.$(FASLEXT)	\
	${AUTO}/br-search.$(FASLEXT)	${AUTO}/br-util.$(FASLEXT)	\
	${AUTO}/topics.$(FASLEXT)     ${AUTO}/br-prof.$(FASLEXT)    \
	${AUTO}/br-saturn.$(FASLEXT)

autoload_objects += $(BFOBJS)

@
The {\bf TRANOBJS} list contains files used by Spad to Aldor convertor.
The files probably are also used by the {\bf boot}
to Common Lisp translator and are probably never used by anyone
but the developers.

When a user requests converting a file from Spad to Aldor the
function
[[spad2AsTranslatorAutoloadOnceTrigger]] is called triggering
load of this group of files. Loading [[$TRANOBJS]] in turn replaces
many compiler functions by versions contain in this files.
 These files should probably be autoloaded
(at least [[${AUTO}/wi1.$(FASLEXT)]] and [[${AUTO}/wi2.$(FASLEXT)]]
(which replace compiler functions) {\em must} be autoloaded).
<<environment>>=
TRANOBJS= ${AUTO}/wi1.$(FASLEXT) ${AUTO}/wi2.$(FASLEXT) ${AUTO}/pspad1.$(FASLEXT) \
	  ${AUTO}/pspad2.$(FASLEXT) ${AUTO}/mark.$(FASLEXT) ${AUTO}/nspadaux.$(FASLEXT) \
	  ${AUTO}/def.$(FASLEXT)

autoload_objects += $(TRANOBJS)

@

The {\bf ASCOMP} list contains files used by the {\bf Aldor}
\cite{5} compiler. These files should probably be autoloaded.
<<environment>>=
ASCOMP= hashcode.$(FASLEXT) as.$(FASLEXT) \
	foam_l.$(FASLEXT) axext_l.$(FASLEXT)

@
The {\bf ASAUTO} list contains files used by the {\bf Aldor}
\cite{5} compiler. These files are autoloaded as needed.
<<environment>>=
ASAUTO= ${AUTO}/ax.$(FASLEXT)

autoload_objects += $(ASAUTO)
@

Axiom versions are given as a string of the form:
"Sunday September 21, 2003 at 20:38:05 "
which describe the day, date, and time of the build.
This is used for reporting bugs. It is only partially useful
in identifying which source code was used. Ideally we could create
a tar file of all of the date/time stamps of all of the source files
and use the MD5 hash of that file as the version stamp. Ultimately
though, this would be chasing the elusive "perfect information" idea.

A new variable [[boot::*build-version*]] is set here and used by the
[[yearweek]] function to display the version number of the Axiom build.
This information is set by hand in the top level Makefile.
<<environment>>=
TIMESTAMP=$(axiom_targetdir)/timestamp
YEARWEEK=(progn (setq timestamp "${TIMESTAMP}") (setq boot::*build-version* "${VERSION}") (yearweek))

@
The {\bf .PRECIOUS} setting will keep make from deleting these
images if the build is stopped. Since once they are built they
are likely to be useable we don't need to redo the work if they
exist.
<<environment>>=

.PRECIOUS:	${DEPSYS}
.PRECIOUS:	${SAVESYS}
.PRECIOUS:	${AXIOMSYS}

@

\section{Codes from Pamphlets}

As noted earlier, the Boot codes are first extrated from the pamphlet
files:
<<extract source codes>>=
.PRECIOUS: %.boot
%.boot: $(srcdir)/%.boot.pamphlet
	$(axiom_build_document) --tangle --output=$@ $<
@

The extracted Boot codes are then fed into [[bootsys]] which translates
them into Common Lisp codes:
<<extract source codes>>=
.PRECIOUS: %.clisp
%.clisp: %.boot
	$(BOOT_TO_LISP)
@

The resulting Common Lips codes are, in turn, compiled to object codes
using the [[depsys]] image.
<<extract source codes>>=
.PRECIOUS: %.$(FASLEXT)
%.$(FASLEXT): %.clisp
	$(COMPILE_LISP)
@

Part of the interpreter is written directly in Common Lisp (instead of the
sugared dialect Boot).  That part is extracted from the pamphlet files
and compiled to native object code, as usual.
<<extract source codes>>=
# Extract and compile the part of the interpreter written
# in Common Lisp
.PRECIOUS: %.lisp
%.$(FASLEXT): %.lisp
	$(COMPILE_LISP)

%.lisp: $(srcdir)/%.lisp.pamphlet
	$(axiom_build_document) --tangle --output=$@ $<
@

\section{Proclaim optimization}
GCL, and possibly other common lisps, can generate much better
code if the function argument types and return values are proclaimed.

In theory what we should do is scan all of the functions in the system
and create a file of proclaim definitions. These proclaim definitions
should be loaded into the image before we do any compiles so they can
allow the compiler to optimize function calling.

GCL has an approximation to this scanning which we use here.

The first step is to build a version of GCL that includes [[gcl_collectfn]].
This file contains code that enhances the lisp compiler and creates a
hash table of structs. Each struct in the hash table describes information
that about the types of the function being compiled and the types of its
arguments. At the end of the compile-file this hash table is written out
to a ".fn" file.

The second step is to build axiom images (depsys, interpsys, AXIOMsys)
which contain the [[gcl_collectfn]] code.

The third step is to build the system. This generates a .fn file for
each lisp file that gets compiled.

The fourth step is to build the proclaims.lisp files. There is one
proclaims.lisp file for
boot (boot-proclaims.lisp),
interp (interp-proclaims.lisp), and
algebra (algebra-proclaims.lisp).

To build the proclaims file (e.g. for interp) we:
\begin{verbatim}
(a) cd to src/interp
(b) (yourpath)/axiom/obj/linux/bin/lisp
(c) (load "sys-pkg.lsp")
(d) (mapcar #'load (directory "*.fn"))
(e) (with-open-file (out "interp-proclaims.lisp" :direction :output)
      (compiler::make-proclaims out))
\end{verbatim}
Note that step (c) is only used for interp, not for boot.

The fifth step is to copy the newly constructed proclaims file back
into the src/interp diretory (or boot, algebra).

In order for this information to be used during compiles we define
<<environment>>=
PROCLAIMS=(progn (load "sys-pkg.lisp") (load "$(srcdir)/interp-proclaims.lisp"))

@

\section{The warm.data file}

This is a file of commands that will be loaded into interpsys
at the last minute. It execute functions that will likely be
used in a running system so all of the required routines will
be in the lisp image thus minimizing their startup time.
<<warm.data.stanza>>=
../algebra/warm.data: $(srcdir)/Makefile.pamphlet
	@ echo 2 building warm.data
	$(axiom_build_document) --tangle=warm.data --output=$@ $<

@

\section{UNUSED}

These files were in the interp distribution from NAG but have
no purpose at the moment. This belief is no doubt due to my
lack of understanding. Rather than erase them they are documented
here for future reference. [[${DOC}/nag-e02a.boot.dvi]] and
[[${DOC}/nag-e02b.boot.dvi]] appear to be two halfs of the file
[[${DOC}/nag-e02.boot.dvi]] and have been removed.
<<environment>>=
UNUSED= ${DOC}/anna.boot.dvi ${DOC}/construc.lisp.dvi \
	${DOC}/domain.lisp.dvi 	${DOC}/guess.boot.dvi \
	${DOC}/interp-fix.boot.dvi \
	${DOC}/pf2atree.boot.dvi \
	${DOC}/redefs.boot.dvi 	${DOC}/word.boot.dvi

@

\section{Building DEPSYS}

\begin{verbatim}
NOTES: depsys proceeds all else. it is the compile-time environment
for all interpreter code.
:oldboot is pushed on the features list because there is a function
in util.lisp that emulates the new boot parser command BOOTTOCL. since
we eventually plan to move to the new boot parser this function (and
the push should disappear.
the load of postpar and parse (without extensions) allows the .${LISP} form
to be loaded in a virgin system. however, if depsys is recreated then
the compiled form will get loaded.
\end{verbatim}

\subsection{save depsys image}

Once the appropriate commands are in the [[makedep.lisp]] file
we can load the file into a fresh image and save it. At least that's
how it used to work. In freebsd we cannot do this so we have to use
a much more complicated procedure.
This code used to read:
\begin{verbatim}
	@ echo '(progn (load "makedep.lisp") (spad-save "$(BASE)$@"))' \
               | ${LISPSYS}
\end{verbatim}

Now game is much more difficult.
\begin{verbatim}

 '(progn \

\end{verbatim}

[[si::*collect-binary-modules*]] instructs GCL to build a list of
binary object modules loaded into the current session with (load ...)
The list will be stored in [[si::*binary-modules*]].
\begin{verbatim}

	       (setq si::*collect-binary-modules* t) \
	       (load "makedep.lisp") \

\end{verbatim}

[[compiler::link]] is a lisp interface to the ``ld'' C-based system linker.
The first argumet is a list of [[.o]] binary object modules to link into a
fresh gcl image. The second argument is the name of the new output
image.  The third argument is a string containing an initialization
command to run in the new image to reinitialize the heap.  The fourth
argument is a list of external C libraries, either static or dynamic,
that one wishes to link into the fresh image.  The last argument is a
flag which indicates whether GCL should initialize all of the freshly
linked in new lisp modules, or whether it should transparently
redirect load calls in the new image to initialization calls for the
already linked in module.

Some lisp systems, such as acl2, have a complex heap initialization,
in which load calls must be interspersed with other form evaluation
comprising the logic of the heap construction.  Others, such as
maxima, have no such complex initialization sequence.
\begin{verbatim}

	       (compiler::link \

\end{verbatim}
[[si::*binary-modules*]] here has the list of compiled lisp binary module
.o files loaded by makedep.lsp above.
\begin{verbatim}

				 (remove-duplicates si::*binary-modules* :test (quote equal)) \

\end{verbatim}

The name of the output image.
\begin{verbatim}

				 "$(DEPSYS)" \

\end{verbatim}

This will be run in the newly linked sub-image.
\begin{verbatim}

				 (format nil "\

\end{verbatim}

Collect loaded binary modules again to make sure that there are none,
as all should be already linked in via ld.  For error checking
purposes.
\begin{verbatim}

(setq si::*collect-binary-modules* t) \

\end{verbatim}

We need to find [[gcl_collectfn.lsp]], so set the [[*load-path*]], and make
sure the source, not the binary, form is loaded here, as we're only
using this entire sequence on machines which cannot load binary object
modules and preserve them in saved images.
\begin{verbatim}

(let ((si::*load-path* (cons ~S si::*load-path*))\
                                     (si::*load-types* ~S))\

\end{verbatim}

Turn on function analyzation and autoload thereby [[gcl_collectfn.lsp]].
\begin{verbatim}

(compiler::emit-fn t))\

\end{verbatim}

Load the heap creation sequence again in the fresh new image, this
time transparently redirecting all calls to load of binary modules
invoked thereby into initialization calls for the already linkned in
module.

Load has code in it to recognize when a module is already linked in,
and to forgo in this case the actual load and replace with a mere
initialization call instead.
\begin{verbatim}

(load \"makedep.lisp\")\

(gbc t)\

\end{verbatim}

It is an error to load a binary module. Calling load will not
reload them but only run initialization.
Throw an error if we've actually loaded any binary modules.
\begin{verbatim}

(when si::*binary-modules* \
(error si::*binary-modules*))\

\end{verbatim}

Unset the binary module collection flags.
\begin{verbatim}

(setq si::collect-binary-modules* nil si::*binary-modules* nil)\
(gbc t)\

\end{verbatim}

Turn on SGC (Stratified Garbage Collection) in the final image.  This
is a optional gbc algorithm which is suitable for images which will
not grow much further.  It marks a large fraction of the heap
read-only, eliminating such pages from the time-consuming gbc
processing.  When writes are actually made to such pages, a segfault
is triggered which is handled by a function which remarks the pages
read-write and continues.
\begin{verbatim}

(when (fboundp (quote si::sgc-on)) (si::sgc-on t))\

\end{verbatim}

This is a flag which instructs the GCL compiler to make unique
initialzation function C names.  This is necessary when using ld, as
all function names must be unique.
\begin{verbatim}

(setq compiler::*default-system-p* t)\

si::*system-directory* goes into the *load-path*, and .lsp in the *load-types*.

" si::*system-directory* (quote (list ".lsp")))\

\end{verbatim}
No C libraries to link in here.
\begin{verbatim}

"" \

\end{verbatim}

Do not run the initialization code for the newly linked in lisp
modules ``by hand'', but rather rely on the transparent load redirection
described above to initialize at the proper moment in the heap
initialization sequence.
\begin{verbatim}

nil))' | $(LISPSYS))

\end{verbatim}
The [[save depsys image]] was supposed to read:
\begin{verbatim}
	@ ( \
	   echo '(progn \
		(setq si::*collect-binary-modules* t) \
		(load "makedep.lisp") \
		(compiler::link \
			(remove-duplicates si::*binary-modules* :test (quote equal)) \
			"$(DEPSYS)" \
			(format nil "\
				(setq si::*collect-binary-modules* t) \
				(let ((si::*load-path* (cons ~S si::*load-path*))\
					(si::*load-types* ~S))\
					(compiler::emit-fn t))\
				(load \"makedep.lisp\")\
				(gbc t)\
				(when si::*binary-modules* \
					(error si::*binary-modules*))\
				(setq si::collect-binary-modules* nil si::*binary-modules* nil)\
				(gbc t)\
				(when (fboundp (quote si::sgc-on)) (si::sgc-on t))\
				(setq compiler::*default-system-p* t)\
			" si::*system-directory* (quote (list ".lsp")))\
			"" \
			nil))' | $(LISPSYS))
\end{verbatim}

This scheme does not work. It fails during loading with multiple messages
of the form:
\begin{verbatim}
/home/axiom--main--1--patch-33/obj/linux/interp/parse.o(.text+0x5660): In function `init_code':
: multiple definition of `init_code'
/home/axiom--main--1--patch-33/obj/linux/interp/postpar.o(.text+0x4e78): first defined here
\end{verbatim}

<<depsys>>=
depsys_lisp_sources += parsing.lisp metalex.lisp bootlex.lisp \
			newaux.lisp preparse.lisp \
			metameta.lisp fnewmeta.lisp

depsys_boot_sources = postpar parse clam slam \
			g-boot g-util

depsys_SOURCES = $(depsys_lisp_SOURCES) $(depsys_boot_SOURCES)

depsys_objects = nocompil.$(FASLEXT) bookvol5.$(FASLEXT) \
		util.$(FASLEXT) postpar.$(FASLEXT) parse.$(FASLEXT) \
		parsing.$(FASLEXT) metalex.$(FASLEXT) bootlex.$(FASLEXT) \
		newaux.$(FASLEXT) preparse.$(FASLEXT) \
		metameta.$(FASLEXT) fnewmeta.$(FASLEXT) clam.$(FASLEXT) \
		slam.$(FASLEXT) g-boot.$(FASLEXT) \
		g-util.$(FASLEXT)

${DEPSYS}:	${DEP} sys-pkg.lisp nocompil.lisp \
	        bookvol5.lisp util.lisp \
	        parsing.lisp metalex.lisp \
	        bootlex.lisp newaux.lisp \
	        preparse.lisp \
	        def.lisp \
	        metameta.lisp fnewmeta.lisp \
	        $(patsubst %, %.clisp, ${depsys_boot_sources})
	@ echo 3 making ${DEPSYS}
	@ $(mkinstalldirs) $(axiom_build_bindir)
	@ echo '${PROCLAIMS}' > makedep.lisp
	@ echo '(push :oldboot *features*)' >> makedep.lisp
	@ echo '(load "nocompil.lisp")' >> makedep.lisp
	@ echo '(load "bookvol5.lisp")' >> makedep.lisp
	@ echo '(load "util.lisp")' >> makedep.lisp
	@ echo '(in-package "BOOT")' >> makedep.lisp
	@ echo '(build-depsys (quote ($(patsubst %, "%", ${DEP}))) "${AXIOM}" "$(builddir)")' >> makedep.lisp
	@ echo '(unless (probe-file "def.$(FASLEXT)") (compile-file "def.lisp" :output-file "def.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "def")' >> makedep.lisp
	for A in postpar.clisp parse.clisp parsing.lisp metalex.lisp \
	         bootlex.lisp newaux.lisp preparse.lisp def.lisp \
	         metameta.lisp fnewmeta.lisp clam.clisp slam.clisp \
	         g-boot.clisp g-util.clisp; do \
	   B=$${A%.*} ; \
	   echo '(unless (probe-file "'$$B'.$(FASLEXT)")' \
	        '(compile-file "'$$A'" :output-file "'$$B'.$(FASLEXT)"))' \
		  >> makedep.lisp ; \
	  echo '(load "'$$B'")' >> makedep.lisp ; \
	done
	echo '(load "makedep.lisp") (BOOT::spad-save "$(BASE)$@" nil)' | ${LISPSYS}
	@ echo 4 ${DEPSYS} created
@

\section{Building SAVESYS and AXIOMSYS}

GCL likes to tell you when it has replaced a function call by a
tail-recursive call. This happens when the last form in a function
is a call to the same function. In general, we don't care so we set
compiler::*suppress-compiler-notes* to true in order to reduce the noise.

Notice that when Axiom uses GCL as the Lisp platform, it is usually not
a good idea to mess with GCL's internal variables.  In particular, GCL
has its own idea about what to do with [[si::*system-directory*]], which
should not be set here just because we happen to save an GCL-based image.
Doing otherwise causes havoc.

<<savesys>>=
${SAVESYS} ${AXIOMSYS}: makeint.lisp \
    ${DEPSYS} ${OBJS}  bookvol5.$(FASLEXT) util.$(FASLEXT) \
    nocompil.lisp sys-pkg.lisp \
    ${OCOBJS} ${OPOBJS} ${BROBJS} \
    database.date ${INOBJS} ${ASCOMP} ${ASAUTO} \
    ${NAGBROBJS} ${TRANOBJS} \
    ${LOADSYS} \
    $(axiom_targetdir)/algebra/exposed.$(FASLEXT) \
    $(axiom_src_datadir)/doc/msgs/s2-us.msgs \
    ../algebra/warm.data

makeint.lisp:
	@ echo 5 invoking make in `pwd` with parms:
	@ echo LSP= ${LSP}
	@ echo PART= ${PART}
	@ echo SRC= $(axiom_src_srcdir)
	@ echo LISP=${LISP} BYE=${BYE}
	$(mkinstalldirs) $(axiom_target_datadir)/msgs
	$(INSTALL_DATA) $(axiom_src_datadir)/doc/msgs/s2-us.msgs \
		 $(axiom_target_datadir)/msgs
	@ echo '${PROCLAIMS}' > makeint.lisp
	@ echo '(load "nocompil.lisp")' >> makeint.lisp
	@ echo '(load "util")' >> makeint.lisp
	@ echo '(in-package "BOOT")' >> makeint.lisp
	@ touch ${TIMESTAMP}
	@ echo '${YEARWEEK}' >> makeint.lisp
	@ echo '(build-interpsys (append (quote ($(patsubst %, "%", ${OBJS}))) (quote ($(patsubst %, "%", ${ASCOMP}))) (quote ($(patsubst %, "%", ${INOBJS})))) (quote ($(patsubst %, "$(BASE)%", ${OPOBJS}))) (quote ($(patsubst %, "$(BASE)%", ${OCOBJS}))) (quote ($(patsubst %, "$(BASE)%", ${BROBJS}))) (quote ($(patsubst %, "$(BASE)%", ${TRANOBJS}))) (quote ($(patsubst %, "$(BASE)%", ${NAGBROBJS}))) (quote ($(patsubst %, "$(BASE)%", ${ASAUTO})))  "${AXIOM}")' >> makeint.lisp
	@ echo '(in-package "BOOT")' >> makeint.lisp
	@ echo '(load "../algebra/warm.data")' >> makeint.lisp
	@ echo '(|clearClams|)' >> makeint.lisp
	@ echo '#+:akcl (setq compiler::*suppress-compiler-notes* t)' >> makeint.lisp
	@ echo '#+:akcl (si::gbc-time 0)' >> makeint.lisp

${SAVESYS}:
	echo '(load "makeint.lisp") (VMLISP::reclaim)' \
	     '(setf BOOT::|$$createLocalLibDb| nil)' \
	     '(BOOT::spad-save "$(BASE)$@" t)' | ${LISPSYS}
	@ echo 6 ${SAVESYS} created
@

\section{Building SAVESYS and AXIOMSYS}

We want to cache database data in the final image, so we dump it only
after databases are build (triggered from \File{etc/Makefile.pamphlet}).
Note that having dependency on databases is not enough, since databases
are re-generated after leaving \File{interp/} directory.

For [[gcl]] we need to reset [[compiler::*default-system-p*]] to [[nil],
otherwise the dumped image would depend on compiler file [[cmpinclude.h]]
which we do not install.

<<axiomsys>>=
.PHONY: all-axiomsys

all-axiomsys: ${AXIOMSYS}

${AXIOMSYS}:
	echo '(load "makeint.lisp") (VMLISP::reclaim)' \
	   '#+:gcl(setf compiler::*default-system-p* nil)' \
	   '#+:gcl(compiler::emit-fn nil)' \
           '(setq *load-verbose* nil)' \
           '#+:clisp(setf custom:*suppress-check-redefinition* t)' \
	   '(BOOT::spad-save "$(BASE)$@" t)' \
             | DAASE="$(BASE)$(axiom_targetdir)" ${LISPSYS}
	@ echo 6a ${AXIOMSYS} created
@

\section{The Interpreter files}

\subsection{DVI files from pmaphlet files}
<<DVI from pamphlet>>=
.PRECIOUS: $(builddir)/%.tex
.PRECIOUS: $(builddir)/%.dvi

$(DOC):
	$(mkinstalldirs) $@

$(DOC)/%.dvi: $(builddir)/%.dvi
	$(INSTALL_DATA) $< $@

$(builddir)/%.dvi: $(axiom_build_texdir)/axiom.sty

$(builddir)/%.dvi: $(builddir)/%.tex
	$(axiom_build_document) --latex $<

$(builddir)/%.tex: $(srcdir)/%.pamphlet
	$(axiom_build_document) --weave --output=$@ $<

$(axiom_build_texdir)/diagrams.tex: $(axiom_src_docdir)/diagrams.tex
	$(INSTALL_DATA) $< $@
@

\subsection{Regular rules}

Most of rules is very regular, however there are files which need
different handling.  We handle generic case using  pattern rules with
explicit list of files.  All other files are handled by different rules.
We prefer pattern rules here over implicit rules because we do not
want to rules beeing used by accident.

<<Regular rules>>=

AUTO_from_IN=\
 apply bootlex def fnewmeta metalex metameta parsing preparse \
 c-util category \
 c-doc compiler profile define functor info iterator modemap \
 nruncomp package parse postpar bc-matrix bc-misc bc-solve \
 bc-util ht-util htsetvar ht-root htcheck ax br-con br-search \
 br-op1 br-op2 br-data br-util br-saturn topics br-prof nspadaux \
 showimp

$(addprefix $(AUTO)/, $(addsuffix .$(FASLEXT), $(AUTO_from_IN))): \
   $(AUTO)/%.$(FASLEXT) : %.$(FASLEXT)
	cp $< $@

IN_from_MID=\
 apply as ax bc-matrix bc-misc bc-solve bc-util br-con br-data \
 br-op1 br-op2 br-prof br-saturn br-search br-util buildom \
 category cattable c-doc clammed compat compiler compress c-util \
 database define format fortcall functor g-cndata g-error g-opt \
 g-timer hashcode htcheck ht-root htsetvar ht-util hypertex \
 i-analy i-code i-coerce i-coerfn i-eval i-funsel \
 i-intern interop i-map info i-output i-resolv i-spec1 i-spec2 \
 i-syscmd iterator i-toplev i-util lisplib match modemap msgdb \
 newfort \
 nruncomp nrunfast nrungo nruntime nrunopt package pathname \
 profile record rulesets server setvars setvart simpbool \
 template termrw topics trace

$(addsuffix .$(FASLEXT), $(IN_from_MID)): \
    %.$(FASLEXT) : %.clisp
	@ echo 10 making $@ from $<
	echo '(progn  (compile-file "$<" :output-file "$@") (${BYE}))' \
	     | ${DEPSYS}

AUTO_from_MID=\
mark pspad1 pspad2 wi1 wi2

$(addprefix $(AUTO)/, $(addsuffix .$(FASLEXT), $(AUTO_from_MID))): \
    $(AUTO)/%.$(FASLEXT) : %.clisp
	@ echo 10 making $@ from $<
	echo '(progn  (compile-file "$<" :output-file "$(notdir $@)")' \
	     ' (${BYE}))' | ${DEPSYS}
	mv "$(notdir $@)" $@

MID_from_IN=\
 apply as ax bc-matrix bc-misc bc-solve bc-util br-con br-data \
 br-op1 br-op2 br-prof br-saturn br-search br-util buildom \
 category cattable c-doc clammed compat compiler compress c-util \
 database define format fortcall functor g-cndata g-error g-opt \
 g-timer hashcode htcheck ht-root htsetvar ht-util hypertex \
 i-analy i-code i-coerce i-coerfn i-eval i-funsel i-intern \
 interop i-map info i-output i-resolv i-spec1 i-spec2 i-syscmd \
 iterator i-toplev i-util lisplib mark match modemap msgdb \
 newfort nruncomp \
 nrunfast nrungo nruntime nrunopt package pathname profile pspad1 \
 pspad2 record rulesets server setvars setvart simpbool template \
 termrw topics trace wi1 wi2

$(addsuffix .clisp, $(MID_from_IN)): \
    %.clisp : $(srcdir)/%.boot.pamphlet
	@ echo 11 making $@ from $<
	$(axiom_build_document) --tangle --output=$*.boot $<; \
	   echo '(progn (boottran::boottocl "$*.boot") (${BYE}))' | ${DEPSYS}
@

\subsection{newaux.lisp \cite{25}}
<<newaux.o (OUT from MID)>>=
newaux.$(FASLEXT): newaux.lisp
	@ echo 79 making newaux.$(FASLEXT) from newaux.lisp
	echo '(progn  (compile-file "newaux.lisp" :output-file ' \
             '"newaux.$(FASLEXT)") (${BYE}))' | ${DEPSYS}

@
<<newaux.lisp (MID from IN)>>=
newaux.lisp: $(srcdir)/newaux.lisp.pamphlet
	$(axiom_build_document) --tangle --output=$@ $<
@


\subsection{bookvol5.lsp}
<<bookvol5.o (OUT from MID)>>=
bookvol5.$(FASLEXT): bookvol5.lisp
	@ echo 297 making $@ from $<
	echo '(progn  (compile-file "bookvol5.lisp" :output-file' \
	       ' "bookvol5.$(FASLEXT)") (${BYE}))' | ${DEPSYS}

@

<<bookvol5.lisp (MID from IN)>>=
bookvol5.lisp: $(srcdir)/bookvol5.pamphlet
	@ echo 298 making $@ from $<
	$(axiom_build_document) --tangle=Interpreter --output=$@ $<
@


\section{The databases}
\begin{verbatim}
 autoload dependencies

 if you are adding a file which is to be autoloaded the following step
 information is useful:
  there are 2 cases:
   1) adding files to currently autoloaded parts
      (as of 2/92: browser old parser and old compiler)
   2) adding new files
   case 1:
     a) you have to add the file to the list of files currently there
        (e.g. see BROBJS above)
     b) add an autolaod rule
        (e.g. ${AUTO}/parsing.$(FASLEXT): parsing.$(FASLEXT))
     c) edit util.lisp to add the 'external' function (those that
        should trigger the autoload
   case 2:
     build-interpsys (in util.lisp) needs an extra argument for the
     new autoload things and several functions in util.lisp need hacking.

 database.date is a marker file used to force a rebuild of interpsys if the
 database is rebuilt (src/algebra/Makefile).

\end{verbatim}
<<databases>>=
exposed.lsp: $(axiom_src_algdir)/exposed.lsp.pamphlet
	@ echo 615 making $@ from $<
	$(axiom_build_document) --tangle --output=$@ $<

$(axiom_targetdir)/algebra/exposed.$(FASLEXT) : exposed.lsp ${DEPSYS}
	@ echo 616 making $@ from exposed.lsp
	echo '(progn  (compile-file "exposed.lsp" :output-file' \
	      ' "$(BASE)$(axiom_targetdir)/algebra/exposed.$(FASLEXT)") (${BYE}))' \
		| ${DEPSYS}

database.date:
	@ echo 617 the database was updated...remaking interpsys
	touch database.date

@

\section{The Makefile}
<<*>>=

subdir = src/interp/

<<environment>>

.SUFFIXES:
.SUFFIXES: .boot .clisp .lisp .pamphlet

.PHONY: all all-ax all-depsys all-interpsys all-axiomsys

all: all-ax

all-ax: stamp
	@echo finished $(srcdir)

stamp:  $(AUTO) remove-stamp build-images
	$(STAMP) stamp

.PHONY: remove-stamp
remove-stamp:
	-rm -f stamp

.PHONY: build-images
build-images: remove-stamp all-interpsys

all-interpsys: all-depsys
	$(mkinstalldirs) $(AUTO)
	$(MAKE) $(SAVESYS)

all-axiomsys: all-depsys
	$(MAKE) $(AXIOMSYS)

all-depsys: $(DEPSYS)

clean:
	@echo 619 cleaning $(builddir)

<<extract source codes>>

mostlyclean-local:
	rm -f *.fn *.data *.o

clean-local: mostlyclean-local
	rm -f *.clisp *.lsp *.boot
	rm -f \
	axext_l.lisp   def.lisp       metalex.lisp   parsing.lisp \
	spad.lisp      bits.lisp      fname.lisp     metameta.lisp \
	patches.lisp   sys-pkg.lisp   bookvol5.lisp  fnewmeta.lisp \
	monitor.lisp   preparse.lisp  union.lisp     bootfuns.lisp \
	foam_l.lisp    nci.lisp       proclaims.lisp \
	bootlex.lisp   ggreater.lisp  newaux.lisp    property.lisp \
	util.lisp      cfuns.lisp     hash.lisp      nlib.lisp \
	setq.lisp      vmlisp.lisp    comp.lisp      \
	nocompil.lisp  sfsfun-l.lisp  daase.lisp     macros.lisp \
	nspadaux.lisp  sockio.lisp    debug.lisp     makedep.lisp \
	spaderror.lisp

distclean-local: clean-local

<<savesys>>
<<depsys>>
<<axiomsys>>
<<databases>>

<<Regular rules>>

<<bookvol5.o (OUT from MID)>>
<<bookvol5.lisp (MID from IN)>>

<<newaux.o (OUT from MID)>>
<<newaux.lisp (MID from IN)>>

<<warm.data.stanza>>

<<DVI from pamphlet>>

@
\eject
\begin{thebibliography}{99}
\bibitem{1} {\bf \$SPAD/Makefile.pamphlet}
\bibitem{2} {\bf \$SPAD/src/boot/Makefile.pamphlet}
\bibitem{3} {\bf \$SPAD/src/interp/bootfuns.lisp.pamphlet}
\bibitem{4} {\bf \$SPAD/src/interp/setq.lisp.pamphlet}
\bibitem{5} {\bf \$SPAD/src/interp/patches.lisp.pamphlet}
\bibitem{6} {\bf www.aldor.org}
\bibitem{7} {\bf \$SPAD/src/interp/apply.boot.pamphlet}
\bibitem{8} {\bf \$SPAD/src/interp/bits.lisp.pamphlet}
\bibitem{9} {\bf \$SPAD/src/interp/bootlex.lisp.pamphlet}
\bibitem{10} {\bf \$SPAD/src/interp/cfuns.lisp.pamphlet}
\bibitem{11} {\bf \$SPAD/src/interp/comp.lisp.pamphlet}
\bibitem{12} {\bf \$SPAD/src/interp/construc.lisp.pamphlet}
\bibitem{13} {\bf \$SPAD/src/interp/daase.lisp.pamphlet}
\bibitem{14} {\bf \$SPAD/src/interp/debug.lisp.pamphlet}
\bibitem{15} {\bf \$SPAD/src/interp/def.lisp.pamphlet}
\bibitem{16} {\bf \$SPAD/src/interp/fortcall.boot.pamphlet}
\bibitem{17} {\bf \$SPAD/src/interp/fname.lisp.pamphlet}
\bibitem{18} {\bf \$SPAD/src/interp/fnewmeta.lisp.pamphlet}
\bibitem{19} {\bf \$SPAD/src/interp/ggreater.lisp.pamphlet}
\bibitem{20} {\bf \$SPAD/src/interp/hash.lisp.pamphlet}
\bibitem{21} {\bf \$SPAD/src/interp/macros.lisp.pamphlet}
\bibitem{22} {\bf \$SPAD/src/interp/metalex.lisp.pamphlet}
\bibitem{23} {\bf \$SPAD/src/interp/metameta.lisp.pamphlet}
\bibitem{24} {\bf \$SPAD/src/interp/monitor.lisp.pamphlet}
\bibitem{25} {\bf \$SPAD/src/interp/newaux.lisp.pamphlet}
\bibitem{26} {\bf \$SPAD/src/interp/nlib.lisp.pamphlet}
\bibitem{27} {\bf \$SPAD/src/interp/nocompil.lisp.pamphlet}
\bibitem{28} {\bf \$SPAD/src/interp/nspadaux.lisp.pamphlet}
\bibitem{29} {\bf \$SPAD/src/interp/parsing.lisp.pamphlet}
\bibitem{30} {deleted}
\bibitem{31} {\bf \$SPAD/src/interp/preparse.lisp.pamphlet}
\bibitem{32} {\bf \$SPAD/src/interp/property.lisp.pamphlet}
\bibitem{33} {\bf \$SPAD/src/interp/sockio.lisp.pamphlet}
\bibitem{34} {\bf \$SPAD/src/interp/spad.lisp.pamphlet}
\bibitem{35} {\bf \$SPAD/src/interp/spaderror.lisp.pamphlet}
\bibitem{36} {\bf \$SPAD/src/interp/sys-pkg.lisp.pamphlet}
\bibitem{37} {\bf \$SPAD/src/interp/union.lisp.pamphlet}
\bibitem{38} {\bf \$SPAD/src/interp/util.lisp.pamphlet}
\bibitem{39} {\bf \$SPAD/src/interp/vmlisp.lisp.pamphlet}
\bibitem{40} {\bf \$SPAD/src/interp/alql.boot.pamphlet}
\bibitem{41} {\bf \$SPAD/src/interp/buildom.boot.pamphlet}
\bibitem{42} {\bf \$SPAD/src/interp/c-util.boot.pamphlet}
\bibitem{43} {\bf \$SPAD/src/interp/nag-c02.boot.pamphlet}
\bibitem{44} {\bf \$SPAD/src/interp/nag-c05.boot.pamphlet}
\bibitem{45} {\bf \$SPAD/src/interp/nag-c06.boot.pamphlet}
\bibitem{46} {\bf \$SPAD/src/interp/nag-d01.boot.pamphlet}
\bibitem{47} {\bf \$SPAD/src/interp/nag-d02.boot.pamphlet}
\bibitem{48} {\bf \$SPAD/src/interp/nag-d03.boot.pamphlet}
\bibitem{49} {\bf \$SPAD/src/interp/nag-e01.boot.pamphlet}
\bibitem{51} {\bf \$SPAD/src/interp/nag-e02.boot.pamphlet}
\bibitem{52} {\bf \$SPAD/src/interp/nag-e04.boot.pamphlet}
\bibitem{53} {\bf \$SPAD/src/interp/nag-f01.boot.pamphlet}
\bibitem{54} {\bf \$SPAD/src/interp/nag-f02.boot.pamphlet}
\bibitem{55} {\bf \$SPAD/src/interp/nag-f04.boot.pamphlet}
\bibitem{56} {\bf \$SPAD/src/interp/nag-f07.boot.pamphlet}
\bibitem{57} {\bf \$SPAD/src/interp/nag-s.boot.pamphlet}
\bibitem{58} {\bf \$SPAD/src/interp/category.boot.pamphlet}
\bibitem{59} {\bf \$SPAD/src/interp/cattable.boot.pamphlet}
\bibitem{60} {\bf \$SPAD/src/interp/c-doc.boot.pamphlet}
\bibitem{61} {\bf \$SPAD/src/interp/clam.boot.pamphlet}
\bibitem{62} {\bf \$SPAD/src/interp/clammed.boot.pamphlet}
\bibitem{63} {\bf \$SPAD/src/interp/compat.boot.pamphlet}
\bibitem{64} {\bf \$SPAD/src/interp/compiler.boot.pamphlet}
\bibitem{65} {\bf \$SPAD/src/interp/profile.boot.pamphlet}
\bibitem{66} {\bf \$SPAD/src/interp/compress.boot.pamphlet}
\bibitem{67} {\bf \$SPAD/src/interp/database.boot.pamphlet}
\end{thebibliography}
\end{document}
