path: root/src/interp/Makefile.pamphlet

%% Oh Emacs, this is a -*- Makefile -*-, so give me tabs.
\documentclass{article}
\usepackage{axiom}

\title{\File{src/interp/Makefile} Pamphlet}
\author{Timothy Daly \and Gabriel Dos~Reis}

\begin{document}
\maketitle

\begin{abstract}
\end{abstract}

\tableofcontents
\eject

\begin{verbatim}
notes for understanding this makefile:
re: postpar.clisp and parse.clisp stanzas: 
NOTE: the .clisp file is copies back into the src directory so that
it is possible to create a new obootsys system from scratch for a 
new platform. parse.clisp needs to be compiled in a depsys.
one thing need to be done to create an obootsys by hand:
  parse and postpar must be loaded along with the depsys files
     into a bare lisp system.
if these two things are done then a obootsys image can be bootstrapped
to a new platform.

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 two are
the traditional {\bf IN}, which is where the source pamphlets are,
and {\bf OUT} which is where we will put the binaries.

In this case the {\bf IN} files are usually written in Boot \cite{2}.
These will be compiled in a \Tool{bootsys} image to translate from
Boot to Common Lisp. 

\subsection{Documentation}

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 [[\$(axiom_target_docdir)/src/interp/]] directory.

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

# Command to translate Boot to Common Lisp
BOOT_TO_LISP = $(BOOTSYS) -- --translate --output=$@ $< 

# Command to translate Common Lisp to native object code
COMPILE_LISP = $(DEPSYS) -- --compile --output=$@ $<
@


\subsection{Autloload}

In order to minimize the size of the OpenAxiom 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 [[$(axiom_targetdir)]] subtree.
<<environment>>=
AUTO=$(axiom_targetdir)/autoload

autoload_objects =

@


\subsection{Initial Lisp image}

We need a raw Lisp image --- running on the build platform ---
that we can use as a base to construct
the other images. This is called {\bf LISPSYS} and is located in the
build platform sub-directory.
<<environment>>=
# Build platform-dependent Lisp image, at the base of other
# derived Lisp images (depsys, interpsys, AXIOMsys)
LISPSYS= $(axiom_build_bindir)/lisp

@

\subsection{Boot translator}

Most of the interpreter is written in the Boot programming language. 
Thus we need a program to translate Boot to Common
Lisp.  That program 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 (on the build platform) by a previous step in the
make process.
<<environment>>=
BOOTSYS= $(axiom_build_bindir)/bootsys    

@

Note also that another translator (built into [[depsys]]) translates
a variant og Boot (called ``old Boot'') to Common Lisp.


\subsection{The old Boot translator}

<<environment>>=
DEPSYS = ./depsys
@

Some of the Common Lisp code we compile uses macros which
are assumed to be available at compile time. The [[DEPSYS]]
image is created to contain the compile time environment
and saved.  Furthermore, it is also used to translate codes written
in ``old Boot'' to Common Lisp.  That translator is in the process of
being phased out in favor of the ``new Boot'' translator found in
\File{src/boot/}.

\subsubsection{Structure of [[depsys]]}

The [[depsys]] image is made of the following Lisp source files

\begin{description}
\item[Interpreted Lisp source files]
  The following files are currently part of [[depsys]] in interpreted
  form.  The exact reasons for that are not well articulated.

  \begin{description}
    \item[\File{nocompil.lisp}]  This file defines obscure functions
    that seem to be there only for obscure reasons.  Most of them are not
    really needed for translating Boot codes.
  
    \item[\File{bookvol5.lisp}]  This file defines functions for
    the Spad interpreter.  None of which seems relevant for translating
    Boot codes to Common Lisp.

    \item[\File{util.lisp}] This file defines various ``system-level''
    helper functions, for building [[depsys]], [[interpsys]], etc.

    \item[\File{vmlisp.lisp}]  This is a collection of various utility
    functions, encapsulations of variabilities of Lisp implementations.
    All those symbols are defined in the package [[VMLISP]].
    It needs some strip down, and possibly have its contents moved
    to the package [[BOOT]].

    \item[\File{ggreater.lisp}]  This file defines various orderings 
    on collections and other aggregates.  Its content is defined in the
    package [[VMLISP]].

    \item[\File{hash.lisp}]  This file defines a ``hash table'' module.
    Its content is defined in package [[VMLISP]].

    \item[\File{union.lisp}]  This file defines functions that
    compute set-theoretic operations (union, difference, intersection, etc.).
    Its content is in package [[VMLISP]].

    \item[\File{nlib.lisp}]  This file defines to work around problems
    with GCL when compiling Spad files.  It is not necessary for
    translating Boot codes to Common Lisp.  Its content is in package
    [[VMLISP]].

    \item[\File{macros.lisp}]  This file collects various helper macros
    and functions for Boot and Spad codes.

    \item[\File{comp.lisp}]  This file defines several functions that
    desugar Boot and Spad codes; in particular, they infer local
    variables from their position in assignment expressions.  Its
    content is defined in package [[BOOT]].

    \item[\File{spaderror.lisp}]  This file defines error handling functions
    that are useful only for Spad codes -- not for translating Boot codes.
    Its content is defined in package [[BOOT]].

    \item[\File{debug.lisp}] This file defines debug utilities for
    essentially Spad codes.  Its content is defined in package [[BOOT]].

    \item[\File{spad.lisp}]  This files defines the entry points for
    processing Spad and Boot codes.  Its content is defined in package
    [[BOOT]].

    \item[\File{bits.lisp}]  This file implements a ``bit vector''
    data type.  Its content is in package [[BOOT]].

    \item[\File{setq.lisp}]  This file defines several global
    variables.  Its content is defined in package [[BOOT]].

    \item[\File{property.lisp}]  This file defines properties of
     Spad and Boot tokens, as well as several constructors.  Its
    content is defined in package [[BOOT]].
 
    \item[\File{unlisp.lisp}]  This file attempts to define interfaces
    to the Operating System, that are not found in strict ANSI 
    Common Lisp (though they may be present as extensions with
    varying spellings.).  Its content is defined in package [[BOOT]].

    \item[\File{foam\_l.lisp}]  This file defines the FOAM functions.
    The packages [[FOAM]] and [[FOAM-USER]] are defined here.
    It is not needed for translating Boot codes to Common Lisp.

    \item[\File{axext\_l.lisp}]  This file defines various macros and
    functions for interoperability between Aldor and OpenAxiom.  Not needed
    for translating Boot codes to Common Lisp.
  \end{description}

\item[Compiled Lisp source files]
  \begin{description}
    \item[\File{parsing.lisp}]
   
    \item[\File{metalex.lisp}]

    \item[\File{bootlex.lisp}]

    \item[\File{newaux.lisp}]

    \item[\File{preparse.lisp}]

    \item[\File{postprop.lisp}]

    \item[\File{def.lisp}]

    \item[\File{fnewmeta.lisp}]
  \end{description}

\item[Compiled Boot source files]
  \begin{description}
    \item[\File{postpar.boot}]

    \item[\File{parse.boot}]

    \item[\File{clam.boot}]

    \item[\File{slam.boot}]

    \item[\File{g-boot.boot}]

    \item[\File{c-util.boot}]

    \item[\File{g-util.boot}]
  \end{description}

\end{description}

%
<<environment>>=
depsys_lisp_compiled_sources += parsing.lisp metalex.lisp bootlex.lisp \
	newaux.lisp preparse.lisp postprop.lisp def.lisp \
	fnewmeta.lisp

depsys_lisp_sources = $(depsys_lisp_noncompiled_sources) \
			$(depsys_lisp_compiled_sources)

depsys_boot_sources = postpar.boot parse.boot clam.boot slam.boot \
	g-boot.boot g-error.boot c-util.boot g-util.boot
@

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=	nlib.lisp	\
	macros.lisp	$(srcdir)/comp.lisp	\
	spaderror.lisp	debug.lisp	\
	spad.lisp	\
	setq.lisp	property.lisp	\
	unlisp.lisp     foam_l.lisp      \
	axext_l.lisp

depsys_lisp_macro_sources = vmlisp.lisp ggreater.lisp hash.lisp \
	union.lisp nlib.lisp macros.lisp	\
	comp.lisp spaderror.lisp debug.lisp \
	spad.lisp bits.lisp setq.lisp property.lisp \
	unlisp.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} (from the build platform), load all 
of the
final executable code and save it out as {\bf SAVESYS}.  This image
is used to bootstrap the Algebra files and generate the
databases.  
The {\bf SAVESYS} image is copied to the [[$(axiom_target_bindir)]]
subdirectory and becomes the axiom executable image.  Technically, that is
not right because the host plaform may not be the same as the build
platform.  However, we don't yet support cross compilation, so that
is alright for the time being.
<<environment>>=
LOADSYS= $(axiom_build_bindir)/lisp$(EXEEXT)
SAVESYS= 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 \Tool{OpenAxiom} interpreter ({\bf SAVESYS}) usually named
\Tool{interpsys}. Most of these files
are translated from Boot to Common Lisp and then 
compiled.  The \File{setq.lisp}
file contains constant initialization code which gains nothing
by being compiled.

\subsection{The Spad interpreter and compiler}

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)	\
	diagnostics.$(FASLEXT)				\
	macros.$(FASLEXT)	\
	unlisp.$(FASLEXT)	setq.$(FASLEXT)	\
	astr.$(FASLEXT)	bits.$(FASLEXT)	\
	alql.$(FASLEXT)	buildom.$(FASLEXT)	\
	cattable.$(FASLEXT)				\
	cformat.$(FASLEXT)	cfuns.$(FASLEXT)	\
	clam.$(FASLEXT)	clammed.$(FASLEXT)	\
	comp.$(FASLEXT)	        foam_l.$(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)	\
	intfile.$(FASLEXT)				\
	lisplib.$(FASLEXT)	macex.$(FASLEXT)	\
	match.$(FASLEXT)				\
	monitor.$(FASLEXT)	msg.$(FASLEXT)		\
	msgdb.$(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.$(FASLEXT)	\
	ptrees.$(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)

interpsys_modules = $(patsubst %.$(FASLEXT), "%", $(OBJS))

AXIOMsys_noncompiled_lisp_sources = nocompil.lisp \
	postprop.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 \
	unlisp.lisp intint.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 \
	intfile.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 \
	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)	\
	setvart.$(FASLEXT)	intint.$(FASLEXT)	\
        xrun.$(FASLEXT)        interop.$(FASLEXT)     \
        patches.$(FASLEXT)

IN_modules = $(patsubst %.$(FASLEXT), "%", $(INOBJS))

@

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}/parse.$(FASLEXT)	${AUTO}/postpar.$(FASLEXT)	\
	${AUTO}/postprop.$(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)	\
        ${AUTO}/xruncomp.$(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 NAGBROBJS} list contains files used to access the 
Numerical Algorithms Group (NAG) fortran libraries. 
These files should probably be autoloaded.
Note that [[${AUTO}/nag-e02a.$(FASLEXT)]] is not included in this
list as it is a subset of [[${AUTO}/nag-e02.$(FASLEXT)]].
<<environment>>=
NAGBROBJS= ${AUTO}/nag-c02.$(FASLEXT)   ${AUTO}/nag-c05.$(FASLEXT) \
           ${AUTO}/nag-c06.$(FASLEXT)   ${AUTO}/nag-d01.$(FASLEXT) \
           ${AUTO}/nag-d02.$(FASLEXT)   ${AUTO}/nag-d03.$(FASLEXT) \
           ${AUTO}/nag-e01.$(FASLEXT)   ${AUTO}/nag-e02.$(FASLEXT) \
           ${AUTO}/nag-e04.$(FASLEXT)   ${AUTO}/nag-f01.$(FASLEXT) \
           ${AUTO}/nag-f02.$(FASLEXT)   ${AUTO}/nag-f04.$(FASLEXT) \
           ${AUTO}/nag-f07.$(FASLEXT)   ${AUTO}/nag-s.$(FASLEXT) 

autoload_objects += $(NAGBROBJS)

@

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)

AS_modules = $(patsubst %.$(FASLEXT), "%", $(ASCOMP))

@

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)
@

OpenAxiom 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 OpenAxiom build.
This information is set by hand in the top level Makefile.
<<environment>>=
TIMESTAMP=$(axiom_targetdir)/timestamp
YEARWEEK=(progn (setq boot::timestamp "${TIMESTAMP}") \
                (setq boot::*build-version* "$(PACKAGE_STRING)") \
                (boot::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 \Tool{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 \Tool{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}

\Tool{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.

\Tool{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 obj/linux/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).

\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=$@ $<

@

<<warm.data>>=
(in-package 'boot)
(setq |$topicHash| (make-hash-table))
(setf (gethash '|basic| |$topicHash|) 2)
(setf (gethash '|algebraic| |$topicHash|) 4)
(setf (gethash '|miscellaneous| |$topicHash|) 13)
(setf (gethash '|extraction| |$topicHash|) 6)
(setf (gethash '|conversion| |$topicHash|) 7)
(setf (gethash '|hidden| |$topicHash|) 3)
(setf (gethash '|extended| |$topicHash|) 1)
(setf (gethash '|destructive| |$topicHash|) 5)
(setf (gethash '|transformation| |$topicHash|) 10)
(setf (gethash '|hyperbolic| |$topicHash|) 12)
(setf (gethash '|construct| |$topicHash|) 9)
(setf (gethash '|predicate| |$topicHash|) 8)
(setf (gethash '|trignometric| |$topicHash|) 11)

@

\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}/nhyper.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. 
[[OLD-BOOT::BOOT]] emulates the new boot parser command [[BOOTTOCL]]. since
we eventually plan to move to the new boot parser this function
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 an initial Lisp image and save it.
In freebsd we cannot do this so we have to use
a much more complicated procedure.
This code used to read:
\begin{verbatim}
<<save depsys image>>=
	../lisp/base-lisp$(EXEEXT) -- --make --output=$@ \
		--load-directory=. makedep.lisp
@
\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}
	@ (cd ${OBJ}/${SYS}/bin ; \
	   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 postprop.lisp \
			fnewmeta.lisp

depsys_boot_sources = postpar.boot parse.boot clam.boot slam.boot \
			g-boot.boot g-error.boot c-util.boot g-util.boot

depsys_SOURCES = $(depsys_lisp_SOURCES) $(depsys_boot_SOURCES)

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


${DEPSYS}:	vmlisp.$(FASLEXT) \
		hash.$(FASLEXT) \
		bits.$(FASLEXT) \
		ggreater.$(FASLEXT) \
		union.$(FASLEXT) \
		boot-pkg.$(FASLEXT) \
		sys-constants.$(FASLEXT) \
		sys-globals.$(FASLEXT) \
		diagnostics.$(FASLEXT) \
		sys-macros.$(FASLEXT) \
		${DEP} \
		nocompil.$(FASLEXT) \
	        bookvol5.$(FASLEXT)\
		util.$(FASLEXT) \
	        postpar.clisp parse.clisp \
	        parsing.lisp metalex.lisp \
	        bootlex.lisp newaux.lisp \
	        preparse.lisp \
	        postprop.lisp def.lisp \
	        fnewmeta.lisp \
		g-error.clisp \
	        g-boot.clisp c-util.${LISP} \
	        g-util.clisp \
	        clam.clisp \
	        slam.clisp
	@ echo 3 making ${DEPSYS} 
	@ rm -f makedep.lisp
	@ $(mkinstalldirs) $(axiom_build_bindir)
	@ echo '(|importModule| "vmlisp")' >> makedep.lisp
	@ echo '(|importModule| "bits")' >> makedep.lisp
	@ echo '(|importModule| "hash")' >> makedep.lisp
	@ echo '(|importModule| "ggreater")' >> makedep.lisp
	@ echo '(|importModule| "union")' >> makedep.lisp
	@ echo '(|importModule| "nocompil")' >> makedep.lisp
	@ echo '(|importModule| "parsing")' >> makedep.lisp
	@ echo '(|importModule| "bookvol5")' >> makedep.lisp
	@ echo '(|importModule| "util")' >> makedep.lisp
	@ echo '(in-package "BOOT")' >> makedep.lisp
	@ echo '(build-depsys (quote ($(patsubst %, "%", ${DEP}))) "${AXIOM}")' >> makedep.lisp
	@ echo '(unless (probe-file "postpar.$(FASLEXT)") (|compileLispFile| "postpar.clisp" "postpar.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "postpar")' >> makedep.lisp
	@ echo '(unless (probe-file "parse.$(FASLEXT)") (|compileLispFile| "parse.clisp" "parse.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "parse")' >> makedep.lisp
	@ echo '(unless (probe-file "metalex.$(FASLEXT)") (|compileLispFile| "$(srcdir)/metalex.lisp" "metalex.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "metalex")' >> makedep.lisp
	@ echo '(unless (probe-file "bootlex.$(FASLEXT)") (|compileLispFile| "$(srcdir)/bootlex.lisp" "bootlex.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "bootlex")' >> makedep.lisp
	@ echo '(unless (probe-file "newaux.$(FASLEXT)") (|compileLispFile| "newaux.lisp" "newaux.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "newaux")' >> makedep.lisp
	@ echo '(unless (probe-file "preparse.$(FASLEXT)") (|compileLispFile| "preparse.lisp" "preparse.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "preparse")' >> makedep.lisp
	@ echo '(unless (probe-file "postprop.$(FASLEXT)") (|compileLispFile| "$(srcdir)/postprop.lisp" "postprop.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "postprop")' >> makedep.lisp
	@ echo '(unless (probe-file "def.$(FASLEXT)") (|compileLispFile| "$(srcdir)/def.lisp" "def.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "def")' >> makedep.lisp
	@ echo '(unless (probe-file "fnewmeta.$(FASLEXT)") (|compileLispFile| "fnewmeta.lisp" "fnewmeta.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "fnewmeta")' >> makedep.lisp
	@ echo '(unless (probe-file "clam.$(FASLEXT)") (|compileLispFile| "clam.clisp" "clam.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "clam")' >> makedep.lisp
	@ echo '(unless (probe-file "slam.$(FASLEXT)") (|compileLispFile| "slam.clisp" "slam.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "slam")' >> makedep.lisp
	@ echo '(unless (probe-file "g-error.$(FASLEXT)") (|compileLispFile| "g-error.clisp" "g-error.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "g-error")' >> makedep.lisp
	@ echo '(unless (probe-file "g-boot.$(FASLEXT)") (|compileLispFile| "g-boot.clisp" "g-boot.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "g-boot")' >> makedep.lisp
	@ echo '(unless (probe-file "c-util.$(FASLEXT)") (|compileLispFile| "c-util.${LISP}" "c-util.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "c-util")' >> makedep.lisp
	@ echo '(unless (probe-file "g-util.$(FASLEXT)") (|compileLispFile| "g-util.clisp" "g-util.$(FASLEXT)"))' >> makedep.lisp
	@ echo '(load "g-util")' >> makedep.lisp
<<save depsys image>>
	@rm $(addsuffix .$(FASLEXT), \
		postpar parse metalex bootlex newaux preparse \
		postprop def fnewmeta clam slam g-error \
		g-boot c-util g-util)
	@ echo 4 ${DEPSYS} created


util.$(FASLEXT): util.lisp parsing.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

parsing.$(FASLEXT): parsing.lisp boot-pkg.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

bookvol5.$(FASLEXT): bookvol5.lisp boot-pkg.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

nocompil.$(FASLEXT): nocompil.lisp boot-pkg.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

sys-macros.$(FASLEXT): sys-macros.lisp diagnostics.$(FASLEXT) \
			union.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

diagnostics.$(FASLEXT): diagnostics.boot sys-constants.$(FASLEXT) \
				sys-globals.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

sys-globals.$(FASLEXT): sys-globals.boot sys-constants.$(FASLEXT) \
				hash.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

sys-constants.$(FASLEXT): sys-constants.boot boot-pkg.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

boot-pkg.$(FASLEXT): boot-pkg.lisp vmlisp.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

hash.$(FASLEXT): hash.lisp vmlisp.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

union.$(FASLEXT): union.lisp vmlisp.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

ggreater.$(FASLEXT): ggreater.lisp vmlisp.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

vmlisp.$(FASLEXT): vmlisp.lisp
	$(BOOTSYS) -- --compile --output=$@ $<

@

\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 OpenAxiom 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>>=
makeint.lisp:	${DEPSYS} ${OBJS} bookvol5.$(FASLEXT) util.$(FASLEXT) \
                nocompil.lisp \
	        ${OUTINTERP} ${OCOBJS} ${OPOBJS} ${BROBJS} obey.$(FASLEXT) \
		database.date ${INOBJS} ${ASCOMP} ${ASAUTO} \
		${NAGBROBJS} ${TRANOBJS} \
	        ${LOADSYS} \
		$(axiom_targetdir)/algebra/exposed.$(FASLEXT) \
		$(axiom_src_docdir)/msgs/s2-us.msgs \
	        ../algebra/warm.data
	@ echo 5 invoking make in `pwd` with parms:
	@rm -f makeint.lisp
	$(mkinstalldirs) $(axiom_target_datadir)/msgs
	$(INSTALL_DATA) $(axiom_src_docdir)/msgs/s2-us.msgs \
		 $(axiom_target_datadir)/msgs
	@ echo '(|importModule| "vmlisp")' >> makeint.lisp
	@ echo '(|importModule| "hash")' >> makeint.lisp
	@ echo '(gbc t)' >> makeint.lisp
	@ echo '(load "nocompil.lisp")' >> makeint.lisp
	@ echo '(|importModule| "bookvol5")' >> makeint.lisp
	@ echo '(|importModule| "util")' >> makeint.lisp
	@ echo '(in-package "BOOT")' >> makeint.lisp
	@ touch ${TIMESTAMP}
	@ echo '${YEARWEEK}' >> makeint.lisp
	@ echo '(boot::build-interpsys (append (quote ($(interpsys_modules))) (quote ($(AS_modules))) (quote ($(IN_modules)))) (quote ($(patsubst %, "%", ${OPOBJS}))) (quote ($(patsubst %, "%", ${OCOBJS}))) (quote ($(patsubst %, "%", ${BROBJS}))) (quote ($(patsubst %, "%", ${TRANOBJS}))) (quote ($(patsubst %, "%", ${NAGBROBJS}))) (quote ($(patsubst %, "%", ${ASAUTO})))  "${AXIOM}")' >> makeint.lisp
	@ echo '(boot::set-restart-hook)' >> makeint.lisp
	@ echo '(in-package "BOOT")' >> makeint.lisp
	@ echo '(load "../algebra/warm.data")' >> makeint.lisp
	@ echo '(boot::|clearClams|)' >> makeint.lisp
	@ echo '(load "obey")' >> makeint.lisp
	@ echo '#+:akcl (setq compiler::*suppress-compiler-notes* t)' >> makeint.lisp
	@ echo '#+:akcl (si::gbc-time 0)' >> makeint.lisp
	@ echo '(gbc t)' >> makeint.lisp

${SAVESYS}: makeint.lisp
	AXIOM="$(AXIOM)" DAASE="$(axiom_src_datadir)" \
		$(LOADSYS) -- --make --output=$@ --main="BOOT::RESTART" \
			 --load-directory=. makeint.lisp
	@ echo 6 ${SAVESYS} created
	$(mkinstalldirs) $(axiom_target_bindir)
@

\section{Building SAVESYS and AXIOMSYS}

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

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

all-axiomsys: ${AXIOMSYS}

${AXIOMSYS}: makeint.lisp
	AXIOM="$(AXIOM)" DAASE="$(axiom_targetdir)" \
		$(LOADSYS) -- --make --output=$@ --main="BOOT::RESTART" \
			--load-directory=. makeint.lisp
	@ echo 6a ${AXIOMSYS} created
@

\section{The Interpreter files}

\subsection{DVI files from pmaphlet files}

<<DVI from pamphlet>>=
$(axiom_build_texdir)/diagrams.tex: $(axiom_src_docdir)/diagrams.tex
	$(INSTALL_DATA) $< $@
@

\subsection{fortcall.boot \cite{16}}

<<fortcall.clisp>>=
fortcall.clisp: fortcall.boot
	@ echo 55 making $@ from $<
	@ echo '(progn (old-boot::boot "fortcall.boot"))' | ${DEPSYS}

@

\subsection{c-util.boot \cite{42}}

Note that the {\bf c-util.boot.pamphlet} file contains both the
original {\bf boot} code and a saved copy of the {\bf c-util.clisp}
code. We need to keep the translated code around so we can bootstrap
the system. In other words, we need this boot code translated so we
can build the boot translator.

{\bf NOTE WELL: IF YOU CHANGE THE BOOT CODE IN C-UTIL.BOOT.PAMPHLET
YOU MUST TRANSLATE THIS CODE TO LISP AND STORE THE RESULTING LISP
CODE BACK INTO THE C-UTIL.BOOT.PAMPHLET FILE. THIS IS NOT AUTOMATED.}
<<c-util.lisp (OUT from IN)>>=
c-util.${LISP}: $(srcdir)/c-util.boot.pamphlet
	@ echo 146 making c-util.${LISP} from $(srcdir)/c-util.boot.pamphlet
	@ rm -f c-util.$(FASLEXT)
	$(axiom_build_document) --tangle=c-util.clisp --output=$@ $<

@
<<c-util.clisp>>=
c-util.clisp: c-util.boot
	@ echo 148 making $@ from $<
	@ echo '(progn (old-boot::boot "c-util.boot"))' | ${DEPSYS}

@

\subsection{nag-c02.boot \cite{43}}

<<nag-c02.clisp>>=
nag-c02.clisp: nag-c02.boot
	@ echo 152 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-c02.boot"))' | ${DEPSYS}

@

\subsection{nag-c05.boot \cite{44}}

<<nag-c05.clisp>>=
nag-c05.clisp: nag-c05.boot
	@ echo 156 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-c05.boot"))' | ${DEPSYS}

@

\subsection{nag-c06.boot \cite{45}}

<<nag-c06.clisp>>=
nag-c06.clisp: nag-c06.boot
	@ echo 160 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-c06.boot"))' | ${DEPSYS}

@

\subsection{nag-d01.boot \cite{46}}

<<nag-d01.clisp>>=
nag-d01.clisp: nag-d01.boot
	@ echo 164 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-d01.boot"))' | ${DEPSYS}

@

\subsection{nag-d02.boot \cite{47}}

<<nag-d02.clisp>>=
nag-d02.clisp: nag-d02.boot
	@ echo 168 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-d02.boot"))' | ${DEPSYS}

@

\subsection{nag-d03.boot \cite{48}}

<<nag-d03.clisp>>=
nag-d03.clisp: nag-d03.boot
	@ echo 172 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-d03.boot"))' | ${DEPSYS}

@

\subsection{nag-e01.boot \cite{49}}

<<nag-e01.clisp>>=
nag-e01.clisp: nag-e01.boot
	@ echo 176 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-e01.boot"))' | ${DEPSYS}

@

\subsection{nag-e02.boot \cite{51}}

<<nag-e02.clisp>>=
nag-e02.clisp: nag-e02.boot
	@ echo 184 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-e02.boot"))' | ${DEPSYS}

@

\subsection{nag-e04.boot \cite{52}}

<<nag-e04.clisp>>=
nag-e04.clisp: nag-e04.boot
	@ echo 188 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-e04.boot"))' | ${DEPSYS}

@

\subsection{nag-f01.boot \cite{53}}

<<nag-f01.clisp>>=
nag-f01.clisp: nag-f01.boot
	@ echo 192 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-f01.boot"))' | ${DEPSYS}

@

\subsection{nag-f02.boot \cite{54}}

<<nag-f02.clisp>>=
nag-f02.clisp: nag-f02.boot
	@ echo 196 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-f02.boot"))' | ${DEPSYS}

@

\subsection{nag-f04.boot \cite{55}}

<<nag-f04.clisp>>=
nag-f04.clisp: nag-f04.boot
	@ echo 200 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-f04.boot"))' | ${DEPSYS}

@

\subsection{nag-f07.boot \cite{56}}

<<nag-f07.clisp>>=
nag-f07.clisp: nag-f07.boot
	@ echo 204 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-f07.boot"))' | ${DEPSYS}

@

\subsection{nag-s.boot \cite{57}}

<<nag-s.clisp>>=
nag-s.clisp: nag-s.boot
	@ echo 208 making $@ from $<
	@ echo '(progn (boot::reroot "${AXIOM}") (old-boot::boot "nag-s.boot"))' | ${DEPSYS}

@

\subsection{category.boot \cite{58}}

<<category.clisp>>=
category.clisp: category.boot
	@ echo 212 making $@ from $<
	@ echo '(progn (old-boot::boot "category.boot"))' | ${DEPSYS} 
@

\subsection{cattable.boot \cite{59}}

<<cattable.clisp>>=
cattable.clisp: cattable.boot
	@ echo 215 making $@ from $<
	@ echo '(progn (old-boot::boot "cattable.boot"))' | ${DEPSYS}
@

\subsection{c-doc.boot \cite{60}}

<<c-doc.clisp>>=
c-doc.clisp: c-doc.boot
	@ echo 219 making $@ from $<
	@ echo '(progn (old-boot::boot "c-doc.boot"))' | ${DEPSYS} 
@


\subsection{clammed.boot \cite{62}}

<<clammed.clisp>>=
clammed.clisp: clammed.boot
	@ echo 226 making $@ from $<
	@ echo '(progn (old-boot::boot "clammed.boot"))' | ${DEPSYS} 
@

\subsection{compat.boot \cite{63}}

<<compat.clisp>>=
compat.clisp: compat.boot
	@ echo 229 making $@ from $<
	@ echo '(progn (old-boot::boot "compat.boot"))' | ${DEPSYS} 
@

\subsection{compiler.boot \cite{64}}

<<compiler.clisp>>=
compiler.clisp: compiler.boot
	@ echo 233 making $@ from $<
	@ echo '(progn (old-boot::boot "compiler.boot"))' | ${DEPSYS}
@

\subsection{profile.boot \cite{65}}

<<profile.clisp>>=
profile.clisp: profile.boot
	@ echo 237 making $@ from $<
	@ echo '(progn (old-boot::boot "profile.boot"))' | ${DEPSYS}
@

\subsection{database.boot \cite{67}}

<<database.clisp>>=
database.clisp: database.boot
	@ echo 243 making $@ from $<
	@ echo '(progn (old-boot::boot "database.boot"))' | ${DEPSYS}
@

\subsection{define.boot}

<<define.clisp>>=
define.clisp: define.boot
	@ echo 247 making $@ from $<
	@ echo '(progn (old-boot::boot "define.boot"))' | ${DEPSYS}
@

\subsection{format.boot}

<<format.clisp>>=
format.clisp: format.boot
	@ echo 250 making $@ from $<
	@ echo '(progn (old-boot::boot "format.boot"))' | ${DEPSYS}
@

\subsection{functor.boot}

<<functor.clisp>>=
functor.clisp: functor.boot
	@ echo 254 making $@ from $<
	@ echo '(progn (old-boot::boot "functor.boot"))' | ${DEPSYS}
@

\subsection{g-cndata.boot}

<<g-cndata.clisp>>=
g-cndata.clisp: g-cndata.boot
	@ echo 261 making $@ from $<
	@ echo '(progn (old-boot::boot "g-cndata.boot"))' | ${DEPSYS}
@

\subsection{g-opt.boot}

<<g-opt.clisp>>=
g-opt.clisp: g-opt.boot
	@ echo 267 making $@ from $<
	@ echo '(progn (old-boot::boot "g-opt.boot"))' | ${DEPSYS}
@

\subsection{g-timer.boot}

<<g-timer.clisp>>=
g-timer.clisp: g-timer.boot
	@ echo 270 making $@ from $<
	@ echo '(progn (old-boot::boot "g-timer.boot"))' | ${DEPSYS}
@


\subsection{hypertex.boot}

<<hypertex.clisp>>=
hypertex.clisp: hypertex.boot
	@ echo 277 making $@ from $<
	@ echo '(progn (old-boot::boot "hypertex.boot"))' | ${DEPSYS}
@

\subsection{i-analy.boot}

<<i-analy.clisp>>=
i-analy.clisp: i-analy.boot
	@ echo 280 making $@ from $<
	@ echo '(progn (old-boot::boot "i-analy.boot"))' | ${DEPSYS}
@

\subsection{i-code.boot}

<<i-code.clisp>>=
i-code.clisp: i-code.boot
	@ echo 283 making $@ from $<
	@ echo '(progn (old-boot::boot "i-code.boot"))' | ${DEPSYS}
@

\subsection{i-coerce.boot}

<<i-coerce.clisp>>=
i-coerce.clisp: i-coerce.boot
	@ echo 286 making $@ from $<
	@ echo '(progn (old-boot::boot "i-coerce.boot"))' | ${DEPSYS}
@

\subsection{i-coerfn.boot}

<<i-coerfn.clisp>>=
i-coerfn.clisp: i-coerfn.boot
	@ echo 289 making $@ from $<
	@ echo '(progn (old-boot::boot "i-coerfn.boot"))' | ${DEPSYS}
@

\subsection{i-eval.boot}

<<i-eval.clisp>>=
i-eval.clisp: i-eval.boot
	@ echo 292 making $@ from $<
	@ echo '(progn (old-boot::boot "i-eval.boot"))' | ${DEPSYS}
@

\subsection{i-funsel.boot}

<<i-funsel.clisp>>=
i-funsel.clisp: i-funsel.boot
	@ echo 295 making $@ from $<
	@ echo '(progn (old-boot::boot "i-funsel.boot"))' | ${DEPSYS}
@

\subsection{bookvol5.lsp}


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

\subsection{i-intern.boot}

<<i-intern.clisp>>=
i-intern.clisp: i-intern.boot
	@ echo 301 making $@ from $<
	@ echo '(progn (old-boot::boot "i-intern.boot"))' | ${DEPSYS}
@

\subsection{i-map.boot}

<<i-map.clisp>>=
i-map.clisp: i-map.boot
	@ echo 304 making $@ from $<
	@ echo '(progn (old-boot::boot "i-map.boot"))' | ${DEPSYS} 
@

\subsection{i-resolv.boot}

<<i-resolv.clisp>>=
i-resolv.clisp: i-resolv.boot
	@ echo 310 making $@ from $<
	@ echo '(progn (old-boot::boot "i-resolv.boot"))' | ${DEPSYS}
@

\subsection{i-spec1.boot}

<<i-spec1.clisp>>=
i-spec1.clisp: i-spec1.boot
	@ echo 313 making $@ from $<
	@ echo '(progn (old-boot::boot "i-spec1.boot"))' | ${DEPSYS}
@

\subsection{i-spec2.boot}

<<i-spec2.clisp>>=
i-spec2.clisp: i-spec2.boot
	@ echo 316 making $@ from i-spec2.boot
	@ echo '(progn (old-boot::boot "i-spec2.boot"))' | ${DEPSYS} 
@

\subsection{i-syscmd.boot}

<<i-syscmd.clisp>>=
i-syscmd.clisp: i-syscmd.boot
	@ echo 319 making $@ from $<
	@ echo '(progn (old-boot::boot "i-syscmd.boot"))' | ${DEPSYS}
@

\subsection{i-toplev.boot}

<<i-toplev.clisp>>=
i-toplev.clisp: i-toplev.boot
	@ echo 322 making $@ from $<
	@ echo '(progn (old-boot::boot "i-toplev.boot"))' | ${DEPSYS}
@

\subsection{i-util.boot}

<<i-util.clisp>>=
i-util.clisp: i-util.boot
	@ echo 325 making $@ from $<
	@ echo '(progn (old-boot::boot "i-util.boot"))' | ${DEPSYS}
@

\subsection{info.boot}

<<info.clisp>>=
info.clisp: info.boot
	@ echo 329 making $@ from $<
	@ echo '(progn (old-boot::boot "info.boot"))' | ${DEPSYS}
@

\subsection{iterator.boot}

<<iterator.clisp>>=
iterator.clisp: iterator.boot
	@ echo 333 making $@ from $<
	@ echo '(progn (old-boot::boot "iterator.boot"))' | ${DEPSYS}
@

\subsection{lisplib.boot}

<<lisplib.clisp>>=
lisplib.clisp: lisplib.boot
	@ echo 336 making $@ from $<
	@ echo '(progn (old-boot::boot "lisplib.boot"))' | ${DEPSYS}
@

\subsection{match.boot}

<<match.clisp>>=
match.clisp: match.boot
	@ echo 339 making $@ from $<
	@ echo '(progn (old-boot::boot "match.boot"))' | ${DEPSYS}
@

\subsection{modemap.boot}

<<modemap.clisp>>=
modemap.clisp: modemap.boot
	@ echo 343 making $@ from $<
	@ echo '(progn (old-boot::boot "modemap.boot"))' | ${DEPSYS}
@

\subsection{msgdb.boot}

<<msgdb.clisp>>=
msgdb.clisp: msgdb.boot
	@ echo 346 making $@ from $<
	@ echo '(progn (old-boot::boot "msgdb.boot"))' | ${DEPSYS}
@

\subsection{newfort.boot}

<<newfort.clisp>>=
newfort.clisp: newfort.boot
	@ echo 349 making $@ from $<
	@ echo '(progn (old-boot::boot "newfort.boot"))' | ${DEPSYS}
@

\subsection{nruncomp.boot}

<<nruncomp.clisp>>=
nruncomp.clisp: nruncomp.boot
	@ echo 353 making $@ from $<
	@ echo '(progn (old-boot::boot "nruncomp.boot"))' | ${DEPSYS}
@

\subsection{nrunfast.boot}

<<nrunfast.clisp>>=
nrunfast.clisp: nrunfast.boot
	@ echo 356 making $@ from $<
	@ echo '(progn (old-boot::boot "nrunfast.boot"))' | ${DEPSYS}
@

\subsection{nrungo.boot}

<<nrungo.clisp>>=
nrungo.clisp: nrungo.boot
	@ echo 359 making $@ from $<
	@ echo '(progn (old-boot::boot "nrungo.boot"))' | ${DEPSYS}
@

\subsection{nruntime.boot}

<<nruntime.clisp>>=
nruntime.clisp: nruntime.boot
	@ echo 362 making $@ from $<
	@ echo '(progn (old-boot::boot "nruntime.boot"))' | ${DEPSYS}
@

\subsection{nrunopt.boot}

<<nrunopt.clisp>>=
nrunopt.clisp: nrunopt.boot
	@ echo 365 making $@ from $<
	@ echo '(progn (old-boot::boot "nrunopt.boot"))' | ${DEPSYS}
@


\subsection{pathname.boot}

\begin{verbatim}
NOTE: the .clisp file is copies back into the src directory so that
it is possible to create a new obootsys system from scratch for a 
new platform. parse.clisp needs to be compiled in a depsys.
One thing need to be done to create an obootsys by hand:
  parse and postpar must be loaded along with the depsys files
     into a bare lisp system.
if these two things are done then a obootsys image can be bootstrapped
to a new platform.
\end{verbatim}
<<pathname.clisp>>=
pathname.clisp: pathname.boot
	@ echo 380 making $@ from $<
	@ echo '(progn (old-boot::boot "pathname.boot"))' | ${DEPSYS}
@

\subsection{postpar.boot}

\begin{verbatim}
NOTE: One thing need to be done to create an DEPSYS by hand:
  parse and postpar must be loaded along with the depsys files
     into a bare lisp system.
if these two things are done then a DEPSYS image can be bootstrapped
to a new platform.
\end{verbatim}

\subsection{rulesets.boot}

<<rulesets.clisp>>=
rulesets.clisp: rulesets.boot
	@ echo 388 making $@ from $<
	@ echo '(progn (old-boot::boot "rulesets.boot"))' | ${DEPSYS}
@

\subsection{server.boot}

<<server.clisp>>=
server.clisp: server.boot
	@ echo 391 making $@ from $<
	@ echo '(progn (old-boot::boot "server.boot"))' | ${DEPSYS}
@


\subsection{setvart.boot}

<<setvart.clisp>>=
setvart.clisp: setvart.boot
	@ echo 398 making $@ from $<
	@ echo '(progn (old-boot::boot "setvart.boot"))' | ${DEPSYS}
@

\subsection{as.boot}

<<as.clisp>>=
as.clisp: as.boot
	@ echo 417 making $@ from $<
	@ echo '(progn (old-boot::boot "as.boot"))' | ${DEPSYS}
@

\subsection{bc-matrix.boot}

<<bc-matrix.clisp>>=
bc-matrix.clisp: bc-matrix.boot
	@ echo 424 making $@ from $<
	@ echo '(progn (old-boot::boot "bc-matrix.boot"))' | ${DEPSYS}
@

\subsection{bc-misc.boot}

<<bc-misc.clisp>>=
bc-misc.clisp: bc-misc.boot
	@ echo 428 making $@ from $<
	@ echo '(progn (old-boot::boot "bc-misc.boot"))' | ${DEPSYS}
@

\subsection{bc-solve.boot}

<<bc-solve.clisp>>=
bc-solve.clisp: bc-solve.boot
	@ echo 432 making $@ from $<
	@ echo '(progn (old-boot::boot "bc-solve.boot"))' | ${DEPSYS}
@

\subsection{bc-util.boot}

<<bc-util.clisp>>=
bc-util.clisp: bc-util.boot
	@ echo 436 making $@ from $<
	@ echo '(progn (old-boot::boot "bc-util.boot"))' | ${DEPSYS}
@

\subsection{ht-util.boot}

<<ht-util.clisp>>=
ht-util.clisp: ht-util.boot
	@ echo 440 making $@ from $<
	@ echo '(progn (old-boot::boot "ht-util.boot"))' | ${DEPSYS}
@

\subsection{htsetvar.boot}

<<htsetvar.clisp>>=
htsetvar.clisp: htsetvar.boot
	@ echo 444 making $@ from $<
	@ echo '(progn (old-boot::boot "htsetvar.boot"))' | ${DEPSYS}
@

\subsection{record.boot}

<<record.clisp>>=
record.clisp: record.boot
	@ echo 447 making $@ $<
	@ echo '(progn (old-boot::boot "record.boot"))' | ${DEPSYS}
@

\subsection{ht-root.boot}

<<ht-root.clisp>>=
ht-root.clisp: ht-root.boot
	@ echo 451 making $@ from $<
	@ echo '(progn (old-boot::boot "ht-root.boot"))' | ${DEPSYS}
@

\subsection{htcheck.boot}

<<htcheck.clisp>>=
htcheck.clisp: htcheck.boot
	@ echo 455 making $@ from $<
	@ echo '(progn (old-boot::boot "htcheck.boot"))' | ${DEPSYS}
@

\subsection{ax.boot}

<<ax.clisp>>=
ax.clisp: ax.boot
	@ echo 463 making $@ $<
	@ echo '(progn (old-boot::boot "ax.boot"))' | ${DEPSYS} 
@

\subsection{br-con.boot}

<<br-con.clisp>>=
br-con.clisp: br-con.boot
	@ echo 467 making $@ from $<
	@ echo '(progn (old-boot::boot "br-con.boot"))' | ${DEPSYS} 
@

\subsection{br-search.boot}

<<br-search.clisp>>=
br-search.clisp: br-search.boot
	@ echo 471 making $@ from $<
	@ echo '(progn (old-boot::boot "br-search.boot"))' | ${DEPSYS} 
@

\subsection{br-op1.boot}

<<br-op1.clisp>>=
br-op1.clisp: br-op1.boot
	@ echo 475 making $@ from $<
	@ echo '(progn (old-boot::boot "br-op1.boot"))' | ${DEPSYS}
@

\subsection{br-op2.boot}

<<br-op2.clisp>>=
br-op2.clisp: br-op2.boot
	@ echo 479 making $@ from $<
	@ echo '(progn (old-boot::boot "br-op2.boot"))' | ${DEPSYS} 
@

\subsection{br-data.boot}

<<br-data.clisp>>=
br-data.clisp: br-data.boot
	@ echo 483 making $@ from $<
	@ echo '(progn (old-boot::boot "br-data.boot"))' | ${DEPSYS} 
@

\subsection{br-util.boot}

<<br-util.clisp>>=
br-util.clisp: br-util.boot
	@ echo 487 making $@ from $<
	@ echo '(progn (old-boot::boot "br-util.boot"))' | ${DEPSYS}
@

\subsection{br-saturn.boot}

<<br-saturn.clisp>>=
br-saturn.clisp: br-saturn.boot
	@ echo 491 making $@ from $<
	@ echo '(progn (old-boot::boot "br-saturn.boot"))' | ${DEPSYS}
@

\subsection{br-prof.boot}

<<br-prof.clisp>>=
br-prof.clisp: br-prof.boot
	@ echo 499 making $@ from $<
	@ ($(axiom_build_document) --tangle --output=br-prof.boot $< ;\
	  echo '(progn (old-boot::boot "br-prof.boot"))' | ${DEPSYS}; \
	  rm br-prof.boot )

@

\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 exposed.lsp from $(axiom_src_algdir)/exposed.lsp.pamphlet
	$(axiom_build_document) --tangle --output=$@ $<

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

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)

<<extract source codes>>

mostlyclean-local:
	@rm -f *.fn *.data *.$(FASLEXT) *.lib

clean-local: mostlyclean-local
	@rm -f *.clisp *.lsp

distclean-local: clean-local

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

## Copy FASLs that are autoloaded to the autoload directory.
.PREVIOUS: $(AUTO)/%.$(FASLEXT)

$(AUTO)/%.$(FASLEXT): %.$(FASLEXT)
	$(INSTALL) $< $@

##
## OpenAxiom's front-end consists of two parts:
##    (a) the interprerter's parser -- also referred to as new parser
##    (b) the compiler parser -- also referred to as parser
##
## The new parser component is always included in a running OpenAxiom
## image.  However the old parser component is so called `autoloaded'.
## While in theory that should work, in practice it turns out that 
## people tend to override functions in the autoload part, correcting
## bugs only there.  The consequence is that the same function will
## bahave very differently based on the history of the seesion.  Ideal
## recipe for creating heisenbugs.
##
## The new parser component roughtly is:
##   astr.boot dq.boot incl.boot pile.boot ptrees.boot
##   posit.boot cparse.boot format.boot cstream.boot
##

cparse.$(FASLEXT): cparse.clisp ptrees.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

ptrees.$(FASLEXT): ptrees.clisp posit.$(FASLEXT) serror.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

pile.$(FASLEXT): pile.clisp scan.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

scan.$(FASLEXT): scan.clisp incl.$(FASLEXT) bits.$(FASLEXT) dq.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

incl.$(FASLEXT): incl.clisp cstream.$(FASLEXT) cformat.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

cformat.$(FASLEXT): cformat.clisp unlisp.$(FASLEXT) posit.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

serror.$(FASLEXT): serror.boot posit.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

unlisp.$(FASLEXT): unlisp.lisp sys-macros.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

posit.$(FASLEXT): posit.clisp sys-macros.$(FASLEXT) astr.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

cstream.$(FASLEXT): cstream.clisp sys-macros.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

astr.$(FASLEXT): astr.clisp boot-pkg.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

bits.$(FASLEXT): bits.lisp boot-pkg.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

dq.$(FASLEXT): dq.boot boot-pkg.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<

<<as.clisp>>

<<ax.clisp>>

<<bc-matrix.clisp>>

<<bc-misc.clisp>>

<<bc-solve.clisp>>

<<bc-util.clisp>>

<<br-con.clisp>>

<<br-data.clisp>>

<<br-op1.clisp>>

<<br-op2.clisp>>

<<br-prof.clisp>>

<<br-saturn.clisp>>

<<br-search.clisp>>

<<br-util.clisp>>

<<category.clisp>>

<<cattable.clisp>>

<<c-doc.clisp>>

<<clammed.clisp>>

<<compat.clisp>>

<<compiler.clisp>>

<<c-util.lisp (OUT from IN)>>
<<c-util.clisp>>

<<database.clisp>>

<<define.clisp>>

<<format.clisp>>

<<fortcall.clisp>>

<<functor.clisp>>

<<g-cndata.clisp>>

<<g-opt.clisp>>

<<g-timer.clisp>>

<<htcheck.clisp>>

<<ht-root.clisp>>

<<htsetvar.clisp>>

<<ht-util.clisp>>

<<hypertex.clisp>>

<<i-analy.clisp>>

<<i-code.clisp>>

<<i-coerce.clisp>>

<<i-coerfn.clisp>>

<<i-eval.clisp>>

<<i-funsel.clisp>>

<<bookvol5.lisp>>

<<i-intern.clisp>>

<<i-map.clisp>>

<<info.clisp>>

<<i-resolv.clisp>>

<<i-spec1.clisp>>

<<i-spec2.clisp>>

<<i-syscmd.clisp>>

<<iterator.clisp>>

<<i-toplev.clisp>>

<<i-util.clisp>>

<<lisplib.clisp>>

<<match.clisp>>

<<modemap.clisp>>

<<msgdb.clisp>>

<<nag-c02.clisp>>

<<nag-c05.clisp>>

<<nag-c06.clisp>>

<<nag-d01.clisp>>

<<nag-d02.clisp>>

<<nag-d03.clisp>>

<<nag-e01.clisp>>

<<nag-e02.clisp>>

<<nag-e04.clisp>>

<<nag-f01.clisp>>

<<nag-f02.clisp>>

<<nag-f04.clisp>>

<<nag-f07.clisp>>

<<nag-s.clisp>>

<<newfort.clisp>>

<<nruncomp.clisp>>

<<nrunfast.clisp>>

<<nrungo.clisp>>

<<nruntime.clisp>>

<<nrunopt.clisp>>

<<profile.clisp>>

<<record.clisp>>

<<rulesets.clisp>>

<<server.clisp>>

<<setvart.clisp>>

<<warm.data.stanza>>

buildom.$(FASLEXT): buildom.boot sys-macros.$(FASLEXT)
	$(BOOTSYS) -- --compile --output=$@ --load-directory=. $<


<<DVI from pamphlet>>

@

\end{document}