diff --git a/books/bookvol9.pamphlet b/books/bookvol9.pamphlet
index 67bacbd..b349633 100644
--- a/books/bookvol9.pamphlet
+++ b/books/bookvol9.pamphlet
@@ -66,7 +66,7 @@ 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 SUBSTIUTE GOODS OR
+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
@@ -381,7 +381,7 @@ Equation(S: Type): public == private where
++ the lhs of eq2 should be a kernel
private ==> add
- Rep := Recod(lhs: S, rhs: S)
+ Rep := Record(lhs: S, rhs: S)
eq1,eq2: $
s : S
if S has IntegralDomain then
@@ -19592,6 +19592,235 @@ deleting entries from u assumes that the first element is useless
\end{chunk}
+\defun{checkRecordHash}{checkRecordHash}
+\calls{checkRecordHash}{member}
+\calls{checkRecordHash}{checkLookForLeftBrace}
+\calls{checkRecordHash}{checkLookForRightBrace}
+\calls{checkRecordHash}{ifcdr}
+\calls{checkRecordHash}{intern}
+\calls{checkRecordHash}{hget}
+\calls{checkRecordHash}{hput}
+\calls{checkRecordHash}{checkGetLispFunctionName}
+\calls{checkRecordHash}{checkGetStringBeforeRightBrace}
+\calls{checkRecordHash}{checkGetParse}
+\calls{checkRecordHash}{checkDocError}
+\calls{checkRecordHash}{opOf}
+\calls{checkRecordHash}{spadSysChoose}
+\calls{checkRecordHash}{checkNumOfArgs}
+\calls{checkRecordHash}{checkIsValidType}
+\calls{checkRecordHash}{form2HtString}
+\calls{checkRecordHash}{getl}
+\refsdollar{checkRecordHash}{charBack}
+\refsdollar{checkRecordHash}{HTlinks}
+\refsdollar{checkRecordHash}{htHash}
+\refsdollar{checkRecordHash}{HTlisplinks}
+\refsdollar{checkRecordHash}{lispHash}
+\refsdollar{checkRecordHash}{glossHash}
+\refsdollar{checkRecordHash}{currentSysList}
+\refsdollar{checkRecordHash}{setOptions}
+\refsdollar{checkRecordHash}{sysHash}
+\refsdollar{checkRecordHash}{name}
+\refsdollar{checkRecordHash}{origin}
+\defsdollar{checkRecordHash}{sysHash}
+\defsdollar{checkRecordHash}{glossHash}
+\defsdollar{checkRecordHash}{lispHash}
+\defsdollar{checkRecordHash}{htHash}
+\begin{chunk}{defun checkRecordHash}
+(defun |checkRecordHash| (u)
+ (let (p q htname entry s parse n key x)
+ (declare (special |$origin| |$name| |$sysHash| |$setOptions| |$glossHash|
+ |$currentSysList| |$lispHash| |$HTlisplinks| |$htHash|
+ |$HTlinks| |$charBack|))
+ (loop while u
+ do
+ (setq x (car u))
+ (when (and (stringp x) (equal (elt x 0) |$charBack|))
+ (cond
+ ((and (|member| x |$HTlinks|)
+ (setq u (|checkLookForLeftBrace| (ifcdr u)))
+ (setq u (|checkLookForRightBrace| (ifcdr u)))
+ (setq u (|checkLookForLeftBrace| (ifcdr u)))
+ (setq u (ifcdr u)))
+ (setq htname (|intern| (ifcar u)))
+ (setq entry (or (hget |$htHash| htname) (list nil)))
+ (hput |$htHash| htname
+ (cons (car entry) (cons (cons |$name| |$origin|) (cdr entry)))))
+ ((and (|member| x |$HTlisplinks|)
+ (setq u (|checkLookForLeftBrace| (ifcdr u)))
+ (setq u (|checkLookForRightBrace| (ifcdr u)))
+ (setq u (|checkLookForLeftBrace| (ifcdr u)))
+ (setq u (ifcdr u)))
+ (setq htname
+ (|intern|
+ (|checkGetLispFunctionName|
+ (|checkGetStringBeforeRightBrace| u))))
+ (setq entry (or (hget |$lispHash| htname) (list nil)))
+ (hput |$lispHash| htname
+ (cons (car entry) (cons (cons |$name| |$origin|) (cdr entry)))))
+ ((and (or (setq p (|member| x '("\\gloss" "\\spadglos")))
+ (setq q (|member| x '("\\glossSee" "\\spadglosSee"))))
+ (setq u (|checkLookForLeftBrace| (ifcdr u)))
+ (setq u (ifcdr u)))
+ (when q
+ (setq u (|checkLookForRightBrace| u))
+ (setq u (|checkLookForLeftBrace| (ifcdr u)))
+ (setq u (ifcdr u)))
+ (setq htname (|intern| (|checkGetStringBeforeRightBrace| u)))
+ (setq entry
+ (or (hget |$glossHash| htname) (list nil)))
+ (hput |$glossHash| htname
+ (cons (car entry) (cons (cons |$name| |$origin|) (cdr entry)))))
+ ((and (boot-equal x "\\spadsys")
+ (setq u (|checkLookForLeftBrace| (ifcdr u)))
+ (setq u (ifcdr u)))
+ (setq s (|checkGetStringBeforeRightBrace| u))
+ (when (char= (elt s 0) #\)) (setq s (substring s 1 nil)))
+ (setq parse (|checkGetParse| s))
+ (cond
+ ((null parse)
+ (|checkDocError| (list "Unparseable \\spadtype: " s)))
+ ((null (|member| (|opOf| parse) |$currentSysList|))
+ (|checkDocError| (list "Bad system command: " s)))
+ ((or (atom parse)
+ (null (and (consp parse) (eq (qcar parse) '|set|)
+ (consp (qcdr parse))
+ (eq (qcddr parse) nil))))
+ '|ok|)
+ ((null (|spadSysChoose| |$setOptions| (qcadr parse)))
+ (progn
+ (|checkDocError| (list "Incorrect \\spadsys: " s))
+ (setq entry (or (hget |$sysHash| htname) (list nil)))
+ (hput |$sysHash| htname
+ (cons (car entry) (cons (cons |$name| |$origin|) (cdr entry))))))))
+ ((and (boot-equal x "\\spadtype")
+ (setq u (|checkLookForLeftBrace| (ifcdr u)))
+ (setq u (ifcdr u)))
+ (setq s (|checkGetStringBeforeRightBrace| u))
+ (setq parse (|checkGetParse| s))
+ (cond
+ ((null parse)
+ (|checkDocError| (list "Unparseable \\spadtype: " s)))
+ (t
+ (setq n (|checkNumOfArgs| parse))
+ (cond
+ ((null n)
+ (|checkDocError| (list "Unknown \\spadtype: " s)))
+ ((and (atom parse) (> n 0))
+ '|skip|)
+ ((null (setq key (|checkIsValidType| parse)))
+ (|checkDocError| (list "Unknown \\spadtype: " s)))
+ ((atom key) '|ok|)
+ (t
+ (|checkDocError|
+ (list "Wrong number of arguments: " (|form2HtString| key))))))))
+ ((and (|member| x '("\\spadop" "\\keyword"))
+ (setq u (|checkLookForLeftBrace| (ifcdr u)))
+ (setq u (ifcdr u)))
+ (setq x (|intern| (|checkGetStringBeforeRightBrace| u)))
+ (when (null (or (getl x '|Led|) (getl x '|Nud|)))
+ (|checkDocError| (list "Unknown \\spadop: " x))))))
+ (pop u))
+ '|done|))
+
+\end{chunk}
+
+\defun{checkGetParse}{checkGetParse}
+\calls{checkGetParse}{ncParseFromString}
+\calls{checkGetParse}{removeBackslashes}
+\begin{chunk}{defun checkGetParse}
+(defun |checkGetParse| (s)
+ (|ncParseFromString| (|removeBackslashes| s)))
+
+\end{chunk}
+
+\defun{checkTexht}{checkTexht}
+\calls{checkTexht}{ifcar}
+\calls{checkTexht}{checkDocError}
+\calls{checkTexht}{nequal}
+\refsdollar{checkTexht}{charRbrace}
+\refsdollar{checkTexht}{charLbrace}
+\begin{chunk}{defun checkTexht}
+(defun |checkTexht| (u)
+ (let (count y x acc)
+ (declare (special |$charRbrace| |$charLbrace|))
+ (setq count 0)
+ (loop while u
+ do
+ (setq x (car u))
+ (when (and (string= x "\\texht") (setq u (ifcdr u)))
+ (when (null (equal (ifcar u) |$charLbrace|))
+ (|checkDocError| "First left brace after \\texht missing"))
+ ; drop first argument including braces of texht
+ (setq count 1)
+ (do ()
+ ((null (or (nequal (setq y (ifcar (setq u (cdr u)))) |$charRbrace|)
+ (> count 1)))
+ nil)
+ (when (equal y |$charLbrace|) (setq count (1+ count)))
+ (when (equal y |$charRbrace|) (setq count (1- count))))
+ ; drop first right brace of 1st arg
+ (setq x (ifcar (setq u (cdr u)))))
+ (when (and (string= x "\\httex") (setq u (ifcdr u))
+ (equal (ifcar u) |$charLbrace|))
+ (setq acc (cons (ifcar u) acc))
+ (do ()
+ ((null (nequal (setq y (ifcar (setq u (cdr u)))) |$charRbrace|))
+ nil)
+ (setq acc (cons y acc)))
+ (setq acc (cons (ifcar u) acc)) ; left brace: add it
+ (setq x (ifcar (setq u (cdr u)))) ; left brace: forget it
+ (do ()
+ ((null (nequal (ifcar (setq u (cdr u))) |$charRbrace|))
+ nil)
+ '|skip|)
+ ; forget right brace; move to next character
+ (setq x (ifcar (setq u (cdr u)))))
+ (setq acc (cons x acc))
+ (pop u))
+ (nreverse acc)))
+
+\end{chunk}
+
+
+\defun{checkDecorateForHt}{checkDecorateForHt}
+\calls{checkDecorateForHt}{checkDocError}
+\calls{checkDecorateForHt}{member}
+\refsdollar{checkDecorateForHt}{checkingXmptex?}
+\refsdollar{checkDecorateForHt}{charRbrace}
+\refsdollar{checkDecorateForHt}{charLbrace}
+\begin{chunk}{defun checkDecorateForHt}
+(defun |checkDecorateForHt| (u)
+ (let (x count spadflag)
+ (declare (special |$checkingXmptex?| |$charRbrace| |$charLbrace|))
+ (setq count 0)
+ (setq spadflag nil)
+ (loop while u
+ do
+ (setq x (car u))
+ (when (equal x "\\em")
+ (if (> count 0)
+ (setq spadflag (1- count))
+ (|checkDocError| (list "\\em must be enclosed in braces"))))
+ (cond
+ ((|member| x '("\\s" "\\spadop" "\\spadtype" "\\spad" "\\spadpaste"
+ "\\spadcommand" "\\footnote"))
+ (setq spadflag count))
+ ((equal x |$charLbrace|)
+ (setq count (1+ count)))
+ ((equal x |$charRbrace|)
+ (setq count (1- count))
+ (when (equal spadflag count) (setq spadflag nil)))
+ ((and (null spadflag) (|member| x '("+" "*" "=" "==" "->")))
+ (when |$checkingXmptex?|
+ (|checkDocError| (list '|Symbol | x " appearing outside \\spad{}"))))
+ (t nil))
+ (when (or (equal x "$") (equal x "%"))
+ (|checkDocError| (list "Unescaped " x)))
+ (pop u))
+ u))
+
+\end{chunk}
+
\defun{checkDocError1}{checkDocError1}
\calls{checkDocError1}{checkDocError}
\refsdollar{checkDocError1}{compileDocumentation}
@@ -19660,6 +19889,30 @@ deleting entries from u assumes that the first element is useless
\end{chunk}
+\defun{whoOwns}{whoOwns}
+\calls{whoOwns}{getdatabase}
+\calls{whoOwns}{strconc}
+\calls{whoOwns}{awk}
+\calls{whoOwns}{shut}
+\refsdollar{whoOwns}{exposeFlag}
+\begin{chunk}{defun whoOwns}
+(defun |whoOwns| (con)
+ (let (filename quoteChar instream value)
+ (declare (special |$exposeFlag|))
+ (cond
+ ((null |$exposeFlag|) nil)
+ (t
+ (setq filename (getdatabase con 'sourcefile))
+ (setq quoteChar #\")
+ (obey (strconc "awk '$2 == " quoteChar filename quoteChar
+ " {print $1}' whofiles > /tmp/temp"))
+ (setq instream (make-instream "/tmp/temp"))
+ (setq value (unless (eofp instream) (readline instream)))
+ (shut instream)
+ value))))
+
+\end{chunk}
+
\defun{checkComments}{checkComments}
\calls{checkComments}{checkGetMargin}
\calls{checkComments}{nequal}
@@ -19732,6 +19985,175 @@ deleting entries from u assumes that the first element is useless
\end{chunk}
+\defun{checkSplit2Words}{checkSplit2Words}
+\calls{checkSplit2Words}{checkSplitBrace}
+\begin{chunk}{defun checkSplit2Words}
+(defun |checkSplit2Words| (u)
+ (let (x verbatim z acc)
+ (setq acc nil)
+ (loop while u
+ do
+ (setq x (car u))
+ (setq acc
+ (cond
+ ((string= x "\\end{verbatim}")
+ (setq verbatim nil)
+ (cons x acc))
+ (verbatim (cons x acc))
+ ((string= x "\\begin{verbatim}")
+ (setq verbatim t)
+ (cons x acc))
+ ((setq z (|checkSplitBrace| x))
+ (append (nreverse z) acc))
+ (t (cons x acc))))
+ (pop u))
+ (nreverse acc)))
+
+\end{chunk}
+
+\defun{checkAddPeriod}{checkAddPeriod}
+\calls{checkAddPeriod}{setelt}
+\calls{checkAddPeriod}{maxindex}
+\begin{chunk}{defun checkAddPeriod}
+(defun |checkAddPeriod| (s)
+ (let (m lastChar)
+ (setq m (maxindex s))
+ (setq lastChar (elt s m))
+ (cond
+ ((or (char= lastChar #\!) (char= lastChar #\?) (char= lastChar #\.)) s)
+ ((or (char= lastChar #\,) (char= lastChar #\;))
+ (setelt s m #\.)
+ s)
+ (t s))))
+
+\end{chunk}
+
+\defun{checkBalance}{checkBalance}
+\calls{checkPrenAlist}{checkBeginEnd}
+\calls{checkPrenAlist}{assoc}
+\calls{checkPrenAlist}{rassoc}
+\calls{checkPrenAlist}{nequal}
+\calls{checkPrenAlist}{checkDocError}
+\calls{checkPrenAlist}{checkSayBracket}
+\calls{checkPrenAlist}{nreverse}
+\refsdollar{checkBalance}{checkPrenAlist}
+\begin{chunk}{defun checkBalance}
+(defun |checkBalance| (u)
+ (let (x openClose open top restStack stack)
+ (declare (special |$checkPrenAlist|))
+ (|checkBeginEnd| u)
+ (setq stack nil)
+ (loop while u
+ do
+ (setq x (car u))
+ (cond
+ ((setq openClose (|assoc| x |$checkPrenAlist|))
+ (setq stack (cons (car openClose) stack)))
+ ((setq open (|rassoc| x |$checkPrenAlist|))
+ (cond
+ ((consp stack)
+ (setq top (qcar stack))
+ (setq restStack (qcdr stack))
+ (when (nequal open top)
+ (|checkDocError|
+ (list "Mismatch: left " (|checkSayBracket| top)
+ " matches right " (|checkSayBracket| open))))
+ (setq stack restStack))
+ (t
+ (|checkDocError|
+ (list "Missing left " (|checkSayBracket| open)))))))
+ (pop u))
+ (when stack
+ (loop for x in (nreverse stack)
+ do
+ (|checkDocError| (list "Missing right " (|checkSayBracket| x)))))
+ u))
+
+\end{chunk}
+
+\defun{checkBeginEnd}{checkBeginEnd}
+\calls{checkBeginEnd}{length}
+\calls{checkBeginEnd}{hget}
+\calls{checkBeginEnd}{ifcar}
+\calls{checkBeginEnd}{ifcdr}
+\calls{checkBeginEnd}{substring?}
+\calls{checkBeginEnd}{checkDocError}
+\calls{checkBeginEnd}{member}
+\refsdollar{checkBeginEnd}{charRbrace}
+\refsdollar{checkBeginEnd}{charLbrace}
+\refsdollar{checkBeginEnd}{beginEndList}
+\refsdollar{checkBeginEnd}{htMacroTable}
+\refsdollar{checkBeginEnd}{charBack}
+\begin{chunk}{defun checkBeginEnd}
+(defun |checkBeginEnd| (u)
+ (let (x y beginEndStack)
+ (declare (special |$charRbrace| |$charLbrace| |$beginEndList| |$charBack|
+ |$htMacroTable|))
+ (loop while u
+ do
+ (setq x (car u))
+ (cond
+ ((and (stringp x) (equal (elt x 0) |$charBack|) (> (|#| x) 2)
+ (null (hget |$htMacroTable| x)) (null (equal x "\\spadignore"))
+ (equal (ifcar (ifcdr u)) |$charLbrace|)
+ (null (or (|substring?| "\\radiobox" x 0)
+ (|substring?| "\\inputbox" x 0))))
+ (|checkDocError| (list '|Unexpected HT command: | x)))
+ ((equal x "\\beginitems")
+ (setq beginEndStack (cons '|items| beginEndStack)))
+ ((equal x "\\begin")
+ (cond
+ ((and (consp u) (consp (qcdr u)) (equal (qcar (qcdr u)) |$charLbrace|)
+ (consp (qcddr u)) (equal (car (qcdddr u)) |$charRbrace|))
+ (setq y (qcaddr u))
+ (cond
+ ((null (|member| y |$beginEndList|))
+ (|checkDocError| (list "Unknown begin type: \\begin{" y "}"))))
+ (setq beginEndStack (cons y beginEndStack))
+ (setq u (qcdddr u)))
+ (t (|checkDocError| (list "Improper \\begin command")))))
+ ((equal x "\\item")
+ (cond
+ ((|member| (ifcar beginEndStack) '("items" "menu")) nil)
+ ((null beginEndStack)
+ (|checkDocError| (list "\\item appears outside a \\begin-\\end")))
+ (t
+ (|checkDocError|
+ (list "\\item appears within a \\begin{"
+ (ifcar beginEndStack) "}..")))))
+ ((equal x "\\end")
+ (cond
+ ((and (consp u) (consp (qcdr u)) (equal (qcar (qcdr u)) |$charLbrace|)
+ (consp (qcddr u)) (equal (car (qcdddr u)) |$charRbrace|))
+ (setq y (qcaddr u))
+ (cond
+ ((equal y (ifcar beginEndStack))
+ (setq beginEndStack (cdr beginEndStack))
+ (setq u (qcdddr u)))
+ (t
+ (|checkDocError|
+ (list "Trying to match \\begin{" (ifcar beginEndStack)
+ "} with \\end{" y "}")))))
+ (t
+ (|checkDocError| (list "Improper \\end command"))))))
+ (pop u))
+ (cond
+ (beginEndStack
+ (|checkDocError| (list "Missing \\end{" (car beginEndStack) "}")))
+ (t '|ok|))))
+
+\end{chunk}
+
+\defun{checkSayBracket}{checkSayBracket}
+\begin{chunk}{defun checkSayBracket}
+(defun |checkSayBracket| (x)
+ (cond
+ ((or (char= x #\() (char= x #\))) "pren")
+ ((or (char= x #\{) (char= x #\})) "brace")
+ (t "bracket")))
+
+\end{chunk}
+
\defun{checkArguments}{checkArguments}
\calls{checkArguments}{hget}
\calls{checkArguments}{checkHTargs}
@@ -19746,12 +20168,72 @@ deleting entries from u assumes that the first element is useless
((null (setq k (hget |$htMacroTable| x))) '|skip|)
((eql k 0) '|skip|)
((> k 0) (|checkHTargs| x (cdr u) k nil))
- (t (|checkHTargs| x (cdr u) -k t)))
+ (t (|checkHTargs| x (cdr u) (- k) t)))
(pop u))
u))
\end{chunk}
+\defun{checkHTargs}{checkHTargs}
+Note that {\tt u} should start with an open brace.
+\calls{checkHTargs}{checkLookForLeftBrace}
+\calls{checkHTargs}{checkLookForRightBrace}
+\calls{checkHTargs}{checkDocError}
+\calls{checkHTargs}{checkHTargs}
+\calls{checkHTargs}{ifcdr}
+\begin{chunk}{defun checkHTargs}
+(defun |checkHTargs| (keyword u nargs inteerValue?)
+ (cond
+ ((eql nargs 0) '|ok|)
+ ((null (setq u (|checkLookForLeftBrace| u)))
+ (|checkDocError| (list "Missing argument for " keyword)))
+ ((null (setq u (|checkLookForRightBrace| (ifcdr u))))
+ (|checkDocError| (list "Missing right brace for " keyword)))
+ (t
+ (|checkHTargs| keyword (cdr u) (1- nargs) inteerValue?))))
+
+\end{chunk}
+
+\defun{checkLookForLeftBrace}{checkLookForLeftBrace}
+\calls{checkLookForLeftBrace}{nequal}
+\refsdollar{checkLookForLeftBrace}{charBlank}
+\refsdollar{checkLookForLeftBrace}{charLbrace}
+\begin{chunk}{defun checkLookForLeftBrace}
+(defun |checkLookForLeftBrace| (u)
+ (declare (special |$charBlank| |$charLbrace|))
+ (loop while u
+ do
+ (cond
+ ((equal (car u) |$charLbrace|) (return (car u)))
+ ((nequal (car u) |$charBlank|) (return nil))
+ (t (pop u))))
+ u)
+
+\end{chunk}
+
+\defun{checkLookForRightBrace}{checkLookForRightBrace}
+This returns a line beginning with right brace
+\refsdollar{checkLookForRightBrace}{charLbrace}
+\refsdollar{checkLookForRightBrace}{charRbrace}
+\begin{chunk}{defun checkLookForRightBrace}
+(defun |checkLookForRightBrace| (u)
+ (let (found count)
+ (declare (special |$charLbrace| |$charRbrace|))
+ (setq count 0)
+ (loop while u
+ do
+ (cond
+ ((equal (car u) |$charRbrace|)
+ (if (eql count 0)
+ (return (setq found u))
+ (setq count (1- count))))
+ ((equal (car u) |$charLbrace|)
+ (setq count (1+ count))))
+ (pop u))
+ found))
+
+\end{chunk}
+
\defun{checkTransformFirsts}{checkTransformFirsts}
\calls{checkTransformFirsts}{pname}
\calls{checkTransformFirsts}{leftTrim}
@@ -24003,22 +24485,34 @@ The current input line.
\getchunk{defun canReturn}
\getchunk{defun char-eq}
\getchunk{defun char-ne}
+\getchunk{defun checkAddPeriod}
\getchunk{defun checkAlphabetic}
\getchunk{defun checkAndDeclare}
\getchunk{defun checkArguments}
+\getchunk{defun checkBalance}
+\getchunk{defun checkBeginEnd}
\getchunk{defun checkComments}
+\getchunk{defun checkDecorateForHt}
\getchunk{defun checkDocError}
\getchunk{defun checkDocError1}
\getchunk{defun checkDocMessage}
\getchunk{defun checkExtract}
\getchunk{defun checkGetMargin}
+\getchunk{defun checkGetParse}
+\getchunk{defun checkHTargs}
\getchunk{defun checkIeEg}
\getchunk{defun checkIeEgfun}
+\getchunk{defun checkLookForLeftBrace}
+\getchunk{defun checkLookForRightBrace}
+\getchunk{defun checkRecordHash}
\getchunk{defun checkRewrite}
+\getchunk{defun checkSayBracket}
\getchunk{defun checkSkipBlanks}
\getchunk{defun checkSkipIdentifierToken}
\getchunk{defun checkSkipOpToken}
\getchunk{defun checkSkipToken}
+\getchunk{defun checkSplit2Words}
+\getchunk{defun checkTexht}
\getchunk{defun checkTransformFirsts}
\getchunk{defun checkWarning}
\getchunk{defun coerce}
@@ -24614,6 +25108,7 @@ The current input line.
\getchunk{defun updateCategoryFrameForCategory}
\getchunk{defun updateCategoryFrameForConstructor}
+\getchunk{defun whoOwns}
\getchunk{defun wrapDomainSub}
\getchunk{defun writeLib1}
diff --git a/changelog b/changelog
index f613b2a..d7dd1ff 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,6 @@
+20111124 tpd src/axiom-website/patches.html 20111124.02.tpd.patch
+20111124 tpd src/interp/c-doc.lisp treeshake compiler
+20111124 tpd books/bookvol9 treeshake compiler
20111124 tpd src/axiom-website/patches.html 20111124.01.tpd.patch
20111124 tpd src/axiom-website/documentation.html add quote
20111124 tpd src/axiom-website/litprog.html add quote
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index 8629e70..0d76dbf 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -3690,5 +3690,7 @@ books/bookvol9 treeshake compiler
src/axiom-website/litprog.html added
20111124.01.tpd.patch
src/axiom-website/litprog.html add quote
+20111124.02.tpd.patch
+books/bookvol9 treeshake compiler