diff --git a/books/bookvol5.pamphlet b/books/bookvol5.pamphlet
index ed8bdf0..a0b8263 100644
--- a/books/bookvol5.pamphlet
+++ b/books/bookvol5.pamphlet
@@ -562,6 +562,14 @@ While not using the ``dollar'' convention this variable is still ``global''.
 (defvar *eof* nil)
 
 @
+\defvar{*whitespace*}
+<<initvars>>=
+(defvar *whitespace*
+ '(#\Space #\Newline #\Tab #\Page #\Linefeed #\Return #\Backspace)
+ "A list of characters used by string-trim considered as whitespace")
+
+@
+
 \defdollar{InteractiveMode}
 <<initvars>>=
 (defvar |$InteractiveMode| t)
@@ -1113,6 +1121,49 @@ this is what the current code does so I won't change it.
 
 @
 
+\defun{incRenumber}{incRenumber}
+<<defun incRenumber>>=
+(defun |incRenumber| (ssx)
+ (|incZip| #'|incRenumberLine| ssx (|incIgen| 0)))
+
+@
+
+\defun{incRenumberLine}{incRenumberLine}
+<<defun incRenumberLine>>=
+(defun |incRenumberLine| (xl gno)
+ (let (l)
+  (setq l (|incRenumberItem| (elt xl 0) gno))
+  (|incHandleMessage| xl)
+  l))
+
+@
+\defun{incRenumberItem}{incRenumberItem}
+<<defun incRenumberItem>>=
+(defun |incRenumberItem| (f i)
+ (let (l)
+  (setq l (caar f))
+  (|lnSetGlobalNum| l i) f))
+
+@
+
+\defun{incHandleMessage}{incHandleMessage}
+<<defun incHandleMessage>>=
+(defun |incHandleMessage| (x)
+ "Message handling for the source includer"
+ (let ((msgtype (elt (elt x 1) 1))
+       (pos (car (elt x 0)))
+       (key (car (elt (elt x 1) 0)))
+       (args (cadr (elt (elt x 1) 0))))
+       
+ (cond
+  ((eq msgtype '|none|)    0)
+  ((eq msgtype '|error|)   (|ncSoftError| pos key args))
+  ((eq msgtype '|warning|) (|ncSoftError| pos key args))
+  ((eq msgtype '|say|)     (|ncSoftError| pos key args))
+  (t                       (|ncBug| key args)))))
+
+@
+
 \defun{incLude}{incLude}
 <<defun incLude>>=
 (defun |incLude| (eb ss ln ufos states) 
@@ -1234,7 +1285,8 @@ this is what the current code does so I won't change it.
 \defun{incLude1}{incLude1}
 <<defun incLude1>>=
 (defun |incLude1| (&rest z)
-(let (pred s1 n tail head includee fn1 info str state lno states ufos ln ss eb)
+ (let (pred s1 n tail head includee fn1 info str state lno states 
+       ufos ln ss eb)
   (setq eb (car z))
   (setq ss (cadr . (z)))
   (setq ln (caddr . (z)))
@@ -1401,6 +1453,456 @@ this is what the current code does so I won't change it.
       (t (cons (|xlCmdBug| eb str lno ufos) |StreamNil|))))))))
 
 @
+\defun{xlPrematureEOF}{xlPrematureEOF}
+<<defun xlPrematureEOF>>=
+(defun |xlPrematureEOF| (eb str lno ufos)
+ (|xlMsg| eb str lno (elt ufos 0)
+          (list (|inclmsgPrematureEOF| (elt ufos 0)) '|error|)))
+
+@
+
+\defun{xlMsg}{xlMsg}
+<<defun xlMsg>>=
+(defun |xlMsg| (eb str lno ufo mess)
+ (list (|incLine| eb str (- 1) lno ufo) mess))
+
+@
+
+\defun{xlOK}{xlOK}
+<<defun xlOK>>=
+(defun |xlOK| (eb str lno ufo)
+ (list (|incLine| eb str -1 lno ufo) (list nil '|none|)))
+
+@
+
+\defun{xlOK1}{xlOK1}
+<<defun xlOK1>>=
+(defun |xlOK1| (eb str str1 lno ufo)
+ (list (|incLine1| eb str str1 -1 lno ufo) (list nil '|none|)))
+
+@
+
+\defun{incLine1}{incLine1}
+<<defun incLine1>>=
+(defun |incLine1| (eb str str1 gno lno ufo)
+  (cons (cons (|lnCreate| eb str gno lno ufo) 1) str1))
+
+@
+
+\defun{inclmsgPrematureEOF}{inclmsgPrematureEOF}
+<<defun inclmsgPrematureEOF>>=
+(defun |inclmsgPrematureEOF| (ufo)
+ (list 'S2CI0002 (list (|%origin| ufo))))))
+
+@
+
+\defun{incLine}{incLine}
+<<defun incLine>>=
+(defun |incLine| (eb str gno lno ufo)
+ (cons (cons (|lnCreate| eb str gno lno ufo) 1) str))
+
+@
+
+\defun{ifCond}{ifCond}
+<<defun ifCond>>=
+(defun |ifCond| (s info)
+ (let (word)
+ (declare (special |$inclAssertions|))
+  (setq word 
+   (|MakeSymbol| (string-trim *whitespace* (|incCommandTail| s info))))
+  (|ListMemberQ?| word |$inclAssertions|)))))
+
+@
+
+\defun{xlSkip}{xlSkip}
+<<defun xlSkip>>=
+(defun |xlSkip| (eb str lno ufo)
+ (list 
+  (|incLine| eb (concat "-- Omitting:" str) -1 lno ufo)
+  (list nil '|none|)))
+
+@
+
+\defun{xlSay}{xlSay}
+<<defun xlSay>>=
+(defun |xlSay| (eb str lno ufos x)
+ (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgSay| x) '|say|)))
+
+@
+
+\defun{inclmsgSay}{inclmsgSay}
+<<defun inclmsgSay>>=
+(defun |inclmsgSay| (str)
+ (list 'S2CI0001 (list (|%id| str))))
+
+@
+
+\defun{xlNoSuchFile}{xlNoSuchFile}
+<<defun xlNoSuchFile>>=
+(defun |xlNoSuchFile| (eb str lno ufos fn)
+ (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgNoSuchFile| fn) '|error|)))
+
+@
+
+\defun{inclmsgNoSuchFile}{inclmsgNoSuchFile}
+<<defun inclmsgNoSuchFile>>=
+(defun |inclmsgNoSuchFile| (fn)
+ (list 'S2CI0010 (list (|%fname| fn))))
+
+@
+
+\defun{xlCannotRead}{xlCannotRead}
+<<defun xlCannotRead>>=
+(defun |xlCannotRead| (eb str lno ufos fn)
+ (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgCannotRead| fn) '|error|)))
+
+@
+
+\defun{inclmsgCannotRead}{inclmsgCannotRead}
+<<defun inclmsgCannotRead>>=
+(defun |inclmsgCannotRead| (fn)
+ (list 'S2CI0011 (list (|%fname| fn))))
+
+@
+
+\defun{xlFileCycle}{xlFileCycle}
+<<defun xlFileCycle>>=
+(defun |xlFileCycle| (eb str lno ufos fn)
+ (|xlMsg| eb str lno (elt ufos 0) 
+  (list (|inclmsgFileCycle| ufos fn) '|error|)))
+
+@
+
+\defun{inclmsgFileCycle}{inclmsgFileCycle}
+\begin{verbatim}
+;inclmsgFileCycle(ufos,fn) ==
+;    flist := [porigin n for n in reverse ufos]
+;    f1    := porigin fn
+;    cycle := [:[:[n,'"==>"] for n in flist], f1]
+;    ['S2CI0004, [%id cycle, %id f1]]
+
+\end{verbatim}
+<<defun inclmsgFileCycle>>=
+(defun |inclmsgFileCycle| (ufos fn)
+ (let (cycle f1 flist)
+  (setq flist
+   ((lambda (Var8 Var7 n)
+     (loop
+      (cond
+       ((or (atom Var7) (progn (setq n (car Var7)) nil))
+        (return (nreverse Var8)))
+       (t
+        (setq Var8 (cons (|porigin| n) Var))))
+      (setq Var7 (cdr Var7))))
+    nil (reverse ufos) nil))
+  (setq f1 (|porigin| fn))
+  (setq cycle
+   (append
+    ((lambda (Var10 Var9 n)
+      (loop
+       (cond
+        ((or (atom Var9) (progn (setq n (car Var9)) nil))
+          (return (nreverse Var10)))
+        (t
+         (setq Var10 (append (reverse (list n "==>")) Var10))))
+       (setq Var9 (cdr Var9))))
+     nil flist nil)
+    (cons f1 nil)))
+  (list 'S2CI0004 (list (|%id| cycle) (|%id| f1)))))
+
+@
+
+\defun{xlConActive}{xlConActive}
+<<defun xlConActive>>=
+(defun |xlConActive| (eb str lno ufos n)
+ (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgConActive| n) '|warning|)))
+
+@
+
+\defun{inclmsgConActive}{inclmsgConActive}
+<<defun inclmsgConActive>>=
+(defun |inclmsgConActive| (n)
+ (list 'S2CI0006 (list (|%id| n))))
+
+@
+
+\defun{xlConStill}{xlConStill}
+<<defun xlConStill>>=
+(defun |xlConStill| (eb str lno ufos n)
+ (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgConStill| n) '|say|)))
+
+@
+
+\defun{inclmsgConStill}{inclmsgConStill}
+<<defun inclmsgConStill>>=
+(defun |inclmsgConStill| (n)
+ (list 'S2CI0007 (list (|%id| n))))
+
+@
+
+\defun{xlConsole}{xlConsole}
+<<defun xlConsole>>=
+(defun |xlConsole| (eb str lno ufos)
+ (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgConsole|) '|say|)))
+
+@
+
+\defun{inclmsgConsole}{inclmsgConsole}
+<<defun inclmsgConsole>>=
+(defun |inclmsgConsole| ()
+ (list 'S2CI0005 nil))
+
+@
+
+\defun{xlSkippingFin}{xlSkippingFin}
+<<defun xlSkippingFin>>=
+(defun |xlSkippingFin| (eb str lno ufos)
+ (|xlMsg| eb str lno (elt ufos 0)
+   (list (|inclmsgFinSkipped|) '|warning|)))
+
+@
+
+\defun{inclmsgFinSkipped}{inclmsgFinSkipped}
+<<defun inclmsgFinSkipped>>=
+(defun |inclmsgFinSkipped| ()
+ (list 'S2CI0008 nil))
+
+@
+
+\defun{xlPrematureFin}{xlPrematureFin}
+<<defun xlPrematureFin>>=
+(defun |xlPrematureFin| (eb str lno ufos)
+ (|xlMsg| eb str lno (elt ufos 0)
+   (list (|inclmsgPrematureFin| (elt ufos 0)) '|error|)))
+
+@
+
+\defun{inclmsgPrematureFin}{inclmsgPrematureFin}
+<<defun inclmsgPrematureFin>>=
+(defun |inclmsgPrematureFin| (ufo)
+ (list 'S2CI0003 (list (|%origin| ufo))))
+
+@
+
+\defun{assertCond}{assertCond}
+<<defun assertCond>>=
+(defun |assertCond| (s info)
+ (let (word)
+ (declare (special |$inclAssertions| *whitespace*))
+  (setq word 
+   (|MakeSymbol| (string-trim *whitespace* (|incCommandTail| s info))))
+  (unless (|ListMemberQ?| word |$inclAssertions|)
+    (setq |$inclAssertions| (cons word |$inclAssertions|)))))
+
+@
+
+\defun{xlIfSyntax}{xlIfSyntax}
+<<defun xlIfSyntax>>=
+(defun |xlIfSyntax| (eb str lno ufos info sts)
+ (let (context found st)
+  (setq st (elt sts 0))
+  (setq found (elt info 2))
+  (setq context
+   (cond
+    ((|Top?| st) '|not in an )if...)endif|)
+    ((|Else?| st) '|after an )else|)
+    (t '|but can't figure out where|)))
+  (|xlMsg| eb str lno (elt ufos 0)
+    (list (|inclmsgIfSyntax| (elt ufos 0) found context) '|error|))))
+
+@
+
+\defun{inclmsgIfSyntax}{inclmsgIfSyntax}
+<<defun inclmsgIfSyntax>>=
+(defun |inclmsgIfSyntax| (ufo found context)
+ (setq found (concat ")" found))
+ (list 'S2CI0009 (list (|%id| found) (|%id| context) (|%origin| ufo))))
+
+@
+
+\defun{xlIfBug}{xlIfBug}
+<<defun xlIfBug>>=
+(defun |xlIfBug| (eb str lno ufos)
+ (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgIfBug|) '|bug|)))
+
+@
+
+\defun{inclmsgIfBug}{inclmsgIfBug}
+<<defun inclmsgIfBug>>=
+(defun |inclmsgIfBug| ()
+  (list 'S2CB0002 nil))
+
+@
+
+\defun{xlCmdBug}{xlCmdBug}
+<<defun xlCmdBug>>=
+(defun |xlCmdBug| (eb str lno ufos)
+ (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgCmdBug|) '|bug|)))
+
+@
+
+\defun{inclmsgCmdBug}{inclmsgCmdBug}
+<<defun inclmsgCmdBug>>=
+(defun |inclmsgCmdBug| ()
+ (list 'S2CB0003 nil))
+
+@
+
+This is a list of commands that can be in an include file
+<<postvars>>=
+(eval-when (eval load)
+(setq |incCommands|
+ (list "say" "include" "console" "fin" "assert" "if" "elseif" "else" "endif")))
+
+@
+
+\defun{incClassify}{incClassify}
+\being{verbatim
+;incClassify(s) ==
+;            not incCommand? s => [false,0, '""]
+;            i := 1; n := #s
+;            while i < n and s.i = char " " repeat i := i + 1
+;            i >= n => [true,0,'"other"]
+;            eb := (i = 1 => 0; i)
+;            bad:=true
+;            for p in incCommands while bad repeat
+;                incPrefix?(p, i, s) =>
+;                    bad:=false
+;                    p1 :=p
+;            if bad then [true,0,'"other"] else [true,eb,p1]
+\end{verbatim}
+<<defun incClassify>>=
+(defun |incClassify| (|s|)
+ (let (|p1| |bad| |eb| |n| |i|)
+  (cond
+   ((null (|incCommand?| |s|)) (list nil 0 ""))
+   (t
+    (setq |i| 1)
+    (setq |n| (length |s|))
+    ((lambda ()
+      (loop
+       (cond
+        ((not (and (< |i| |n|) (equal (ELT |s| |i|) (|char| '| |))))
+         (return nil))
+        (t (setq |i| (+ |i| 1)))))))
+    (cond
+     ((not (< |i| |n|)) (list T 0 "other"))
+     (t
+      (setq |eb| (cond ((eql |i| 1) 0) (t |i|)))
+      (setq |bad| t)
+      ((lambda (|bfVar#2| |p|)
+        (loop
+         (cond
+          ((or (atom |bfVar#2|)
+               (progn (setq |p| (car |bfVar#2|)) nil)
+               (not |bad|))
+            (return nil))
+          (t
+           (cond
+            ((|incPrefix?| |p| |i| |s|)
+             (identity
+              (progn
+               (setq |bad| nil)
+               (setq |p1| |p|)))))))
+         (setq |bfVar#2| (cdr |bfVar#2|))))
+        |incCommands| nil)
+      (cond
+       (|bad| (list t 0 "other"))
+       (t (list t |eb| |p1|)))))))))
+
+@
+
+\defun{incCommand?}{incCommand?}
+<<defun incCommand?>>=
+(defun |incCommand?| (s)
+  "does this start with a close paren?"
+  (and (< 0 (length s)) (equal (elt s 0) (|char| '|)|))))
+
+@
+
+\defun{incPrefix?}{incPrefix?}
+\begin{verbatim}
+;incPrefix?(prefix, start, whole) ==
+;            #prefix > #whole-start => false
+;            good:=true
+;            for i in 0..#prefix-1 for j in start.. while good repeat
+;                good:= prefix.i = whole.j
+;            good
+\end{verbatim}
+<<defun incPrefix?>>=
+(defun |incPrefix?| (prefix start whole)
+ (let (good)
+  (cond
+   ((< (- (length whole) start) (length prefix)) nil)
+   (t
+    (setq good t)
+    ((lambda (Var i j)
+      (loop
+       (cond
+        ((or (> i Var) (not good)) (return nil))
+        (t (setq good (equal (elt prefix i) (elt whole j)))))
+       (setq i (+ i 1))
+       (setq j (+ j 1))))
+      (- (length prefix) 1) 0 start)
+    good))))
+
+@
+
+\defun{incCommandTail}{incCommandTail}
+<<defun incCommandTail>>=
+(defun |incCommandTail| (s info)
+ (let ((start (elt info 1)))
+  (when (= start 0) (setq start 1))
+  (|incDrop| (+ start (length (elt info 2)) 1) s)))
+
+@
+
+\defun{incDrop}{incDrop}
+<<defun incDrop>>=
+(defun |incDrop| (n b)
+ (if (>= n (length b)) 
+  '||
+  (substring b n nil)))
+
+@
+
+\defun{inclFname}{inclFname}
+<<defun inclFname>>=
+(defun |inclFname| (s info)
+ (|incFileName| (|incCommandTail| s info)))
+
+@
+
+\defun{incFileInput}{incFileInput}
+<<defun incFileInput>>=
+(defun |incFileInput| (fn)
+  (|incRgen| (make-instream fn)))
+
+@
+
+\defun{incConsoleInput}{incConsoleInput}
+<<defun incConsoleInput>>=
+(defun |incConsoleInput| ()
+  (|incRgen| (make-instream 0)))
+
+@
+
+\defun{incNConsoles}{incNConsoles}
+<<defun incNConsoles>>=
+(defun |incNConsoles| (ufos)
+ (let ((a (member "console" ufos)))
+  (if a
+   (+ 1 (|incNConsoles| (cdr a)))
+   0)))
+
+@
+
+\defun{incActive?}{incActive?}
+<<defun incActive?>>=
+(defun |incActive?| (fn ufos)
+ (member fn ufos))
+
+@
 
 \defun{incRgen}{incRgen}
 Note that incRgen1 recursively calls this function.
@@ -17091,7 +17593,6 @@ $directory-list
 |$HistListLen|
 |$HistRecord|
 |$inLispVM|
-|$inclAssertions|
 |$InitialModemapFrame|)) 
 in-stream
 |$InteractiveFrame| 
@@ -17153,7 +17654,6 @@ $spadroot
 |$texOutputStream|
 /timerlist
 |$timerTicksPerSecond|
-|Top|
 |$tracedMapSignatures|
 |$tracedModemap|
 |$tracedSpadModemap|
@@ -17173,19 +17673,30 @@ $traceletflag
 \section{undefined functions}
 \begin{verbatim}
 currenttime
+|%d| -- used as a function in inclmsgSay but never defined.
 error
-|incRenumber|
-|incRgen1|
+expand-tabs
+|%fname|
+|incAppend|
+|%id|
 |insertpile|
 |intloopEchoParse|
 |intloopProcess|
 |intloopProcessString|
 |intnplisp|
 |lineoftoks|
+|ListMemberQ?|
+|lnCreate|
+|lnSetGlobalNum|
+|MakeSymbol|
+|ncBug|
 |ncloopEchoParse|
 |ncloopProcess|
+|%origin|
+|porigin|
 |resetStackLimits|
 |shoeread-line|
+|StreamNull|
 stringimage
 \end{verbatim}
 
@@ -17205,6 +17716,7 @@ stringimage
 <<defun addNewInterpreterFrame>>
 <<defun addTraceItem>>
 <<defun apropos>>
+<<defun assertCond>>
 <<defun augmentTraceNames>>
 
 <<defun break>>
@@ -17330,11 +17842,40 @@ stringimage
 <<defun historySpad2Cmd>>
 
 <<defun If?>>
+<<defun ifCond>>
 <<defun importFromFrame>>
+<<defun incActive?>>
 <<defun incBiteOff>>
+<<defun incClassify>>
+<<defun incCommand?>>
+<<defun incCommandTail>>
+<<defun incConsoleInput>>
+<<defun incDrop>>
+<<defun incFileInput>>
+<<defun incFileName>>
+<<defun incHandleMessage>>
+<<defun inclFname>>
+<<defun incLine>>
+<<defun incLine1>>
+<<defun inclmsgCannotRead>>
+<<defun inclmsgFileCycle>>
+<<defun inclmsgFinSkipped>>
+<<defun inclmsgPrematureEOF>>
+<<defun inclmsgPrematureFin>>
 <<defun incLude>>
 <<defun incLude1>>
-<<defun incFileName>>
+<<defun inclmsgCmdBug>>
+<<defun inclmsgConActive>>
+<<defun inclmsgConStill>>
+<<defun inclmsgIfBug>>
+<<defun inclmsgIfSyntax>>
+<<defun inclmsgNoSuchFile>>
+<<defun inclmsgSay>>
+<<defun incNConsoles>>
+<<defun incPrefix?>>
+<<defun incRenumber>>
+<<defun incRenumberItem>>
+<<defun incRenumberLine>>
 <<defun incRgen>>
 <<defun incRgen1>>
 <<defun incStream>>
@@ -17559,6 +18100,23 @@ stringimage
 <<defun writifyComplain>>
 <<defun writify,writifyInner>>
 
+<<defun xlCannotRead>>
+<<defun xlCmdBug>>
+<<defun xlConActive>>
+<<defun xlConStill>>
+<<defun xlFileCycle>>
+<<defun xlIfBug>>
+<<defun xlIfSyntax>>
+<<defun xlMsg>>
+<<defun xlNoSuchFile>>
+<<defun xlOK>>
+<<defun xlOK1>>
+<<defun xlPrematureEOF>>
+<<defun xlPrematureFin>>
+<<defun xlSay>>
+<<defun xlSkip>>
+<<defun xlSkippingFin>>
+
 <<defun yesanswer>>
 
 <<defun zsystemdevelopment>>
@@ -17638,7 +18196,6 @@ curoutstream                 & ncIntLoop           & \\
 \$historyDirectory           &                     & makeHistFileName \\
                              &                     & makeHistFileName \\
 \$historyFileType            & initvars           & histInputFileName \\
-\$inclAssertions             & SpadInterpretStream & \\
 \$inLispVM                   & spad                & \\
 \$InteractiveFrame           & restart             & ncTopLevel \\
                              & undo                & recordFrame \\
@@ -17820,10 +18377,6 @@ is intended to be used as a filetype extension.
 It is part of the history mechanism. It is used in makeHistFileName
 as part of the history file name.
 
-\subsection{\$inclAssertions}
-The \verb|$inclAssertions| is set 
-in the function SpadInterpretStream to the list (aix |CommonLisp|)
-
 \subsection{\$internalHistoryTable}
 The \verb|$internalHistoryTable| variable is set at load time by a call to
 initvars to a value of NIL.
diff --git a/changelog b/changelog
index c0a3be1..943dc9c 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,8 @@
+20091018 tpd src/axiom-website/patches.html 20091018.01.tpd.patch
+20091018 tpd books/bookvol5 merge incl.lisp
+20091018 tpd src/interp/incl.lisp merged with bookvol5, removed
+20091018 tpd src/interp/vmlisp remove WhiteSpaceCset
+20091018 tpd src/interp/Makefile remove incl.lisp
 20091015 tpd src/axiom-website/patches.html 20091015.01.tpd.patch
 20091015 tpd src/input/zimmbron.input fix typo
 20091011 tpd src/axiom-website/patches.html 20091011.01.tpd.patch
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index d975244..3f9d84a 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -2151,5 +2151,7 @@ src/interp/slam.lisp cleanup<br/>
 src/interp/wi2.lisp cleanup<br/>
 <a href="patches/20091015.01.tpd.patch">20091015.01.tpd.patch</a>
 src/input/zimmbron.input fix typo<br/>
+<a href="patches/20091018.01.tpd.patch">20091018.01.tpd.patch</a>
+books/bookvol5 merge and remove incl.lisp<br/>
  </body>
 </html>
diff --git a/src/interp/Makefile.pamphlet b/src/interp/Makefile.pamphlet
index f4187d2..f5cd870 100644
--- a/src/interp/Makefile.pamphlet
+++ b/src/interp/Makefile.pamphlet
@@ -196,7 +196,7 @@ OBJS= ${OUT}/vmlisp.${O}      \
       ${OUT}/i-spec1.${O}    \
       ${OUT}/i-spec2.${O}     ${OUT}/i-syscmd.${O} \
       ${OUT}/i-toplev.${O}    ${OUT}/i-util.${O} \
-      ${OUT}/incl.${O}        ${OUT}/int-top.${O} \
+      ${OUT}/int-top.${O} \
       ${OUT}/intfile.${O}    \
       ${OUT}/lisplib.${O}     ${OUT}/macex.${O} \
       ${OUT}/match.${O}    \
@@ -221,7 +221,7 @@ OBJS= ${OUT}/vmlisp.${O}      \
       ${OUT}/daase.${O}   \
       ${OUT}/fortcall.${O} \
       ${OUT}/parsing.${O} ${OUT}/fnewmeta.${O} \
-      ${OUT}/postprop.${LISP}	\
+      ${OUT}/postprop.lisp	\
       ${OUT}/apply.${O}	      ${OUT}/c-doc.${O}    \
       ${OUT}/c-util.${O}      ${OUT}/profile.${O}  \
       ${OUT}/category.${O}    ${OUT}/compiler.${O} \
@@ -1163,17 +1163,11 @@ ${MID}/patches.lisp: ${IN}/patches.lisp.pamphlet
 @
 
 \subsection{postprop.lisp \cite{30}}
-<<postprop.lisp (AUTO from OUT)>>=
-${AUTO}/postprop.lisp: ${OUT}/postprop.lisp
-	@ echo 102 making ${AUTO}/postprop.lisp from ${OUT}/postprop.lisp
-	@ cp ${OUT}/postprop.lisp ${AUTO}
-
-@
 <<postprop.lisp (OUT from MID)>>=
 ${OUT}/postprop.lisp: ${MID}/postprop.lisp
 	@ echo 103 making ${OUT}/postprop.lisp from ${MID}/postprop.lisp
 	@ rm -f ${OUT}/postprop.${O}
-	@ cp ${MID}/postprop.lisp ${OUT}/postprop.${LISP}
+	@ cp ${MID}/postprop.lisp ${OUT}/postprop.lisp
 
 @
 <<postprop.lisp (MID from IN)>>=
@@ -3395,29 +3389,6 @@ ${MID}/topics.lisp: ${IN}/topics.lisp.pamphlet
 
 @
 
-\subsection{incl.lisp}
-<<incl.o (OUT from MID)>>=
-${OUT}/incl.${O}: ${MID}/incl.lisp
-	@ echo 136 making ${OUT}/incl.${O} from ${MID}/incl.lisp
-	@ ( cd ${MID} ; \
-	  if [ -z "${NOISE}" ] ; then \
-	   echo '(progn  (compile-file "${MID}/incl.lisp"' \
-             ':output-file "${OUT}/incl.${O}") (${BYE}))' | ${DEPSYS} ; \
-	  else \
-	   echo '(progn  (compile-file "${MID}/incl.lisp"' \
-             ':output-file "${OUT}/incl.${O}") (${BYE}))' | ${DEPSYS} \
-             >${TMP}/trace ; \
-	  fi )
-
-@
-<<incl.lisp (MID from IN)>>=
-${MID}/incl.lisp: ${IN}/incl.lisp.pamphlet
-	@ echo 137 making ${MID}/incl.lisp from ${IN}/incl.lisp.pamphlet
-	@ (cd ${MID} ; \
-	   ${TANGLE} ${IN}/incl.lisp.pamphlet >incl.lisp )
-
-@
-
 \subsection{scan.lisp}
 <<scan.o (OUT from MID)>>=
 ${OUT}/scan.${O}: ${MID}/scan.lisp
@@ -4423,9 +4394,6 @@ clean:
 <<i-map.o (OUT from MID)>>
 <<i-map.lisp (MID from IN)>>
 
-<<incl.o (OUT from MID)>>
-<<incl.lisp (MID from IN)>>
-
 <<info.o (OUT from MID)>>
 <<info.lisp (MID from IN)>>
 
@@ -4610,7 +4578,6 @@ clean:
 <<posit.o (OUT from MID)>>
 <<posit.lisp (MID from IN)>>
 
-<<postprop.lisp (AUTO from OUT)>>
 <<postprop.lisp (OUT from MID)>>
 <<postprop.lisp (MID from IN)>>
 
diff --git a/src/interp/incl.lisp.pamphlet b/src/interp/incl.lisp.pamphlet
deleted file mode 100644
index 66faf7a..0000000
--- a/src/interp/incl.lisp.pamphlet
+++ /dev/null
@@ -1,683 +0,0 @@
-\documentclass{article}
-\usepackage{axiom}
-\begin{document}
-\title{\$SPAD/src/interp incl.lisp}
-\author{The Axiom Team}
-\maketitle
-\begin{abstract}
-\end{abstract}
-\eject
-\tableofcontents
-\eject
-<<*>>=
-
-(IN-PACKAGE "BOOT")
-
-;incStringStream s==
-;   incRenumber incLude(0,incRgen s,0,['"strings"] ,[Top])
-
-(DEFUN |incStringStream| (|s|)
-  (PROG ()
-    (RETURN
-      (|incRenumber|
-          (|incLude| 0 (|incRgen| |s|) 0 (LIST "strings") (LIST |Top|))))))
-
-;incFile fn==
-;   incRenumber incLude(0,incRgen OPEN fn,0,[fn],[Top])
-
-(DEFUN |incFile| (|fn|)
-  (PROG ()
-    (RETURN
-      (|incRenumber|
-          (|incLude| 0 (|incRgen| (OPEN |fn|)) 0 (LIST |fn|)
-              (LIST |Top|))))))
-
-;incFileInput    fn == incRgen  MAKE_-INSTREAM fn
-
-(DEFUN |incFileInput| (|fn|)
-  (PROG () (RETURN (|incRgen| (MAKE-INSTREAM |fn|)))))
-
-;incConsoleInput () == incRgen  MAKE_-INSTREAM 0
-(DEFUN |incConsoleInput| ()
-  (PROG () (RETURN (|incRgen| (MAKE-INSTREAM 0)))))
-
-;incLine(eb, str, gno, lno, ufo) ==
-;            ln := lnCreate(eb,str,gno,lno,ufo)
-;            CONS(CONS(ln,1), str)
-
-(DEFUN |incLine| (|eb| |str| |gno| |lno| |ufo|)
-  (PROG (|ln|)
-    (RETURN
-      (PROGN
-        (SETQ |ln| (|lnCreate| |eb| |str| |gno| |lno| |ufo|))
-        (CONS (CONS |ln| 1) |str|)))))
-
-;incPos f == CAR f
-
-(DEFUN |incPos| (|f|) (PROG () (RETURN (CAR |f|))))
-
-;incRenumberItem(f, i) ==
-;            l := CAAR f
-;            lnSetGlobalNum(l, i)
-;            f
-
-(DEFUN |incRenumberItem| (|f| |i|)
-  (PROG (|l|)
-    (RETURN
-      (PROGN (SETQ |l| (CAAR |f|)) (|lnSetGlobalNum| |l| |i|) |f|))))
-
-;incRenumberLine(xl, gno) ==
-;            l := incRenumberItem(xl.0, gno)
-;            incHandleMessage xl
-;            l
-
-(DEFUN |incRenumberLine| (|xl| |gno|)
-  (PROG (|l|)
-    (RETURN
-      (PROGN
-        (SETQ |l| (|incRenumberItem| (ELT |xl| 0) |gno|))
-        (|incHandleMessage| |xl|)
-        |l|))))
-
-;incRenumber ssx == incZip (function incRenumberLine, ssx, incIgen 0)
-
-(DEFUN |incRenumber| (|ssx|)
-  (PROG ()
-    (RETURN (|incZip| #'|incRenumberLine| |ssx| (|incIgen| 0)))))
-
-;incPrefix?(prefix, start, whole) ==
-;            #prefix > #whole-start => false
-;            good:=true
-;            for i in 0..#prefix-1 for j in start.. while good repeat
-;                good:= prefix.i = whole.j
-;            good
-
-(DEFUN |incPrefix?| (|prefix| |start| |whole|)
-  (PROG (|good|)
-    (RETURN
-      (COND
-        ((< (- (LENGTH |whole|) |start|) (LENGTH |prefix|)) NIL)
-        ('T
-         (PROGN
-           (SETQ |good| T)
-           ((LAMBDA (|bfVar#1| |i| |j|)
-              (LOOP
-                (COND
-                  ((OR (> |i| |bfVar#1|) (NOT |good|)) (RETURN NIL))
-                  ('T
-                   (SETQ |good|
-                         (EQUAL (ELT |prefix| |i|) (ELT |whole| |j|)))))
-                (SETQ |i| (+ |i| 1))
-                (SETQ |j| (+ |j| 1))))
-            (- (LENGTH |prefix|) 1) 0 |start|)
-           |good|))))))
-
-;incCommand?(s) == #s > 0 and s.0 = char ")"
-
-(DEFUN |incCommand?| (|s|)
-  (PROG ()
-    (RETURN
-      (AND (< 0 (LENGTH |s|)) (EQUAL (ELT |s| 0) (|char| '|)|))))))
-
-;incCommands :=
-;            ['"say"    , _
-;             '"include", _
-;             '"console", _
-;             '"fin"    , _
-;             '"assert" , _
-;             '"if"     , _
-;             '"elseif" , _
-;             '"else"   , _
-;             '"endif" ]
-
-(EVAL-WHEN (EVAL LOAD)
-  (SETQ |incCommands|
-        (LIST "say" "include" "console" "fin" "assert" "if" "elseif"
-              "else" "endif")))
-
-;incClassify(s) ==
-;            not incCommand? s => [false,0, '""]
-;            i := 1; n := #s
-;            while i < n and s.i = char " " repeat i := i + 1
-;            i >= n => [true,0,'"other"]
-;            eb := (i = 1 => 0; i)
-;            bad:=true
-;            for p in incCommands while bad repeat
-;                incPrefix?(p, i, s) =>
-;                    bad:=false
-;                    p1 :=p
-;            if bad then [true,0,'"other"] else [true,eb,p1]
-
-(DEFUN |incClassify| (|s|)
-  (PROG (|p1| |bad| |eb| |n| |i|)
-    (RETURN
-      (COND
-        ((NULL (|incCommand?| |s|)) (LIST NIL 0 ""))
-        ('T
-         (PROGN
-           (SETQ |i| 1)
-           (SETQ |n| (LENGTH |s|))
-           ((LAMBDA ()
-              (LOOP
-                (COND
-                  ((NOT (AND (< |i| |n|)
-                             (EQUAL (ELT |s| |i|) (|char| '| |))))
-                   (RETURN NIL))
-                  ('T (SETQ |i| (+ |i| 1)))))))
-           (COND
-             ((NOT (< |i| |n|)) (LIST T 0 "other"))
-             ('T
-              (PROGN
-                (SETQ |eb| (COND ((EQL |i| 1) 0) ('T |i|)))
-                (SETQ |bad| T)
-                ((LAMBDA (|bfVar#2| |p|)
-                   (LOOP
-                     (COND
-                       ((OR (ATOM |bfVar#2|)
-                            (PROGN (SETQ |p| (CAR |bfVar#2|)) NIL)
-                            (NOT |bad|))
-                        (RETURN NIL))
-                       ('T
-                        (COND
-                          ((|incPrefix?| |p| |i| |s|)
-                           (IDENTITY
-                               (PROGN
-                                 (SETQ |bad| NIL)
-                                 (SETQ |p1| |p|)))))))
-                     (SETQ |bfVar#2| (CDR |bfVar#2|))))
-                 |incCommands| NIL)
-                (COND
-                  (|bad| (LIST T 0 "other"))
-                  ('T (LIST T |eb| |p1|))))))))))))
-
-;incCommandTail(s, info) ==
-;            start := (info.1 = 0 => 1; info.1)
-;            incDrop(start+#info.2+1, s)
-
-(DEFUN |incCommandTail| (|s| |info|)
-  (PROG (|start|)
-    (RETURN
-      (PROGN
-        (SETQ |start|
-              (COND ((EQL (ELT |info| 1) 0) 1) ('T (ELT |info| 1))))
-        (|incDrop| (+ (+ |start| (LENGTH (ELT |info| 2))) 1) |s|)))))
-
-;incDrop(n, b) ==
-;            n >= #b => ""
-;            SUBSTRING(b,n,nil)
-
-(DEFUN |incDrop| (|n| |b|)
-  (PROG ()
-    (RETURN
-      (COND
-        ((NOT (< |n| (LENGTH |b|))) '||)
-        ('T (SUBSTRING |b| |n| NIL))))))
-
-;inclFname(s, info) == incFileName incCommandTail(s, info)
-
-(DEFUN |inclFname| (|s| |info|)
-  (PROG () (RETURN (|incFileName| (|incCommandTail| |s| |info|)))))
-
-;incTrunc (n,x)==
-;     if #x>n
-;     then SUBSTRING(x,0,n)
-;     else x
-
-(DEFUN |incTrunc| (|n| |x|)
-  (PROG ()
-    (RETURN
-      (COND ((< |n| (LENGTH |x|)) (SUBSTRING |x| 0 |n|)) ('T |x|)))))
-
-;incFileName x == first incBiteOff x
-
-(DEFUN |incFileName| (|x|)
-  (PROG () (RETURN (CAR (|incBiteOff| |x|)))))
-
-;fileNameStrings fn==[PNAME(fn.0),PNAME(fn.1),PNAME(fn.2)]
-
-(DEFUN |fileNameStrings| (|fn|)
-  (PROG ()
-    (RETURN
-      (LIST (PNAME (ELT |fn| 0)) (PNAME (ELT |fn| 1))
-            (PNAME (ELT |fn| 2))))))
-
-;ifCond(s, info) ==
-;    word := MakeSymbol StringTrim(incCommandTail(s, info), WhiteSpaceCset)
-;    ListMemberQ?(word, $inclAssertions)
-
-(DEFUN |ifCond| (|s| |info|)
-  (PROG (|word|)
-    (DECLARE (SPECIAL |$inclAssertions|))
-    (RETURN
-      (PROGN
-        (SETQ |word|
-              (|MakeSymbol|
-                  (|StringTrim| (|incCommandTail| |s| |info|)
-                      |WhiteSpaceCset|)))
-        (|ListMemberQ?| |word| |$inclAssertions|)))))
-
-;assertCond(s, info) ==
-;    word := MakeSymbol StringTrim(incCommandTail(s, info), WhiteSpaceCset)
-;    if not ListMemberQ?(word, $inclAssertions) then
-;        $inclAssertions := [word, :$inclAssertions]
-
-(DEFUN |assertCond| (|s| |info|)
-  (PROG (|word|)
-    (DECLARE (SPECIAL |$inclAssertions|))
-    (RETURN
-      (PROGN
-        (SETQ |word|
-              (|MakeSymbol|
-                  (|StringTrim| (|incCommandTail| |s| |info|)
-                      |WhiteSpaceCset|)))
-        (COND
-          ((NULL (|ListMemberQ?| |word| |$inclAssertions|))
-           (SETQ |$inclAssertions| (CONS |word| |$inclAssertions|))))))))
-
-;incActive?(fn,ufos)==MEMBER(fn,ufos)
-
-(DEFUN |incActive?| (|fn| |ufos|)
-  (PROG () (RETURN (MEMBER |fn| |ufos|))))
-
-;incNConsoles ufos==
-;        a:=MEMBER('"console",ufos)
-;        if a then 1+incNConsoles CDR a else 0
-
-(DEFUN |incNConsoles| (|ufos|)
-  (PROG (|a|)
-    (RETURN
-      (PROGN
-        (SETQ |a| (MEMBER "console" |ufos|))
-        (COND (|a| (+ 1 (|incNConsoles| (CDR |a|)))) ('T 0))))))
-
-;        --% Message Handling
-;incHandleMessage(xl) ==
-;          xl.1.1 = "none" =>
-;              0
-;          xl.1.1 = "error" =>
-;              inclHandleError(incPos xl.0, xl.1.0)
-;          xl.1.1 = "warning" =>
-;              inclHandleWarning(incPos xl.0, xl.1.0)
-;          xl.1.1 = "say" =>
-;              inclHandleSay(incPos xl.0, xl.1.0)
-;          inclHandleBug(incPos xl.0, xl.1.0)
-
-(DEFUN |incHandleMessage| (|xl|)
-  (PROG ()
-    (RETURN
-      (COND
-        ((EQ (ELT (ELT |xl| 1) 1) '|none|) 0)
-        ((EQ (ELT (ELT |xl| 1) 1) '|error|)
-         (|inclHandleError| (|incPos| (ELT |xl| 0))
-             (ELT (ELT |xl| 1) 0)))
-        ((EQ (ELT (ELT |xl| 1) 1) '|warning|)
-         (|inclHandleWarning| (|incPos| (ELT |xl| 0))
-             (ELT (ELT |xl| 1) 0)))
-        ((EQ (ELT (ELT |xl| 1) 1) '|say|)
-         (|inclHandleSay| (|incPos| (ELT |xl| 0)) (ELT (ELT |xl| 1) 0)))
-        ('T
-         (|inclHandleBug| (|incPos| (ELT |xl| 0)) (ELT (ELT |xl| 1) 0)))))))
-
-;xlOK(eb, str, lno, ufo)  ==
-;                [incLine(eb, str, -1, lno, ufo), [NIL, "none"]]
-
-(DEFUN |xlOK| (|eb| |str| |lno| |ufo|)
-  (PROG ()
-    (RETURN
-      (LIST (|incLine| |eb| |str| (- 1) |lno| |ufo|)
-            (LIST NIL '|none|)))))
-
-;xlOK1(eb, str,str1, lno, ufo)  ==
-;                [incLine1(eb, str,str1, -1, lno, ufo), [NIL, "none"]]
-
-(DEFUN |xlOK1| (|eb| |str| |str1| |lno| |ufo|)
-  (PROG ()
-    (RETURN
-      (LIST (|incLine1| |eb| |str| |str1| (- 1) |lno| |ufo|)
-            (LIST NIL '|none|)))))
-
-;incLine1(eb, str,str1, gno, lno, ufo) ==
-;            ln := lnCreate(eb,str,gno,lno,ufo)
-;            CONS(CONS(ln,1), str1)
-
-(DEFUN |incLine1| (|eb| |str| |str1| |gno| |lno| |ufo|)
-  (PROG (|ln|)
-    (RETURN
-      (PROGN
-        (SETQ |ln| (|lnCreate| |eb| |str| |gno| |lno| |ufo|))
-        (CONS (CONS |ln| 1) |str1|)))))
-
-;xlSkip(eb, str, lno, ufo) ==
-;        str := CONCAT('"-- Omitting:", str)
-;        [incLine(eb, str, -1, lno, ufo), [NIL, "none"]]
-
-(DEFUN |xlSkip| (|eb| |str| |lno| |ufo|)
-  (PROG ()
-    (RETURN
-      (PROGN
-        (SETQ |str| (CONCAT "-- Omitting:" |str|))
-        (LIST (|incLine| |eb| |str| (- 1) |lno| |ufo|)
-              (LIST NIL '|none|))))))
-
-;xlMsg(eb, str, lno, ufo, mess) ==
-;                [incLine(eb, str, -1, lno, ufo), mess]
-
-(DEFUN |xlMsg| (|eb| |str| |lno| |ufo| |mess|)
-  (PROG ()
-    (RETURN (LIST (|incLine| |eb| |str| (- 1) |lno| |ufo|) |mess|))))
-
-;xlPrematureEOF(eb, str, lno, ufos) ==
-;          xlMsg(eb, str, lno,ufos.0,
-;              [inclmsgPrematureEOF(ufos.0),"error"])
-
-(DEFUN |xlPrematureEOF| (|eb| |str| |lno| |ufos|)
-  (PROG ()
-    (RETURN
-      (|xlMsg| |eb| |str| |lno| (ELT |ufos| 0)
-               (LIST (|inclmsgPrematureEOF| (ELT |ufos| 0)) '|error|)))))
-
-;xlPrematureFin(eb, str, lno, ufos) ==
-;          xlMsg(eb, str, lno,ufos.0,
-;              [inclmsgPrematureFin(ufos.0),"error"])
-
-(DEFUN |xlPrematureFin| (|eb| |str| |lno| |ufos|)
-  (PROG ()
-    (RETURN
-      (|xlMsg| |eb| |str| |lno| (ELT |ufos| 0)
-               (LIST (|inclmsgPrematureFin| (ELT |ufos| 0)) '|error|)))))
-
-;xlFileCycle(eb, str, lno, ufos, fn) ==
-;          xlMsg(eb, str, lno,ufos.0,
-;              [inclmsgFileCycle(ufos,fn),"error"])
-
-(DEFUN |xlFileCycle| (|eb| |str| |lno| |ufos| |fn|)
-  (PROG ()
-    (RETURN
-      (|xlMsg| |eb| |str| |lno| (ELT |ufos| 0)
-               (LIST (|inclmsgFileCycle| |ufos| |fn|) '|error|)))))
-
-;xlNoSuchFile(eb, str, lno, ufos, fn) ==
-;          xlMsg(eb, str, lno,ufos.0,
-;              [inclmsgNoSuchFile(fn), "error"])
-
-(DEFUN |xlNoSuchFile| (|eb| |str| |lno| |ufos| |fn|)
-  (PROG ()
-    (RETURN
-      (|xlMsg| |eb| |str| |lno| (ELT |ufos| 0)
-               (LIST (|inclmsgNoSuchFile| |fn|) '|error|)))))
-
-;xlCannotRead(eb, str, lno, ufos, fn) ==
-;          xlMsg(eb, str, lno,ufos.0,
-;              [inclmsgCannotRead(fn), "error"])
-
-(DEFUN |xlCannotRead| (|eb| |str| |lno| |ufos| |fn|)
-  (PROG ()
-    (RETURN
-      (|xlMsg| |eb| |str| |lno| (ELT |ufos| 0)
-               (LIST (|inclmsgCannotRead| |fn|) '|error|)))))
-
-;xlConsole(eb, str, lno, ufos)  ==
-;          xlMsg(eb, str, lno,ufos.0,
-;              [inclmsgConsole(),"say"])
-
-(DEFUN |xlConsole| (|eb| |str| |lno| |ufos|)
-  (PROG ()
-    (RETURN
-      (|xlMsg| |eb| |str| |lno| (ELT |ufos| 0)
-               (LIST (|inclmsgConsole|) '|say|)))))
-
-;xlConActive(eb, str, lno, ufos, n) ==
-;          xlMsg(eb, str, lno,ufos.0,
-;              [inclmsgConActive(n),"warning"])
-
-(DEFUN |xlConActive| (|eb| |str| |lno| |ufos| |n|)
-  (PROG ()
-    (RETURN
-      (|xlMsg| |eb| |str| |lno| (ELT |ufos| 0)
-               (LIST (|inclmsgConActive| |n|) '|warning|)))))
-
-;xlConStill(eb, str, lno, ufos, n) ==
-;          xlMsg(eb, str, lno,ufos.0,
-;              [inclmsgConStill(n), "say"])
-
-(DEFUN |xlConStill| (|eb| |str| |lno| |ufos| |n|)
-  (PROG ()
-    (RETURN
-      (|xlMsg| |eb| |str| |lno| (ELT |ufos| 0)
-               (LIST (|inclmsgConStill| |n|) '|say|)))))
-
-;xlSkippingFin(eb, str, lno, ufos) ==
-;          xlMsg(eb, str, lno,ufos.0,
-;              [inclmsgFinSkipped(),"warning"])
-
-(DEFUN |xlSkippingFin| (|eb| |str| |lno| |ufos|)
-  (PROG ()
-    (RETURN
-      (|xlMsg| |eb| |str| |lno| (ELT |ufos| 0)
-               (LIST (|inclmsgFinSkipped|) '|warning|)))))
-
-;xlIfBug(eb, str, lno, ufos) ==
-;          xlMsg(eb, str, lno,ufos.0,
-;              [inclmsgIfBug(), "bug"])
-
-(DEFUN |xlIfBug| (|eb| |str| |lno| |ufos|)
-  (PROG ()
-    (RETURN
-      (|xlMsg| |eb| |str| |lno| (ELT |ufos| 0)
-               (LIST (|inclmsgIfBug|) '|bug|)))))
-
-;xlCmdBug(eb, str, lno, ufos) ==
-;          xlMsg(eb, str, lno,ufos.0,
-;              [inclmsgCmdBug(), "bug"])
-
-(DEFUN |xlCmdBug| (|eb| |str| |lno| |ufos|)
-  (PROG ()
-    (RETURN
-      (|xlMsg| |eb| |str| |lno| (ELT |ufos| 0)
-               (LIST (|inclmsgCmdBug|) '|bug|)))))
-
-;xlSay(eb, str, lno, ufos, x) ==
-;          xlMsg(eb, str, lno,ufos.0,
-;              [inclmsgSay(x), "say"])
-
-(DEFUN |xlSay| (|eb| |str| |lno| |ufos| |x|)
-  (PROG ()
-    (RETURN
-      (|xlMsg| |eb| |str| |lno| (ELT |ufos| 0)
-               (LIST (|inclmsgSay| |x|) '|say|)))))
-
-;xlIfSyntax(eb, str, lno,ufos,info,sts) ==
-;          st := sts.0
-;          found := info.2
-;          context :=
-;              Top? st  => "not in an )if...)endif"
-;              Else? st => "after an )else"
-;              "but can't figure out where"
-;          xlMsg(eb, str, lno, ufos.0,
-;               [inclmsgIfSyntax(ufos.0,found,context), "error"])
-(DEFUN |xlIfSyntax| (|eb| |str| |lno| |ufos| |info| |sts|)
-  (PROG (|context| |found| |st|)
-    (RETURN
-      (PROGN
-        (SETQ |st| (ELT |sts| 0))
-        (SETQ |found| (ELT |info| 2))
-        (SETQ |context|
-              (COND
-                ((|Top?| |st|) '|not in an )if...)endif|)
-                ((|Else?| |st|) '|after an )else|)
-                ('T '|but can't figure out where|)))
-        (|xlMsg| |eb| |str| |lno| (ELT |ufos| 0)
-                 (LIST (|inclmsgIfSyntax| (ELT |ufos| 0) |found|
-                           |context|)
-                       '|error|))))))
-
-;        --% This is it
-; 
-; --% Message handling for the source includer
-;--  SMW June 88
-; 
-;inclHandleError(pos, [key, args]) ==
-;    ncSoftError(pos, key, args)
-
-(DEFUN |inclHandleError| (|pos| |bfVar#3|)
-  (PROG (|args| |key|)
-    (RETURN
-      (PROGN
-        (SETQ |key| (CAR |bfVar#3|))
-        (SETQ |args| (CADR |bfVar#3|))
-        (|ncSoftError| |pos| |key| |args|)))))
-
-;inclHandleWarning(pos, [key, args]) ==
-;    ncSoftError(pos, key,args)
-
-(DEFUN |inclHandleWarning| (|pos| |bfVar#4|)
-  (PROG (|args| |key|)
-    (RETURN
-      (PROGN
-        (SETQ |key| (CAR |bfVar#4|))
-        (SETQ |args| (CADR |bfVar#4|))
-        (|ncSoftError| |pos| |key| |args|)))))
-
-;inclHandleBug(pos, [key, args]) ==
-;    ncBug(key, args)
-
-(DEFUN |inclHandleBug| (|pos| |bfVar#5|)
-  (PROG (|args| |key|)
-    (RETURN
-      (PROGN
-        (SETQ |key| (CAR |bfVar#5|))
-        (SETQ |args| (CADR |bfVar#5|))
-        (|ncBug| |key| |args|)))))
-
-;inclHandleSay(pos, [key, args]) ==
-;    ncSoftError(pos, key, args)
-
-(DEFUN |inclHandleSay| (|pos| |bfVar#6|)
-  (PROG (|args| |key|)
-    (RETURN
-      (PROGN
-        (SETQ |key| (CAR |bfVar#6|))
-        (SETQ |args| (CADR |bfVar#6|))
-        (|ncSoftError| |pos| |key| |args|)))))
-
-;inclmsgSay str  ==
-;    ['S2CI0001, [%id str]]
-
-(DEFUN |inclmsgSay| (|str|)
-  (PROG () (RETURN (LIST 'S2CI0001 (LIST (|%id| |str|))))))
-
-;inclmsgPrematureEOF ufo  ==
-;    ['S2CI0002, [%origin ufo]]
-
-(DEFUN |inclmsgPrematureEOF| (|ufo|)
-  (PROG () (RETURN (LIST 'S2CI0002 (LIST (|%origin| |ufo|))))))
-
-;inclmsgPrematureFin ufo  ==
-;    ['S2CI0003, [%origin ufo]]
-
-(DEFUN |inclmsgPrematureFin| (|ufo|)
-  (PROG () (RETURN (LIST 'S2CI0003 (LIST (|%origin| |ufo|))))))
-
-;inclmsgFileCycle(ufos,fn) ==
-;    flist := [porigin n for n in reverse ufos]
-;    f1    := porigin fn
-;    cycle := [:[:[n,'"==>"] for n in flist], f1]
-;    ['S2CI0004, [%id cycle, %id f1]]
-
-(DEFUN |inclmsgFileCycle| (|ufos| |fn|)
-  (PROG (|cycle| |f1| |flist|)
-    (RETURN
-      (PROGN
-        (SETQ |flist|
-              ((LAMBDA (|bfVar#8| |bfVar#7| |n|)
-                 (LOOP
-                   (COND
-                     ((OR (ATOM |bfVar#7|)
-                          (PROGN (SETQ |n| (CAR |bfVar#7|)) NIL))
-                      (RETURN (NREVERSE |bfVar#8|)))
-                     ('T
-                      (SETQ |bfVar#8| (CONS (|porigin| |n|) |bfVar#8|))))
-                   (SETQ |bfVar#7| (CDR |bfVar#7|))))
-               NIL (REVERSE |ufos|) NIL))
-        (SETQ |f1| (|porigin| |fn|))
-        (SETQ |cycle|
-              (APPEND ((LAMBDA (|bfVar#10| |bfVar#9| |n|)
-                         (LOOP
-                           (COND
-                             ((OR (ATOM |bfVar#9|)
-                                  (PROGN
-                                    (SETQ |n| (CAR |bfVar#9|))
-                                    NIL))
-                              (RETURN (NREVERSE |bfVar#10|)))
-                             ('T
-                              (SETQ |bfVar#10|
-                                    (APPEND (REVERSE (LIST |n| "==>"))
-                                     |bfVar#10|))))
-                           (SETQ |bfVar#9| (CDR |bfVar#9|))))
-                       NIL |flist| NIL)
-                      (CONS |f1| NIL)))
-        (LIST 'S2CI0004 (LIST (|%id| |cycle|) (|%id| |f1|)))))))
-
-;inclmsgConsole   () ==
-;    ['S2CI0005, []]
-
-(DEFUN |inclmsgConsole| () (PROG () (RETURN (LIST 'S2CI0005 NIL))))
-
-;inclmsgConActive n  ==
-;    ['S2CI0006, [%id n]]
-
-(DEFUN |inclmsgConActive| (|n|)
-  (PROG () (RETURN (LIST 'S2CI0006 (LIST (|%id| |n|))))))
-
-;inclmsgConStill  n  ==
-;    ['S2CI0007, [%id n]]
-
-(DEFUN |inclmsgConStill| (|n|)
-  (PROG () (RETURN (LIST 'S2CI0007 (LIST (|%id| |n|))))))
-
-;inclmsgFinSkipped() ==
-;    ['S2CI0008, []]
-
-(DEFUN |inclmsgFinSkipped| () (PROG () (RETURN (LIST 'S2CI0008 NIL))))
-
-;inclmsgIfSyntax(ufo,found,context) ==
-;    found := CONCAT('")", found)
-;    ['S2CI0009, [%id found, %id context, %origin ufo]]
-
-(DEFUN |inclmsgIfSyntax| (|ufo| |found| |context|)
-  (PROG ()
-    (RETURN
-      (PROGN
-        (SETQ |found| (CONCAT ")" |found|))
-        (LIST 'S2CI0009
-              (LIST (|%id| |found|) (|%id| |context|)
-                    (|%origin| |ufo|)))))))
-
-;inclmsgNoSuchFile fn ==
-;    ['S2CI0010, [%fname fn]]
-
-(DEFUN |inclmsgNoSuchFile| (|fn|)
-  (PROG () (RETURN (LIST 'S2CI0010 (LIST (|%fname| |fn|))))))
-
-;inclmsgCannotRead fn ==
-;    ['S2CI0011, [%fname fn]]
-
-(DEFUN |inclmsgCannotRead| (|fn|)
-  (PROG () (RETURN (LIST 'S2CI0011 (LIST (|%fname| |fn|))))))
-
-;inclmsgIfBug() ==
-;    ['S2CB0002, []]
-
-(DEFUN |inclmsgIfBug| () (PROG () (RETURN (LIST 'S2CB0002 NIL))))
-
-;inclmsgCmdBug() ==
-;    ['S2CB0003, []]
-
-(DEFUN |inclmsgCmdBug| () (PROG () (RETURN (LIST 'S2CB0003 NIL))))
-
-@
-\eject
-\begin{thebibliography}{99}
-\bibitem{1} nothing
-\end{thebibliography}
-\end{document}
diff --git a/src/interp/vmlisp.lisp.pamphlet b/src/interp/vmlisp.lisp.pamphlet
index c0e6068..44b5b94 100644
--- a/src/interp/vmlisp.lisp.pamphlet
+++ b/src/interp/vmlisp.lisp.pamphlet
@@ -9064,10 +9064,6 @@ The following functions are provided:
 (defvar |UpperCaseCset|    (|Cset| "ABCDEFGHIJKLMNOPQRSTUVWXYZ") )
 (defvar |AlphaCset|        (|CsetUnion| |LowerCaseCset| |UpperCaseCset|))
 (defvar |AlphaNumericCset| (|CsetUnion| |AlphaCset| |NumericCset|) )
-(defvar |WhiteSpaceCset|   
-  (|Cset| (coerce 
-    (list #\Space #\Newline #\Tab #\Page #\Linefeed #\Return #\Backspace)
-    'string )) )
 
 ;;;
 ;;; Character Strings