aboutsummaryrefslogtreecommitdiff
path: root/src/interp/util.lisp.pamphlet
diff options
context:
space:
mode:
Diffstat (limited to 'src/interp/util.lisp.pamphlet')
-rw-r--r--src/interp/util.lisp.pamphlet1557
1 files changed, 0 insertions, 1557 deletions
diff --git a/src/interp/util.lisp.pamphlet b/src/interp/util.lisp.pamphlet
deleted file mode 100644
index e43af5be..00000000
--- a/src/interp/util.lisp.pamphlet
+++ /dev/null
@@ -1,1557 +0,0 @@
-% Oh Emacs, this is a -*- Lisp -*- file, despite appearance.
-\documentclass{article}
-\usepackage{axiom}
-
-\title{\$SPAD/src/interp util.lisp}
-\author{Timothy Daly}
-
-\begin{document}
-\maketitle
-
-\begin{abstract}
-\end{abstract}
-\eject
-\tableofcontents
-\eject
-
-
-\section{util.lisp}
-
-This file is a collection of utility functions that are useful
-for system level work. A couple of the functions, {\bf build-depsys}
-and {\bf build-interpsys} interface to the src/interp/Makefile.
-
-A second group of related functions allows us to rebuild portions
-of the system from the command prompt. This varies from rebuilding
-individual files to whole directories. The most complex functions
-like {\bf makespad} can rebuild the whole algebra tree.
-
-A third group of related functions are used to set up the
-{\bf autoload} mechanism. These enable whole subsystems to
-be kept out of memory until they are used.
-
-A fourth group of related functions are used to construct and
-search Emacs TAGS files.
-
-A fifth group of related functions are some translated boot
-functions we need to define here so they work and are available
-at load time.
-
-\subsection{Building Depsys (build-depsys)}
-
-The {\bf depsys} image is one of the two images we build from
-the src/interp subdirectory (the other is {\bf interpsys}). We
-use {\bf depsys} as a compile-time image as it contains all of
-the necessary functions and macros to compile any file. The
-{\bf depsys} image is almost the same as an {\bf interpsys}
-image but it does not have any autoload triggers or databases
-loaded.
-<<build-depsys>>=
-(defun build-depsys (load-files)
-#+:CCL
- (setq *package* (find-package "BOOT"))
-#+:AKCL
- (in-package "BOOT")
- (mapcar #'load load-files)
- (reroot)
- #+:AKCL
- (init-memory-config :cons 1000 :fixnum 400 :symbol 1000 :package 16
- :array 800 :string 1000 :cfun 200 :cpages 2000
- :rpages 2000 :hole 4000) )
-;; (init-memory-config :cons 500 :fixnum 200 :symbol 500 :package 8
-;; :array 400 :string 500 :cfun 100 :cpages 1000
-;; :rpages 1000 :hole 2000) )
-
-@
-
-\subsection{Building Interpsys (build-interpsys)}
-\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.${O}: ${OUT}/parsing.${O})
-;# 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.
-;############################################################################
-\end{verbatim}
-The {\bf build-interpsys} function takes a list of files to load
-into the image ({\bf load-files}). It also takes several lists of files,
-one for each subsystem which will be autoloaded. Autoloading is explained
-below. This function is called in the src/interp/Makefile.
-
-This function calls {\bf reroot} to set up pathnames we need. Next
-it sets up the lisp system memory (at present only for AKCL/GCL). Next
-it loads all of the named files, resets a few global state variables,
-loads the databases, sets up autoload triggers and clears out hash tables.
-After this function is called the image is clean and can be saved.
-<<build-interpsys>>=
-(defun build-interpsys (load-files
- translate-files nagbr-files asauto-files)
- (reroot)
- #+:AKCL
- (init-memory-config :cons 500 :fixnum 200 :symbol 500 :package 8
- :array 400 :string 500 :cfun 100 :cpages 1000
- :rpages 1000 :hole 2000)
- <<compiler-notes>>
- (mapcar #'|AxiomCore|::|importModule| load-files)
- (|resetWorkspaceVariables|)
- (|initHist|)
- (|initNewWorld|)
- (compressopen)
- (interpopen)
- (create-initializers)
- (|start| :fin)
-#+:CCL
- (resethashtables)
- (setq *load-verbose* nil)
- (|setBootAutloadProperties| translate-functions translate-files)
- (|setNAGBootAutloadProperties| nagbr-functions nagbr-files)
- (|setBootAutloadProperties| asauto-functions asauto-files)
- (setf (symbol-function 'boot::|addConsDB|) #'identity)
- (resethashtables) ; the databases into core, then close the streams
- )
-
-@
-
-\subsubsection{GCL porting changes}
-
-GCL likes to output lines of the form:
-\begin{verbatim}
-;; Note: Tail-recursive call of |matSuperList1| was replaced by iteration.
-\end{verbatim}
-which is pointless and should be removed. Bill Schelter added this while
-he was debugging tail-recursive replacement and it never was removed.
-<<compiler-notes>>=
- #+:AKCL
- (setq compiler::*suppress-compiler-notes* t)
-@
-
-
-\subsection{The variables}
-
-Various lisps use different ``extensions'' on the filename to indicate
-that a file has been compiled. We set this variable correctly depending
-on the system we are using.
-<<bin-path>>=
-(defvar *bin-path*
- #+kcl "o"
- #+lucid "bbin"
- #+symbolics "bin"
- #+cmulisp "fasl"
- #+:ccl "not done this way at all")
-
-@
-
-
-\subsubsection{relative-directory-list}
-
-The relative directory list specifies a search path for files
-for the current directory structure. It has been changed from the
-NAG distribution back to the original form.
-<<relative-directory-list>>=
-(defvar $relative-directory-list
- '("/../../src/input/"
- "/share/msgs/"
- "/../../src/algebra/"
- "/../../src/interp/" ; for boot and lisp files (helps fd)
- "/doc/spadhelp/" ))
-
-@
-
-
-\subsubsection{relative-library-directory-list}
-
-The relative directory list specifies how to find the algebra
-directory from the current {\bf AXIOM} shell variable.
-<<relative-library-directory-list>>=
-(defvar $relative-library-directory-list '("/algebra/"))
-
-@
-
-
-\subsection{The autoload list}
-
-There are several subsystems within {\bf AXIOM} that are not normally
-loaded into a running system. They will be loaded only if you invoke
-one of the functions listed here. Each of these listed functions will
-have their definitions replaced by a special ``autoloader'' function.
-The first time a function named here is called it will trigger a
-load of the associated subsystem, the autoloader functions will get
-overwritten, the function call is retried and now succeeds. Files
-containing functions listed here are assumed to exist in the
-{\bf autoload} subdirectory. The list of files to load is defined
-in the src/interp/Makefile.
-
-\subsubsection{setBootAutloadProperties}
-
-This function is called by {\bf build-interpsys}. It takes two lists.
-The first is a list of functions that need to be used as
-``autoload triggers''. The second is a list of files to load if one
-of the trigger functions is called. At system build time each of the
-functions in the first list is set up to load every file in the second
-list. In this way we will automatically load a whole subsystem if we
-touch any function in that subsystem. We call a helper function
-called {\bf setBootAutoLoadProperty} to set up the autoload trigger.
-This helper function is listed below.
-<<setBootAutloadProperties>>=
-(defun |setBootAutloadProperties| (fun-list file-list)
-#+:AKCL
- (mapc #'(lambda (fun) (|setBootAutoLoadProperty| fun file-list)) fun-list)
-#+:CCL
- (mapc #'(lambda (fun) (lisp::set-autoload fun file-list)) fun-list)
-)
-
-@
-
-\subsubsection{setBootAutoLoadProperty}
-
-This is a helper function to set up the autoload trigger. It sets
-the function cell of each symbol to {\bf mkBootAutoLoad} which is
-listed below.
-<<setBootAutoLoadProperty>>=
-(defun |setBootAutoLoadProperty| (func file-list)
- (setf (symbol-function func) (|mkBootAutoLoad| func file-list)) )
-
-@
-
-\subsubsection{mkBootAutoLoad}
-
-This is how the autoload magic happens. Every function named in the
-autoload lists is actually just another name for this function. When
-the named function is called we call {\bf boot-load} on all of the
-files in the subsystem. This overwrites all of the autoload triggers.
-We then look up the new (real) function definition and call it again
-with the real arguments. Thus the subsystem loads and the original
-call succeeds.
-<<mkBootAutoLoad>>=
-(defun |mkBootAutoLoad| (fn file-list)
- (function (lambda (&rest args)
- (mapc #'boot-load file-list)
- (unless (string= (subseq (string fn) 0 4) "LOAD")
- (apply (symbol-function fn) args)))))
-
-@
-
-\subsubsection{boot-load}
-
-This function knows where the {\bf autoload} subdirectory lives.
-It is called by {\bf mkBootAutoLoad} above to find the necessary
-files.
-<<boot-load>>=
-(defun boot-load (file)
- (let ((name (concat (|systemRootDirectory|)
- "/autoload/"
- (pathname-name file))))
- (if |$printLoadMsgs|
- (format t " Loading ~A.~%" name))
- (load name)))
-
-@
-
-\subsubsection{setNAGBootAutloadProperties}
-
-This is a further refinement of the autoload scheme. Since the
-Numerical Algorithms Group (NAG) fortran library contains many
-functions we subdivide the NAG library subsystem into chapters.
-We use a different helper function {\bf get-NAG-chapter} to decide
-which files to load.
-<<setNAGBootAutloadProperties>>=
-(defun |setNAGBootAutloadProperties| (function-list file-list)
- (mapcar
- #'(lambda (f)
- (|setBootAutloadProperties|
- (get-NAG-chapter (chapter-name f) function-list)
- (nag-files f file-list)))
- file-list))
-
-@
-
-\subsubsection{get-NAG-chapter}
-
-This function is used to find the names of the files to load.
-On solaris 9 under GCL the original implementation will fail because
-the max number of arguments is 63. We rewrite it to get around this
-problem. It originally read:
-\begin{verbatim}
-(defun get-NAG-chapter (chapter function-list)
- (apply 'append
- (mapcar
- #'(lambda (f)
- (cond
- ((equalp chapter (subseq (string f) 0 (length chapter))) (list f ))))
- function-list)))
-
-\end{verbatim}
-<<get-NAG-chapter>>=
-(defun get-NAG-chapter (chapter function-list)
- (let ((l (length chapter)) r)
- (dolist (f function-list)
- (when (equalp chapter (subseq (string f) 0 l))
- (push f r)))
- (nreverse r)))
-
-@
-
-\subsubsection{nag-files}
-
-We analyze the function names to decide which chapter we are in.
-We load files based on the chapter.
-<<nag-files>>=
-(defun nag-files (filename filelist)
- (apply 'append (mapcar
- #'(lambda (f)
- (cond ((equalp (chapter-name filename) (chapter-name f)) (list f))) )
- filelist)))
-
-@
-
-\subsubsection{chapter-name}
-
-The library names follow a convention that allows us to extract
-the chapter name.
-<<chapter-name>>=
-(defun chapter-name (f)
-#+:AKCL
- (apply
- #'(lambda (s)
- (cond ((equalp (aref s 0) #\s) "s") (T (reverse (subseq s 0 3)))))
- (list (string-left-trim "a.o" (reverse f) )) )
-#+:CCL
- (subseq (string-downcase (string f)) 4 (length (string f)))
-)
-
-@
-
-\subsubsection{translate-functions}
-
-This is a little used subsystem to generate {\bf ALDOR} code
-from {\bf Spad} code. Frankly, I'd be amazed if it worked.
-<<translate-functions>>=
-(setq translate-functions '(
-;; .spad to .as translator, in particular
-;; loadtranslate
- |spad2AsTranslatorAutoloadOnceTrigger|
- ))
-
-@
-
-\subsubsection{asauto-functions}
-
-This is part of the {\bf ALDOR subsystem}. These will be loaded
-if you compile a {\bf .as} file rather than a {\bf .spad} file.
-{\bf ALDOR} is an external compiler that gets automatically called
-if the file extension is {\bf .as}.
-<<asauto-functions>>=
-(setq asauto-functions '(
- loadas
-;; |as| ;; now in as.boot
-;; |astran| ;; now in as.boot
- |spad2AxTranslatorAutoloadOnceTrigger|
- |sourceFilesToAxcliqueAxFile|
- |sourceFilesToAxFile|
- |setExtendedDomains|
- |makeAxFile|
- |makeAxcliqueAxFile|
- |nrlibsToAxFile|
- |attributesToAxFile| ))
-
-@
-
-\subsubsection{debug-functions}
-
-These are some {\bf debugging} functions that I use. I can't imagine
-why you might autoload them but they don't need to be in a running
-system.
-<<debug-functions>>=
-(setq debug-functions '(
- loaddebug
- |showSummary|
- |showPredicates|
- |showAttributes|
- |showFrom|
- |showImp|))
-
-@
-
-\subsubsection{anna-functions}
-
-The {\bf ANNA} subsystem, invoked thru {\bf hypertex}, is an
-expert system that understands the Numerical Algorithms Group (NAG)
-fortran library.
-<<anna-functions>>=
-(setq anna-functions '(
- |annaInt|
- |annaMInt|
- |annaOde|
- |annaOpt|
- |annaOpt2|
- |annaPDESolve|
- |annaOptDefaultSolve1|
- |annaOptDefaultSolve2|
- |annaOptDefaultSolve3|
- |annaOptDefaultSolve4|
- |annaOptDefaultSolve5|
- |annaOpt2DefaultSolve|
- |annaFoo|
- |annaBar|
- |annaJoe|
- |annaSue|
- |annaAnn|
- |annaBab|
- |annaFnar|
- |annaDan|
- |annaBlah|
- |annaTub|
- |annaRats|
- |annaMInt|
- |annaOdeDefaultSolve1|
- |annaOdeDefaultSolve2|))
-
-@
-
-\subsubsection{nagbr-functions}
-
-The Numerical Algorithms Group (NAG) fortran library has a set
-of cover functions. These functions need to be loaded if you use
-the NAG library.
-<<nagbr-functions>>=
-(setq nagbr-functions '(
- loadnag
- |c02aff| |c02agf|
- |c05adf| |c05nbf| |c05pbf|
- |c06eaf| |c06ebf| |c06ecf| |c06ekf| |c06fpf| |c06fqf| |c06frf|
- |c06fuf| |c06gbf| |c06gcf| |c06gqf| |c06gsf|
- |d01ajf| |d01akf| |d01alf| |d01amf| |d01anf| |d01apf| |d01aqf|
- |d01asf| |d01bbf| |d01fcf| |d01gaf| |d01gbf|
- |d02bbf| |d02bhf| |d02cjf| |d02ejf| |d02gaf| |d02gbf| |d02kef|
- |d02raf|
- |d03edf| |d03eef| |d03faf|
- |e01baf| |e01bef| |e01bff| |e01bgf| |e01bhf| |e01daf| |e01saf|
- |e01sbf| |e01sef|
- |e02adf| |e02aef| |e02agf| |e02ahf| |e02ajf| |e02akf| |e02baf|
- |e02bbf| |e02bcf| |e02bdf| |e02bef| |e02daf| |e02dcf|
- |e02ddf| |e02def| |e02dff| |e02gaf| |e02zaf|
- |e04dgf| |e04fdf| |e04gcf| |e04jaf| |e04mbf| |e04naf| |e04ucf|
- |e04ycf|
- |f01brf| |f01bsf| |f01maf| |f01mcf| |f01qcf| |f01qdf| |f01qef|
- |f01rcf| |f01rdf| |f01ref|
- |f02aaf| |f02abf| |f02adf| |f02aef| |f02aff| |f02agf| |f02ajf|
- |f02akf| |f02awf| |f02axf| |f02bbf| |f02bjf| |f02fjf|
- |f02wef| |f02xef|
- |f04adf| |f04arf| |f04asf| |f04atf| |f04axf| |f04faf| |f04jgf|
- |f04maf| |f04mbf| |f04mcf| |f04qaf|
- |f07adf| |f07aef| |f07fdf| |f07fef|
- |s01eaf| |s13aaf| |s13acf| |s13adf| |s14aaf| |s14abf| |s14baf|
- |s15adf| |s15aef| |s17acf| |s17adf| |s17aef| |s17aff|
- |s17agf| |s17ahf| |s17ajf| |s17akf| |s17dcf| |s17def|
- |s17dgf| |s17dhf| |s17dlf| |s18acf| |s18adf| |s18aef|
- |s18aff| |s18dcf| |s18def| |s19aaf| |s19abf| |s19acf|
- |s19adf| |s20acf| |s20adf| |s21baf| |s21bbf| |s21bcf|
- |s21bdf|
- ))
-
-@
-
-
-\subsection{The command-line build functions}
-
-\subsubsection{translist}
-
-Translate a list of boot files to common lisp.
-<<translist>>=
-(defun translist (fns)
- (mapcar #'(lambda (f) (format t "translating ~a~%" (concat f ".boot"))
- (translate f))
- fns))
-
-@
-
-\subsubsection{translate}
-
-Translate a single boot file to common lisp
-<<translate>>=
-(defun translate (file) ;; translates a single boot file
-#+:CCL
- (setq *package* (find-package "BOOT"))
-#+:AKCL
- (in-package "BOOT")
- (let (*print-level* *print-length* (fn (pathname-name file))
- (bootfile (merge-pathnames file (concat (|systemRootDirectory|) "nboot/.boot"))))
- (declare (special *print-level* *print-length*))
- (boot bootfile (make-pathname :type "lisp" :defaults bootfile))))
-
-@
-
-\subsubsection{compile-boot-file}
-
-Translate a single boot file to common lisp, compile it
-and load it.
-<<compile-boot-file>>=
-(defun compile-boot-file (file)
- "compile and load a boot file"
- (boot (concat file ".boot") (concat file ".lisp"))
-#+:AKCL
- (compile-file (concat file ".lisp"))
-#+:AKCL
- (load (concat file "." *bin-path*))
-#+:CCL
- (load (concat file ".lisp"))
-)
-
-@
-
-\subsubsection{retranslate-file-if-necessary}
-
-Retranslate a single boot file if it has been changed.
-<<retranslate-file-if-necessary>>=
-(defun retranslate-file-if-necessary (bootfile)
- (let* ((lfile (make-pathname :type "lisp" :defaults bootfile))
- (ldate (our-write-date lfile))
- (binfile (make-pathname :type *bin-path* :defaults bootfile))
- (bindate (our-write-date binfile))
- (bootdate (our-write-date bootfile)))
- (if (and ldate bootdate (> ldate bootdate)) nil
- (if (and bindate bootdate (> bindate bootdate)) nil
- (progn (format t "translating ~a~%" bootfile)
- (boot bootfile lfile) (list bootfile))))))
-
-@
-
-\subsubsection{retranslate-directory}
-
-Translate a directory of boot code to common lisp if the boot code
-is newer.
-<<retranslate-directory>>=
-(defun retranslate-directory (dir)
- (let* ((direc (make-directory dir))
- (pattern (make-pathname :directory (pathname-directory direc)
- :name :wild :type "boot"))
- (files (directory pattern)))
- (mapcan #'retranslate-file-if-necessary files)))
-
-@
-
-\subsubsection{recompile-NRLIB-if-necessary}
-
-Recompile a single library's lisp file if it is out of date.
-The {\bf recompile-lib-file-if-necessary} is defined in nlib.lisp.
-<<recompile-NRLIB-if-necessary>>=
-(defun recompile-NRLIB-if-necessary (lib)
- (recompile-lib-file-if-necessary (concat (namestring lib) "/code.lsp"))
- (lift-NRLIB-name (namestring lib)))
-
-@
-
-\subsubsection{lift-NRLIB-name}
-
-We used to use FOO.NRLIB/code.o files for algebra. However there
-was no need for this additional level of indirection since the rest
-of the information in an NRLIB is now kept in the daase files. Thus
-we lift the FOO.NRLIB/code.o to FOO.o in the final system.
-<<lift-NRLIB-name>>=
-(defun lift-NRLIB-name (f)
- (obey (concat "cp " f "/code.o " (subseq f 0 (position #\. f)) ".o"))
- nil)
-
-@
-
-\subsubsection{recompile-lib-directory}
-
-Recompile library lisp code if necessary.
-<<recompile-lib-directory>>=
-(defun recompile-lib-directory (dir)
- (let* ((direc (make-directory dir))
- (pattern (make-pathname :directory (pathname-directory direc)
- :name :wild :type "NRLIB"))
- (files (directory pattern)))
- (mapcan #'recompile-NRLIB-if-necessary files)))
-
-@
-
-\subsubsection{recompile-all-files}
-
-Force recompilation of all lisp files in a directory.
-<<recompile-all-files>>=
-(defun recompile-all-files (dir)
- (let* ((direc (make-directory dir))
- (pattern (make-pathname :directory (pathname-directory direc)
- :name :wild :type "lisp"))
- (files (directory pattern)))
- (mapcar #'compile-file files)))
-
-@
-
-\subsubsection{recompile-directory}
-
-This function will compile any lisp code that has changed in a directory.
-<<recompile-directory>>=
-(defun recompile-directory (dir)
- (let* ((direc (make-directory dir))
- (pattern (make-pathname :directory (pathname-directory direc)
- :name :wild :type "lisp"))
- (files (directory pattern)))
- (mapcan #'recompile-file-if-necessary files)))
-
-@
-
-\subsubsection{recompile-file-if-necessary}
-
-This is a helper function that checks the time stamp between
-the given file and its compiled binary. If the file has changed
-since it was last compiled this function will recompile it.
-<<recompile-file-if-necessary>>=
-(defun recompile-file-if-necessary (lfile)
- (let* ((bfile (make-pathname :type *bin-path* :defaults lfile))
- (bdate (our-write-date bfile))
- (ldate (our-write-date lfile)))
- (if (and bdate ldate (> bdate ldate)) nil
- (progn
- (format t "compiling ~a~%" lfile)
- (compile-file lfile)
- (list bfile)))))
-
-@
-
-\subsubsection{our-write-date}
-
-Get the write date of a file. In GCL we need to check that it
-exists first. This is a simple helper function.
-<<our-write-date>>=
-(defun our-write-date (file) (and #+kcl (probe-file file)
- (file-write-date file)))
-
-@
-
-\subsubsection{fe}
-
-I'm unsure what this does but I believe it is related to an interpreter
-command. Invoking ``)fe'' in the interpreter tries to get at the
-src/interp/TAGS file.
-<<fe>>=
-(defun fe (function file &optional (compflag nil) &aux (fn (pathname-name file)))
- (let ((tbootfile (concat "/tmp/" fn ".boot"))
- (tlispfile (concat "/tmp/" fn ".lisp")))
- (system::run-aix-program "fc"
- :arguments (list (string function)
- (namestring
- (merge-pathnames file
- (concat (|systemRootDirectory|)
- "nboot/.boot"))))
- :if-output-exists :supersede :output tbootfile)
- (boot tbootfile tlispfile)
- (if compflag (progn (compile-file tlispfile)
- (load (make-pathname :type *bin-path* :defaults tlispfile)))
- (load tlispfile))))
-@
-
-\subsubsection{fc}
-
-I'm unsure what this does but I believe it is related to an interpreter
-command. Invoking ``)fc'' in the interpreter tries to get at the
-src/interp/TAGS file.
-<<fc>>=
-(defun fc (function file) (fe function file t))
-
-@
-
-\subsubsection{compspadfiles}
-
-The {\bf compspadfiles} function will recompile a list of {\bf spad} files.
-The filelist should be a file containing names of files to compile.
-<<compspadfiles>>=
-(defun compspadfiles (filelist ;; should be a file containing files to compile
- &optional (*default-pathname-defaults*
- (pathname (concat (|systemRootDirectory|)
- "nalgebra/"))))
- (with-open-file (stream filelist)
- (do ((fname (read-line stream nil nil) (read-line stream nil nil)))
- ((null fname) 'done)
- (setq fname (string-right-trim " *" fname))
- (when (not (equal (elt fname 0) #\*))
- (spad fname (concat (pathname-name fname) ".out"))))))
-
-@
-
-\subsubsection{load-directory}
-
-Load a whole subdirectory of compiled files
-<<load-directory>>=
-(defun load-directory (dir)
- (let* ((direc (make-directory dir))
- (pattern (make-pathname :directory (pathname-directory direc)
- :name :wild :type *bin-path*))
- (files (directory pattern)))
- (mapcar #'load files)))
-
-@
-
-\subsubsection{interp-make-directory}
-
-This is used by the ")cd" system command.
-<<interp-make-directory>>=
-(defun interp-make-directory (direc)
- (setq direc (namestring direc))
- (if (string= direc "") $current-directory
- (if (or (memq :unix *features*)
- (memq 'unix *features*))
- (progn
- (if (char/= (char $current-directory (1-(length $current-directory))) #\/)
- (setq $current-directory (concat $current-directory "/")))
- (if (char/= (char direc 0) #\/)
- (setq direc (concat $current-directory direc)))
- (if (char/= (char direc (1- (length direc))) #\/)
- (setq direc (concat direc "/")))
- direc)
- (progn ;; Assume Windows conventions
- (if (not (or (char= (char $current-directory (1- (length $current-directory))) #\/)
- (char= (char $current-directory (1- (length $current-directory))) #\\ )))
- (setq $current-directory (concat $current-directory "\\")))
- (if (not (or (char= (char direc 0) #\/)
- (char= (char direc 0) #\\)
- (find #\: direc)))
- (setq direc (concat $current-directory direc)))
- (if (not (or (char= (char direc (1- (length direc))) #\/)
- (char= (char direc (1- (length direc))) #\\ )))
- (setq direc (concat direc "\\")))
- direc))))
-
-@
-
-\subsubsection{make-directory}
-
-Make a directory relative to the running system root directory.
-<<make-directory>>=
-(defun make-directory (direc)
- (setq direc (namestring direc))
- (if (string= direc "") (|systemRootDirectory|)
- (if (or (memq :unix *features*)
- (memq 'unix *features*))
- (progn
- (if (char/= (char direc 0) #\/)
- (setq direc (concat (|systemRootDirectory|) "/" direc)))
- (if (char/= (char direc (1- (length direc))) #\/)
- (setq direc (concat direc "/")))
- direc)
- (progn ;; Assume Windows conventions
- (if (not (or (char= (char direc 0) #\/)
- (char= (char direc 0) #\\)
- (find #\: direc)))
- (setq direc (concat (|systemRootDirectory|) "\\" direc)))
- (if (not (or (char= (char direc (1- (length direc))) #\/)
- (char= (char direc (1- (length direc))) #\\ )))
- (setq direc (concat direc "\\")))
- direc))))
-
-@
-
-\subsubsection{recompile-all-libs}
-
-Occasionally it will be necessary to iterate over all of the NRLIB
-directories and compile each of the code.lsp files in every NRLIB.
-This function will do that. A correct call looks like:
-\begin{verbatim}
-(in-package "BOOT")
-(recompile-all-libs "/spad/mnt/${SYS}/algebra")
-\end{verbatim}
-where the [[${SYS}]] variable is same as the one set at build time.
-<<recompile-all-libs>>=
-(defun recompile-all-libs (dir)
- (let* ((direc (make-directory dir))
- (pattern (make-pathname :directory (pathname-directory direc)
- :name :wild :type "NRLIB"))
- (files (directory pattern)))
- (mapcar
- #'(lambda (lib) (compile-lib-file (concat (namestring lib) "/code.lsp")))
- files)))
-
-@
-
-\subsubsection{recompile-all-algebra-files}
-
-We occasionally need to completely rebuild the algebra from the spad
-files. This function will iterate across a directory containing all
-of the spad files and attempt to recompile them. A correct call looks
-like:
-\begin{verbatim}
-(in-package "BOOT")
-(recompile-all-algebra-files "nalg")
-\end{verbatim}
-Note that it will build a pathname from the current {\bf AXIOM}
-shell variable. So if the {\bf AXIOM} shell variable had the value
-\begin{verbatim}
-/spad/mnt/${SYS}
-\end{verbatim}
-(where the [[${SYS}]] variable is the same one set at build time)
-then the wildcard expands to
-\begin{verbatim}
-/spad/mnt/${SYS}/nalg/*.spad
-\end{verbatim}
-and all of the matching files would be recompiled.
-<<recompile-all-algebra-files>>=
-(defun recompile-all-algebra-files (dir) ;; a desperation measure
- (let* ((direc (make-directory dir))
- (pattern (make-pathname :directory (pathname-directory direc)
- :name :wild :type "spad"))
- (files (directory pattern))
- (*default-pathname-defaults* (pathname direc)))
- (mapcar
- #'(lambda (fname) (spad fname (concat (pathname-name fname) ".out")))
- files)))
-
-@
-
-\subsubsection{boottocl}
-
-The {\bf boottocl} function is the workhorse function that translates
-{\bf .boot} files to {\bf Common Lisp}. It basically wraps the actual
-{\bf boot} function call to ensure that we don't truncate lines
-because of {\bf *print-level*} or {\bf *print-length*}.
-<<boottocl>>=
-(in-package "OLD-BOOT")
-
-(defun boot (file) ;; translates a single boot file
-#+:CCL
- (setq *package* (find-package "BOOT"))
-#+:AKCL
- (in-package "BOOT")
- (let (*print-level*
- *print-length*
- (fn (pathname-name file))
- (*print-pretty* t))
- (declare (special *print-level* *print-length*))
- (boot::boot
- file
- (merge-pathnames (make-pathname :type "clisp") file))))
-
-@
-
-\subsubsection{yearweek}
-
-We need a way of distinguishing different versions of the system.
-There used to be a way to touch the src/timestamp file whenever
-you checked in a change to the change control subsystem.
-During make PART=interp (the default for make) we set timestamp
-to the filename of this timestamp file. This function converts it
-to a luser readable string and sets the *yearweek* variable.
-
-The result of this function is a string that is printed as a banner
-when Axiom starts. The actual printing is done by the function
-[[spadStartUpMsgs]] in [[src/interp/msgdb.boot]]. It uses a
-format string from the file [[src/doc/msgs/s2-us.msgs]].
-<<yearweek>>=
-(defun yearweek ()
- "set *yearweek* to the current time string for the version banner"
- (declare (special timestamp) (special *yearweek*))
- (if (and (boundp 'timestamp) (probe-file timestamp))
- (let (sec min hour date month year day dayvec monvec)
- (setq dayvec '("Monday" "Tuesday" "Wednesday" "Thursday"
- "Friday" "Saturday" "Sunday"))
- (setq monvec '("January" "February" "March" "April" "May" "June"
- "July" "August" "September" "October" "November"
- "December"))
- (multiple-value-setq (sec min hour date month year day)
- (decode-universal-time
- (file-write-date timestamp)))
- (setq *yearweek*
- (copy-seq
- (format nil "~a ~a ~d, ~d at ~2,'0d:~2,'0d:~2,'0d "
- (elt dayvec day)
- (elt monvec (1- month)) date year hour min sec))))
- (setq *yearweek* "no timestamp")))
-
-@
-
-\subsubsection{makelib}
-
-Make will not compare dates across directories.
-Rather than copy all of the code.lsp files to the MNT directory
-we run this function to compile the files that are out of date
-this function assumes that the shell variables INT and MNT are set.
-
-Also of note: on the rt some files (those in the nooptimize list)
-need to be compiled without optimize due to compiler bugs
-<<makelib>>=
-(defun makelib (mid out stype btype)
- "iterate over the NRLIBs, compiling ones that are out of date.
- mid is the directory containing code.lsp
- out is the directory containing code.o"
- (let (libs lspdate odate nooptimize (alphabet #\space))
-#+(and :akcl :rt)
- (setq nooptimize '("FFCAT-.NRLIB" "CHVAR.NRLIB" "PFO.NRLIB" "SUP.NRLIB"
- "INTG0.NRLIB" "FSPRMELT.NRLIB" "VECTOR.NRLIB"
- "EUCDOM-.NRLIB"))
- (if (and mid out)
- (format t "doing directory on ~s...~%" (concatenate 'string mid "/*"))
- (error "makelib:MID=~a OUT=~a~% these are not set properly~%" mid out))
-#+:akcl (compiler::emit-fn nil)
-#+:akcl (si::chdir mid)
-#-:akcl (obey (concatenate 'string "cd " mid))
- (setq libs (directory "*.NRLIB"))
- (unless libs
- (format t "makelib:directory of ~a returned NIL~%" mid)
- (bye -1))
- (princ "checking ")
- (dolist (lib libs)
- (unless (char= (schar (pathname-name lib) 0) alphabet)
- (setq alphabet (schar (pathname-name lib) 0))
- (princ alphabet)
- (finish-output))
- (let (dotlsp doto mntlib intkaf mntkaf intkafdate mntkafdate)
- (setq dotlsp
- (concatenate 'string mid "/" (file-namestring lib) "/code." stype))
- (setq doto
- (concatenate 'string out "/" (pathname-name lib) ".NRLIB/code." btype))
- (setq mntlib
- (concatenate 'string out "/" (pathname-name lib) ".NRLIB"))
- (setq intkaf
- (concatenate 'string mid "/" (file-namestring lib) "/index.KAF*"))
- (setq mntkaf
- (concatenate 'string out "/" (pathname-name lib) ".NRLIB/index.KAF*"))
- (unless (probe-file mntlib)
- (format t "creating directory ~a~%" mntlib)
- (obey (concatenate 'string "cp -pr " (namestring lib) " " out))
- (when (probe-file (concatenate 'string mntlib "/code." stype))
- (delete-file (concatenate 'string mntlib "/code." stype))))
- (setq intkafdate (and (probe-file intkaf) (file-write-date intkaf)))
- (setq mntkafdate (and (probe-file mntkaf) (file-write-date mntkaf)))
- (when intkafdate
- (unless (and mntkafdate (> mntkafdate intkafdate))
- (format t "~&copying ~s to ~s" intkaf mntkaf)
- (obey
- (concatenate 'string "cp "
- (namestring intkaf) " " (namestring mntkaf)))))
- (setq lspdate (and (probe-file dotlsp) (file-write-date dotlsp)))
- (setq odate (and (probe-file doto) (file-write-date doto)))
- (when lspdate
- (unless (and odate (> odate lspdate))
-#+(and :akcl :rt)
- (if (member (file-namestring lib) nooptimize :test #'string=)
- (setq compiler::*speed* 0)
- (setq compiler::*speed* 3))
- (compile-lib-file dotlsp :output-file doto)))))))
-
-@
-
-\subsubsection{makespad}
-
-Make will not compare dates across directories.
-In particular, it cannot compare the algebra files because there
-is a one-to-many correspondence. This function will walk over
-all of the algebra NRLIB files and find all of the spad files
-that are out of date and need to be recompiled. This function
-creates a file "/tmp/compile.input" to be used later in the
-makefile.
-
-Note that the file /tmp/compile.input is not currently used
-as algebra source recompiles are not necessarily something
-we want done automatically. Nevertheless, in the quest for
-quality we check anyway.
-<<makespad>>=
-(defun makespad (src mid stype)
- "iterate over the spad files, compiling ones that are out of date.
- src is the directory containing .spad
- mid is the directory containing code.lsp
- out is the directory containing code.o"
- (let (mntlibs spadwork (alphabet #\space))
- (labels (
- (findsrc (mid libname)
- "return a string name of the source file given the library file
- name (eg PI) as a string"
- (let (kaffile index alist)
- (setq kaffile
- (concatenate 'string mid "/" libname ".NRLIB/index.KAF*"))
- (with-open-file (kaf kaffile)
- (setq index (read kaf))
- (file-position kaf index)
- (setq alist (read kaf))
- (setq index (third (assoc "sourceFile" alist :test #'string=)))
- (file-position kaf index)
- (pathname-name (pathname (read kaf index)))))))
- (format t "makespad:src=~s mid=~s stype=~s~%" src mid stype)
- (if (and src mid)
- (format t "doing directory on ~s...~%" (concatenate 'string src "/*"))
- (error "makespad:SRC=~a MID=~a not set properly~%" src mid))
-#+:akcl (si::chdir mid)
-#-:akcl (obey (concatenate 'string "cd " mid))
- (setq mntlibs (directory "*.NRLIB"))
- (unless mntlibs
- (format t "makespad:directory of ~a returned NIL~%" src)
- (bye 1))
- (princ "checking ")
- (dolist (lib mntlibs)
- (unless (char= (schar (pathname-name lib) 0) alphabet)
- (setq alphabet (schar (pathname-name lib) 0))
- (princ alphabet)
- (finish-output))
- (let (spad spaddate lsp lspdate)
- (setq spad
- (concatenate 'string src "/" (findsrc mid (pathname-name lib)) ".spad"))
- (setq spaddate
- (and (probe-file spad) (file-write-date spad)))
- (setq lsp
- (concatenate 'string mid "/" (pathname-name lib) ".NRLIB/code." stype))
- (setq lspdate
- (and (probe-file lsp) (file-write-date lsp)))
- (cond
- ((and spaddate lspdate (<= spaddate lspdate)))
- ((and spaddate lspdate (> spaddate lspdate))
- (setq spadwork (adjoin spad spadwork :test #'string=)))
- ((and spaddate (not lspdate))
- (setq spadwork (adjoin spad spadwork :test #'string=)))
- ((and (not spaddate) lspdate)
- (format t "makespad:missing spad file ~a for lisp file ~a~%" spad lsp))
- ((and (not spaddate) (not lspdate))
- (format t "makespad:NRLIB ~a exist but is spad ~a and lsp ~a don't~%"
- lib spad lsp)))))
- (with-open-file (tmp "/tmp/compile.input" :direction :output)
- (dolist (spad spadwork)
- (format t "~a is out of date~%" spad)
- (format tmp ")co ~a~%" spad))))))
-
-@
-
-\subsubsection{libcheck}
-
-We need to ensure that the INTERP.EXPOSED list, which is a list
-of the exposed constructors, is consistent with the actual libraries.
-<<libcheck>>=
-(defun libcheck (int)
- "check that INTERP.EXPOSED and NRLIBs are consistent"
- (let (interp nrlibs)
- (labels (
- (CONSTRUCTORNAME (nrlib)
- "find the long name of a constructor given an abbreviation string"
- (let (file sourcefile name)
- (setq file (findsrc nrlib))
- (setq sourcefile
- (concatenate 'string int "/" file ".spad"))
- (when (and file (probe-file sourcefile))
- (setq name (searchsource sourcefile nrlib)))))
- (NOCAT (longnames)
- "remove the categories from the list of long names"
- (remove-if
- #'(lambda (x)
- (let ((c (schar x (1- (length x)))))
- (or (char= c #\&) (char= c #\-)))) longnames))
- (FINDSRC (libname)
- "return a string name of the source file given the library file
- name (eg PI) as a string"
- (let (kaffile index alist result)
- (setq kaffile
- (concatenate 'string int "/" libname ".NRLIB/index.KAF*"))
- (if (probe-file kaffile)
- (with-open-file (kaf kaffile)
- (setq index (read kaf))
- (file-position kaf index)
- (setq alist (read kaf))
- (setq index (third (assoc "sourceFile" alist :test #'string=)))
- (file-position kaf index)
- (setq result (pathname-name (pathname (read kaf index))))))
- (format t "~a does not exist~%" kaffile)
- result))
- (READINTERP ()
- "read INTERP.EXPOSED and return a sorted abbreviation list"
- (let (expr names longnames)
- (with-open-file (in (concatenate 'string int "/INTERP.EXPOSED"))
- (catch 'eof
- (loop
- (setq expr (read-line in nil 'eof))
- (when (eq expr 'eof) (throw 'eof nil))
- (when
- (and
- (> (length expr) 58)
- (char= (schar expr 0) #\space)
- (not (char= (schar expr 8) #\space)))
- (push (string-trim '(#\space) (subseq expr 8 57)) longnames)
- (push (string-right-trim '(#\space) (subseq expr 58)) names)))))
- (setq longnames (sort longnames #'string<))
- (setq names (sort names #'string<))
- (values names longnames)))
- (READLIBS (algebra)
- "read the NRLIB directory and return a sorted abbreviation list"
- (let (libs nrlibs)
-#+:akcl (si::chdir algebra)
-#-:akcl (obey (concatenate 'string "cd " algebra))
- (setq nrlibs (directory "*.NRLIB"))
- (unless nrlibs
- (error "libcheck: (directory ~s) returned NIL~%"
- (concatenate 'string algebra "/*.NRLIB")))
- (dolist (lib nrlibs)
- (push (pathname-name lib) libs))
- (sort libs #'string<)))
- (SEARCHSOURCE (sourcefile nrlib)
- "search a sourcefile for the long constructor name of the nrlib string"
- (let (in expr start)
- (setq nrlib (concatenate 'string " " nrlib " "))
- (catch 'done
- (with-open-file (in sourcefile)
- (loop
- (setq expr (read-line in nil 'done))
- (when (eq expr 'done) (throw 'done nil))
- (when (and (> (length expr) 4)
- (string= ")abb" (subseq expr 0 4))
- (search nrlib expr :test #'string=)
- (setq start (position #\space expr :from-end t :test #'char=)))
- (throw 'done (string-trim '(#\space) (subseq expr start)))))))))
- (SRCABBREVS (sourcefile)
- (let (in expr start end names longnames)
- (catch 'done
- (with-open-file (in sourcefile)
- (loop
- (setq expr (read-line in nil 'done))
- (when (eq expr 'done) (throw 'done nil))
- (when (and (> (length expr) 4)
- (string= ")abb" (subseq expr 0 4)))
- (setq point (position #\space expr :from-end t :test #'char=))
- (push (string-trim '(#\space) (subseq expr point)) longnames)
- (setq mark
- (position #\space
- (string-right-trim '(#\space)
- (subseq expr 0 (1- point))) :from-end t))
- (push (string-trim '(#\space) (subseq expr mark point)) names)))))
- (values names longnames)))
- (SRCSCAN ()
- (let (longnames names)
-#+:gcl (system::chdir int)
-#-:gcl (obey (concatenate 'string "cd " int))
- (setq spads (directory "*.spad"))
- (dolist (spad spads)
- (multiple-value-setq (short long) (srcabbrevs spad))
- (setq names (nconc names short))
- (setq longnames (nconc longnames long)))
- (setq names (sort names #'string<))
- (setq longnames (sort longnames #'string<))
- (values names longnames))))
- (multiple-value-setq (abbrevs constructors) (readinterp))
- (setq nrlibs (readlibs int))
- (dolist (lib (set-difference nrlibs abbrevs :test #'string=))
- (format t "libcheck:~a/~a.NRLIB is not in INTERP.EXPOSED~%" int lib))
- (dolist (expose (set-difference abbrevs nrlibs :test #'string=))
- (format t "libcheck:~a is in INTERP.EXPOSED with no NRLIB~%" expose))
- (multiple-value-setq (srcabbrevs srcconstructors) (srcscan))
- (setq abbrevs (nocat abbrevs))
- (setq constructors (nocat constructors))
- (dolist (item (set-difference srcabbrevs abbrevs :test #'string=))
- (format t "libcheck:~a is in ~a but not in INTERP.EXPOSED~%" item
- (findsrc item)))
- (dolist (item (set-difference abbrevs srcabbrevs :test #'string=))
- (format t "libcheck:~a is in INTERP.EXPOSED but has no spad sourcfile~%"
- item))
- (dolist (item (set-difference srcconstructors constructors :test #'string=))
- (format t "libcheck:~a is not in INTERP.EXPOSED~%" item))
- (dolist (item (set-difference constructors srcconstructors :test #'string=))
- (format t "libcheck:~a has no spad source file~%" item)))))
-
-@
-
-
-\subsection{Constructing TAGS}
-
-TAGS are useful for finding functions if you run Emacs. We have a
-set of functions that construct TAGS files for Axiom.
-\subsubsection{make-tags-file}
-Run the etags command on all of the lisp code. Then run the
-{\bf spadtags-from-directory} function on the boot code. The
-final TAGS file is constructed in the {\bf tmp} directory.
-<<make-tags-file>>=
-(defun make-tags-file ()
-#+:gcl (system:chdir "/tmp")
-#-:gcl (obey (concatenate 'string "cd " "/tmp"))
- (obey (concat "etags " (make-absolute-filename "../../src/interp/*.lisp")))
- (spadtags-from-directory "../../src/interp" "boot")
- (obey "cat /tmp/boot.TAGS >> /tmp/TAGS"))
-
-@
-
-\subsubsection{spadtags-from-directory}
-
-This function will walk across a directory and call
-{\bf spadtags-from-file} on each file.
-<<spadtags-from-directory>>=
-(defun spadtags-from-directory (dir type)
- (let* ((direc (make-directory dir))
- (pattern (make-pathname :directory (pathname-directory direc)
- :name :wild :type type))
- (files (directory pattern)))
- (with-open-file
- (tagstream (concatenate 'string "/tmp/" type ".TAGS") :direction :output
- :if-exists :supersede :if-does-not-exist :create)
- (dolist (file files (namestring tagstream))
- (print (list "processing:" file))
- (write-char #\page tagstream)
- (terpri tagstream)
- (write-string (namestring file) tagstream)
- (write-char #\, tagstream)
- (princ (spadtags-from-file file) tagstream)
- (terpri tagstream)
- (with-open-file (stream "/tmp/*TAGS")
- (do ((line (read-line stream nil nil)
- (read-line stream nil nil)))
- ((null line) nil)
- (write-line line tagstream)))))))
-
-@
-
-\subsubsection{spadtags-from-file}
-
-This function knows how to find function names in {\bf boot} code
-so we can add them to the TAGS file using standard etags format.
-<<spadtags-from-file>>=
-(defun spadtags-from-file (spadfile)
- (with-open-file (tagstream "/tmp/*TAGS" :direction :output
- :if-exists :supersede :if-does-not-exist :create)
- (with-open-file (stream spadfile)
- (do ((char-count 0 (file-position stream))
- (line (read-line stream nil nil) (read-line stream nil nil))
- (line-count 1 (1+ line-count)))
- ((null line) (file-length tagstream))
- (if (/= (length line) 0)
- (let ((firstchar (elt line 0)) (end nil)
- (len (length line)))
- (cond ((member firstchar '(#\space #\{ #\} #\tab )
- :test #'char= ) "skip")
- ((string= line ")abb" :end1 (min 4 len))
- (setq end (position #\space line :from-end t
- :test-not #'eql)
- end (and end (position #\space line :from-end t
- :end end)))
- (write-tag-line line tagstream end
- line-count char-count))
- ((char= firstchar #\)) "skip")
- ((and (> len 1) (string= line "--" :end1 2)) "skip")
- ((and (> len 1) (string= line "++" :end1 2)) "skip")
- ((search "==>" line) "skip")
- ((and (setq end (position #\space line)
- end (or (position #\( line :end end) end)
- end (or (position #\: line :end end) end)
- end (or (position #\[ line :end end) end))
- (equal end 0)) "skip")
- ((position #\] line :end end) "skip")
- ((string= line "SETANDFILEQ" :end1 end) "skip")
- ((string= line "EVALANDFILEACTQ" :end1 end) "skip")
- (t (write-tag-line line tagstream
- (if (numberp end) (+ end 1) end)
- line-count char-count)) )))))))
-
-@
-
-\subsubsection{write-tag-line}
-
-This function knows how to write a single line into a TAGS file
-using the etags file format.
-<<write-tag-line>>=
-(defun write-tag-line (line tagstream endcol line-count char-count)
- (write-string line tagstream :end endcol)
- (write-char #\rubout tagstream)
- (princ line-count tagstream)
- (write-char #\, tagstream)
- (princ char-count tagstream)
- (terpri tagstream))
-
-@
-
-\subsubsection{blankcharp}
-
-This is a trivial predicate for calls to {\bf position-if-not} in the
-{\bf findtag} function.
-<<blankcharp>>=
-(defun blankcharp (c) (char= c #\Space))
-
-@
-
-\subsubsection{findtag}
-
-The {\bf findtag} function is a user-level function to figure out
-which file contains a given tag. This is sometimes useful if Emacs
-is not around or TAGS are not loaded.
-<<findtag>>=
-(defun findtag (tag &optional (tagfile (concat (|systemRootDirectory|) "/../../src/interp/TAGS")) )
- ;; tag is an identifier
- (with-open-file (tagstream tagfile)
- (do ((tagline (read-line tagstream nil nil)
- (read-line tagstream nil nil))
- (*package* (symbol-package tag))
- (sourcefile)
- (stringtag (string tag))
- (pos)
- (tpos)
- (type))
- ((null tagline) ())
- (cond ((char= (char tagline 0) #\Page)
- (setq tagline (read-line tagstream nil nil))
- (setq sourcefile (subseq tagline 0
- (position #\, tagline)))
- (setq type (pathname-type sourcefile)))
- ((string= type "lisp")
- (if (match-lisp-tag tag tagline)
- (return (cons sourcefile tagline))))
- ((> (mismatch ")abb" tagline) 3)
- (setq pos (position #\Space tagline :start 3))
- (setq pos (position-if-not #'blankcharp tagline
- :start pos))
- (setq pos (position #\Space tagline :start pos))
- (setq pos (position-if-not #'blankcharp tagline
- :start pos))
- (setq tpos (mismatch stringtag tagline :start2 pos))
- (if (and (= tpos (length (string tag)))
- (member (char tagline (+ pos tpos)) '(#\Space #\Rubout)))
- (return (cons sourcefile tagline))))
- ((setq pos (mismatch stringtag tagline))
- (if (and (= pos (length stringtag))
- (> (length tagline) pos)
- (member (char tagline pos)
- '( #\Space #\( #\:) ))
- (return (cons sourcefile tagline))))))))
-
-@
-
-\subsubsection{match-lisp-tag}
-
-The {\bf match-lisp-tag} function is used by {\bf findtag}. This
-function assumes that \\ can only appear as first character of name.
-<<match-lisp-tag>>=
-(defun match-lisp-tag (tag tagline &optional (prefix nil)
- &aux (stringtag (string tag)) pos tpos)
- (when (and (if prefix
- (= (mismatch prefix tagline :test #'char-equal)
- (length prefix))
- t)
- (numberp (setq pos (position #\Space tagline)))
- (numberp (setq pos (position-if-not #'blankcharp tagline
- :start pos))))
- (if (char= (char tagline pos) #\') (incf pos))
- (if (member (char tagline pos) '( #\\ #\|))
- (setq tpos (1+ pos))
- (setq tpos pos))
- (and (= (mismatch stringtag tagline :start2 tpos :test #'char-equal)
- (length stringtag))
- (eq tag (read-from-string tagline nil nil :start pos))) ))
-
-@
-
-
-\subsection{Translated Boot functions}
-
-\subsubsection{string2BootTree}
-
-<<string2BootTree>>=
-(DEFUN |string2BootTree| (S)
- (init-boot/spad-reader)
- (LET* ((BOOT-LINE-STACK (LIST (CONS 1 S)))
- ($BOOT T)
- ($SPAD NIL)
- (XTOKENREADER 'GET-BOOT-TOKEN)
- (LINE-HANDLER 'NEXT-BOOT-LINE)
- (PARSEOUT (PROGN (|PARSE-Expression|) (POP-STACK-1))))
- (DECLARE (SPECIAL BOOT-LINE-STACK $BOOT $SPAD XTOKENREADER LINE-HANDLER))
- (DEF-RENAME (|new2OldLisp| PARSEOUT))))
-
-@
-
-\subsubsection{string2SpadTree}
-
-<<string2SpadTree>>=
-(DEFUN |string2SpadTree| (LINE)
- (DECLARE (SPECIAL LINE))
- (if (and (> (LENGTH LINE) 0) (EQ (CHAR LINE 0) #\) ))
- (|processSynonyms|))
- (ioclear)
- (LET* ((BOOT-LINE-STACK (LIST (CONS 1 LINE)))
- ($BOOT NIL)
- ($SPAD T)
- (XTOKENREADER 'GET-BOOT-TOKEN)
- (LINE-HANDLER 'NEXT-BOOT-LINE)
- (PARSEOUT (PROG2 (|PARSE-NewExpr|) (POP-STACK-1))))
- (DECLARE (SPECIAL BOOT-LINE-STACK $BOOT $SPAD XTOKENREADER LINE-HANDLER))
- PARSEOUT))
-
-@
-
-\subsubsection{processSynonyms}
-
-;;--------------------> NEW DEFINITION (see i-syscmd.boot.pamphlet)
-<<processSynonyms>>=
-(defun |processSynonyms| () nil) ;;dummy def for depsys, redefined later
-
-@
-
-
-\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.
-
-@
-<<*>>=
-<<license>>
-
-(IMPORT-MODULE "vmlisp")
-(import-module "parsing")
-
-(in-package "BOOT")
-(export '($directory-list $current-directory reroot
- make-absolute-filename |$msgDatabaseName| |$defaultMsgDatabaseName|))
-
-<<our-write-date>>
-<<make-directory>>
-<<interp-make-directory>>
-<<bin-path>>
-<<load-directory>>
-<<compspadfiles>>
-<<recompile-all-algebra-files>>
-<<fe>>
-<<fc>>
-<<recompile-directory>>
-<<recompile-file-if-necessary>>
-<<recompile-all-files>>
-<<recompile-lib-directory>>
-<<recompile-all-libs>>
-<<recompile-NRLIB-if-necessary>>
-<<lift-NRLIB-name>>
-<<retranslate-directory>>
-<<retranslate-file-if-necessary>>
-<<make-tags-file>>
-<<spadtags-from-directory>>
-<<spadtags-from-file>>
-<<write-tag-line>>
-<<blankcharp>>
-<<findtag>>
-<<match-lisp-tag>>
-<<compile-boot-file>>
-<<translate>>
-<<translist>>
-<<relative-directory-list>>
-<<relative-library-directory-list>>
-<<boottocl>>
-
-(in-package "BOOT")
-
-<<translate-functions>>
-<<asauto-functions>>
-<<debug-functions>>
-<<anna-functions>>
-<<nagbr-functions>>
-<<setBootAutloadProperties>>
-<<boot-load>>
-<<setBootAutoLoadProperty>>
-<<mkBootAutoLoad>>
-<<build-interpsys>>
-<<setNAGBootAutloadProperties>>
-<<get-NAG-chapter>>
-<<nag-files>>
-<<chapter-name>>
-<<build-depsys>>
-
-<<string2BootTree>>
-<<string2SpadTree>>
-<<processSynonyms>>
-
-;; the following are for conditional reading
-#+:ieee-floating-point (setq $ieee t)
-#-:ieee-floating-point (setq $ieee nil)
-(setq |$opSysName| '"shell")
-#+:CCL (defun machine-type () "unknown")
-(setq |$machineType| (machine-type))
-; spad-clear-input patches around fact that akcl clear-input leaves newlines chars
-(defun spad-clear-input (st) (clear-input st) (if (listen st) (read-char st)))
-
-<<yearweek>>
-(defun sourcepath (f)
- "find the sourcefile in the system directories"
- (let (axiom algebra naglink)
- (setq axiom (|systemRootDirectory|))
- (setq algebra (concatenate 'string axiom "/../../src/algebra/" f ".spad"))
- (setq naglink (concatenate 'string axiom "/../../src/naglink/" f ".spad"))
- (cond
- ((probe-file algebra) algebra)
- ((probe-file naglink) naglink)
- ('else nil))))
-
-(defun srcabbrevs (sourcefile)
- "read spad source files and return the constructor names and abbrevs"
- (let (expr point mark names longnames)
- (catch 'done
- (with-open-file (in sourcefile)
- (loop
- (setq expr (read-line in nil 'done))
- (when (eq expr 'done) (throw 'done nil))
- (when (and (> (length expr) 4) (string= ")abb" (subseq expr 0 4)))
- (setq expr (string-right-trim '(#\space #\tab) expr))
- (setq point (position #\space expr :from-end t :test #'char=))
- (push (subseq expr (1+ point)) longnames)
- (setq expr (string-right-trim '(#\space #\tab)
- (subseq expr 0 point)))
- (setq mark (position #\space expr :from-end t))
- (push (subseq expr (1+ mark)) names)))))
- (values longnames names)))
-
-
-#+(and :AKCL (not (or :dos :win32)))
-(in-package "COMPILER")
-#+(and :AKCL (not (or :dos :win32)))
-(defun gazonk-name ( &aux tem)
- "return the name of the intermediate compiler file"
- (dotimes (i 1000)
- (setq tem (merge-pathnames (format nil "/tmp/gazonk~d.lsp" i)))
- (unless (probe-file tem)
- (return-from gazonk-name (pathname tem))))
- (error "1000 gazonk names used already!"))
-
-(in-package "BOOT")
-
-(defun |tr| (fn)
- (|spad2AsTranslatorAutoloadOnceTrigger|)
- (|convertSpadFile| fn) )
-
-<<makelib>>
-<<makespad>>
-<<libcheck>>
-
-@
-\eject
-\begin{thebibliography}{99}
-\bibitem{1} nothing
-\end{thebibliography}
-\end{document}