diff --git a/books/bookvol5.pamphlet b/books/bookvol5.pamphlet
index 397a321..cef4206 100644
--- a/books/bookvol5.pamphlet
+++ b/books/bookvol5.pamphlet
@@ -2533,7 +2533,7 @@ carrier[lines,messages,..]-> carrier[lines,messages,..]
((> i Var3) (return nil))
(t
(cond
- ((not (equal (elt str i) (|char| '| |)))
+ ((not (equal (elt str i) #\Space))
(identity (progn (setq value t) (return value)))))))
(setq i (+ i 1))))
(maxindex str) 0)
@@ -3575,7 +3575,7 @@ b ==> 7
\begin{chunk}{defun incCommand? 0}
(defun |incCommand?| (s)
"does this start with a close paren?"
- (and (< 0 (length s)) (equal (elt s 0) (|char| '|)|))))
+ (and (< 0 (length s)) (equal (elt s 0) #\) )))
\end{chunk}
@@ -13491,7 +13491,7 @@ makeLeaderMsg chPosList ==
t)
(progn
(setq st
- (strconc st (|rep| (|char| '|.|) (- posNum oldPos 1)) posLetter))
+ (strconc st (|rep| #\. (- posNum oldPos 1)) posLetter))
(setq oldPos posNum)))))
(setq Var15 (cdr Var15))))
(reverse chPosList) nil)
@@ -46605,6 +46605,3822 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\end{chunk}
+;;; ht-util merge
+
+\defdollar{bcParseOnly}
+\begin{chunk}{initvars}
+(defvar |$bcParseOnly| t)
+
+\end{chunk}
+
+\defdollar{htLineList}
+\begin{chunk}{initvars}
+(defvar |$htLineList| nil)
+
+\end{chunk}
+
+\defdollar{curpage}
+\begin{chunk}{initvars}
+(defvar |$curPage| nil)
+
+\end{chunk}
+
+\defdollar{activePageList}
+\begin{chunk}{initvars}
+(defvar |$activePageList| nil)
+
+\end{chunk}
+
+\defun{htpDestroyPage}{htpDestroyPage}
+\begin{chunk}{defun htpDestroyPage}
+(defun |htpDestroyPage| (pageName)
+ (declare (special |$activePageList|))
+ (SEQ (cond
+ ((|member| pageName |$activePageList|)
+ (EXIT (progn
+ (set pageName nil)
+ (setq |$activePageList|
+ (NREMOVE |$activePageList| pageName))))))))
+
+\end{chunk}
+
+\defun{htpName}{htpName}
+\begin{chunk}{defun htpName}
+(defun |htpName| (htPage) (elt htPage 0))
+
+\end{chunk}
+
+\defun{htpSetName}{htpSetName}
+\begin{chunk}{defun htpSetName}
+(defun |htpSetName| (htPage val) (setelt htPage 0 val))
+
+\end{chunk}
+
+\defun{htpDomainConditions}{htpDomainConditions}
+\begin{chunk}{defun htpDomainConditions}
+(defun |htpDomainConditions| (htPage) (elt htPage 1))
+
+\end{chunk}
+
+\defun{htpSetDomainConditions}{htpSetDomainConditions}
+\begin{chunk}{defun htpSetDomainConditions}
+(defun |htpSetDomainConditions| (htPage val)
+ (setelt htPage 1 val))
+
+\end{chunk}
+
+\defun{htpDomainVariableAlist}{htpDomainVariableAlist}
+\begin{chunk}{defun htpDomainVariableAlist}
+(defun |htpDomainVariableAlist| (htPage) (elt htPage 2))
+
+\end{chunk}
+
+\defun{htpSetDomainVariableAlist}{htpSetDomainVariableAlist}
+\begin{chunk}{defun htpSetDomainVariableAlist}
+(defun |htpSetDomainVariableAlist| (htPage val)
+ (setelt htPage 2 val))
+
+\end{chunk}
+
+\defun{htpDomainPvarSubstList}{htpDomainPvarSubstList}
+\begin{chunk}{defun htpDomainPvarSubstList}
+(defun |htpDomainPvarSubstList| (htPage) (elt htPage 3))
+
+\end{chunk}
+
+\defun{htpSetDomainPvarSubstList}{htpSetDomainPvarSubstList}
+\begin{chunk}{defun htpSetDomainPvarSubstList}
+(defun |htpSetDomainPvarSubstList| (htPage val)
+ (setelt htPage 3 val))
+
+\end{chunk}
+
+\defun{htpRadioButtonAlist}{htpRadioButtonAlist}
+\begin{chunk}{defun htpRadioButtonAlist}
+(defun |htpRadioButtonAlist| (htPage) (elt htPage 4))
+
+\end{chunk}
+
+\defun{htpButtonValue}{htpButtonValue}
+\begin{chunk}{defun htpButtonValue}
+(defun |htpButtonValue| (htPage groupName)
+ (prog ()
+ (return
+ (SEQ (DO ((G166092
+ (LASSOC groupName
+ (|htpRadioButtonAlist| htPage))
+ (CDR G166092))
+ (|buttonName| nil))
+ ((OR (ATOM G166092)
+ (progn (setq |buttonName| (car G166092)) nil))
+ NIL)
+ (SEQ (EXIT (COND
+ ((BOOT-EQUAL
+ (|stripSpaces|
+ (|htpLabelInputString| htPage
+ |buttonName|))
+ "t")
+ (EXIT (RETURN |buttonName|)))))))))))
+
+\end{chunk}
+
+\defun{htpSetRadioButtonAlist}{htpSetRadioButtonAlist}
+\begin{chunk}{defun htpSetRadioButtonAlist}
+(defun |htpSetRadioButtonAlist| (htPage val)
+ (setelt htPage 4 val))
+
+\end{chunk}
+
+\defun{htpInputAreaAlist}{htpInputAreaAlist}
+\begin{chunk}{defun htpInputAreaAlist}
+(defun |htpInputAreaAlist| (htPage) (elt htPage 5))
+
+\end{chunk}
+
+\defun{htpSetInputAreaAlist}{htpSetInputAreaAlist}
+\begin{chunk}{defun htpSetInputAreaAlist}
+(defun |htpSetInputAreaAlist| (htPage val)
+ (setelt htPage 5 val))
+
+\end{chunk}
+
+\defun{htpAddInputAreaProp}{htpAddInputAreaProp}
+\begin{chunk}{defun htpAddInputAreaProp}
+(defun |htpAddInputAreaProp| (htPage label prop)
+ (setelt htPage 5
+ (cons (cons label (cons nil (cons nil (cons nil prop))))
+ (elt htPage 5))))
+
+\end{chunk}
+
+\defun{htpPropertyList}{htpPropertyList}
+\begin{chunk}{defun htpPropertyList}
+(defun |htpPropertyList| (htPage) (elt htPage 6))
+
+\end{chunk}
+
+\defun{htpProperty}{htpProperty}
+\begin{chunk}{defun htpProperty}
+(defun |htpProperty| (htPage propName)
+ (LASSOC propName (elt htPage 6)))
+\end{chunk}
+
+\defun{htpSetProperty}{htpSetProperty}
+\begin{chunk}{defun htpSetProperty}
+(defun |htpSetProperty| (htPage propName val)
+ (prog (pair)
+ (return
+ (progn
+ (setq pair (|assoc| propName (elt htPage 6)))
+ (cond
+ (pair (rplacd pair val))
+ (t
+ (setelt htPage 6
+ (cons (cons propName val) (elt htPage 6)))))))))
+
+\end{chunk}
+
+\defun{htpLabelInputString}{htpLabelInputString}
+\begin{chunk}{defun htpLabelInputString}
+(defun |htpLabelInputString| (htPage label)
+ (prog (props s)
+ (return
+ (progn
+ (setq props
+ (LASSOC label (|htpInputAreaAlist| htPage)))
+ (cond
+ ((and props (stringp (setq s (elt props 0))))
+ (cond
+ ((equal s "") s)
+ (t (|trimString| s))))
+ (t nil))))))
+
+\end{chunk}
+
+\defun{htpLabelFilteredInputString}{htpLabelFilteredInputString}
+\begin{chunk}{defun htpLabelFilteredInputString}
+(defun |htpLabelFilteredInputString| (htPage label)
+ (prog (props)
+ (return
+ (progn
+ (setq props
+ (LASSOC label (|htpInputAreaAlist| htPage)))
+ (cond
+ (props (cond
+ ((and (> (|#| props) 5) (elt props 6))
+ (funcall (symbol-function (elt props 6))
+ (elt props 0)))
+ (t (|replacePercentByDollar| (elt props 0)))))
+ (t nil))))))
+
+\end{chunk}
+
+\defun{replacePercentByDollar,fn}{replacePercentByDollar,fn}
+\begin{chunk}{defun replacePercentByDollar,fn}
+(defun |replacePercentByDollar,fn| (s i n)
+ (prog (m)
+ (return
+ (SEQ (if (> i n) (EXIT ""))
+ (if (> (setq m (|charPosition| #\% s i))
+ n)
+ (EXIT (SUBSTRING s i nil)))
+ (EXIT (STRCONC (SUBSTRING s i (- m i))
+ "$"
+ (|replacePercentByDollar,fn| s (1+ m)
+ n)))))))
+
+\end{chunk}
+
+\defun{replacePercentByDollar}{replacePercentByDollar}
+\begin{chunk}{defun replacePercentByDollar}
+(defun |replacePercentByDollar| (s)
+ (|replacePercentByDollar,fn| s 0 (maxindex s)))
+
+\end{chunk}
+
+\defun{htpSetLabelInputString}{htpSetLabelInputString}
+\begin{chunk}{defun htpSetLabelInputString}
+(defun |htpSetLabelInputString| (htPage label val)
+ (prog (props)
+ (return
+ (progn
+ (setq props
+ (LASSOC label (|htpInputAreaAlist| htPage)))
+ (cond
+ (props (setelt props 0 (stringimage val)))
+ (t nil))))))
+
+\end{chunk}
+
+\defun{htpLabelSpadValue}{htpLabelSpadValue}
+\begin{chunk}{defun htpLabelSpadValue}
+(defun |htpLabelSpadValue| (htPage label)
+ (prog (props)
+ (return
+ (progn
+ (setq props
+ (LASSOC label (|htpInputAreaAlist| htPage)))
+ (cond (props (elt props 1)) (t nil))))))
+
+\end{chunk}
+
+\defun{htpSetLabelSpadValue}{htpSetLabelSpadValue}
+\begin{chunk}{defun htpSetLabelSpadValue}
+(defun |htpSetLabelSpadValue| (htPage label val)
+ (prog (props)
+ (return
+ (progn
+ (setq props
+ (LASSOC label (|htpInputAreaAlist| htPage)))
+ (cond (props (setelt props 1 |val|)) (t nil))))))
+
+\end{chunk}
+
+\defun{htpLabelErrorMsg}{htpLabelErrorMsg}
+\begin{chunk}{defun htpLabelErrorMsg}
+(defun |htpLabelErrorMsg| (htPage label)
+ (prog (props)
+ (return
+ (progn
+ (setq props
+ (LASSOC label (|htpInputAreaAlist| htPage)))
+ (cond (props (elt props 2)) (t nil))))))
+
+\end{chunk}
+
+\defun{htpSetLabelErrorMsg}{htpSetLabelErrorMsg}
+\begin{chunk}{defun htpSetLabelErrorMsg}
+(defun |htpSetLabelErrorMsg| (htPage label val)
+ (prog (props)
+ (return
+ (progn
+ (setq props
+ (LASSOC label (|htpInputAreaAlist| htPage)))
+ (cond (props (setelt props 2 val)) (t nil))))))
+
+\end{chunk}
+
+\defun{htpLabelType}{htpLabelType}
+\begin{chunk}{defun htpLabelType}
+(defun |htpLabelType| (htPage label)
+ (prog (props)
+ (return
+ (progn
+ (setq props
+ (LASSOC label (|htpInputAreaAlist| htPage)))
+ (cond (props (elt props 3)) (t nil))))))
+
+\end{chunk}
+
+\defun{htpLabelDefault}{htpLabelDefault}
+\begin{chunk}{defun htpLabelDefault}
+(defun |htpLabelDefault| (htPage label)
+ (prog (msg props)
+ (return
+ (cond
+ ((setq msg (|htpLabelInputString| htPage label))
+ (cond
+ ((equal msg "t") 1)
+ ((equal msg "nil") 0)
+ (t msg)))
+ (t
+ (setq props
+ (LASSOC label (|htpInputAreaAlist| htPage)))
+ (cond (props (elt props 4)) (t nil)))))))
+
+\end{chunk}
+
+\defun{htpLabelSpadType}{htpLabelSpadType}
+\begin{chunk}{defun htpLabelSpadType}
+(defun |htpLabelSpadType| (htPage label)
+ (prog (props)
+ (return
+ (progn
+ (setq props
+ (LASSOC label (|htpInputAreaAlist| htPage)))
+ (cond (props (elt props 5)) (t nil))))))
+
+\end{chunk}
+
+\defun{htpLabelFilter}{htpLabelFilter}
+\begin{chunk}{defun htpLabelFilter}
+(defun |htpLabelFilter| (htPage label)
+ (prog (props)
+ (return
+ (progn
+ (setq props
+ (LASSOC label (|htpInputAreaAlist| htPage)))
+ (cond (props (elt props 6)) (t nil))))))
+
+\end{chunk}
+
+\defun{htpPageDescription}{htpPageDescription}
+\begin{chunk}{defun htpPageDescription}
+(defun |htpPageDescription| (htPage) (elt htPage 7))
+
+\end{chunk}
+
+\defun{htpSetPageDescription}{htpSetPageDescription}
+\begin{chunk}{defun htpSetPageDescription}
+(defun |htpSetPageDescription| (htPage pageDescription)
+ (setelt htPage 7 pageDescription))
+
+\end{chunk}
+
+\defun{htpAddToPageDescription}{htpAddToPageDescription}
+\begin{chunk}{defun htpAddToPageDescription}
+(defun |htpAddToPageDescription| (htPage pageDescrip)
+ (setelt htPage 7
+ (NCONC (NREVERSE (COPY-LIST pageDescrip)) (elt htPage 7))))
+
+\end{chunk}
+
+\defun{iht}{issue a single hypertex line or group of lines}
+\begin{chunk}{defun iht}
+(defun |iht| (line)
+ (declare (special |$htLineList| |$newPage|))
+ (cond
+ (|$newPage| nil)
+ ((consp line)
+ (setq |$htLineList|
+ (NCONC (NREVERSE (|mapStringize| (COPY-LIST line)))
+ |$htLineList|)))
+ (t
+ (setq |$htLineList|
+ (cons (|basicStringize| line) |$htLineList|)))))
+
+\end{chunk}
+
+\defun{bcHt}{bcHt}
+\begin{chunk}{defun bcHt}
+(defun |bcHt| (line)
+ (declare (special |$curPage| |$newPage|))
+ (progn
+ (|iht| line)
+ (cond
+ ((consp line)
+ (cond
+ (|$newPage|
+ (|htpAddToPageDescription| |$curPage|
+ (cons (cons '|text| line) nil)))
+ (t nil)))
+ (|$newPage|
+ (|htpAddToPageDescription| |$curPage|
+ (cons (cons '|text| (cons line nil)) nil)))
+ (t nil))))
+
+\end{chunk}
+
+\defun{bcIssueHt}{bcIssueHt}
+\begin{chunk}{defun bcIssueHt}
+(defun |bcIssueHt| (line)
+ (cond ((consp line) (|htMakePage1| line)) (t (|iht| line))))
+
+\end{chunk}
+
+\defun{mapStringize}{mapStringize}
+\begin{chunk}{defun mapStringize}
+(defun |mapStringize| (z)
+ (cond
+ ((atom z) z)
+ (t (rplaca z (|basicStringize| (car z)))
+ (rplacd z (|mapStringize| (cdr z))) z)))
+
+\end{chunk}
+
+\defun{basicStringize}{basicStringize}
+\begin{chunk}{defun basicStringize}
+(defun |basicStringize| (s)
+ (cond
+ ((stringp s)
+ (cond
+ ((equal s "\\$") "\\%")
+ ((equal s "{\\em $}") "{\\em \\%}")
+ (t s)))
+ ((eq s '$) "\\%")
+ (t (princ-to-string s))))
+
+\end{chunk}
+
+\defun{stringize}{stringize}
+\begin{chunk}{defun stringize}
+(defun |stringize| (s)
+ (cond ((stringp s) s) (t (princ-to-string s))))
+
+\end{chunk}
+
+\defun{htInitPage}{htInitPage}
+\begin{chunk}{defun htInitPage}
+(defun |htInitPage| (title propList)
+ (declare (special |$curPage|))
+ (progn
+ (|htInitPageNoScroll| propList title)
+ (|htSayStandard| "\\beginscroll ")
+ |$curPage|))
+
+\end{chunk}
+
+\defun{htAddHeading}{htAddHeading}
+\begin{chunk}{defun htAddHeading}
+(defun |htAddHeading| (title)
+ (declare (special |$curPage|))
+ (|htNewPage| title)
+ |$curPage|)
+
+\end{chunk}
+
+\defun{htShowPage}{htShowPage}
+\begin{chunk}{defun htShowPage}
+(defun |htShowPage| ()
+ (|htSayStandard| "\\endscroll")
+ (|htShowPageNoScroll|))
+
+\end{chunk}
+
+\defun{htShowPageNoScroll}{show the page which has been computed}
+\begin{chunk}{defun htShowPageNoScroll}
+(defun |htShowPageNoScroll| ()
+ (prog (line)
+ (declare (special |$htLineList| |$curPage| |$newPage|))
+ (return
+ (progn
+ (|htSayStandard| "\\autobuttons")
+ (|htpSetPageDescription| |$curPage|
+ (NREVERSE (|htpPageDescription| |$curPage|)))
+ (setq |$newPage| nil)
+ (setq |$htLineList| nil)
+ (|htMakePage| (|htpPageDescription| |$curPage|))
+ (setq line (apply (|function| CONCAT) (NREVERSE |$htLineList|)))
+ (|issueHT| line)
+ (|endHTPage|)))))
+
+\end{chunk}
+
+\defun{htMakePage}{make a page given the description in itemList}
+\begin{chunk}{defun htMakePage}
+(defun |htMakePage| (itemList)
+ (declare (special |$curPage| |$newPage|))
+ (progn
+ (cond
+ (|$newPage| (|htpAddToPageDescription| |$curPage| itemList)))
+ (|htMakePage1| itemList)))
+
+\end{chunk}
+
+\defun{htMakePage1}{htMakePage1}
+\begin{chunk}{defun htMakePage1}
+(defun |htMakePage1| (itemList)
+ (prog (itemType items)
+ (return
+ (SEQ (DO ((G166261 itemList (CDR G166261)) (G166253 NIL))
+ ((OR (ATOM G166261)
+ (PROGN (SETQ G166253 (CAR G166261)) NIL)
+ (PROGN
+ (PROGN
+ (setq itemType (CAR G166253))
+ (setq items (CDR G166253))
+ G166253)
+ NIL))
+ NIL)
+ (SEQ (EXIT (COND
+ ((eq itemType '|text|)
+ (|iht| items))
+ ((eq itemType '|lispLinks|)
+ (|htLispLinks| items))
+ ((eq itemType '|lispmemoLinks|)
+ (|htLispMemoLinks| items))
+ ((eq itemType '|bcLinks|)
+ (|htBcLinks| items))
+ ((eq itemType '|bcLinksNS|)
+ (|htBcLinks| items t))
+ ((eq itemType '|bcLispLinks|)
+ (|htBcLispLinks| items))
+ ((eq itemType '|radioButtons|)
+ (|htRadioButtons| items))
+ ((eq itemType '|bcRadioButtons|)
+ (|htBcRadioButtons| items))
+ ((eq itemType '|inputStrings|)
+ (|htInputStrings| items))
+ ((eq itemType '|domainConditions|)
+ (|htProcessDomainConditions| items))
+ ((eq itemType '|bcStrings|)
+ (|htProcessBcStrings| items))
+ ((eq itemType '|toggleButtons|)
+ (|htProcessToggleButtons| items))
+ ((eq itemType '|bcButtons|)
+ (|htProcessBcButtons| items))
+ ((eq itemType '|doneButton|)
+ (|htProcessDoneButton| items))
+ ((eq itemType '|doitButton|)
+ (|htProcessDoitButton| items))
+ (t
+ (|systemError|
+ (cons "unknown itemType"
+ (cons itemType nil))))))))))))
+
+\end{chunk}
+
+\defun{htMakeErrorPage}{htMakeErrorPage}
+\begin{chunk}{defun htMakeErrorPage}
+(defun |htMakeErrorPage| (htPage)
+ (prog (line)
+ (declare (special |$curPage| |$htLineList| |$newPage|))
+ (return
+ (progn
+ (setq |$newPage| nil)
+ (setq |$htLineList| nil)
+ (setq |$curPage| htPage)
+ (|htMakePage| (|htpPageDescription| htPage))
+ (setq line (apply (|function| CONCAT) (NREVERSE |$htLineList|)))
+ (|issueHT| line)
+ (|endHTPage|)))))
+
+\end{chunk}
+
+\defun{htQuote}{htQuote}
+\begin{chunk}{defun htQuote}
+(defun |htQuote| (s)
+ (progn
+ (|iht| "\"")
+ (|iht| s)
+ (|iht| "\"")))
+
+\end{chunk}
+
+\defun{htProcessToggleButtons}{htProcessToggleButtons}
+\begin{chunk}{defun htProcessToggleButtons}
+(defun |htProcessToggleButtons| (buttons)
+ (prog (message info defaultValue buttonName)
+ (declare (special |$curPage|))
+ (return
+ (SEQ (progn
+ (|iht| "\\newline\\indent{5}\\beginitems ")
+ (DO ((G166302 buttons (CDR G166302))
+ (G166286 nil))
+ ((OR (ATOM G166302)
+ (progn (setq G166286 (car G166302)) nil)
+ (progn
+ (progn
+ (setq message (car G166286))
+ (setq info (CADR G166286))
+ (setq defaultValue (CADDR G166286))
+ (setq buttonName (CADDDR G166286))
+ G166286)
+ nil))
+ nil)
+ (SEQ (EXIT (progn
+ (cond
+ ((NULL (LASSOC buttonName
+ (|htpInputAreaAlist| |$curPage|)))
+ (|setUpDefault| buttonName
+ (cons '|button|
+ (cons defaultValue nil)))))
+ (|iht| (cons
+ "\\item{\\em\\inputbox["
+ (cons
+ (|htpLabelDefault| |$curPage|
+ buttonName)
+ (cons "]{"
+ (cons buttonName
+ (cons
+ "}{\\htbmfile{pick}}{\\htbmfile{unpick}}\\space{}"
+ nil))))))
+ (|bcIssueHt| message)
+ (|iht| "\\space{}}")
+ (|bcIssueHt| info)))))
+ (|iht| "\\enditems\\indent{0} "))))))
+
+\end{chunk}
+
+\defun{htProcessBcButtons}{htProcessBcButtons}
+\begin{chunk}{defun htProcessBcButtons}
+(defun |htProcessBcButtons| (buttons)
+ (prog (defaultValue buttonName k)
+ (declare (special |$curPage|))
+ (return
+ (SEQ (DO ((G166328 buttons (CDR G166328)) (G166317 nil))
+ ((OR (ATOM G166328)
+ (progn (setq G166317 (car G166328)) nil)
+ (progn
+ (progn
+ (setq defaultValue (car G166317))
+ (setq buttonName (CADR G166317))
+ G166317)
+ nil))
+ nil)
+ (SEQ (EXIT (progn
+ (cond
+ ((NULL (LASSOC buttonName
+ (|htpInputAreaAlist| |$curPage|)))
+ (|setUpDefault| buttonName
+ (cons '|button|
+ (cons defaultValue nil)))))
+ (setq k
+ (|htpLabelDefault| |$curPage|
+ buttonName))
+ (cond
+ ((EQL k 0)
+ (|iht| (cons "\\off{"
+ (cons buttonName
+ (cons "}" nil)))))
+ ((EQL k 1)
+ (|iht| (cons "\\on{"
+ (cons buttonName
+ (cons "}" nil)))))
+ (t
+ (|iht| (cons "\\inputbox["
+ (cons
+ (|htpLabelDefault| |$curPage|
+ buttonName)
+ (cons "]{"
+ (cons buttonName
+ (cons
+ "}{\\htbmfile{pick}}{\\htbmfile{unpick}}"
+ nil))))))))))))))))
+
+\end{chunk}
+
+\defun{htProcessBcStrings}{htProcessBcStrings}
+\begin{chunk}{defun htProcessBcStrings}
+(defun |htProcessBcStrings| (strings)
+ (PROG (numChars default stringName spadType filter mess2)
+ (declare (special |$curPage|))
+ (return
+ (SEQ (DO ((G166358 strings (CDR G166358)) (G166343 nil))
+ ((or (atom G166358)
+ (progn (setq G166343 (CAR G166358)) nil)
+ (progn
+ (progn
+ (setq numChars (car G166343))
+ (setq default (cadr G166343))
+ (setq stringName (caddr G166343))
+ (setq spadType (cadddr G166343))
+ (setq filter (cddddr G166343))
+ G166343)
+ nil))
+ nil)
+ (SEQ (EXIT (progn
+ (setq mess2 "")
+ (cond
+ ((null (LASSOC stringName
+ (|htpInputAreaAlist| |$curPage|)))
+ (|setUpDefault| stringName
+ (cons '|string|
+ (cons default
+ (cons spadType
+ (cons filter nil)))))))
+ (cond
+ ((|htpLabelErrorMsg| |$curPage|
+ stringName)
+ (|iht| (cons
+ "\\centerline{{\\em "
+ (cons
+ (|htpLabelErrorMsg| |$curPage|
+ stringName)
+ (cons "}}" nil))))
+ (setq mess2
+ (concat mess2 (|bcSadFaces|)))
+ (|htpSetLabelErrorMsg| |$curPage|
+ stringName nil)))
+ (|iht| (cons "\\inputstring{"
+ (cons stringName
+ (cons "}{"
+ (cons numChars
+ (cons "}{"
+ (cons
+ (|htpLabelDefault|
+ |$curPage| stringName)
+ (cons "} "
+ (cons mess2 nil)))))))))))))))))
+
+\end{chunk}
+
+\defun{bcSadFaces}{bcSadFaces}
+\begin{chunk}{defun bcSadFaces}
+(defun |bcSadFaces| ()
+ "\\space{1}{\\em\\htbitmap{error}\\htbitmap{error}\\htbitmap{error}}")
+
+\end{chunk}
+
+\defun{htLispLinks}{htLispLinks}
+\begin{chunk}{defun htLispLinks}
+(defun |htLispLinks| (&REST G166422 &AUX option links)
+ (setq links (car G166422))
+ (setq option (cdr G166422))
+ (prog (t1 options indent message info func value call)
+ (return
+ (SEQ (progn
+ (setq t1 (|beforeAfter| '|options| links))
+ (setq links (car t1))
+ (setq options (cadr t1))
+ (setq indent (or (LASSOC '|indent| options) 5))
+ (|iht| "\\newline\\indent{")
+ (|iht| (|stringize| indent))
+ (|iht| "}\\beginitems")
+ (DO ((G166403 links (CDR G166403)) (G166387 nil))
+ ((or (atom G166403)
+ (progn (setq G166387 (car G166403)) nil)
+ (progn
+ (progn
+ (setq message (car G166387))
+ (setq info (cadr G166387))
+ (setq func (caddr G166387))
+ (setq value (cdddr G166387))
+ G166387)
+ nil))
+ nil)
+ (SEQ (EXIT (progn
+ (|iht| "\\item[")
+ (setq call
+ (cond
+ ((IFCAR option)
+ "\\lispmemolink")
+ (t
+ "\\lispdownlink")))
+ (|htMakeButton| call message
+ (|mkCurryFun| func value))
+ (|iht| (cons "]\\space{}" nil))
+ (|bcIssueHt| info)))))
+ (|iht| "\\enditems\\indent{0} "))))))
+
+\end{chunk}
+
+\defun{htLispMemoLinks}{htLispMemoLinks}
+\begin{chunk}{defun htLispMemoLinks}
+(defun |htLispMemoLinks| (links) (|htLispLinks| links t))
+
+\end{chunk}
+
+\defun{htBcLinks}{htBcLinks}
+\begin{chunk}{defun htBcLinks}
+(defun |htBcLinks| (&REST G166465 &AUX options links)
+ (setq links (car G166465))
+ (setq options (cdr G166465))
+ (prog (skipStateInfo? t1 message info func value)
+ (return
+ (SEQ (progn
+ (setq |skipStateInfo?| (IFCAR options))
+ (setq t1 (|beforeAfter| '|options| links))
+ (setq links (car t1))
+ (setq options (cadr t1))
+ (DO ((G166447 links (CDR G166447)) (G166434 nil))
+ ((or (atom G166447)
+ (progn (setq G166434 (car G166447)) nil)
+ (progn
+ (progn
+ (setq message (car G166434))
+ (setq info (cadr G166434))
+ (setq func (caddr G166434))
+ (setq value (cdddr G166434))
+ G166434)
+ nil))
+ nil)
+ (SEQ (EXIT (progn
+ (|htMakeButton|
+ "\\lispdownlink" message
+ (|mkCurryFun| func value)
+ skipStateInfo?)
+ (|bcIssueHt| info))))))))))
+
+\end{chunk}
+
+\defun{htBcLispLinks}{htBcLispLinks}
+\begin{chunk}{defun htBcLispLinks}
+(defun |htBcLispLinks| (links)
+ (prog (t1 options message info func value)
+ (return
+ (SEQ (progn
+ (setq t1 (|beforeAfter| '|options| links))
+ (setq links (car t1))
+ (setq options (cadr t1))
+ (DO ((G166487 links (cdr G166487)) (G166474 nil))
+ ((or (atom G166487)
+ (progn (setq G166474 (car G166487)) nil)
+ (progn
+ (progn
+ (setq message (car G166474))
+ (setq info (cadr G166474))
+ (setq func (caddr G166474))
+ (setq value (cdddr G166474))
+ G166474)
+ nil))
+ nil)
+ (SEQ (EXIT (progn
+ (|htMakeButton| "\\lisplink"
+ message
+ (|mkCurryFun| func value))
+ (|bcIssueHt| info))))))))))
+
+\end{chunk}
+
+\defun{beforeAfter}{beforeAfter}
+\begin{chunk}{defun beforeAfter}
+(defun |beforeAfter| (x u)
+ (prog (y r)
+ (return
+ (SEQ (cons (prog (G166514)
+ (setq G166514 nil)
+ (return
+ (DO ((G166504 u (CDR G166504)))
+ ((or (atom G166504)
+ (progn
+ (progn
+ (setq y (car G166504))
+ (setq r (cdr G166504))
+ G166504)
+ nil)
+ (null (NEQUAL x y)))
+ (NREVERSE0 G166514))
+ (SEQ (EXIT (setq G166514 (cons y G166514)))))))
+ (cons r nil))))))
+
+\end{chunk}
+
+\defun{mkCurryFun}{mkCurryFun}
+\begin{chunk}{defun mkCurryFun}
+(defun |mkCurryFun| (fun val)
+ (prog (name code)
+ (return
+ (progn
+ (setq name (gentemp))
+ (setq code
+ (cons 'defun
+ (cons name
+ (cons '(arg)
+ (cons
+ (cons 'apply
+ (cons (mkq fun)
+ (cons
+ (cons 'cons
+ (cons 'arg
+ (cons (mkq val) nil)))
+ nil)))
+ nil)))))
+ (eval code)
+ name))))
+
+\end{chunk}
+
+\defun{htRadioButtons}{htRadioButtons}
+\begin{chunk}{defun htRadioButtons}
+(defun |htRadioButtons| (G166546)
+ (prog (groupName buttons boxesName message info buttonName defaultValue)
+ (declare (special |$curPage|))
+ (return
+ (SEQ (progn
+ (setq groupName (car G166546))
+ (setq buttons (cdr G166546))
+ (|htpSetRadioButtonAlist| |$curPage|
+ (cons (cons groupName (|buttonNames| buttons))
+ (|htpRadioButtonAlist| |$curPage|)))
+ (setq boxesName (gentemp))
+ (|iht| (cons "\\newline\\indent{5}\\radioboxes{"
+ (cons boxesName
+ (cons
+ "}{\\htbmfile{pick}}{\\htbmfile{unpick}}\\beginitems "
+ nil))))
+ (setq defaultValue "1")
+ (DO ((G166568 buttons (cdr G166568))
+ (G166540 nil))
+ ((or (atom G166568)
+ (progn (setq G166540 (car G166568)) nil)
+ (progn
+ (progn
+ (setq message (car G166540))
+ (setq info (cadr G166540))
+ (setq buttonName (caddr G166540))
+ G166540)
+ nil))
+ nil)
+ (SEQ (EXIT (progn
+ (cond
+ ((null (LASSOC buttonName
+ (|htpInputAreaAlist| |$curPage|)))
+ (|setUpDefault| buttonName
+ (cons '|button|
+ (cons defaultValue nil)))
+ (setq defaultValue
+ "0")))
+ (|iht| (cons "\\item{\\em\\radiobox["
+ (cons
+ (|htpLabelDefault| |$curPage|
+ buttonName)
+ (cons "]{"
+ (cons buttonName
+ (cons "}{"
+ (cons boxesName
+ (cons
+ "}\\space{}"
+ nil))))))))
+ (|bcIssueHt| message)
+ (|iht| "\\space{}}")
+ (|bcIssueHt| info)))))
+ (|iht| "\\enditems\\indent{0} "))))))
+
+\end{chunk}
+
+\defun{htBcRadioButtons}{htBcRadioButtons}
+\begin{chunk}{defun htBcRadioButtons}
+(defun |htBcRadioButtons| (G166594)
+ (prog (groupName buttons boxesName message info buttonName defaultValue)
+ (declare (special |$curPage|))
+ (return
+ (SEQ (progn
+ (setq groupName (car G166594))
+ (setq buttons (cdr G166594))
+ (|htpSetRadioButtonAlist| |$curPage|
+ (cons (cons groupName (|buttonNames| buttons))
+ (|htpRadioButtonAlist| |$curPage|)))
+ (setq boxesName (gentemp))
+ (|iht| (cons "\\radioboxes{"
+ (cons boxesName
+ (cons "}{\\htbmfile{pick}}{\\htbmfile{unpick}} "
+ nil))))
+ (setq defaultValue "1")
+ (DO ((G166616 buttons (cdr G166616))
+ (G166588 nil))
+ ((or (atom G166616)
+ (progn (setq G166588 (car G166616)) nil)
+ (progn
+ (progn
+ (setq message (car G166588))
+ (setq info (cadr G166588))
+ (setq buttonName (caddr G166588))
+ G166588)
+ nil))
+ nil)
+ (SEQ (EXIT (progn
+ (cond
+ ((null (LASSOC buttonName
+ (|htpInputAreaAlist| |$curPage|)))
+ (|setUpDefault| buttonName
+ (cons '|button|
+ (cons defaultValue nil)))
+ (setq defaultValue
+ "0")))
+ (|iht| (cons
+ "{\\em\\radiobox["
+ (cons
+ (|htpLabelDefault| |$curPage|
+ buttonName)
+ (cons "]{"
+ (cons buttonName
+ (cons "}{"
+ (cons boxesName
+ (cons "}" nil))))))))
+ (|bcIssueHt| message)
+ (|iht| "\\space{}}")
+ (|bcIssueHt| info))))))))))
+
+\end{chunk}
+
+\defun{setUpDefault}{setUpDefault}
+\begin{chunk}{defun setUpDefault}
+(defun |setUpDefault| (name props)
+ (declare (special |$curPage|))
+ (|htpAddInputAreaProp| |$curPage| name props))
+
+\end{chunk}
+
+\defun{buttonNames}{buttonNames}
+\begin{chunk}{defun buttonNames}
+(defun |buttonNames| (buttons)
+ (prog (buttonName)
+ (return
+ (SEQ (prog (G166645)
+ (setq G166645 nil)
+ (return
+ (DO ((G166651 buttons (cdr G166651))
+ (G166637 nil))
+ ((or (atom G166651)
+ (progn (setq G166637 (car G166651)) nil)
+ (progn
+ (progn
+ (setq buttonName (caddr G166637))
+ G166637)
+ nil))
+ (NREVERSE0 G166645))
+ (SEQ (EXIT (setq G166645
+ (cons buttonName G166645)))))))))))
+
+\end{chunk}
+
+\defun{htInputStrings}{htInputStrings}
+\begin{chunk}{defun htInputStrings}
+(defun |htInputStrings| (strings)
+ (prog (mess1 numChars default stringName spadType filter mess2)
+ (declare (special |$curPage|))
+ (return
+ (SEQ (progn
+ (|iht| "\\newline\\indent{5}\\beginitems ")
+ (DO ((G166685 strings (cdr G166685))
+ (G166665 nil))
+ ((or (atom G166685)
+ (progn (setq G166665 (car G166685)) nil)
+ (progn
+ (progn
+ (setq mess1 (car G166665))
+ (setq mess2 (cadr G166665))
+ (setq numChars (caddr G166665))
+ (setq default (cadddr G166665))
+ (setq stringName
+ (car (cddddr G166665)))
+ (setq spadType
+ (cadr (cddddr G166665)))
+ (setq filter (cddr (cddddr G166665)))
+ G166665)
+ nil))
+ nil)
+ (SEQ (EXIT (progn
+ (cond
+ ((null (LASSOC stringName
+ (|htpInputAreaAlist| |$curPage|)))
+ (|setUpDefault| stringName
+ (cons '|string|
+ (cons default
+ (cons spadType
+ (cons filter nil)))))))
+ (cond
+ ((|htpLabelErrorMsg| |$curPage|
+ stringName)
+ (|iht| (cons "\\centerline{{\\em "
+ (cons
+ (|htpLabelErrorMsg| |$curPage|
+ stringName)
+ (cons "}}" nil))))
+ (setq mess2
+ (CONCAT mess2 (|bcSadFaces|)))
+ (|htpSetLabelErrorMsg| |$curPage|
+ stringName nil)))
+ (|iht| "\\item ")
+ (|bcIssueHt| mess1)
+ (|iht| (cons "\\inputstring{"
+ (cons stringName
+ (cons "}{"
+ (cons numChars
+ (cons "}{"
+ (cons
+ (|htpLabelDefault| |$curPage|
+ stringName)
+ (cons "} " nil))))))))
+ (|bcIssueHt| mess2)))))
+ (|iht| "\\enditems\\indent{0}\\newline "))))))
+
+\end{chunk}
+
+\defun{htProcessDomainConditions}{htProcessDomainConditions}
+\begin{chunk}{defun htProcessDomainConditions}
+(defun |htProcessDomainConditions| (condList)
+ (declare (special |$curPage|))
+ (progn
+ (|htpSetDomainConditions| |$curPage|
+ (|renamePatternVariables| condList))
+ (|htpSetDomainVariableAlist| |$curPage|
+ (|computeDomainVariableAlist|))))
+
+\end{chunk}
+
+\defun{renamePatternVariables}{renamePatternVariables}
+\begin{chunk}{defun renamePatternVariables}
+(defun |renamePatternVariables| (condList)
+ (declare (special |$curPage| |$PatternVariableList|))
+ (progn
+ (|htpSetDomainPvarSubstList| |$curPage|
+ (|renamePatternVariables1| condList nil
+ |$PatternVariableList|))
+ (|substFromAlist| condList (|htpDomainPvarSubstList| |$curPage|))))
+
+\end{chunk}
+
+\defun{renamePatternVariables1}{renamePatternVariables1}
+\begin{chunk}{defun renamePatternVariables1}
+(defun |renamePatternVariables1| (condList substList patVars)
+ (prog (restConds pattern t2 pv t3 cond nsubst)
+ (declare (special |$EmptyMode|))
+ (return
+ (cond
+ ((null condList) substList)
+ (t (setq cond (car condList))
+ (setq restConds (cdr condList))
+ (cond
+ ((or (and (consp cond) (eq (qcar cond) '|isDomain|)
+ (progn
+ (setq t2 (qcdr cond))
+ (and (consp t2)
+ (progn
+ (setq pv (qcar t2))
+ (setq t3 (qcdr t2))
+ (and (consp t3)
+ (eq (qcdr t3) nil)
+ (progn
+ (setq pattern
+ (qcar t3))
+ t))))))
+ (and (consp cond) (eq (qcar cond) '|ofCategory|)
+ (progn
+ (setq t2 (qcdr cond))
+ (and (consp t2)
+ (progn
+ (setq pv (qcar t2))
+ (setq t3 (qcdr t2))
+ (and (consp t3)
+ (eq (qcdr t3) nil)
+ (progn
+ (setq pattern
+ (qcar t3))
+ t))))))
+ (and (consp cond) (eq (qcar cond) '|Satisfies|)
+ (progn
+ (setq t2 (qcdr cond))
+ (and (consp t2)
+ (progn
+ (setq pv (qcar t2))
+ (setq t3 (qcdr t2))
+ (and (consp t3)
+ (eq (qcdr t3) nil)
+ (progn
+ (setq cond (qcar t3))
+ t)))))))
+ (cond
+ ((equal pv |$EmptyMode|)
+ (setq nsubst substList))
+ (t
+ (setq nsubst
+ (cons (cons pv (car patVars)) substList))))
+ (|renamePatternVariables1| restConds nsubst
+ (cdr patVars)))
+ (t substList)))))))
+
+\end{chunk}
+
+\defun{substFromAlist}{substFromAlist}
+\begin{chunk}{defun substFromAlist}
+(defun |substFromAlist| (z substAlist)
+ (prog (pvar replace)
+ (return
+ (SEQ (progn
+ (DO ((G166792 substAlist (cdr G166792))
+ (G166783 nil))
+ ((or (atom G166792)
+ (progn (setq G166783 (car G166792)) nil)
+ (progn
+ (progn
+ (setq pvar (car G166783))
+ (setq replace (cdr G166783))
+ G166783)
+ nil))
+ nil)
+ (SEQ (EXIT (setq z (MSUBST replace pvar z)))))
+ z)))))
+
+\end{chunk}
+
+\defun{computeDomainVariableAlist}{computeDomainVariableAlist}
+\begin{chunk}{defun computeDomainVariableAlist}
+(defun |computeDomainVariableAlist| ()
+ (prog (pvar)
+ (declare (special |$curPage|))
+ (return
+ (SEQ (prog (G166813)
+ (setq G166813 nil)
+ (return
+ (DO ((G166819 (|htpDomainPvarSubstList| |$curPage|)
+ (cdr G166819))
+ (G166805 NIL))
+ ((or (atom G166819)
+ (progn (setq G166805 (car G166819)) nil)
+ (progn
+ (progn
+ (setq pvar (cdr G166805))
+ G166805)
+ NIL))
+ (NREVERSE0 G166813))
+ (SEQ (EXIT (setq G166813
+ (cons (cons pvar
+ (|pvarCondList| pvar))
+ G166813)))))))))))
+
+\end{chunk}
+
+\defun{pvarCondList}{pvarCondList}
+\begin{chunk}{defun pvarCondList}
+(defun |pvarCondList| (pvar)
+ (declare (special |$curPage|))
+ (NREVERSE
+ (|pvarCondList1| (cons pvar nil) nil
+ (|htpDomainConditions| |$curPage|))))
+
+\end{chunk}
+
+\defun{pvarCondList1}{pvarCondList1}
+\begin{chunk}{defun pvarCondList1}
+(defun |pvarCondList1| (pvarList activeConds condList)
+ (prog (cond restConds t2 pv t3 pattern)
+ (return
+ (cond
+ ((null condList) activeConds)
+ (t (setq cond (car condList))
+ (setq restConds (cdr condList))
+ (cond
+ ((and (consp cond)
+ (progn
+ (setq t2 (qcdr cond))
+ (and (consp t2)
+ (progn
+ (setq pv (qcar t2))
+ (setq t3 (qcdr t2))
+ (and (consp t3)
+ (eq (qcdr t3) nil)
+ (progn
+ (setq pattern (qcar t3))
+ t)))))
+ (|member| pv pvarList))
+ (|pvarCondList1|
+ (NCONC pvarList (|pvarsOfPattern| pattern))
+ (cons cond activeConds) restConds))
+ (t (|pvarCondList1| pvarList activeConds restConds))))))))
+
+\end{chunk}
+
+\defun{pvarsOfPattern}{pvarsOfPattern}
+\begin{chunk}{defun pvarsOfPattern}
+(defun |pvarsOfPattern| (pattern)
+ (prog ()
+ (declare (special |$PatternVariableList|))
+ (return
+ (SEQ (cond
+ ((null (listp pattern)) nil)
+ (t
+ (prog (G166869)
+ (setq G166869 nil)
+ (return
+ (DO ((G166875 (cdr pattern) (cdr G166875))
+ (pvar nil))
+ ((or (atom G166875)
+ (progn (setq pvar (car G166875)) nil))
+ (NREVERSE0 G166869))
+ (SEQ (EXIT (cond
+ ((|member| pvar
+ |$PatternVariableList|)
+ (setq G166869
+ (cons pvar G166869)))))))))))))))
+
+\end{chunk}
+
+\defun{htMakeTemplates,substLabel}{htMakeTemplates,substLabel}
+\begin{chunk}{defun htMakeTemplates,substLabel}
+(defun |htMakeTemplates,substLabel| (i template)
+ (SEQ (if (consp template)
+ (EXIT (intern (CONCAT (car template) (princ-to-string i)
+ (cdr template)))))
+ (EXIT template)))
+
+\end{chunk}
+
+\defun{htMakeTemplates}{htMakeTemplates}
+\begin{chunk}{defun htMakeTemplates}
+(defun |htMakeTemplates| (templateList numLabels)
+ (prog ()
+ (return
+ (SEQ (progn
+ (setq templateList
+ (prog (G166895)
+ (setq G166895 nil)
+ (return
+ (DO ((G166900 templateList
+ (CDR G166900))
+ (template nil))
+ ((or (atom G166900)
+ (progn
+ (setq template (car G166900))
+ nil))
+ (NREVERSE0 G166895))
+ (SEQ (EXIT (setq G166895
+ (cons
+ (|templateParts| template)
+ G166895))))))))
+ (prog (G166910)
+ (setq G166910 nil)
+ (return
+ (DO ((i 1 (1+ i)))
+ ((qsgreaterp i numLabels)
+ (NREVERSE0 G166910))
+ (SEQ (EXIT (setq G166910
+ (cons
+ (prog (G166922)
+ (setq G166922 nil)
+ (return
+ (DO
+ ((G166927 templateList
+ (CDR G166927))
+ (template nil))
+ ((or (atom G166927)
+ (progn
+ (setq template
+ (car G166927))
+ nil))
+ (NREVERSE0 G166922))
+ (SEQ
+ (EXIT
+ (setq G166922
+ (cons
+ (|htMakeTemplates,substLabel|
+ i template)
+ G166922)))))))
+ G166910))))))))))))
+
+\end{chunk}
+
+\defun{templateParts}{templateParts}
+\begin{chunk}{defun templateParts}
+(defun |templateParts| (template)
+ (prog (i)
+ (return
+ (cond
+ ((null (stringp template)) template)
+ (t (setq i (SEARCH "%l" template))
+ (cond
+ ((null i) template)
+ (t
+ (cons (SUBSEQ template 0 i)
+ (SUBSEQ template (+ i 2))))))))))
+
+\end{chunk}
+
+\defun{htMakeDoneButton}{htMakeDoneButton}
+\begin{chunk}{defun htMakeDoneButton}
+(defun |htMakeDoneButton| (message func)
+ (progn
+ (|bcHt| "\\newline\\vspace{1}\\centerline{")
+ (cond
+ ((equal message "Continue")
+ (|bchtMakeButton| "\\lispdownlink"
+ '|\\ContinueBitmap| func))
+ (t
+ (|bchtMakeButton| "\\lispdownlink"
+ (CONCAT "\\box{" message "}")
+ func)))
+ (|bcHt| "} ")))
+
+\end{chunk}
+
+\defun{htProcessDoneButton}{htProcessDoneButton}
+\begin{chunk}{defun htProcessDoneButton}
+(defun |htProcessDoneButton| (G166950)
+ (prog (label func)
+ (return
+ (progn
+ (setq label (car G166950))
+ (setq func (cadr G166950))
+ (|iht| "\\newline\\vspace{1}\\centerline{")
+ (cond
+ ((equal label "Continue")
+ (|htMakeButton| "\\lispdownlink"
+ '|\\ContinueBitmap| func))
+ ((equal label "Push to enter names")
+ (|htMakeButton| "\\lispdownlink"
+ "\\ControlBitmap{clicktoset}" func))
+ (t
+ (|htMakeButton| "\\lispdownlink"
+ (CONCAT "\\box{" label "}")
+ func)))
+ (|iht| "} ")))))
+
+\end{chunk}
+
+\defun{htMakeButton}{htMakeButton}
+\begin{chunk}{defun htMakeButton}
+(defun |htMakeButton|
+ (&REST G166990 &AUX options func message htCommand)
+ (DSETQ (htCommand message func . options) G166990)
+ (prog (skipStateInfo? id type)
+ (declare (special |$curPage|))
+ (return
+ (SEQ (progn
+ (setq skipStateInfo? (IFCAR options))
+ (|iht| (cons htCommand (cons "{" nil)))
+ (|bcIssueHt| message)
+ (cond
+ (skipStateInfo?
+ (|iht| (cons "}{(|htDoneButton| '|"
+ (cons func
+ (cons "| "
+ (cons (|htpName| |$curPage|)
+ (cons ")}" nil)))))))
+ (t
+ (|iht| (cons "}{(|htDoneButton| '|"
+ (cons func
+ (cons "| (progn " nil))))
+ (DO ((G166977 (|htpInputAreaAlist| |$curPage|)
+ (CDR G166977))
+ (G166965 nil))
+ ((OR (ATOM G166977)
+ (progn (setq G166965 (car G166977)) nil)
+ (progn
+ (progn
+ (setq id (car G166965))
+ (setq type (car (cddddr G166965)))
+ G166965)
+ nil))
+ nil)
+ (SEQ (EXIT (progn
+ (|iht| (cons "(|htpSetLabelInputString| "
+ (cons (|htpName| |$curPage|)
+ (cons "'|"
+ (cons id
+ (cons "| " nil))))))
+ (cond
+ ((eq type '|string|)
+ (|iht| (cons "\"\\stringvalue{"
+ (cons id
+ (cons "}\""
+ nil)))))
+ (t
+ (|iht| (cons
+ "\"\\boxvalue{"
+ (cons id
+ (cons "}\""
+ nil))))))
+ (|iht| ") ")))))
+ (|iht| (cons (|htpName| |$curPage|)
+ (cons "))}" nil))))))))))
+
+\end{chunk}
+
+\defun{bchtMakeButton}{bchtMakeButton}
+\begin{chunk}{defun bchtMakeButton}
+(defun |bchtMakeButton| (htCommand message func)
+ (prog (id type)
+ (declare (special |$curPage|))
+ (return
+ (SEQ (progn
+ (|bcHt| (cons htCommand
+ (cons "{"
+ (cons message
+ (cons "}{(|htDoneButton| '|"
+ (cons func
+ (cons "| (progn "
+ nil)))))))
+ (DO ((G167004 (|htpInputAreaAlist| |$curPage|)
+ (cdr G167004))
+ (G166992 nil))
+ ((or (atom G167004)
+ (progn (setq G166992 (car G167004)) nil)
+ (progn
+ (progn
+ (setq id (car G166992))
+ (setq type (car (cddddr G166992)))
+ G166992)
+ nil))
+ nil)
+ (SEQ (EXIT (progn
+ (|bcHt| (cons "(|htpSetLabelInputString| "
+ (cons (|htpName| |$curPage|)
+ (cons "'|"
+ (cons id
+ (cons "| " nil))))))
+ (cond
+ ((eq type '|string|)
+ (|bcHt| (cons
+ "\"\\stringvalue{"
+ (cons id
+ (cons "}\"" nil)))))
+ (t
+ (|bcHt| (cons
+ "\"\\boxvalue{"
+ (cons id
+ (cons "}\"" nil))))))
+ (|bcHt| ") ")))))
+ (|bcHt| (cons (|htpName| |$curPage|)
+ (cons "))} " nil))))))))
+
+\end{chunk}
+
+\defun{htProcessDoitButton}{htProcessDoitButton}
+\begin{chunk}{defun htProcessDoitButton}
+(defun |htProcessDoitButton| (G167017)
+ (prog (label command func fun)
+ (return
+ (progn
+ (setq label (car G167017))
+ (setq command (cadr G167017))
+ (setq func (caddr G167017))
+ (setq fun (|mkCurryFun| func (cons command nil)))
+ (|iht| "\\newline\\vspace{1}\\centerline{")
+ (|htMakeButton| "\\lispcommand"
+ (CONCAT "\\box{" label "}")
+ fun)
+ (|iht| "} ")
+ (|iht| "\\vspace{2}{Select \\ \\UpButton{} \\ to go back one page.}")
+ (|iht| "\\newline{Select \\ \\ExitButton{QuitPage} \\ to remove this window.}")))))
+
+\end{chunk}
+
+\defun{htMakeDoitButton}{htMakeDoitButton}
+\begin{chunk}{defun htMakeDoitButton}
+(defun |htMakeDoitButton| (label command)
+ (declare (special |$curPage|))
+ (progn
+ (cond
+ ((equal label "Do It")
+ (|bcHt| "\\newline\\vspace{1}\\centerline{\\lispcommand{\\DoItBitmap}{(|doDoitButton| "))
+ (t
+ (|bcHt| (cons "\\newline\\vspace{1}\\centerline{\\lispcommand{\\box{"
+ (cons label
+ (cons "}}{(|doDoitButton| "
+ nil))))))
+ (|bcHt| (|htpName| |$curPage|))
+ (|bcHt| (cons " \""
+ (cons (|htEscapeString| command)
+ (cons "\"" nil))))
+ (|bcHt| ")}}")
+ (|bcHt| "\\vspace{2}{Select \\ \\UpButton{} \\ to go back one page.}")
+ (|bcHt| "\\newline{Select \\ \\ExitButton{QuitPage} \\ to remove this window.}")))
+
+\end{chunk}
+
+\defun{doDoitButton}{doDoitButton}
+\begin{chunk}{defun doDoitButton}
+(defun |doDoitButton| (htPage command)
+ (declare (ignore htPage))
+ (|executeInterpreterCommand| command))
+
+\end{chunk}
+
+\defun{executeInterpreterCommand}{executeInterpreterCommand}
+\begin{chunk}{defun executeInterpreterCommand}
+(defun |executeInterpreterCommand| (command)
+ (progn
+ (princ command)
+ (terpri)
+ (|setCurrentLine| command)
+ (catch 'spad_reader (|parseAndInterpret| command))
+ (princ (mkprompt))
+ (finish-output)))
+
+\end{chunk}
+
+\defun{htDoneButton}{htDoneButton}
+\begin{chunk}{defun htDoneButton}
+(defun |htDoneButton| (func htPage)
+ (cond
+ ((|typeCheckInputAreas| htPage) (|htMakeErrorPage| htPage))
+ ((null (fboundp func))
+ (|systemError| (cons "unknown function" (cons func nil))))
+ (t (funcall (symbol-function func) htPage))))
+
+\end{chunk}
+
+\defun{typeCheckInputAreas}{typeCheckInputAreas}
+\begin{chunk}{defun typeCheckInputAreas}
+(defun |typeCheckInputAreas| (htPage)
+ (prog (inputAlist stringName t2 t3 t4 t5 t6 t7 spadType t8 filter
+ condList string val errorCondition)
+ (declare (special |$bcParseOnly|))
+ (return
+ (SEQ (progn
+ (setq inputAlist nil)
+ (setq errorCondition nil)
+ (DO ((G167160 (|htpInputAreaAlist| htPage)
+ (cdr G167160))
+ (entry nil))
+ ((or (atom G167160)
+ (progn (setq entry (car G167160)) nil))
+ nil)
+ (SEQ (EXIT (cond
+ ((and (consp entry)
+ (progn
+ (setq stringName
+ (QCAR entry))
+ (setq t2 (QCDR entry))
+ (and (consp t2)
+ (progn
+ (setq t3
+ (QCDR t2))
+ (and (consp t3)
+ (progn
+ (setq t4
+ (QCDR t3))
+ (and (consp t4)
+ (progn
+ (setq t5
+ (QCDR t4))
+ (and (consp t5)
+ (eq (QCAR t5)
+ '|string|)
+ (progn
+ (setq t6
+ (QCDR t5))
+ (and (consp t6)
+ (progn
+ (setq t7
+ (QCDR t6))
+ (and
+ (consp t7)
+ (progn
+ (setq
+ spadType
+ (QCAR t7))
+ (setq
+ t8
+ (QCDR t7))
+ (and
+ (consp
+ t8)
+ (eq
+ (QCDR
+ t8)
+ nil)
+ (progn
+ (setq
+ filter
+ (QCAR
+ t8))
+ t))))))))))))))))
+ (progn
+ (setq condList
+ (LASSOC
+ (LASSOC spadType
+ (|htpDomainPvarSubstList|
+ htPage))
+ (|htpDomainVariableAlist|
+ htPage)))
+ (setq string
+ (|htpLabelFilteredInputString|
+ htPage stringName))
+ (cond
+ (|$bcParseOnly|
+ (cond
+ ((null
+ (|ncParseFromString| string))
+ (|htpSetLabelErrorMsg| htPage
+ "Syntax Error"
+ "Syntax Error"))
+ (t nil)))
+ (t
+ (setq val
+ (|checkCondition|
+ (|htpLabelInputString|
+ htPage stringName)
+ string condList))
+ (cond
+ ((stringp val)
+ (setq errorCondition t)
+ (|htpSetLabelErrorMsg| htPage
+ stringName val))
+ (t
+ (|htpSetLabelSpadValue| htPage
+ stringName val)))))))))))
+ errorCondition)))))
+
+\end{chunk}
+
+\defun{checkCondition}{checkCondition}
+\begin{chunk}{defun checkCondition}
+(defun |checkCondition| (s1 string condList)
+ (prog (pred t2 t3 pvar t4 pattern val type data newType)
+ (return
+ (cond
+ ((and (consp condList) (eq (QCDR condList) nil)
+ (progn
+ (setq t2 (QCAR |condList|))
+ (and (consp t2)
+ (eq (QCAR t2) '|Satisfies|)
+ (progn
+ (setq t3 (QCDR t2))
+ (and (consp t3)
+ (progn
+ (setq pvar (QCAR t3))
+ (setq t4 (QCDR t3))
+ (AND (consp t4)
+ (eq (QCDR t4) nil)
+ (progn
+ (setq pred (QCAR t4))
+ t))))))))
+ (setq val (funcall pred string))
+ (cond
+ ((stringp val) val)
+ (t (cons '(|String|) (|wrap| s1)))))
+ ((null (and (consp condList) (eq (QCDR condList) nil)
+ (progn
+ (setq t2 (QCAR condList))
+ (and (consp t2)
+ (eq (QCAR t2) '|isDomain|)
+ (progn
+ (setq t3 (QCDR t2))
+ (and (consp t3)
+ (progn
+ (setq pvar (QCAR t3))
+ (setq t4
+ (QCDR t3))
+ (and (consp t4)
+ (eq (QCDR t4) nil)
+ (progn
+ (setq pattern
+ (QCAR t4))
+ t)))))))))
+ (|systemError|
+ "currently invalid domain condition"))
+ ((equal |pattern| '(|String|))
+ (cons '(|String|) (|wrap| s1)))
+ (t (setq val (|parseAndEval| string))
+ (cond
+ ((stringp val)
+ (cond
+ ((equal val "Syntax Error ")
+ "Error: Syntax Error ")
+ (t (|condErrorMsg| pattern))))
+ (t (setq type (car val))
+ (setq data (cdr val))
+ (setq newType
+ (catch 'spad_reader
+ (|resolveTM| type pattern)))
+ (cond
+ ((null newType) (|condErrorMsg| pattern))
+ (t (|coerceInt| val newType))))))))))
+
+\end{chunk}
+
+\defun{condErrorMsg}{condErrorMsg}
+\begin{chunk}{defun condErrorMsg}
+(defun |condErrorMsg| (type)
+ (prog (typeString)
+ (return
+ (progn
+ (setq typeString (|form2String| type))
+ (cond
+ ((consp typeString)
+ (setq typeString
+ (apply (|function| CONCAT) typeString))))
+ (CONCAT "Error: Could not make your input into a "
+ typeString)))))
+
+\end{chunk}
+
+\defun{parseAndEval}{parseAndEval}
+\begin{chunk}{defun parseAndEval}
+(defun |parseAndEval| (string)
+ (prog (|$InteractiveMode| $boot $spad |$e| |$QuietCommand|)
+ (declare (special |$InteractiveMode| $boot $spad |$e|
+ |$QuietCommand|))
+ (return
+ (progn
+ (setq |$InteractiveMode| t)
+ (setq $boot nil)
+ (setq $spad t)
+ (setq |$e| |$InteractiveFrame|)
+ (setq |$QuietCommand| t)
+ (|parseAndEval1| string)))))
+
+\end{chunk}
+
+\defun{parseAndEval1}{parseAndEval1}
+\begin{chunk}{defun parseAndEval1}
+(defun |parseAndEval1| (string)
+ (let (v syntaxError pform val)
+ (setq syntaxError nil)
+ (setq pform
+ (progn
+ (setq v
+ (|applyWithOutputToString| '|ncParseFromString| (cons string nil)))
+ (cond
+ ((car v) (car v))
+ (t (setq syntaxError t) (cdr v)))))
+ (cond
+ (syntaxError "Syntax Error ")
+ (pform
+ (setq val
+ (|applyWithOutputToString| '|processInteractive|
+ (cons pform (list nil))))
+ (cond
+ ((car val) (car val))
+ (t "Type Analysis Error")))
+ (t nil))))
+
+\end{chunk}
+
+\defun{oldParseString}{oldParseString}
+\begin{chunk}{defun oldParseString}
+(defun |oldParseString| (string)
+ (prog (tree)
+ (return
+ (progn
+ (setq tree
+ (|applyWithOutputToString| '|string2SpadTree|
+ (cons string nil)))
+ (cond
+ ((car tree)
+ (|parseTransform| (postTransform (car tree))))
+ (t (cdr tree)))))))
+
+\end{chunk}
+
+\defun{makeSpadCommand}{makeSpadCommand}
+\begin{chunk}{defun makeSpadCommand}
+(defun |makeSpadCommand| (&REST G167322 &AUX z)
+ (setq z G167322)
+ (prog (opForm lastArg argList)
+ (return
+ (SEQ (progn
+ (setq opForm (CONCAT (car z) "("))
+ (setq lastArg (|last| z))
+ (setq z (cdr z))
+ (setq argList nil)
+ (DO ((G167306 l (cdr G167306)) (arg nil))
+ ((or (atom G167306)
+ (progn (setq arg (car G167306)) nil)
+ (null (NEQUAL arg lastArg)))
+ nil)
+ (SEQ (EXIT (setq argList
+ (cons
+ (CONCAT arg ", ")
+ argList)))))
+ (setq argList (NREVERSE (cons lastArg argList)))
+ (CONCAT opForm (apply (|function| CONCAT) argList)
+ ")"))))))
+
+\end{chunk}
+
+\defun{htMakeInputList}{htMakeInputList}
+\begin{chunk}{defun htMakeInputList}
+(defun |htMakeInputList| (stringList)
+ (prog (lastArg argList)
+ (return
+ (SEQ (progn
+ (setq lastArg (|last| stringList))
+ (setq argList nil)
+ (DO ((G167328 stringList (cdr G167328)) (arg nil))
+ ((or (atom G167328)
+ (progn (setq arg (car G167328)) nil)
+ (null (NEQUAL arg lastArg)))
+ nil)
+ (SEQ (EXIT (setq argList
+ (cons
+ (CONCAT arg ", ")
+ argList)))))
+ (setq argList (NREVERSE (cons lastArg argList)))
+ (|bracketString| (apply (|function| CONCAT) argList)))))))
+
+\end{chunk}
+
+\defun{bracketString}{bracketString}
+\begin{chunk}{defun bracketString}
+(defun |bracketString| (string)
+ (CONCAT "[" string "]"))
+
+\end{chunk}
+
+\defun{quoteString}{quoteString}
+\begin{chunk}{defun quoteString}
+(defun |quoteString| (string)
+ (CONCAT "\"" string "\""))
+
+\end{chunk}
+
+\defdollar{funnyQuote}
+\begin{chunk}{initvars}
+(defvar |$funnyQuote| #\Rubout)
+
+\end{chunk}
+
+\defdollar{funnyBacks}
+\begin{chunk}{initvars}
+(defvar |$funnyBacks| #\\200)
+
+\end{chunk}
+
+\defun{htEscapeString}{htEscapeString}
+\begin{chunk}{defun htEscapeString}
+(defun |htEscapeString| (str)
+ (declare (special |$funnyBacks| |$funnyQuote|))
+ (progn
+ (setq str (SUBSTITUTE |$funnyQuote| #\" str))
+ (SUBSTITUTE |$funnyBacks| #\\ str)))
+
+\end{chunk}
+
+\defun{htsv}{htsv}
+\begin{chunk}{defun htsv}
+(defun |htsv| ()
+ (|startHTPage| 50)
+ (|htSetVars|)))
+
+\end{chunk}
+
+\defun{htSetVars}{htSetVars}
+\begin{chunk}{defun htSetVars}
+(defun |htSetVars| ()
+ (declare (special |$setOptions| |$lastTree| |$path|))
+ (progn
+ (setq |$path| nil)
+ (setq |$lastTree| nil)
+ (cond
+ ((NEQUAL 0 (LASTATOM |$setOptions|))
+ (|htMarkTree| |$setOptions| 0)))
+ (|htShowSetTree| |$setOptions|)))
+
+\end{chunk}
+
+\defun{htShowSetTree}{htShowSetTree}
+\begin{chunk}{defun htShowSetTree}
+(defun |htShowSetTree| (setTree)
+ (prog (page okList maxWidth1 maxWidth2 tabset1 tabset2 label links)
+ (declare (special |$path|))
+ (return
+ (SEQ (progn
+ (setq |$path|
+ (TAKE (SPADDIFFERENCE (LASTATOM setTree))
+ |$path|))
+ (setq page (|htInitPage| (|mkSetTitle|) nil))
+ (|htpSetProperty| page '|setTree| setTree)
+ (setq links nil)
+ (setq maxWidth1 (setq maxWidth2 0))
+ (SEQ (DO ((G167379 setTree (cdr G167379))
+ (setData nil))
+ ((or (atom G167379)
+ (progn
+ (setq setData (car G167379))
+ nil))
+ nil)
+ (SEQ (EXIT (cond
+ ((|satisfiesUserLevel|
+ (elt setData 2))
+ (EXIT (progn
+ (setq okList
+ (cons setData okList))
+ (setq maxWidth1
+ (max
+ (|#|
+ (PNAME (elt setData 0)))
+ maxWidth1))
+ (setq maxWidth2
+ (max
+ (|htShowCount|
+ (STRINGIMAGE
+ (elt setData 1)))
+ |maxWidth2|)))))))))
+ (setq maxWidth1 (max 9 maxWidth1))
+ (setq maxWidth2 (max 41 maxWidth2))
+ (setq tabset1 (STRINGIMAGE maxWidth1))
+ (setq tabset2
+ (STRINGIMAGE
+ (SPADDIFFERENCE
+ (+ maxWidth2 maxWidth1) 1)))
+ (|htSay| "\\tab{2}\\newline Variable\\tab{"
+ (STRINGIMAGE
+ (+ maxWidth1
+ (quotient maxWidth2 3)))
+ "}Description\\tab{"
+ (STRINGIMAGE
+ (+ (+ maxWidth2 maxWidth1) 2))
+ "}Value\\newline\\beginitems ")
+ (DO ((G167392 (reverse okList) (CDR G167392))
+ (setData nil))
+ ((or (atom G167392)
+ (progn
+ (setq setData (car G167392))
+ nil))
+ nil)
+ (SEQ (EXIT (progn
+ (|htSay| "\\item")
+ (setq label
+ (STRCONC "\\menuitemstyle{"
+ (elt setData 0)
+ "}"))
+ (setq links
+ (cons label
+ (cons
+ (cons
+ (cons '|text|
+ (cons
+ "\\tab{"
+ (cons tabset1
+ (cons "}"
+ (cons
+ (elt setData 1)
+ (cons "\\tab{"
+ (cons tabset2
+ (cons "}{\\em "
+ (cons
+ (|htShowSetTreeValue|
+ setData)
+ (cons
+ "}"
+ nil))))))))))
+ nil)
+ (cons '|htShowSetPage|
+ (cons (elt setData 0)
+ nil)))))
+ (|htMakePage|
+ (cons
+ (cons '|bcLispLinks|
+ (cons links
+ (cons '|options|
+ (cons '(|indent| . 0) nil))))
+ nil))))))
+ (|htSay| "\\enditems") (|htShowPage|)))))))
+
+\end{chunk}
+
+\defun{htShowCount}{htShowCount}
+\begin{chunk}{defun htShowCount}
+(defun |htShowCount| (s)
+ (prog (m i count)
+ (return
+ (SEQ (progn
+ (setq m (|#| s))
+ (cond
+ ((> 8 m) (- m 1))
+ (t (setq i 0) (setq count 0)
+ (DO () ((NULL (> (- m 7) i)) nil)
+ (SEQ (EXIT (cond
+ ((and (equal (elt s i) #\{)
+ (equal (elt s (1+ i)) #\\)
+ (equal (elt s (+ i 2)) #\e)
+ (equal (elt s (+ i 3)) #\m))
+ (setq i (+ i 6)))
+ (t (setq i (1+ i))
+ (setq count (1+ count)))))))
+ (+ count (- m i)))))))))
+
+\end{chunk}
+
+\defun{htShowSetTreeValue}{htShowSetTreeValue}
+\begin{chunk}{defun htShowSetTreeValue}
+(defun |htShowSetTreeValue| (setData)
+ (prog (st)
+ (return
+ (progn
+ (setq st (elt setData 3))
+ (cond
+ ((eq st 'function)
+ (|object2String| (FUNCALL (elt setData 4) '|%display%|)))
+ ((eq st 'integer)
+ (|object2String| (|eval| (elt setData 4))))
+ ((eq st 'string)
+ (|object2String| (|eval| (elt setData 4))))
+ ((eq st 'literals)
+ (|object2String|
+ (|translateTrueFalse2YesNo| (|eval| (elt setData 4)))))
+ ((eq st 'tree) "...")
+ (t (|systemError|)))))))
+
+\end{chunk}
+
+\defun{mkSetTitle}{mkSetTitle}
+\begin{chunk}{defun mkSetTitle}
+(defun |mkSetTitle| ()
+ (declare (special |$path|))
+ (STRCONC "Command {\\em )set "
+ (|listOfStrings2String| |$path|) "}"))
+
+\end{chunk}
+
+\defun{listOfStrings2String}{listOfStrings2String}
+\begin{chunk}{defun listOfStrings2String}
+(defun |listOfStrings2String| (u)
+ (cond
+ ((null u) "")
+ (t
+ (STRCONC (|listOfStrings2String| (cdr u)) " "
+ (|stringize| (car u))))))
+
+\end{chunk}
+
+\defun{htShowSetPage}{htShowSetPage}
+\begin{chunk}{defun htShowSetPage}
+(defun |htShowSetPage| (htPage branch)
+ (prog (setTree setData st)
+ (declare (special |$path|))
+ (return
+ (progn
+ (setq setTree (|htpProperty| htPage '|setTree|))
+ (setq |$path|
+ (cons branch
+ (TAKE (- (LASTATOM setTree))
+ |$path|)))
+ (setq setData (|assoc| branch setTree))
+ (cond
+ ((null setData) (|systemError| "No Set Data"))
+ (t (setq st (elt setData 3))
+ (cond
+ ((eq st 'function)
+ (|htShowFunctionPage| htPage setData))
+ ((eq st 'integer)
+ (|htShowIntegerPage| htPage setData))
+ ((eq st 'literals)
+ (|htShowLiteralsPage| htPage setData))
+ ((eq st 'tree)
+ (|htShowSetTree| (elt setData 5)))
+ ((eq st 'string)
+ (|htSetNotAvailable| htPage
+ ")set compiler"))
+ (t (|systemError| "Unknown data type")))))))))
+
+\end{chunk}
+
+\defun{htShowLiteralsPage}{htShowLiteralsPage}
+\begin{chunk}{defun htShowLiteralsPage}
+(defun |htShowLiteralsPage| (htPage setData)
+ (|htSetLiterals| htPage (elt setData 0) (elt setData 1)
+ (elt setData 4) (elt setData 5) '|htSetLiteral|))
+
+\end{chunk}
+
+\defun{htSetLiterals}{htSetLiterals}
+\begin{chunk}{defun htSetLiterals}
+(defun |htSetLiterals| (htPage name message variable values functionToCall)
+ (prog (page links)
+ (return
+ (SEQ (progn
+ (setq page
+ (|htInitPage| "Set Command"
+ (|htpPropertyList| htPage)))
+ (|htpSetProperty| page '|variable| variable)
+ (|bcHt| (cons "\\centerline{Set {\\em "
+ (cons name
+ (cons "}}\\newline" nil))))
+ (|bcHt| (cons "{\\em Description: } "
+ (cons message
+ (cons "\\newline\\vspace{1} "
+ nil))))
+ (|bcHt| "Select one of the following: \\newline\\tab{3} ")
+ (setq links
+ (prog (G167460)
+ (setq G167460 nil)
+ (return
+ (DO ((G167465 values (cdr G167465))
+ (opt nil))
+ ((or (atom G167465)
+ (progn
+ (setq opt (car G167465))
+ nil))
+ (NREVERSE0 G167460))
+ (SEQ (EXIT (setq G167460
+ (cons
+ (cons
+ (STRCONC ""
+ (STRINGIMAGE opt))
+ (cons "\\newline\\tab{3}"
+ (cons functionToCall
+ (cons opt nil))))
+ G167460))))))))
+ (|htMakePage| (cons (cons '|bcLispLinks| links) nil))
+ (|bcHt|
+ (cons
+ '|\\indent{0}\\newline\\vspace{1} The current setting is: {\\em |
+ (cons (|translateTrueFalse2YesNo|
+ (eval variable))
+ (cons "} " nil))))
+ (|htShowPage|))))))
+
+\end{chunk}
+
+\defun{htSetLiteral}{htSetLiteral}
+\begin{chunk}{defun htSetLiteral}
+(defun |htSetLiteral| (htPage val)
+ (progn
+ (|htInitPage| "Set Command" nil)
+ (set (|htpProperty| htPage '|variable|)
+ (|translateYesNo2TrueFalse| val))
+ (|htKill| htPage val)))
+
+\end{chunk}
+
+\defun{htShowIntegerPage}{htShowIntegerPage}
+\begin{chunk}{defun htShowIntegerPage}
+(defun |htShowIntegerPage| (htPage setData)
+ (prog (page message t1)
+ (declare (special |$htFinal| |$htInitial|))
+ (return
+ (progn
+ (setq page
+ (|htInitPage| (|mkSetTitle|)
+ (|htpPropertyList| htPage)))
+ (|htpSetProperty| page '|variable| (elt setData 4))
+ (|bcHt| (cons "\\centerline{Set {\\em "
+ (cons (elt setData 0)
+ (cons "}}\\newline" nil))))
+ (setq message (elt setData 1))
+ (|bcHt| (cons "{\\em Description: } "
+ (cons message
+ (cons "\\newline\\vspace{1} "
+ nil))))
+ (setq t1 (elt setData 5))
+ (setq |$htInitial| (car t1))
+ (setq |$htFinal| (cadr t1))
+ (cond
+ ((equal |$htFinal| (+ |$htInitial| 1))
+ (|bcHt| "Enter the integer {\\em ")
+ (|bcHt| (|stringize| |$htInitial|))
+ (|bcHt| "} or {\\em ")
+ (|bcHt| (|stringize| |$htFinal|))
+ (|bcHt| "}:"))
+ ((null |$htFinal|)
+ (|bcHt| "Enter an integer greater than {\\em ")
+ (|bcHt| (|stringize| (- |$htInitial| 1)))
+ (|bcHt| "}:"))
+ (t (|bcHt| "Enter an integer between {\\em ")
+ (|bcHt| (|stringize| |$htInitial|))
+ (|bcHt| "} and {\\em ")
+ (|bcHt| (|stringize| |$htFinal|))
+ (|bcHt| "}:")))
+ (|htMakePage|
+ (cons '(|domainConditions| (|Satisfies| S chkRange))
+ (cons (cons '|bcStrings|
+ (cons (cons 5
+ (cons (|eval| (elt setData 4))
+ (cons '|value| (cons 'S nil))))
+ nil))
+ nil)))
+ (|htSetvarDoneButton| "Select to Set Value"
+ '|htSetInteger|)
+ (|htShowPage|)))))
+
+\end{chunk}
+
+\defun{htSetInteger}{htSetInteger}
+\begin{chunk}{defun htSetInteger}
+(defun |htSetInteger| (htPage)
+ (prog (val)
+ (return
+ (progn
+ (|htInitPage| (|mkSetTitle|) nil)
+ (setq val
+ (|chkRange| (|htpLabelInputString| htPage '|value|)))
+ (cond
+ ((null (integerp val))
+ (|errorPage| htPage
+ (cons "Value Error"
+ (cons nil
+ (cons "\\vspace{3}\\centerline{{\\em "
+ (cons val
+ (cons
+ "}}\\vspace{2}\\newline\\centerline{Click on \\UpBitmap{} to re-enter value}"
+ nil)))))))
+ (t (set (|htpProperty| htPage '|variable|) val)
+ (|htKill| htPage val)))))))
+
+\end{chunk}
+
+\defun{htShowFunctionPage}{htShowFunctionPage}
+\begin{chunk}{defun htShowFunctionPage}
+(defun |htShowFunctionPage| (htPage setData)
+ (prog (fn)
+ (return
+ (cond
+ ((setq fn (elt setData 6)) (funcall fn htPage))
+ (t (|htpSetProperty| htPage '|setData| setData)
+ (|htpSetProperty| htPage '|parts| (elt setData 5))
+ (|htShowFunctionPageContinued| htPage))))))
+
+\end{chunk}
+
+\defun{htShowFunctionPageContinued}{htShowFunctionPageContinued}
+\begin{chunk}{defun htShowFunctionPageContinued}
+(defun |htShowFunctionPageContinued| (htPage)
+ (prog (parts setData phrase kind variable checker
+ initValue restParts page currentValue)
+ (return
+ (progn
+ (setq parts (|htpProperty| htPage '|parts|))
+ (setq setData (|htpProperty| htPage '|setData|))
+ (setq phrase (caar parts))
+ (setq kind (cadar parts))
+ (setq variable (caddar parts))
+ (setq checker (car (cdddar parts)))
+ (setq initValue (cadr (cdddar parts)))
+ (setq restParts (cdr parts))
+ (|htpSetProperty| htPage '|variable| variable)
+ (|htpSetProperty| htPage '|checker| checker)
+ (|htpSetProperty| htPage '|parts| restParts)
+ (cond
+ ((eq kind 'literals)
+ (|htSetLiterals| htPage (elt setData 0) phrase
+ variable checker '|htFunctionSetLiteral|))
+ (t
+ (setq page
+ (|htInitPage| (|mkSetTitle|)
+ (|htpPropertyList| htPage)))
+ (|bcHt| (cons "\\centerline{Set {\\em "
+ (cons (elt setData 0)
+ (cons "}}\\newline" nil))))
+ (|bcHt| (cons "{\\em Description: } "
+ (cons (elt setData 1)
+ (cons "\\newline\\vspace{1} "
+ nil))))
+ (setq currentValue (eval variable))
+ (|htMakePage|
+ (cons (cons '|domainConditions|
+ (cons (cons '|Satisfies|
+ (cons 'S (cons checker nil)))
+ nil))
+ (cons (cons '|text| phrase)
+ (cons (cons '|inputStrings|
+ (cons
+ (cons ""
+ (cons ""
+ (cons 60
+ (cons currentValue
+ (cons '|value|
+ (cons 'S nil))))))
+ nil))
+ nil))))
+ (|htSetvarDoneButton| "Select To Set Value" '|htSetFunCommand|)
+ (|htShowPage|)))))))
+
+\end{chunk}
+
+\defun{htSetvarDoneButton}{htSetvarDoneButton}
+\begin{chunk}{defun htSetvarDoneButton}
+(defun |htSetvarDoneButton| (message func)
+ (progn
+ (|bcHt| "\\newline\\vspace{1}\\centerline{")
+ (cond
+ ((OR (equal message "Select to Set Value")
+ (equal message "Select to Set Values"))
+ (|bchtMakeButton| "\\lisplink"
+ "\\ControlBitmap{clicktoset}" func))
+ (t
+ (|bchtMakeButton| "\\lisplink"
+ (CONCAT "\\fbox{" message "}")
+ func)))
+ (|bcHt| "} ")))
+
+\end{chunk}
+
+\defun{htFunctionSetLiteral}{htFunctionSetLiteral}
+\begin{chunk}{defun htFunctionSetLiteral}
+(defun |htFunctionSetLiteral| (htPage val)
+ (progn
+ (|htInitPage| "Set Command" nil)
+ (set (|htpProperty| htPage '|variable|)
+ (|translateYesNo2TrueFalse| val))
+ (|htSetFunCommandContinue| htPage val)))
+
+\end{chunk}
+
+\defun{htSetFunCommand}{htSetFunCommand}
+\begin{chunk}{defun htSetFunCommand}
+(defun |htSetFunCommand| (htPage)
+ (prog (variable checker value)
+ (return
+ (progn
+ (setq variable (|htpProperty| htPage '|variable|))
+ (setq checker (|htpProperty| htPage '|checker|))
+ (setq value
+ (|htCheck| checker
+ (|htpLabelInputString| htPage '|value|)))
+ (set variable value)
+ (|htSetFunCommandContinue| htPage value)))))
+
+\end{chunk}
+
+\defun{htSetFunCommandContinue}{htSetFunCommandContinue}
+\begin{chunk}{defun htSetFunCommandContinue}
+(defun |htSetFunCommandContinue| (htPage value)
+ (prog (parts t2 t3 predicate restParts continue)
+ (return
+ (progn
+ (setq parts (|htpProperty| htPage '|parts|))
+ (setq continue
+ (cond
+ ((null parts) nil)
+ ((and (consp parts)
+ (progn
+ (setq t2 (QCAR parts))
+ (and (consp t2)
+ (eq (QCAR t2) '|break|)
+ (progn
+ (setq t3 (QCDR t2))
+ (AND (consp t3)
+ (eq (QCDR t3) nil)
+ (progn
+ (setq predicate
+ (QCAR t3))
+ t)))))
+ (progn
+ (setq restParts (QCDR parts))
+ t))
+ (|eval| predicate))
+ (t t)))
+ (cond
+ (|continue| (|htpSetProperty| htPage '|parts| restParts)
+ (|htShowFunctionPageContinued| htPage))
+ (t (|htKill| htPage value)))))))
+
+\end{chunk}
+
+\defun{htKill}{htKill}
+\begin{chunk}{defun htKill}
+(defun |htKill| (htPage value)
+ (declare (ignore htPage))
+ (prog (string)
+ (declare (special |$path|))
+ (return
+ (progn
+ (|htInitPage| "System Command" nil)
+ (setq string
+ (STRCONC "{\\em )set "
+ (|listOfStrings2String|
+ (cons value |$path|))
+ "}"))
+ (|htMakePage|
+ (cons '(|text| "{Here is the AXIOM system command you could have issued:}"
+ "\\vspace{2}\\newline\\centerline{\\tt")
+ (cons (cons '|text| string) nil)))
+ (|htMakePage| '((|text| . "}\\vspace{1}\\newline\\rm")))
+ (|htSay| "\\vspace{2}{Select \\ \\UpButton{} \\ to go back.}")
+ (|htSay| "\\newline{Select \\ \\ExitButton{QuitPage} \\ to remove this window.}")
+ (|htProcessDoitButton|
+ (cons "Press to Remove Page"
+ (cons "" (cons '|htDoNothing| nil))))
+ (|htShowPage|)))))
+
+\end{chunk}
+
+\defun{htSetNotAvailable}{htSetNotAvailable}
+\begin{chunk}{defun htSetNotAvailable}
+(defun |htSetNotAvailable| (htPage whatToType)
+ (prog (page string)
+ (return
+ (progn
+ (setq page
+ (|htInitPage| "Unavailable Set Command"
+ (|htpPropertyList| htPage)))
+ (|htInitPage| "Unavailable System Command" nil)
+ (setq |string|
+ (STRCONC "{\\em " whatToType
+ "}"))
+ (|htMakePage|
+ (cons '(|text| "\\vspace{1}\\newline"
+ "{Sorry, but this system command is not available through HyperDoc. Please directly issue this command in an AXIOM window for more information:}"
+ "\\vspace{2}\\newline\\centerline{\\tt")
+ (cons (cons '|text| string) nil)))
+ (|htMakePage| '((|text| . "}\\vspace{1}\\newline")))
+ (|htProcessDoitButton|
+ (cons "Press to Remove Page"
+ (cons "" (cons '|htDoNothing| nil))))
+ (|htShowPage|)))))
+
+\end{chunk}
+
+\defun{htDoNothing}{htDoNothing}
+\begin{chunk}{defun htDoNothing}
+(defun |htDoNothing| (htPage command)
+ (declare (ignore htPage command))
+ nil)
+
+\end{chunk}
+
+\defun{htCheck}{htCheck}
+\begin{chunk}{defun htCheck}
+(defun |htCheck| (checker value)
+ (cond
+ ((consp checker) (|htCheckList| checker (|parseWord| value)))
+ (t (funcall checker value))))
+
+\end{chunk}
+
+\defun{parseWord}{parseWord}
+\begin{chunk}{defun parseWord}
+(defun |parseWord| (x)
+ (prog ()
+ (return
+ (SEQ (cond
+ ((stringp x)
+ (cond
+ ((prog (G167588)
+ (setq G167588 t)
+ (return
+ (DO ((G167594 nil (null G167588))
+ (G167595 (maxindex x))
+ (i 0 (1+ i)))
+ ((OR G167594 (QSGREATERP i G167595))
+ G167588)
+ (SEQ (EXIT (setq G167588
+ (AND G167588
+ (digitp (elt x i)))))))))
+ (parse-integer x))
+ (t (intern x))))
+ (t x))))))
+
+\end{chunk}
+
+\defun{htCheckList}{htCheckList}
+\begin{chunk}{defun htCheckList}
+(defun |htCheckList| (checker value)
+ (prog (n t2 m)
+ (return
+ (progn
+ (cond
+ ((|member| value '(|y| |ye| |yes| Y YE YES))
+ (setq value '|yes|)))
+ (cond
+ ((|member| value '(|n| |no| N NO)) (setq value '|no|)))
+ (cond
+ ((and (consp checker)
+ (progn
+ (setq n (qcar checker))
+ (setq t2 (qcdr checker))
+ (and (consp t2) (eq (QCDR t2) nil)
+ (progn (setq m (QCAR t2)) t)))
+ (integerp n))
+ (cond
+ ((eql m (1+ n))
+ (cond ((|member| value checker) value) (t n)))
+ ((null m)
+ (cond
+ ((and (integerp value) (>= value n)) value)
+ (t n)))
+ ((integerp m)
+ (cond
+ ((and (integerp value) (>= value n)
+ (<= value m))
+ value)
+ (t n)))))
+ ((|member| value checker) value)
+ (t (car checker)))))))
+
+\end{chunk}
+
+\defun{translateYesNoToTrueFalse}{translateYesNoToTrueFalse}
+\begin{chunk}{defun translateYesNoToTrueFalse}
+(defun |translateYesNoToTrueFalse| (x)
+ (cond
+ ((eq x '|yes|) t)
+ ((eq x '|no|) nil)
+ (t x)))
+
+\end{chunk}
+
+\defun{chkNameList}{chkNameList}
+\begin{chunk}{defun chkNameList}
+(defun |chkNameList| (x)
+ (prog (u parsedNames)
+ (return
+ (SEQ (progn
+ (setq u (|bcString2ListWords| x))
+ (setq parsedNames
+ (prog (G167635)
+ (setq G167635 nil)
+ (return
+ (DO ((G167640 u (CDR G167640))
+ (x nil))
+ ((or (atom G167640)
+ (progn
+ (setq x (car G167640))
+ nil))
+ (NREVERSE0 G167635))
+ (SEQ (EXIT (setq G167635
+ (cons (|ncParseFromString| x)
+ G167635))))))))
+ (cond
+ ((prog (G167646)
+ (setq G167646 t)
+ (return
+ (DO ((G167652 nil (NULL G167646))
+ (G167653 parsedNames (CDR G167653))
+ (x nil))
+ ((OR G167652 (ATOM G167653)
+ (progn (setq x (car G167653)) nil))
+ G167646)
+ (SEQ (EXIT (setq G167646
+ (AND G167646 (identp x))))))))
+ parsedNames)
+ (t
+ "Please enter a list of identifiers separated by blanks")))))))
+
+\end{chunk}
+
+\defun{chkPosInteger}{chkPosInteger}
+\begin{chunk}{defun chkPosInteger}
+(defun |chkPosInteger| (s)
+ (prog (u)
+ (return
+ (cond
+ ((and (setq u (|parseOnly| s)) (integerp u) (> u 0))
+ u)
+ (t "Please enter a positive integer")))))
+
+\end{chunk}
+
+\defun{chkOutputFileName}{chkOutputFileName}
+\begin{chunk}{defun chkOutputFileName}
+(defun |chkOutputFileName| (s)
+ (cond
+ ((|member| (|bcString2WordList| s) '(CONSOLE |console|))
+ '|console|)
+ (t (|chkDirectory| s))))
+
+\end{chunk}
+
+\defun{chkDirectory}{chkDirectory}
+\begin{chunk}{defun chkDirectory}
+(defun |chkDirectory| (s) s)
+
+\end{chunk}
+
+\defun{chkNonNegativeInteger}{chkNonNegativeInteger}
+\begin{chunk}{defun chkNonNegativeInteger}
+(defun |chkNonNegativeInteger| (s)
+ (prog (u)
+ (return
+ (cond
+ ((and (setq u (|ncParseFromString| s)) (integerp u)
+ (>= u 0))
+ u)
+ (t "Please enter a non-negative integer")))))
+
+\end{chunk}
+
+\defun{chkRange}{chkRange}
+\begin{chunk}{defun chkRange}
+(defun |chkRange| (s)
+ (prog (u)
+ (declare (special |$htFinal| |$htInitial|))
+ (return
+ (cond
+ ((and (setq u (|ncParseFromString| s)) (integerp u)
+ (>= u |$htInitial|)
+ (or (null |$htFinal|) (<= u |$htFinal|)))
+ u)
+ ((null |$htFinal|)
+ (STRCONC "Please enter an integer greater than "
+ (|stringize| (- |$htInitial| 1))))
+ (t
+ (STRCONC "Please enter an integer between "
+ (|stringize| |$htInitial|) " and "
+ (|stringize| |$htFinal|)))))))
+
+\end{chunk}
+
+\defun{chkAllNonNegativeInteger}{chkAllNonNegativeInteger}
+\begin{chunk}{defun chkAllNonNegativeInteger}
+(defun |chkAllNonNegativeInteger| (s)
+ (prog (u)
+ (return
+ (or (and (setq u (|ncParseFromString| s))
+ (|member| u '(|a| |al| |all| A AL ALL)) 'ALL)
+ (|chkNonNegativeInteger| s)
+ "Please enter {\\em all} or a non-negative integer"))))
+
+\end{chunk}
+
+\defun{htMakePathKey,fn}{htMakePathKey,fn}
+\begin{chunk}{defun htMakePathKey,fn}
+(defun |htMakePathKey,fn| (a b)
+ (SEQ (if (null b) (EXIT a))
+ (EXIT (|htMakePathKey,fn|
+ (STRCONC a "." (PNAME (car b)))
+ (cdr b)))))
+
+\end{chunk}
+
+\defun{htMakePathKey}{htMakePathKey}
+\begin{chunk}{defun htMakePathKey}
+(defun |htMakePathKey| (path)
+ (cond
+ ((null path) (|systemError| "path is not set"))
+ (t
+ (intern (|htMakePathKey,fn| (PNAME (car path)) (cdr path))))))
+
+\end{chunk}
+
+\defun{htMarkTree}{htMarkTree}
+\begin{chunk}{defun htMarkTree}
+(defun |htMarkTree| (tree n)
+ (SEQ (progn
+ (rplacd (LASTTAIL tree) n)
+ (SEQ (DO ((G167706 tree (cdr G167706)) (branch nil))
+ ((OR (ATOM G167706)
+ (progn (setq branch (car G167706)) nil))
+ nil)
+ (SEQ (EXIT (cond
+ ((eq (elt branch 3) 'tree)
+ (EXIT (|htMarkTree| (elt branch 5)
+ (1+ n))))))))))))
+
+\end{chunk}
+
+\defun{htSetHistory}{htSetHistory}
+\begin{chunk}{defun htSetHistory}
+(defun |htSetHistory| (htPage)
+ (prog (msg data)
+ (return
+ (progn
+ (setq msg
+ '|when the history facility is on (yes), results of computations are saved in memory|)
+ (setq data
+ (cons '|history|
+ (cons msg
+ (cons '|history|
+ (cons 'literals
+ (cons '|$HiFiAccess|
+ (cons '(|on| |off| |yes| |no|)
+ nil)))))))
+ (|htShowLiteralsPage| htPage data)))))
+
+\end{chunk}
+
+\defun{htSetOutputLibrary}{htSetOutputLibrary}
+\begin{chunk}{defun htSetOutputLibrary}
+(defun |htSetOutputLibrary| (htPage)
+ (|htSetNotAvailable| htPage ")set compiler output"))
+
+\end{chunk}
+
+\defun{htSetInputLibrary}{htSetInputLibrary}
+\begin{chunk}{defun htSetInputLibrary}
+(defun |htSetInputLibrary| (htPage)
+ (|htSetNotAvailable| htPage ")set compiler input"))
+
+\end{chunk}
+
+\defun{htSetExpose}{htSetExpose}
+\begin{chunk}{defun htSetExpose}
+(defun |htSetExpose| (htPage)
+ (|htSetNotAvailable| htPage ")set expose"))
+
+\end{chunk}
+
+\defun{htSetOutputCharacters}{htSetOutputCharacters}
+\begin{chunk}{defun htSetOutputCharacters}
+(defun |htSetOutputCharacters| (htPage)
+ (|htSetNotAvailable| htPage ")set output characters"))
+
+\end{chunk}
+
+\defun{htSetLinkerArgs}{htSetLinkerArgs}
+\begin{chunk}{defun htSetLinkerArgs}
+(defun |htSetLinkerArgs| (htPage)
+ (|htSetNotAvailable| htPage ")set fortran calling linker"))
+
+\end{chunk}
+
+\defun{htSetCache}{htSetCache}
+\begin{chunk}{defun htSetCache}
+(defun |htSetCache| (&REST G167749 &AUX options htPage)
+ (declare (special |$valueList| |$path|))
+ (setq htPage (car G167749))
+ (setq options (cdr G167749))
+ (progn
+ (setq |$path| '(|functions| |cache|))
+ (setq |htPage| (|htInitPage| (|mkSetTitle|) nil))
+ (setq |$valueList| nil)
+ (|htMakePage|
+ '((|text|
+ "Use this system command to cause the AXIOM interpreter to `remember' "
+ "past values of interpreter functions. "
+ "To remember a past value of a function, the interpreter "
+ "sets up a {\\em cache} for that function based on argument values. "
+ "When a value is cached for a given argument value, its value is gotten "
+ "from the cache and not recomputed. Caching can often save much "
+ "computing time, particularly with recursive functions or functions that "
+ "are expensive to compute and that are called repeatedly "
+ "with the same argument." "\\vspace{1}\\newline ")
+ (|domainConditions| (|Satisfies| S chkNameList))
+ (|text|
+"Enter below a list of interpreter functions you would like specially cached. "
+ "Use the name {\\em all} to give a default setting for all "
+ "interpreter functions. " "\\vspace{1}\\newline "
+ "Enter {\\em all} or a list of names (separate names by blanks):")
+ (|inputStrings| ("" "" 60 "all" names S))
+ (|doneButton| "Push to enter names" |htCacheAddChoice|)))
+ (|htShowPage|)))
+
+\end{chunk}
+
+\defun{htCacheAddChoice}{htCacheAddChoice}
+\begin{chunk}{defun htCacheAddChoice}
+(defun |htCacheAddChoice| (htPage)
+ (prog (names page)
+ (declare (special |$valueList|))
+ (return
+ (SEQ (progn
+ (setq names
+ (|bcString2WordList|
+ (|htpLabelInputString| htPage '|names|)))
+ (setq |$valueList|
+ (cons (|listOfStrings2String| names)
+ |$valueList|))
+ (cond
+ ((null names) (|htCacheAddQuery|))
+ ((null (cdr names)) (|htCacheOne| names))
+ (t (setq page (|htInitPage| (|mkSetTitle|) nil))
+ (|htpSetProperty| page '|names| names)
+ (|htMakePage|
+ '((|domainConditions|
+ (|Satisfies| ALLPI chkAllPositiveInteger))
+ (|text|
+ "For each function, enter below a {\\em cache length}, a positive integer. "
+ "This number tells how many past values will "
+ "be cached. "
+ "A cache length of {\\em 0} means the function won't be cached. "
+ "To cache all past values, "
+ "enter {\\em all}."
+ "\\vspace{1}\\newline "
+ "For each function name, enter {\\em all} or a positive integer:")))
+ (DO ((i 1 (QSADD1 i))
+ (G167755 names (CDR G167755)) (name nil))
+ ((or (atom G167755)
+ (progn (setq name (car G167755)) nil))
+ nil)
+ (SEQ (EXIT (|htMakePage|
+ (cons (cons '|inputStrings|
+ (cons
+ (cons
+ (STRCONC "Function {\\em "
+ name
+ "} will cache")
+ (cons "values"
+ (cons 5
+ (cons 10
+ (cons
+ (|htMakeLabel|
+ "c" i)
+ (cons 'ALLPI nil))))))
+ nil))
+ nil)))))
+ (|htSetvarDoneButton| "Select to Set Values" '|htCacheSet|)
+ (|htShowPage|))))))))
+
+\end{chunk}
+
+\defun{htMakeLabel}{htMakeLabel}
+\begin{chunk}{defun htMakeLabel}
+(defun |htMakeLabel| (prefix i)
+ (intern (strconc prefix (|stringize| i))))
+
+\end{chunk}
+
+\defun{htCacheSet}{htCacheSet}
+\begin{chunk}{defun htCacheSet}
+(defun |htCacheSet| (htPage)
+ (prog (names num n name val)
+ (declare (special |$cacheCount| |$cacheAlist|))
+ (return
+ (SEQ (progn
+ (setq names (|htpProperty| htPage '|names|))
+ (DO ((i 1 (QSADD1 i))
+ (G167785 names (CDR G167785)) (name nil))
+ ((or (atom G167785)
+ (progn (setq name (car G167785)) nil))
+ nil)
+ (SEQ (EXIT (progn
+ (setq num
+ (|chkAllNonNegativeInteger|
+ (|htpLabelInputString| htPage
+ (|htMakeLabel| "c"
+ i))))
+ (setq |$cacheAlist|
+ (ADDASSOC (intern name) num
+ |$cacheAlist|))))))
+ (cond
+ ((setq n (LASSOC '|all| |$cacheAlist|))
+ (setq |$cacheCount| n)
+ (setq |$cacheAlist|
+ (|deleteAssoc| '|all| |$cacheAlist|))))
+ (|htInitPage| "Cache Summary" nil)
+ (|bcHt| "In general, interpreter functions ")
+ (|bcHt| (cond
+ ((EQL |$cacheCount| 0)
+ '|will {\\em not} be cached.|)
+ (t (|bcHt| "cache ")
+ (|htAllOrNum| |$cacheCount|)
+ "} values.")))
+ (|bcHt| "\\vspace{1}\\newline ")
+ (cond
+ (|$cacheAlist|
+ (DO ((G167801 |$cacheAlist| (cdr G167801))
+ (G167774 nil))
+ ((or (atom G167801)
+ (progn
+ (setq G167774 (car G167801))
+ nil)
+ (progn
+ (progn
+ (setq name (car G167774))
+ (setq val (CDR G167774))
+ G167774)
+ nil))
+ nil)
+ (SEQ (EXIT (cond
+ ((NEQUAL val |$cacheCount|)
+ (progn
+ (|bcHt| "\\newline function {\\em ")
+ (|bcHt| (|stringize| name))
+ (|bcHt| "} will cache ")
+ (|htAllOrNum| val)
+ (|bcHt| "} values")))))))))
+ (|htProcessDoitButton|
+ (cons "Press to Remove Page"
+ (cons "" (cons '|htDoNothing| nil))))
+ (|htShowPage|))))))
+
+\end{chunk}
+
+\defun{htAllOrNum}{htAllOrNum}
+\begin{chunk}{defun htAllOrNum}
+(defun |htAllOrNum| (val)
+ (|bcHt| (cond
+ ((eq val '|all|) "{\\em all")
+ ((eql val 0) "{\\em no")
+ (t
+ (STRCONC "the last {\\em "
+ (|stringize| val))))))
+
+\end{chunk}
+
+\defun{htCacheOne}{htCacheOne}
+\begin{chunk}{defun htCacheOne}
+(defun |htCacheOne| (names)
+ (prog (page)
+ (return
+ (progn
+ (setq page (|htInitPage| (|mkSetTitle|) nil))
+ (|htpSetProperty| page '|names| names)
+ (|htMakePage|
+ '((|domainConditions|
+ (|Satisfies| ALLPI |chkAllPositiveInteger|))
+ (|text| "Enter below a {\\em cache length}, a positive integer. "
+ "This number tells how many past values will "
+ "be cached. To cache all past values, "
+ "enter {\\em all}." "\\vspace{1}\\newline ")
+ (|inputStrings|
+ ("Enter {\\em all} or a positive integer:" "" 5 10
+ |c1| ALLPI))))
+ (|htSetvarDoneButton| "Select to Set Value"
+ '|htCacheSet|)
+ (|htShowPage|)))))
+
+\end{chunk}
+
+\defdollar{historyDisplayWidth}
+\begin{chunk}{initvars}
+(defvar |$historyDisplayWidth| 120)
+
+\end{chunk}
+
+\defdollar{newline}
+\begin{chunk}{initvars}
+(defvar |$newline| #\Newline)
+
+\end{chunk}
+
+\defun{downlink}{downlink}
+\begin{chunk}{defun downlink}
+(defun |downlink| (page)
+ (declare (special |$saturn|))
+ (cond
+ (|$saturn| (|downlinkSaturn| page))
+ (t (|htInitPage| "Bridge" nil)
+ (|htSay| "\\replacepage{" page "}")
+ (|htShowPage|))))
+
+\end{chunk}
+
+\defun{downlinkSaturn}{downlinkSaturn}
+\begin{chunk}{defun downlinkSaturn}
+(defun |downlinkSaturn| (fn)
+ (prog (line u n lines)
+ (return
+ (SEQ (progn
+ (setq u (|dbReadLines| fn))
+ (setq lines "")
+ (DO ()
+ ((null (and (consp u)
+ (progn
+ (setq line (QCAR u))
+ (setq u (QCDR u))
+ t)))
+ nil)
+ (SEQ (EXIT (progn
+ (setq n (MAXINDEX line))
+ (cond
+ ((> 1 n) nil)
+ ((equal (elt line 0) #\%)
+ nil)
+ (t
+ (setq lines
+ (STRCONC lines line))))))))
+ (|issueHTSaturn| lines))))))
+
+\end{chunk}
+
+\defun{dbNonEmptyPattern}{dbNonEmptyPattern}
+\begin{chunk}{defun dbNonEmptyPattern}
+(defun |dbNonEmptyPattern| (pattern)
+ (cond
+ ((null pattern) "*")
+ (t (setq pattern (STRINGIMAGE pattern))
+ (cond ((> (|#| pattern) 0) pattern) (t "*")))))
+
+\end{chunk}
+
+\defun{htSystemVariables,gn}{htSystemVariables,gn}
+\begin{chunk}{defun htSystemVariables,gn}
+(defun |htSystemVariables,gn| (t1 al)
+ (prog (class key options)
+ (declare (special |$heading| |$levels|))
+ (return
+ (SEQ (progn
+ (setq class (caddr t1))
+ (setq key (cadddr t1))
+ (setq options (cadr (cddddr t1)))
+ t1)
+ (if (null (member class |$levels|)) (EXIT al))
+ (if (or (or (eq key 'literals)
+ (eq key 'integer))
+ (eq key 'string))
+ (EXIT (cons (cons |$heading| t1) al)))
+ (if (eq key 'tree)
+ (EXIT (|htSystemVariables,fn| options al nil)))
+ (if (eq key 'function)
+ (EXIT (cons (cons |$heading| t1) al)))
+ (EXIT (|systemError| key))))))
+
+\end{chunk}
+
+\defun{htSystemVariables,fn}{htSystemVariables,fn}
+\begin{chunk}{defun htSystemVariables,fn}
+(defun |htSystemVariables,fn| (t1 al firstTime)
+ (declare (special |$heading|))
+ (SEQ (if (atom t1) (EXIT al))
+ (if firstTime (setq |$heading| (|opOf| (car t1))) nil)
+ (EXIT (|htSystemVariables,fn| (cdr t1)
+ (|htSystemVariables,gn| (car t1) al) firstTime))))
+
+\end{chunk}
+
+\defun{htSystemVariables,displayOptions}{htSystemVariables,displayOptions}
+\begin{chunk}{defun htSystemVariables,displayOptions}
+(defun |htSystemVariables,displayOptions| (name class variable val options)
+ (SEQ (if (eq class 'integer)
+ (EXIT (SEQ (|htMakePage|
+ (cons (cons '|bcLispLinks|
+ (cons
+ (cons
+ (cons
+ (cons '|text|
+ (cons (elt options 0)
+ (cons "-"
+ (cons
+ (or (elt options 1)
+ "")
+ nil))))
+ nil)
+ (cons ""
+ (cons
+ '|htSetSystemVariableKind|
+ (cons
+ (cons variable
+ (cons name
+ (cons 'parse-integer nil)))
+ nil))))
+ nil))
+ nil))
+ (|htMakePage|
+ '((|domainConditions|
+ (|isDomain| INT (|Integer|)))))
+ (EXIT (|htMakePage|
+ (cons (cons '|bcStrings|
+ (cons
+ (cons 5
+ (cons (STRINGIMAGE val)
+ (cons name (cons 'INT nil))))
+ nil))
+ nil))))))
+ (if (eq class 'string)
+ (EXIT (|htSay| "{\\em " val
+ "}\\space{1}")))
+ (EXIT (DO ((G167913 options (cdr G167913)) (x nil))
+ ((or (atom G167913)
+ (progn (setq x (car G167913)) nil))
+ nil)
+ (SEQ (if (or (or (equal val x)
+ (and (eq val t)
+ (eq x '|on|)))
+ (and (null val) (eq x '|off|)))
+ (EXIT (|htSay| "{\\em " x
+ "}\\space{1}")))
+ (EXIT (|htMakePage|
+ (cons (cons '|bcLispLinks|
+ (cons
+ (cons x
+ (cons " "
+ (cons '|htSetSystemVariable|
+ (cons
+ (cons variable
+ (cons x nil))
+ nil))))
+ nil))
+ nil))))))))
+
+\end{chunk}
+
+\defun{htSystemVariables,functionTail}{htSystemVariables,functionTail}
+\begin{chunk}{defun htSystemVariables,functionTail}
+(defun |htSystemVariables,functionTail| (name class var valuesOrFunction)
+ (prog (val)
+ (return
+ (SEQ (setq val (|eval| var))
+ (if (atom valuesOrFunction)
+ (EXIT (SEQ (|htMakePage|
+ '((|domainConditions|
+ (|isDomain| STR (|String|)))))
+ (|htMakePage|
+ (cons (cons '|bcLinks|
+ (cons
+ (cons "reset"
+ (cons ""
+ (cons
+ '|htSetSystemVariableKind|
+ (cons
+ (cons var
+ (cons name (cons nil nil)))
+ nil))))
+ nil))
+ nil))
+ (EXIT (|htMakePage|
+ (cons
+ (cons '|bcStrings|
+ (cons
+ (cons 30
+ (cons (STRINGIMAGE val)
+ (cons name
+ (cons valuesOrFunction nil))))
+ nil))
+ nil))))))
+ (EXIT (|htSystemVariables,displayOptions| name class
+ var val valuesOrFunction))))))
+
+\end{chunk}
+
+\defun{htSystemVariables}{htSystemVariables}
+\begin{chunk}{defun htSystemVariables}
+(defun |htSystemVariables| ()
+ (prog (|$levels| |$heading| classlevel table heading name
+ message key variable options func lastHeading
+ t1 msg class var valuesOrFunction val)
+ (DECLARE (SPECIAL |$levels| |$heading| |$setOptions| |$UserLevel|
+ |$fullScreenSysVars|))
+ (return
+ (SEQ (cond
+ ((null |$fullScreenSysVars|) (|htSetVars|))
+ (t (setq classlevel |$UserLevel|)
+ (setq |$levels| '(|compiler| |development| |interpreter|))
+ (setq |$heading| nil)
+ (DO () ((NULL (NEQUAL classlevel (car |$levels|))) nil)
+ (SEQ (EXIT (setq |$levels| (cdr |$levels|)))))
+ (setq table
+ (NREVERSE
+ (|htSystemVariables,fn| |$setOptions| nil
+ t)))
+ (|htInitPage| "System Variables" nil)
+ (|htSay| "\\beginmenu")
+ (setq lastHeading nil)
+ (DO ((G167961 table (cdr G167961)) (G167879 nil))
+ ((or (atom G167961)
+ (progn (setq G167879 (car G167961)) nil)
+ (progn
+ (progn
+ (setq heading (car G167879))
+ (setq name (cadr G167879))
+ (setq message (caddr G167879))
+ (setq key (car (cddddr G167879)))
+ (setq variable (cadr (cddddr G167879)))
+ (setq options (caddr (cddddr G167879)))
+ (setq func (cadddr (cddddr G167879)))
+ G167879)
+ nil))
+ nil)
+ (SEQ (EXIT (progn
+ (|htSay| "\\newline\\item ")
+ (cond
+ ((equal heading lastHeading)
+ (|htSay| "\\tab{8}"))
+ (t
+ (|htSay| heading
+ "\\tab{8}")
+ (setq lastHeading heading)))
+ (|htSay| "{\\em " name
+ '|}\\tab{22}| message)
+ (|htSay| "\\tab{80}")
+ (cond
+ ((eq key 'function)
+ (cond
+ ((null options)
+ (|htMakePage|
+ (cons
+ (cons '|bcLinks|
+ (cons
+ (cons "reset"
+ (cons ""
+ (cons func (cons nil nil))))
+ nil))
+ nil)))
+ (t
+ (setq t1 (car options))
+ (setq msg (car t1))
+ (setq class (cadr t1))
+ (setq var (caddr t1))
+ (setq valuesOrFunction (cadddr t1))
+ (|htSystemVariables,functionTail|
+ name class var valuesOrFunction)
+ (DO
+ ((G167971 (cdr options)
+ (cdr G167971))
+ (option nil))
+ ((or (atom G167971)
+ (progn
+ (setq option (car G167971))
+ nil))
+ nil)
+ (SEQ
+ (EXIT
+ (cond
+ ((and (consp option)
+ (eq (QCAR option)
+ '|break|))
+ '|skip|)
+ (t
+ (setq msg (car option))
+ (setq class (cadr option))
+ (setq var (caddr option))
+ (setq valuesOrFunction
+ (cadddr option))
+ (|htSay| "\\newline\\tab{22}"
+ msg
+ "\\tab{80}")
+ (|htSystemVariables,functionTail|
+ name class var
+ valuesOrFunction)))))))))
+ (t (setq val (|eval| variable))
+ (|htSystemVariables,displayOptions|
+ name key variable val options)))))))
+ (|htSay| "\\endmenu") (|htShowPage|)))))))
+
+\end{chunk}
+
+\defun{htSetSystemVariableKind}{htSetSystemVariableKind}
+\begin{chunk}{defun htSetSystemVariableKind}
+(defun |htSetSystemVariableKind| (htPage G168009)
+ (prog (variable name fun value)
+ (return
+ (progn
+ (setq variable (car G168009))
+ (setq name (cadr G168009))
+ (setq fun (caddr G168009))
+ (setq value (|htpLabelInputString| htPage name))
+ (cond
+ ((and (stringp value) fun)
+ (setq value (funcall fun value))))
+ (set variable value)
+ (|htSystemVariables|)))))
+
+\end{chunk}
+
+\defun{htSetSystemVariable}{htSetSystemVariable}
+\begin{chunk}{defun htSetSystemVariable}
+(defun |htSetSystemVariable| (htPage G168030)
+ (declare (ignore htPage))
+ (prog (name value)
+ (return
+ (progn
+ (setq name (car G168030))
+ (setq value (cadr G168030))
+ (setq value
+ (cond
+ ((eq value '|on|) t)
+ ((eq value '|off|) nil)
+ (t value)))
+ (set name value)
+ (|htSystemVariables|)))))
+
+\end{chunk}
+
+\defun{htGloss}{htGloss}
+\begin{chunk}{defun htGloss}
+(defun |htGloss| (pattern)
+ (|htGlossPage| nil
+ (or (|dbNonEmptyPattern| pattern) "*") t))
+
+\end{chunk}
+
+\defun{htGlossPage}{htGlossPage}
+\begin{chunk}{defun htGlossPage}
+(defun |htGlossPage| (htPage pattern tryAgain?)
+ (prog (|$wildCard| |$key| filter grepForm results defstream
+ lines heading k tick)
+ (declare (special |$wildCard| |$key| |$tick|))
+ (return
+ (SEQ (progn
+ (setq |$wildCard| #\*)
+ (cond
+ ((equal pattern "*")
+ (|downlink| '|GlossaryPage|))
+ (t (setq filter (|pmTransFilter| pattern))
+ (setq grepForm (|mkGrepPattern| filter '|none|))
+ (setq |$key| '|none|)
+ (setq results (|applyGrep| grepForm '|gloss|))
+ (setq defstream
+ (make-instream
+ (STRCONC (|getEnv| "AXIOM")
+ "/algebra/glossdef.text")))
+ (setq lines
+ (|gatherGlossLines| results defstream))
+ (setq heading
+ (cond
+ ((equal pattern "")
+ "Glossary")
+ ((null lines)
+ (cons "No glossary items match {\\em "
+ (cons pattern
+ (cons "}" nil))))
+ (t
+ (cons "Glossary items matching {\\em "
+ (cons pattern
+ (cons "}" nil))))))
+ (cond
+ ((null lines)
+ (cond
+ ((and tryAgain? (> (|#| pattern) 0))
+ (cond
+ ((equal
+ (elt pattern
+ (setq k (MAXINDEX pattern)))
+ #\s)
+ (|htGlossPage| htPage
+ (SUBSTRING pattern 0 k) t))
+ ((upper-case-p (elt pattern 0))
+ (|htGlossPage| htPage (downcase pattern)
+ nil))
+ (t
+ (|errorPage| htPage
+ (cons "Sorry"
+ (cons nil
+ (cons
+ (cons "\\centerline{"
+ (append heading
+ (cons "}" nil)))
+ nil)))))))
+ (t
+ (|errorPage| htPage
+ (cons "Sorry"
+ (cons nil
+ (cons
+ (cons
+ "\\centerline{"
+ (append heading
+ (cons "}" nil)))
+ nil)))))))
+ (t (|htInitPageNoScroll| nil heading)
+ (|htSay| "\\beginscroll\\beginmenu")
+ (DO ((G168058 lines (cdr G168058))
+ (line nil))
+ ((or (atom G168058)
+ (progn (setq line (car G168058)) nil))
+ nil)
+ (SEQ (EXIT (progn
+ (setq tick
+ (|charPosition| |$tick|
+ line 1))
+ (|htSay|
+ "\\item{\\em \\menuitemstyle{}}\\tab{0}{\\em "
+ (|escapeString|
+ (SUBSTRING line 0 tick))
+ "} "
+ (SUBSTRING line
+ (1+ tick) nil))))))
+ (|htSay| "\\endmenu ")
+ (|htSay| "\\endscroll\\newline ")
+ (|htMakePage|
+ (cons (cons '|bcLinks|
+ (cons
+ (cons "Search"
+ (cons ""
+ (cons '|htGlossSearch|
+ (cons nil nil))))
+ nil))
+ nil))
+ (|htSay| " for glossary entry matching ")
+ (|htMakePage|
+ (cons (cons '|bcStrings|
+ (cons
+ (cons 24
+ (cons "*"
+ (cons '|filter| (cons 'em nil))))
+ nil))
+ nil))
+ (|htShowPageNoScroll|))))))))))
+
+\end{chunk}
+
+\defun{gatherGlossLines}{gatherGlossLines}
+\begin{chunk}{defun gatherGlossLines}
+(defun |gatherGlossLines| (results defstream)
+ (prog (n keyAndTick byteAddress line k pointer def x
+ j nextPointer xtralines acc)
+ (declare (special |$tick|))
+ (return
+ (SEQ (progn
+ (setq acc nil)
+ (DO ((G168098 results (cdr G168098))
+ (keyline nil))
+ ((or (atom G168098)
+ (progn (setq keyline (car G168098)) nil))
+ nil)
+ (SEQ (EXIT (progn
+ (setq n
+ (|charPosition| |$tick| keyline
+ 0))
+ (setq keyAndTick
+ (SUBSTRING keyline 0
+ (1+ n)))
+ (setq byteAddress
+ (|string2Integer|
+ (SUBSTRING keyline (1+ n)
+ nil)))
+ (file-position defstream byteAddress)
+ (setq line (readline defstream))
+ (setq k
+ (|charPosition| |$tick| line 1))
+ (setq pointer
+ (SUBSTRING line 0 k))
+ (setq def
+ (SUBSTRING line (1+ k)
+ nil))
+ (setq xtralines nil)
+ (DO ()
+ ((null (and (null (eofp defstream))
+ (setq x
+ (readline defstream))
+ (setq j
+ (|charPosition| |$tick| x 1))
+ (setq nextPointer
+ (SUBSTRING x 0 j))
+ (equal nextPointer
+ pointer)))
+ nil)
+ (SEQ (EXIT
+ (setq xtralines
+ (cons
+ (SUBSTRING x (1+ j) nil)
+ xtralines)))))
+ (setq acc
+ (cons
+ (STRCONC keyAndTick def
+ (prog (G168110)
+ (setq G168110 "")
+ (return
+ (DO
+ ((G168115
+ (NREVERSE xtralines)
+ (CDR G168115))
+ (G168081 nil))
+ ((OR (ATOM G168115)
+ (progn
+ (setq G168081
+ (car G168115))
+ nil))
+ G168110)
+ (SEQ
+ (EXIT
+ (setq G168110
+ (STRCONC G168110
+ G168081))))))))
+ acc))))))
+ (reverse acc))))))
+
+\end{chunk}
+
+\defun{htGlossSearch}{htGlossSearch}
+\begin{chunk}{defun htGlossSearch}
+(defun |htGlossSearch| (htPage junk)
+ (declare (ignore junk))
+ (|htGloss| (|htpLabelInputString| htPage '|filter|)))
+
+\end{chunk}
+
+\defun{htGreekSearch}{htGreekSearch}
+\begin{chunk}{defun htGreekSearch}
+(defun |htGreekSearch| (filter)
+ (prog (ss s names matches nonmatches)
+ (return
+ (SEQ (progn
+ (setq ss (|dbNonEmptyPattern| filter))
+ (setq s (|pmTransFilter| ss))
+ (cond
+ ((and (consp s) (eq (QCAR s) '|error|))
+ (|bcErrorPage| s))
+ ((null s)
+ (|errorPage| nil
+ (cons (cons "Missing search string"
+ nil)
+ (cons nil
+ (cons
+ "\\vspace{2}\\centerline{To select one of the greek letters:}\\newline "
+ (cons
+ "\\centerline{{\\em first} enter a search key into the input area}\\newline "
+ (cons
+ "\\centerline{{\\em then } move the mouse cursor to the work {\\em search} and click}"
+ nil)))))))
+ (t (setq filter (|patternCheck| s))
+ (setq names
+ '(|alpha| |beta| |gamma| |delta| |epsilon|
+ |zeta| |eta| |theta| |iota| |kappa|
+ |lambda| |mu| |nu| |pi|))
+ (DO ((G168149 names (CDR G168149)) (x nil))
+ ((or (atom G168149)
+ (progn (setq x (car G168149)) nil))
+ nil)
+ (SEQ (EXIT (cond
+ ((|superMatch?| filter (PNAME x))
+ (setq matches
+ (cons x matches)))
+ (t
+ (setq nonmatches
+ (cons x nonmatches)))))))
+ (setq matches (NREVERSE matches))
+ (setq nonmatches (NREVERSE nonmatches))
+ (|htInitPage| "Greek Names" nil)
+ (cond
+ ((null matches)
+ (|htInitPage|
+ (cons "Greek names matching search string {\\em "
+ (cons ss (cons "}" nil)))
+ nil)
+ (|htSay| '|\\vspace{2}\\centerline{Sorry, but no greek letters match your search string}\\centerline{{\\em |
+ ss
+ '|}}\\centerline{Click on the up-arrow to try again}|)
+ (|htShowPage|))
+ (t
+ (|htInitPage|
+ (cons "Greek letters matching search string {\\em "
+ (cons ss (cons "}" nil)))
+ nil)
+ (cond
+ (|nonmatches|
+ (|htSay|
+ "The greek letters that {\\em match} your search string {\\em "
+ ss "}:"))
+ (t
+ (|htSay| "Your search string {\\em "
+ ss
+ '|} matches all of the greek letters:|)))
+ (|htSay| "{\\em \\table{")
+ (DO ((G168158 matches (CDR G168158))
+ (x nil))
+ ((or (atom G168158)
+ (progn (setq x (car G168158)) nil))
+ nil)
+ (SEQ (EXIT (|htSay| "{" x
+ "}"))))
+ (|htSay| "}}\\vspace{1}")
+ (cond
+ (|nonmatches|
+ (|htSay|
+"The greek letters that {\\em do not match} your search string:{\\em \\table{")
+ (DO ((G168167 nonmatches (CDR G168167))
+ (x nil))
+ ((or (atom G168167)
+ (progn
+ (setq x (car G168167))
+ nil))
+ nil)
+ (SEQ (EXIT (|htSay| "{" x
+ "}"))))
+ (|htSay| "}}")))
+ (|htShowPage|))))))))))
+
+\end{chunk}
+
+\defun{htTextSearch}{htTextSearch}
+\begin{chunk}{defun htTextSearch}
+(defun |htTextSearch| (filter)
+ (prog (s lines matches nonmatches)
+ (return
+ (SEQ (progn
+ (setq s
+ (|pmTransFilter| (|dbNonEmptyPattern| filter)))
+ (cond
+ ((and (consp s) (eq (QCAR s) '|error|))
+ (|bcErrorPage| s))
+ ((null s)
+ (|errorPage| nil
+ (cons (cons "Missing search string"
+ nil)
+ (cons nil
+ (cons
+ "\\vspace{2}\\centerline{To select one of the lines of text:}\\newline "
+ (cons
+ "\\centerline{{\\em first} enter a search key into the input area}\\newline "
+ (cons
+ "\\centerline{{\\em then } move the mouse cursor to the work {\\em search} and click}"
+ nil)))))))
+ (t (setq filter s)
+ (setq lines
+ (cons
+ "{{\\em Fruit flies} *like* a {\\em banana and califlower ears.}}"
+ (cons
+ "{{\\em Sneak Sears Silas with Savings Snatch}}"
+ nil)))
+ (DO ((G168191 lines (cdr G168191)) (x nil))
+ ((or (atom G168191)
+ (progn (setq x (car G168191)) nil))
+ nil)
+ (SEQ (EXIT (cond
+ ((|superMatch?| filter x)
+ (setq matches
+ (cons x matches)))
+ (t
+ (setq nonmatches
+ (cons x nonmatches)))))))
+ (setq matches (NREVERSE matches))
+ (setq nonmatches (NREVERSE nonmatches))
+ (|htInitPage| "Text Matches" nil)
+ (cond
+ ((null matches)
+ (|htInitPage|
+ (cons "Lines matching search string {\\em "
+ (cons s (cons "}" nil)))
+ nil)
+ (|htSay|
+'|\\vspace{2}\\centerline{Sorry, but no lines match your search string}\\centerline{{\\em |
+ s
+ '|}}\\centerline{Click on the up-arrow to try again}|)
+ (|htShowPage|))
+ (t
+ (|htInitPage|
+ (cons "Lines matching search string {\\em "
+ (cons s (cons "}" nil)))
+ nil)
+ (cond
+ (nonmatches
+ (|htSay| "The lines that {\\em match} your search string {\\em "
+ s "}:"))
+ (t
+ (|htSay| "Your search string {\\em "
+ s '|} matches both lines:|)))
+ (|htSay| "{\\em \\table{")
+ (DO ((G168200 matches (CDR G168200))
+ (x nil))
+ ((or (atom G168200)
+ (progn (setq x (car G168200)) nil))
+ nil)
+ (SEQ (EXIT (|htSay| "{" x
+ "}"))))
+ (|htSay| "}}\\vspace{1}")
+ (cond
+ (nonmatches
+ (|htSay|
+ "The line that {\\em does not match} your search string:{\\em \\table{")
+ (DO ((G168209 nonmatches (cdr G168209))
+ (x nil))
+ ((or (atom G168209)
+ (progn
+ (setq x (car G168209))
+ nil))
+ nil)
+ (SEQ (EXIT (|htSay| "{" x
+ "}"))))
+ (|htSay| "}}")))
+ (|htShowPage|))))))))))
+
+\end{chunk}
+
+\defun{htTutorialSearch}{htTutorialSearch}
+\begin{chunk}{defun htTutorialSearch}
+(defun |htTutorialSearch| (pattern)
+ (prog (s source target lines t1 name title)
+ (return
+ (SEQ (progn
+ (setq s
+ (or (|dbNonEmptyPattern| pattern)
+ (return
+ (|errorPage| nil
+ (cons "Empty search key"
+ (cons nil
+ (cons
+ "\\vspace{3}\\centerline{You must enter some search string"
+ nil)))))))
+ (setq s (|mkUnixPattern| s))
+ (setq source "$AXIOM/doc/hypertex/pages/ht.db")
+ (setq target "/tmp/temp.text.$SPADNUM")
+ (OBEY (STRCONC "$AXIOM/lib/hthits"
+ " \"" s "\" "
+ source " > " target))
+ (setq lines (|dbReadLines| '|temp|))
+ (|htInitPageNoScroll| nil
+ (cons "Tutorial Pages mentioning {\\em "
+ (cons pattern (cons "}" nil))))
+ (|htSay| "\\beginscroll\\table{")
+ (DO ((G168241 lines (cdr G168241)) (line nil))
+ ((or (atom G168241)
+ (progn (setq line (car G168241)) nil))
+ nil)
+ (SEQ (EXIT (progn
+ (setq t1 (|dbParts| line 3 0))
+ (setq name (car t1))
+ (setq title (cadr t1))
+ (|htSay| (cons "{\\downlink{"
+ (cons title
+ (cons "}{"
+ (cons name
+ (cons "}}" nil))))))))))
+ (|htSay| "}")
+ (|htShowPage|))))))
+
+\end{chunk}
+
+\defun{mkUnixPattern}{mkUnixPattern}
+\begin{chunk}{defun mkUnixPattern}
+(defun |mkUnixPattern| (s)
+ (prog (starPositions k u)
+ (declare (special |$wild|))
+ (return
+ (SEQ (progn
+ (setq u (|mkUpDownPattern| s))
+ (setq starPositions
+ (reverse (prog (G168264)
+ (setq G168264 nil)
+ (return
+ (DO
+ ((G168270
+ (+ (- 1)
+ (MAXINDEX u)))
+ (i 1 (QSADD1 i)))
+ ((QSGREATERP i G168270)
+ (NREVERSE0 G168264))
+ (SEQ
+ (EXIT
+ (cond
+ ((equal (elt u i)
+ |$wild|)
+ (setq G168264
+ (cons i G168264)))))))))))
+ (DO ((G168277 starPositions (cdr G168277))
+ (i nil))
+ ((or (atom G168277)
+ (progn (setq i (car G168277)) nil))
+ nil)
+ (SEQ (EXIT (setq u
+ (STRCONC (SUBSTRING u 0 i)
+ ".*"
+ (SUBSTRING u (1+ i) nil))))))
+ (cond
+ ((NEQUAL (elt u 0) |$wild|)
+ (setq u (STRCONC "[^a-zA-Z]" u)))
+ (t (setq u (SUBSTRING u 1 nil))))
+ (cond
+ ((NEQUAL (elt u (setq k (MAXINDEX u))) |$wild|)
+ (setq u (STRCONC u "[^a-zA-Z]")))
+ (t (setq u (SUBSTRING u 0 k))))
+ u)))))
+
+\end{chunk}
+
\chapter{The Interpreter}
\begin{chunk}{Interpreter}
(setq *print-array* nil)
@@ -47042,6 +50858,7 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun basicLookup}
\getchunk{defun basicLookupCheckDefaults}
+\getchunk{defun basicStringize}
\getchunk{defun bcComplexLimit}
\getchunk{defun bcComplexLimitGen}
\getchunk{defun bcCreateVariableString}
@@ -47070,6 +50887,8 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun bcGen}
\getchunk{defun bcGenEquations}
\getchunk{defun bcGenExplicitMatrix}
+\getchunk{defun bcHt}
+\getchunk{defun bchtMakeButton}
\getchunk{defun bcIndefiniteIntegrate}
\getchunk{defun bcIndefiniteIntegrateGen}
\getchunk{defun bcInputEquations}
@@ -47078,6 +50897,7 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun bcInputMatrixByFormula}
\getchunk{defun bcInputMatrixByFormulaGen}
\getchunk{defun bcInputSolveInfo}
+\getchunk{defun bcIssueHt}
\getchunk{defun bcLaurentSeries}
\getchunk{defun bcLaurentSeriesGen}
\getchunk{defun bcLimit}
@@ -47108,6 +50928,7 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun bcRealLimit}
\getchunk{defun bcRealLimitGen}
\getchunk{defun bcRealLimitGen1}
+\getchunk{defun bcSadFaces}
\getchunk{defun bcSeries}
\getchunk{defun bcSeriesByFormula}
\getchunk{defun bcSeriesByFormulaGen}
@@ -47131,18 +50952,29 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun bcVectorGen}
\getchunk{defun bcvspace}
\getchunk{defun bcwords2liststring}
+\getchunk{defun beforeAfter}
+\getchunk{defun bracketString}
\getchunk{defun break}
\getchunk{defun breaklet}
\getchunk{defun brightprint}
\getchunk{defun brightprint-0}
\getchunk{defun browse}
\getchunk{defun browseOpen}
+\getchunk{defun buttonNames}
\getchunk{defun cacheKeyedMsg}
\getchunk{defun categoryOpen}
\getchunk{defun changeHistListLen}
\getchunk{defun changeToNamedInterpreterFrame}
\getchunk{defun charDigitVal}
+\getchunk{defun checkCondition}
+\getchunk{defun chkAllNonNegativeInteger}
+\getchunk{defun chkDirectory}
+\getchunk{defun chkNameList}
+\getchunk{defun chkNonNegativeInteger}
+\getchunk{defun chkOutputFileName}
+\getchunk{defun chkPosInteger}
+\getchunk{defun chkRange}
\getchunk{defun cleanline}
\getchunk{defun clear}
\getchunk{defun clearCmdAll}
@@ -47171,6 +51003,8 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun compiledLookup}
\getchunk{defun compiledLookupCheck}
\getchunk{defun compressOpen}
+\getchunk{defun computeDomainVariableAlist}
+\getchunk{defun condErrorMsg}
\getchunk{defun constoken}
\getchunk{defun constructSubst}
\getchunk{defun containsVars}
@@ -47179,6 +51013,7 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun countCache}
\getchunk{defun DaaseName}
+\getchunk{defun dbNonEmptyPattern}
\getchunk{defun decideHowMuch}
\getchunk{defun defaultTargetFE}
\getchunk{defun defiostream}
@@ -47229,10 +51064,13 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun displayType}
\getchunk{defun displayValue}
\getchunk{defun displayWorkspaceNames}
+\getchunk{defun doDoitButton}
\getchunk{defun domainToGenvar}
\getchunk{defun domArg}
\getchunk{defun domArg2}
\getchunk{defun doSystemCommand}
+\getchunk{defun downlink}
+\getchunk{defun downlinkSaturn}
\getchunk{defun dqConcat}
\getchunk{defun dropInputLibrary}
\getchunk{defun dumbTokenize}
@@ -47253,6 +51091,7 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun evaluateSignature}
\getchunk{defun evaluateType}
\getchunk{defun evaluateType1}
+\getchunk{defun executeInterpreterCommand}
\getchunk{defun ExecuteInterpSystemCommand}
\getchunk{defun executeQuietCommand}
\getchunk{defun explainLinear}
@@ -47278,6 +51117,7 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun functionp}
\getchunk{defun funfind,LAM}
+\getchunk{defun gatherGlossLines}
\getchunk{defun genDomainTraceName}
\getchunk{defun gensymInt}
\getchunk{defun getAliasIfTracedMapParameter}
@@ -47304,6 +51144,9 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun getPosStL}
\getchunk{defun getPreviousMapSubNames}
\getchunk{defun getProplist}
+\getchunk{defun getRefvU8}
+\getchunk{defun getRefvU16}
+\getchunk{defun getRefvU32}
\getchunk{defun getStFromMsg}
\getchunk{defun getSystemCommandLine}
\getchunk{defun getTraceOption}
@@ -47338,11 +51181,122 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun historySpad2Cmd}
\getchunk{defun hkeys}
\getchunk{defun hput}
+\getchunk{defun htAddHeading}
+\getchunk{defun htAllOrNum}
+\getchunk{defun htBcLinks}
+\getchunk{defun htBcLispLinks}
+\getchunk{defun htBcRadioButtons}
+\getchunk{defun htCacheAddChoice}
+\getchunk{defun htCacheOne}
+\getchunk{defun htCacheSet}
+\getchunk{defun htCheckList}
+\getchunk{defun htCheck}
+\getchunk{defun htDoneButton}
+\getchunk{defun htDoNothing}
+\getchunk{defun htEscapeString}
+\getchunk{defun htFunctionSetLiteral}
+\getchunk{defun htGlossPage}
+\getchunk{defun htGlossSearch}
+\getchunk{defun htGloss}
+\getchunk{defun htGreekSearch}
+\getchunk{defun htInitPage}
+\getchunk{defun htInputStrings}
+\getchunk{defun htKill}
+\getchunk{defun htLispLinks}
+\getchunk{defun htLispMemoLinks}
+\getchunk{defun htMakeButton}
+\getchunk{defun htMakeDoitButton}
+\getchunk{defun htMakeDoneButton}
+\getchunk{defun htMakeErrorPage}
+\getchunk{defun htMakeInputList}
+\getchunk{defun htMakeLabel}
+\getchunk{defun htMakePage}
+\getchunk{defun htMakePage1}
+\getchunk{defun htMakePathKey,fn}
+\getchunk{defun htMakePathKey}
+\getchunk{defun htMakeTemplates,substLabel}
+\getchunk{defun htMakeTemplates}
+\getchunk{defun htMarkTree}
\getchunk{defun htMkName}
+\getchunk{defun htpAddInputAreaProp}
+\getchunk{defun htpAddToPageDescription}
+\getchunk{defun htpButtonValue}
+\getchunk{defun htpDestroyPage}
+\getchunk{defun htpDomainConditions}
+\getchunk{defun htpDomainPvarSubstList}
+\getchunk{defun htpDomainVariableAlist}
+\getchunk{defun htpInputAreaAlist}
+\getchunk{defun htpLabelDefault}
+\getchunk{defun htpLabelErrorMsg}
+\getchunk{defun htpLabelFilteredInputString}
+\getchunk{defun htpLabelFilter}
+\getchunk{defun htpLabelInputString}
+\getchunk{defun htpLabelSpadType}
+\getchunk{defun htpLabelSpadValue}
+\getchunk{defun htpLabelType}
+\getchunk{defun htpName}
+\getchunk{defun htpPageDescription}
+\getchunk{defun htpProperty}
+\getchunk{defun htpPropertyList}
+\getchunk{defun htProcessBcButtons}
+\getchunk{defun htProcessBcStrings}
+\getchunk{defun htProcessDoitButton}
+\getchunk{defun htProcessDomainConditions}
+\getchunk{defun htProcessDoneButton}
+\getchunk{defun htProcessToggleButtons}
+\getchunk{defun htpSetDomainConditions}
+\getchunk{defun htpSetDomainPvarSubstList}
+\getchunk{defun htpSetDomainVariableAlist}
+\getchunk{defun htpSetInputAreaAlist}
+\getchunk{defun htpSetLabelErrorMsg}
+\getchunk{defun htpSetLabelInputString}
+\getchunk{defun htpSetLabelSpadValue}
+\getchunk{defun htpSetName}
+\getchunk{defun htpSetPageDescription}
+\getchunk{defun htpSetProperty}
+\getchunk{defun htpSetRadioButtonAlist}
+\getchunk{defun htQuote}
+\getchunk{defun htRadioButtons}
+\getchunk{defun htSetCache}
+\getchunk{defun htSetExpose}
+\getchunk{defun htSetFunCommandContinue}
+\getchunk{defun htSetFunCommand}
+\getchunk{defun htSetHistory}
+\getchunk{defun htSetInputLibrary}
+\getchunk{defun htSetInteger}
+\getchunk{defun htSetLinkerArgs}
+\getchunk{defun htSetLiterals}
+\getchunk{defun htSetLiteral}
+\getchunk{defun htSetNotAvailable}
+\getchunk{defun htSetOutputCharacters}
+\getchunk{defun htSetOutputLibrary}
+\getchunk{defun htSetSystemVariableKind}
+\getchunk{defun htSetSystemVariable}
+\getchunk{defun htSetVars}
+\getchunk{defun htSetvarDoneButton}
+\getchunk{defun htShowCount}
+\getchunk{defun htShowFunctionPageContinued}
+\getchunk{defun htShowFunctionPage}
+\getchunk{defun htShowIntegerPage}
+\getchunk{defun htShowLiteralsPage}
+\getchunk{defun htShowPage}
+\getchunk{defun htShowPageNoScroll}
+\getchunk{defun htShowSetPage}
+\getchunk{defun htShowSetTreeValue}
+\getchunk{defun htShowSetTree}
\getchunk{defun htStringPad}
+\getchunk{defun htsv}
+\getchunk{defun htSystemVariables,displayOptions}
+\getchunk{defun htSystemVariables,fn}
+\getchunk{defun htSystemVariables,functionTail}
+\getchunk{defun htSystemVariables,gn}
+\getchunk{defun htSystemVariables}
+\getchunk{defun htTextSearch}
+\getchunk{defun htTutorialSearch}
\getchunk{defun If?}
\getchunk{defun ifCond}
+\getchunk{defun iht}
\getchunk{defun importFromFrame}
\getchunk{defun incAppend}
\getchunk{defun incAppend1}
@@ -47445,6 +51399,7 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun linkGen}
\getchunk{defun listConstructorAbbreviations}
\getchunk{defun listDecideHowMuch}
+\getchunk{defun listOfStrings2String}
\getchunk{defun listOutputter}
\getchunk{defun lnFileName}
\getchunk{defun load}
@@ -47478,9 +51433,6 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun mac0SubstituteOuter}
\getchunk{defun make-appendstream}
\getchunk{defun make-databases}
-\getchunk{defun getRefvU8}
-\getchunk{defun getRefvU16}
-\getchunk{defun getRefvU32}
\getchunk{defun makeFullNamestring}
\getchunk{defun makeHistFileName}
\getchunk{defun makeInputFilename}
@@ -47490,12 +51442,15 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun makeOrdinal}
\getchunk{defun make-outstream}
\getchunk{defun makePathname}
+\getchunk{defun makeSpadCommand}
\getchunk{defun makeStream}
\getchunk{defun mapLetPrint}
+\getchunk{defun mapStringize}
\getchunk{defun mergePathnames}
\getchunk{defun messageprint}
\getchunk{defun messageprint-1}
\getchunk{defun messageprint-2}
+\getchunk{defun mkCurryFun}
\getchunk{defun mkDomPvar}
\getchunk{defun mkEvalable}
\getchunk{defun mkEvalableMapping}
@@ -47503,6 +51458,8 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun mkEvalableUnion}
\getchunk{defun mkLineList}
\getchunk{defun mkprompt}
+\getchunk{defun mkSetTitle}
+\getchunk{defun mkUnixPattern}
\getchunk{defun msgCreate}
\getchunk{defun msgImPr?}
\getchunk{defun msgNoRep?}
@@ -47726,6 +51683,7 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun ofCategory}
\getchunk{defun oldCompLookup}
\getchunk{defun oldHistFileName}
+\getchunk{defun oldParseString}
\getchunk{defun om-bindTCP}
\getchunk{defun om-closeConn}
\getchunk{defun om-closeDev}
@@ -47790,9 +51748,12 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun optionUserLevelError}
\getchunk{defun orderBySlotNumber}
+\getchunk{defun parseAndEval}
+\getchunk{defun parseAndEval1}
\getchunk{defun parseAndInterpret}
\getchunk{defun parseFromString}
\getchunk{defun parseSystemCmd}
+\getchunk{defun parseWord}
\getchunk{defun pathname}
\getchunk{defun pathnameDirectory}
\getchunk{defun pathnameName}
@@ -48025,12 +51986,16 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun punctuation?}
\getchunk{defun putDatabaseStuff}
\getchunk{defun putHist}
+\getchunk{defun pvarCondList1}
+\getchunk{defun pvarCondList}
\getchunk{defun pvarPredTran}
+\getchunk{defun pvarsOfPattern}
\getchunk{defun queryClients}
\getchunk{defun queueUpErrors}
\getchunk{defun quit}
\getchunk{defun quitSpad2Cmd}
+\getchunk{defun quoteString}
\getchunk{defun rassocSub}
\getchunk{defun rdefinstream}
@@ -48053,7 +52018,11 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun remover}
\getchunk{defun removeTracedMapSigs}
\getchunk{defun removeUndoLines}
+\getchunk{defun renamePatternVariables1}
+\getchunk{defun renamePatternVariables}
\getchunk{defun replaceFile}
+\getchunk{defun replacePercentByDollar,fn}
+\getchunk{defun replacePercentByDollar}
\getchunk{defun replaceSharps}
\getchunk{defun reportOperations}
\getchunk{defun reportOpsFromLisplib}
@@ -48166,6 +52135,7 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun setOutputOpenMath}
\getchunk{defun setOutputTex}
\getchunk{defun setStreamsCalculate}
+\getchunk{defun setUpDefault}
\getchunk{defun shortenForPrinting}
\getchunk{defun show}
\getchunk{defun showdatabase}
@@ -48207,6 +52177,7 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun startsNegComment?}
\getchunk{defun statisticsInitialization}
\getchunk{defun streamChop}
+\getchunk{defun stringize}
\getchunk{defun stringList2String}
\getchunk{defun stringMatches?}
\getchunk{defun StringToDir}
@@ -48214,6 +52185,7 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun strposl}
\getchunk{defun stupidIsSpadFunction}
\getchunk{defun subMatch}
+\getchunk{defun substFromAlist}
\getchunk{defun substringMatch}
\getchunk{defun subTypes}
\getchunk{defun summary}
@@ -48228,6 +52200,7 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun ?t}
\getchunk{defun tabbing}
+\getchunk{defun templateParts}
\getchunk{defun tangle}
\getchunk{defun terminateSystemCommand}
\getchunk{defun tersyscommand}
@@ -48252,8 +52225,10 @@ Given \verb|("one" "two" "three")| generate \verb|"(one,two,three)"|
\getchunk{defun traceSpad2Cmd}
\getchunk{defun translateTrueFalse2YesNo}
\getchunk{defun translateYesNo2TrueFalse}
+\getchunk{defun translateYesNoToTrueFalse}
\getchunk{defun transOnlyOption}
\getchunk{defun transTraceItem}
+\getchunk{defun typeCheckInputAreas}
\getchunk{defun unAbbreviateKeyword}
\getchunk{defun undo}
diff --git a/changelog b/changelog
index 2982a44..988824a 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,8 @@
+20130513 tpd src/axiom-website/patches.html 20130513.01.tpd.patch
+20130513 tpd src/interp/util.lisp remove autoload of ht-util
+20130513 tpd src/interp/Makefile remove autoload of ht-util
+20130513 tpd books/bookvol5 merge ht-util.lisp
+20130513 tpd src/interp/ht-util.lisp deleted, merged with bookvol5
20130512 tpd src/axiom-website/patches.html 20130512.01.tpd.patch
20130512 tpd src/share/doc/hypertex/pages/util.ht deleted, unused
20130511 tpd src/axiom-website/patches.html 20130511.02.tpd.patch
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index 45ad0a6..dc9e20f 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -4173,6 +4173,8 @@ src/doc/axiom.bib removed
buglist remove dead items
20130512.01.tpd.patch
src/share/doc/hypertex/pages/util.ht deleted, unused
+20130513.01.tpd.patch
+books/bookvol5 merge ht-util.lisp