aboutsummaryrefslogtreecommitdiff
path: root/src/lisp/core.lisp.pamphlet
diff options
context:
space:
mode:
Diffstat (limited to 'src/lisp/core.lisp.pamphlet')
-rw-r--r--src/lisp/core.lisp.pamphlet775
1 files changed, 775 insertions, 0 deletions
diff --git a/src/lisp/core.lisp.pamphlet b/src/lisp/core.lisp.pamphlet
new file mode 100644
index 00000000..8c06119d
--- /dev/null
+++ b/src/lisp/core.lisp.pamphlet
@@ -0,0 +1,775 @@
+%% Oh Emacs, this is a -*- Lisp -*- file, despite apperance
+\documentclass{article}
+\usepackage{axiom}
+
+\title{\File{src/lisp/core.lisp} Pamphlet}
+\author{Gabriel Dos~Reis}
+
+\begin{document}
+\maketitle
+
+\begin{abstract}
+ This pamphlet defines the core of the system utilities for building
+ Boot and Axiom executable.. It essentially etablishes a namespace
+ (package \Code{AxiomCore}) and defines some macros and functions
+ that need to be present during during compilation and executable
+ image construction.
+\end{abstract}
+
+\section{The [[AxiomCore]] package}
+
+<<AxiomCore>>=
+(defpackage "AxiomCore"
+ #+:common-lisp (:use "COMMON-LISP")
+ #-:common-lisp (:use "SYSTEM" "LISP" "USER")
+ ;; For GCL we need to explicitly use the DEFPACKAGE, otherwise the
+ ;; image obtained from compiler link will not work. The root cause
+ ;; is a non-ANSI compliant organization of GCL's implementation.
+ #+:gcl (:use "DEFPACKAGE")
+ (:export "quit"
+ "fatalError"
+ "internalError"
+ "error"
+ "errorCount"
+ "countError"
+ "warn"
+ "getCommandLineArguments"
+ "processCommandLine"
+ "handleCommandLine"
+ "$originalLispTopLevel"
+ "link"
+ "installDriver"
+ "associateRequestWithFileType"
+ "ensureTrailingSlash"
+ "getOutputPathname"
+ "loadPathname"
+ "compileLispFile"
+ "compileLispHandler"
+ "Option"
+
+ "IMPORT-MODULE"
+ ))
+
+(in-package "AxiomCore")
+@
+
+\section{Base Lisp system top level entry point}
+
+<<AxiomCore>>=
+;; The top level read-eval-print loop function of the base
+;; Lisp system we are using. This is a very brittle way
+;; of achieving something conceptually simple.
+(defconstant |$originalLispTopLevel|
+ #+:ecl #'si::top-level
+ #+:gcl #'si::top-level
+ #+:sbcl #'sb-impl::toplevel-init
+ #+clisp #'system::main-loop)
+@
+
+\section{File types}
+
+<<AxiomCore>>=
+(defconstant |$LispFileType| "lisp")
+;; Extenstion of FASL files.
+(defconstant |$faslType|
+ (pathname-type (compile-file-pathname "foo.lisp")))
+(defconstant |$BootFileType| "boot")
+(defconstant |$LibraryFileType| "spad")
+(defconstant |$ScriptFileType| "input")
+@
+
+\subsection{File type canonilization}
+
+<<AxiomCore>>=
+(defun |getFileType|(file)
+ (let ((file-type (pathname-type file)))
+ (cond ((or (equal "clisp" file-type)
+ (equal "lsp" file-type))
+ |$LispFileType|)
+ (t file-type))))
+@
+
+\section{Drivers table}
+
+\subsection{The driver table}
+
+<<AxiomCore>>=
+;; Global map from requests to drivers.
+;; Ideally we want to handle
+;; --help: just print a help menu and exit
+;; --version: Print version information and exit
+;; --compile: boot or lisp files
+;; --translate: boot files
+;; --make: boot, lisp, or fasl files
+(defparameter |$driverTable| (make-hash-table :test #'equal :size 5))
+@
+
+\subsection{Obtaining a driver for a request}
+
+<<AxiomCore>>=
+;; Look up the driver that can handle REQUEST. Returns nil when
+;; no driver exists.
+(defun |getDriver| (request)
+ (gethash request |$driverTable|))
+@
+
+\subsection{Installing a driver for a request}
+
+<<AxiomCore>>=
+(defun |installDriver| (request driver)
+ (when (|getDriver| request)
+ (|internalError| "attempt to override driver"))
+ (setf (gethash request |$driverTable|) driver))
+@
+
+<<AxiomCore>>=
+;; Register DRIVER for a REQUEST
+(defun |associateRequestWithFileType| (request file-type driver)
+ ;; If a driver is already installed, it must be non-null.
+ ;; We don't allow overriding at the moment.
+ (let ((key (cons request file-type)))
+ (unless (|useFileType?| request)
+ (setf (get request 'use-file-type) t))
+ (|installDriver| key driver)))
+@
+
+
+\subsection{Making names for options}
+
+<<AxiomCore>>=
+(defun |Option| (msg)
+ (intern msg (find-package "AxiomCore")))
+@
+
+\subsection{Parsing command line options}
+
+<<AxiomCore>>=
+;; Returns a pair (name . value) if OPTION if of the form "--name=value",
+;; where name is a symbol and value is a string. Otherwise, if
+;; OPTION is of the form "--name", returns the symbol name.
+(defun |parseOption| (option)
+ (setq option (subseq option 2))
+ (let ((p (position #\= option)))
+ (if p
+ (cons (|Option| (subseq option 0 p)) (subseq option (1+ p)))
+ (|Option| option))))
+
+;; Returns the value specified for OPTION. Otherwise, return nil
+(defun |getOptionValue| (opt options)
+ (let ((val (assoc opt options)))
+ (cond (val (cdr val))
+ (t nil))))
+
+;; Walk through the command line arguments ARGV, separating options
+;; of the form --opt or --opt=val into an a-list, and the rest
+;; of the command line into a list. The processing stop as soon as
+;; a non-option form is encountered. OPTIONS-SO-FAR accumulates the
+;; the list of processed options.
+(defun |processCommandLine| (argv options-so-far)
+ (if (and argv
+ (equal "--" (subseq (car argv) 0 2)))
+ (let ((option (|parseOption| (car argv))))
+ (cond ((symbolp option)
+ (|processCommandLine| (cdr argv)
+ (cons (cons option t) options-so-far)))
+ ((consp option)
+ (|processCommandLine| (cdr argv) (cons option options-so-far)))
+ (t (|internalError|
+ (format nil "processCommandLine: unknown option ~S"
+ option)))))
+ (values options-so-far argv)))
+@
+
+
+\section{Building new Lisp images}
+
+At many points, the build machinery makes new Lisp images that
+are the results of augmenting a given Lisp image with new
+Lisp files (either compiled or in source form). For most Lisp
+implementations, this is done by loading the Lisp files in the
+current image and dumping the result on disk as an executable.
+
+\subsection{Pathname of output program}
+
+<<AxiomCore>>=
+(defun |getOutputPathname| (options &optional (default-output "a.out"))
+ (let ((output-option (assoc (|Option| "output") options)))
+ (if output-option
+ ;; If an output file name was specified on the command line, it
+ ;; is so relative to the current workding directory. In
+ ;; particular we want to prevent overly zelous SBCL to mess
+ ;; around with the output file when we call compile-file-pathname.
+ ;; The SBCL-specific hack below does not work all the time, but in
+ ;; most cases, it is OK.
+ #+:sbcl (merge-pathnames (cdr output-option)
+ *default-pathname-defaults*)
+ #-:sbcl (cdr output-option)
+ default-output)))
+@
+
+\subsection{User-supplied main entry point}
+
+<<AxiomCore>>=
+(defun |getMainEntryPoint| (options)
+ (|getOptionValue| (|Option| "main") options))
+@
+
+\subsection{Saving Lisp image to disk}
+
+<<AxiomCore>>=
+;; Save current image on disk as executable and quit.
+(defun |saveCore| (core-image &optional (entry-point nil))
+ ;; When building the Axiom system, and in many other cases I suspect,
+ ;; the main entry point is some function in a package not known to
+ ;; the Lisp system at compile time, so we have delayed the
+ ;; evaluation of the entry point in a form of a suspension. At this
+ ;; point we must have all data needed to complete the evaluation.
+ (when (consp entry-point)
+ (setq entry-point (apply (car entry-point)
+ (cdr entry-point))))
+ #+:sbcl (if (null entry-point)
+ (sb-ext::save-lisp-and-die core-image :executable t)
+ (sb-ext::save-lisp-and-die core-image
+ :toplevel entry-point
+ :executable t))
+ #+:gcl (progn
+ (when entry-point
+ (setq si::*top-level-hook* entry-point))
+ (system::save-system core-image))
+ #+:clisp (progn
+ (if entry-point
+ (ext::saveinitmem core-image
+ :init-function entry-point
+ :executable t
+ :norc t
+ )
+ (ext::saveinitmem core-image
+ :executable t
+ :norc t
+ ))
+ (ext::quit))
+ (error "don't know how to save Lisp image"))
+@
+
+\section{Program termination}
+
+
+When working in batch mode, we need to return so-called `exit status'
+to the calling shell. Common Lisp has no provision for that ---
+not even exiting from the toplevel read-eval-print loop. Most
+Lisp implementations provide an `exit' function as extensions, though
+they don't agree on the exact spelling, therefore on the API.
+
+The function [[|quit|]] is our abstractions over those variabilties.
+It takes an optional small integer value, the exit status code to
+return to the calling shell. When no exit status code is specified,
+it would return $0$, meaning that everything is OK.
+
+<<AxiomCore>>=
+(defun |quit| (&optional (status 0))
+ #+:sbcl (sb-ext:quit :unix-status status)
+ #+:clisp (ext:quit status)
+ #+:gcl (quit status)
+ #+:ecl (ext:quit status)
+ #-(or :sbcl :clisp :gcl :ecl)
+ (error "`quit' not implemented for this Lisp"))
+@
+
+
+\section{Basic diagnostic routines}
+
+<<AxiomCore>>=
+;; Basic diagnostic machinery:
+;; For the most basic batch stuff, we want:
+;; (1) fatal error: output message and exit with nonzero status
+;; (2) internal error: same. This is for use on reporting internal
+;; consistency error.
+(defun |diagnosticMessage|(prefix msg)
+ (let ((text (concatenate 'string prefix ": " msg)))
+ (write-line text *error-output*)))
+
+;; Keep count of number of hard errors.
+(defparameter |$errorCount| 0)
+
+(defun |errorCount| nil
+ |$errorCount|)
+
+(defun |countError| nil
+ (setq |$errorCount| (1+ |$errorCount|)))
+
+(defun |fatalError| (msg)
+ (|countError|)
+ (|diagnosticMessage| "fatal error" msg)
+ (|quit| 1))
+
+(defun |internalError| (msg)
+ (|countError|)
+ (|diagnosticMessage| "internal error" msg)
+ (|quit| 1))
+
+(defun |error| (msg)
+ (|countError|)
+ (|diagnosticMessage| "error"
+ (cond ((consp msg)
+ (reduce #'(lambda (x y)
+ (concatenate 'string x y))
+ msg :initial-value ""))
+ (t msg))))
+
+(defun |warn| (msg)
+ (|diagnosticMessage| "warning"
+ (cond ((consp msg)
+ (reduce #'(lambda (x y)
+ (concatenate 'string x y))
+ msg :initial-value ""))
+ (t msg))))
+@
+
+
+\section{Command line arguments}
+
+<<AxiomCore>>=
+;; Ideally, we would just like to have a traditional command line
+;; passing mechanism from the shell to the application. That
+;; mechanism works fine with GCL. Some Lisp implementations such as
+;; SBCL or CLISP will insist on processing the command lines. Some
+;; such CLISP will barfle when they hit an option they don't
+;; understand. Which is silly. It seems like the only common ground,
+;; as ever, is to go with the most annoying behaviour and penalize
+;; the good "citizen", sensible, Lisp implementations interfaces.
+;; Consequently, we have standardize on the the following practice:
+;; always issue a double bash (--) after the command line, and afterwards
+;; supply options and other arguments. The double dash has the effect
+;; of disuading the underlying lisp implementation of trying to
+;; process whatever comes after as options.
+
+;; Command line arguments: equivalent of traditional `argv[]' from
+;; systems programming world.
+(defun |getCommandLineArguments| nil
+ #-(or :gcl :sbcl :clisp :ecl)
+ (|fatalError| "don't know how to get command line args")
+ (let* ((all-args
+ #+:ecl (ext:command-args)
+ #+:gcl si::*command-args*
+ #+:sbcl sb-ext::*posix-argv*
+ #+:clisp (coerce (ext::argv) 'list))
+ (args (member "--" all-args :test #'equal)))
+ (cons (car all-args) (if args (cdr args) args))))
+@
+
+
+\section{Program startup}
+
+<<AxiomCore>>=
+;; The top level entry point to most saved Lisp image.
+(defun |main| nil
+ (setq *package* (find-package "BOOT"))
+ ;; Existing system programming practive, and POSIX, have it
+ ;; that the first argument on the command line is the name
+ ;; of the current instantiation of the program.
+ ;; We require at least two arguments:
+ ;; (0) the program name
+ ;; (1) either one of --help or --version, or
+ ;; a filename.
+ (let ((command-args (|getCommandLineArguments|)))
+ (when (null command-args)
+ (|internalError| "empty command line args"))
+ (when (fboundp '|main|)
+ (|quit| (funcall '|main| command-args)))
+
+ ;; Huh, the main entry point was not defined.
+ (|fatalError| "missing definition for main function")
+ (|quit| 1)))
+@
+
+\section{Building standalone executable}
+
+<<AxiomCore>>=
+;; Build a standalone excutable from LISP-FILES -- a list of
+;; pathnames designating compiled source files (either FASLs, for
+;; most Lisp systems, or object files for systems like ECL.)
+;; ENTRY-POINT is the entry point of the program. If not supplied, or
+;; if null, then the entry entry is supposed to be the top level
+;; read-eval-print loop of original Lisp system.
+(defun |link| (core-image lisp-files &optional (entry-point nil))
+ (if (and entry-point (stringp entry-point))
+ (setq entry-point `(read-from-string ,entry-point)))
+ #-:ecl (progn
+ (mapcar #'(lambda (p) (|loadOrElse| p)) lisp-files)
+ (|saveCore| core-image entry-point))
+ #+:ecl (progn
+ (unless entry-point
+ (setq entry-point si::top-level))
+ (c:build-program core-image
+ :lisp-files lisp-files
+ :epilogue-code `(funcall ,entry-point))
+ (|quit|)))
+@
+
+\section{Handling command line arguments}
+
+<<AxiomCore>>=
+(defun |handleRequest| (prog-name request options args)
+ (let ((driver (|getDriver| request)))
+ (when (null driver)
+ (|fatalError| (format nil "invalid option ~S" request)))
+ (funcall driver prog-name options args)))
+@
+
+<<AxiomCore>>=
+(defun |hasHandler?| (request)
+ (|getDriver| request))
+@
+
+<<AxiomCore>>=
+(defun |useFileType?| (request)
+ (get request 'use-file-type))
+@
+
+<<AxiomCore>>=
+(defun |handleCommandLine| (prog-name options args)
+
+ ;; If no argument was specified on command line, then pretend
+ ;; we must act as the underlying Lisp system's REPL. This is hard
+ ;; to do portabl and correctly, for obvious reasons So what follows
+ ;; is an approximation, good enough for now. FIXME: revisit this
+ ;; gorss hack.
+ (unless (or options args)
+ ;; GCL called us through system::*top-level-hook* which we set
+ ;; in a previous life. Now unset it, otherwise, it will call
+ ;; us again, and we will find ourselves in the same place
+ ;; again, again, until death follows.
+ #+:gcl (setq system::*top-level-hook* nil)
+ (funcall |$originalLispTopLevel|))
+
+ (dolist (opt options)
+ (cond ((eq (car opt) (|Option| "help")) ; print help, get out of here
+ (|helpHandler| prog-name))
+
+ ((null args) ; we must have at least one arg
+ (|printUsage| prog-name)
+ (|quit| 1))
+
+ ((|useFileType?| (car opt)) ; process based on file type
+ (dolist (f args)
+ (let* ((file-type (|getFileType| f))
+ (opt-name (car opt))
+ (request (cons opt-name file-type)))
+ (|handleRequest| prog-name request options f))))
+
+ ((stringp (cdr opt)) ; option value
+ (when (|hasHandler?| (car opt))
+ (|handleRequest| prog-name (car opt) options args)))
+
+ (t ; assume we must execute this
+ (|handleRequest| prog-name (car opt) options args)))))
+@
+
+\subsection{The \verb!--help! handler}
+
+<<AxiomCore>>=
+;; Print help screen
+(defun |printUsage|(prog-name)
+ (write-line "usage:")
+ (write-line
+ (concatenate 'string prog-name " -- options [files]"))
+ (write-line "option:")
+ (write-line " --help print this message")
+ (write-line " --compile compile file")
+ (write-line " --output=OUT set output file to OUT")
+ (write-line " --load-directory=DIR use DIR as search path for modules")
+ (write-line " --make create an executable"))
+
+(defun |helpHandler|(prog-name)
+ (|printUsage| prog-name)
+ (|quit|))
+
+(|installDriver| (|Option| "help") #'|helpHandler|)
+@
+
+
+\subsection{The \verb!--make! handler}
+
+<<AxiomCore>>=
+(defun |makeHandler| (prog-name options args)
+ (declare (ignore prog-name))
+ (unless (> (length args) 0)
+ (|fatalError| "--make requires at least one file"))
+
+ (|link| (|getOutputPathname| options) args (|getMainEntryPoint| options))
+ (|quit|))
+
+(|installDriver| (|Option| "make") #'|makeHandler|)
+@
+
+\subsection{The \verb!--load-directory! handler}
+
+<<AxiomCore>>=
+;; Remember value specified for the --load-dircetory option. Notice
+;; that this is the direct handler for that option. Consequently, it
+;; passed all three arguments: PROG-NAME OPTIONS ARGS. Only the second
+;; argument is of interest.
+(defun |recordLoadDirectory| (prog-name options args)
+ (declare (ignore prog-name args)
+ (special |$LoadDirectories|))
+ (let ((load-option (assoc (|Option| "load-directory") options)))
+ (unless load-option
+ (|internalError| "`recordLoadDirectory' called without option"))
+ (unless (cdr load-option)
+ (|fatalError| "--load-directory option without value"))
+ (pushnew (cdr load-option) |$LoadDirectories| :test #'equal)
+ ))
+
+(|installDriver| (|Option| "load-directory") #'|recordLoadDirectory|)
+@
+
+
+\section{Compiling Lisp source files}
+
+<<AxiomCore>>=
+(declaim (inline |compileFilePathname|))
+(defun |compileFilePathname| (file)
+ #-:ecl (compile-file-pathname file)
+ #+:ecl (compile-file-pathname file :type :object))
+
+;; Compile Lisp source files to target object code. Most of the time
+;; this function is called externally to accomplish just that: compile
+;; a Lisp file. So, by default, we exit the read-eval-print loop after
+;; the task is done.
+;;
+;; NOTE: The Lisp system ECL has an interesting compilation and program
+;; build model. It distinguishes between FASL files (results of
+;; compilation usable as operand to LOAD) and object files (result of
+;; compilation usable to build standalone programs). We are primarily
+;; interested in producing compiled files that can be used to produce
+;; standalone programs. Consequently we must convince ECL to produce
+;; object files. Notice that when program components require that
+;; previously compiled files be loaded in the startup environment,
+;; the system will load the FASL file. So, we end up compiling
+;; twice: once as object code, once as FASL. That is surely wrong. There
+;; me be ways to build one from the one with less work.
+(defun |compileLispFile| (file out-file)
+ (multiple-value-bind (result warning-p failure-p)
+ #-:ecl (compile-file file :output-file out-file)
+ #+:ecl (multiple-value-prog1
+ (compile-file file
+ :output-file out-file
+ :system-p t)
+ (c::build-fasl
+ (compile-file-pathname out-file)
+ :lisp-files `(,out-file)))
+ (unless result
+ (|error| "compilation of Lisp code failed"))
+ (cond ((and failure-p)
+ (|error| "Lisp code contained errors"))
+ (warning-p
+ (|warn| "Lisp code contained warnings")))
+ result))
+
+(defun |compileLispHandler| (prog-name options file)
+ (declare (ignore prog-name))
+ (let ((out-file (|getOutputPathname| options
+ (|compileFilePathname| file))))
+ (|compileLispFile| file out-file)))
+
+(|associateRequestWithFileType| (|Option| "compile") |$LispFileType|
+ #'|compileLispHandler|)
+@
+
+
+\section{Predefined system entry point}
+
+<<AxiomCore>>=
+;; The top level entry point to most saved Lisp image.
+(defun |topLevel|()
+ (setq *package* (find-package "AxiomCore"))
+ (let ((command-args (|getCommandLineArguments|)))
+ (when (null command-args)
+ (|internalError| "empty command line args"))
+ ;; Existing system programming practive, and POSIX, have it
+ ;; that the first argument on the command line is the name
+ ;; of the current instantiation of the program.
+ ;; We require at least two arguments:
+ ;; (0) the program name
+ ;; (1) either one of --help or --version, or
+ ;; a filename.
+ (multiple-value-bind
+ (options args) (|processCommandLine| (cdr command-args) nil)
+
+ ;; Push into the system's preferred namespace. Ideally, this should
+ ;; be run of initialization code if needed. However, a curiously
+ ;; nasty bug in GCL prevents us from expressing the natural semantics
+ ;; in a clean way.
+ (when (boundp '|$sysScope|)
+ (setq *package* (find-package (symbol-value '|$sysScope|))))
+
+ (|handleCommandLine| (car command-args) options args)
+ (|quit| (if (> (|errorCount|) 0) 1 0)))))
+
+@
+
+
+\section{File system}
+
+\subsection{Directory name}
+
+<<AxiomCore>>=
+;; Make sure that directory name DIR ends with a slash.
+(defun |ensureTrailingSlash| (dir)
+ (let ((l (length dir)))
+ (unless (> l 0)
+ (|fatalError| "null directory name"))
+ (if (char= (char dir (- l 1)) #\/)
+ dir
+ (concatenate 'string dir "/"))))
+@
+
+\section{Modules in Axiom}
+
+\subsection{Module load directories}
+
+<<AxiomCore>>=
+;; List of directories to search for FASLs.
+(defparameter |$LoadDirectories| nil)
+@
+
+
+\subsection{Keeping track of imported modules}
+
+\subsubsection{List of imported modules}
+
+<<AxiomCore>>=
+;; List of FASLs imported
+(defparameter |$ImportedModules| nil)
+@
+
+\subsubsection{Updating the list of imported modules}
+
+<<AxiomCore>>=
+;; Return true if MODULE is known to have been imported or loaded.
+(defun |alreadyLoaded?| (module)
+ (member (namestring module) |$ImportedModules| :test #'equal))
+
+;; Remember that MODULE is imported or loaded.
+(defun |noteLoadUnit| (module)
+ (pushnew (namestring module) |$ImportedModules|))
+@
+
+
+\subsection{Load pathname}
+
+<<AxiomCore>>=
+;; We are searching for MODULE (currently a FASL) in DIRECTORY. So, this
+;; function returns a (tentative) pathname designating that module.
+(defun |loadPathname| (module dir)
+ (setq dir (|ensureTrailingSlash| dir))
+ (make-pathname :directory (pathname-directory dir)
+ :name module
+ #-:ecl :type #-:ecl |$faslType|))
+@
+
+\subsection{Module import}
+
+<<AxiomCore>>=
+(defun |loadIfPresent| (module)
+ (if (|alreadyLoaded?| module)
+ module
+ (when (load module :if-does-not-exist nil)
+ (|noteLoadUnit| module)
+ module)))
+
+(defun |loadOrElse| (module)
+ (if (|alreadyLoaded?| module)
+ module
+ (when (load module :if-does-not-exist :error)
+ (|noteLoadUnit| module)
+ module)))
+
+(defun do-import-module (module directories)
+ (unless directories
+ (|fatalError|
+ (format nil
+ "module ~S not found in search path ~S"
+ module
+ |$LoadDirectories|)))
+ (let ((p (|loadPathname| module (car directories))))
+ (unless (|loadIfPresent| p)
+ (do-import-module module (cdr directories)))))
+
+(defun |importModule| (module)
+ (do-import-module module |$LoadDirectories|))
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+(defmacro import-module (module)
+ `(progn (eval-when (:execute :compile-toplevel)
+ (|importModule| ,module))
+
+ (eval-when (:execute :load-toplevel)
+ (|importModule| ,module))))
+)
+@
+
+
+\subsection{Lisp implementation-dependent support}
+
+\subsubsection{SBCL}
+
+<<AxiomCore>>=
+#+ :sbcl
+(defun shoe-provide-module(name)
+ (load name)
+ (provide name))
+
+#+ :sbcl
+(eval-when (:load-toplevel :execute)
+ (pushnew #'shoe-provide-module sb-ext:*module-provider-functions*))
+@
+
+
+
+\section{Putting it all together}
+
+<<*>>=
+<<license>>
+
+;(proclaim '(optimize safety))
+<<AxiomCore>>
+@
+
+\section{License}
+
+<<license>>=
+;; Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
+;; All rights reserved.
+;;
+;; Redistribution and use in source and binary forms, with or without
+;; modification, are permitted provided that the following conditions are
+;; met:
+;;
+;; - Redistributions of source code must retain the above copyright
+;; notice, this list of conditions and the following disclaimer.
+;;
+;; - Redistributions in binary form must reproduce the above copyright
+;; notice, this list of conditions and the following disclaimer in
+;; the documentation and/or other materials provided with the
+;; distribution.
+;;
+;; - Neither the name of The Numerical ALgorithms Group Ltd. nor the
+;; names of its contributors may be used to endorse or promote products
+;; derived from this software without specific prior written permission.
+;;
+;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+;; IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+;; TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+;; PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+;; OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+;; EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+;; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+;; PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+@
+
+\end{document}