From eee8ac49caeb9b6c91170f909fc80e3d9ce7fabb Mon Sep 17 00:00:00 2001 From: Tim Daly Date: Wed, 8 Apr 2015 10:01:00 -0400 Subject: [PATCH] books/bookvol5 inline all error messages Inlining message text and removing s2-us.msgs. Add new chapter header for tracing. Update test cases to reflect minor spacing syntax changes. --- books/bookvol5.pamphlet | 5245 +++++++++++++++++++---------------- books/bookvol9.pamphlet | 14 +- changelog | 19 + patch | 7 +- src/axiom-website/patches.html | 2 + src/doc/msgs/s2-us.msgs | 761 ----- src/input/cachedf.input.pamphlet | 2 +- src/input/clements.input.pamphlet | 2 +- src/input/cmds.input.pamphlet | 10 +- src/input/davis.input.pamphlet | 13 +- src/input/ico.input.pamphlet | 2 +- src/input/ifthenelse.input.pamphlet | 6 +- src/input/iprntpk.input.pamphlet | 2 +- src/input/lodof.input.pamphlet | 2 +- src/input/op1.input.pamphlet | 2 +- src/input/r21bugs.input.pamphlet | 2 +- src/input/setcmd.input.pamphlet | 4 +- src/input/sqmatrix.input.pamphlet | 2 +- src/input/tuplebug.input.pamphlet | 2 +- src/input/unittest1.input.pamphlet | 22 +- src/input/unittest2.input.pamphlet | 6 +- 21 files changed, 2923 insertions(+), 3204 deletions(-) diff --git a/books/bookvol5.pamphlet b/books/bookvol5.pamphlet index ed1fb5b..310a866 100644 --- a/books/bookvol5.pamphlet +++ b/books/bookvol5.pamphlet @@ -346,7 +346,7 @@ Tenth Frame Component -- frameExposureData (setq frameArgs '(|drop| |import| |last| |names| |new| |next|)) (cond (|$options| - (|throwKeyedMsg| 'S2IZ0016 ; frame command does not take options + (|throwKeyedMsg| "The %1 system command takes arguments but no options." (cons ")frame" nil))) ((null args) (|helpSpad2Cmd| (cons '|frame| nil))) (t @@ -360,7 +360,7 @@ Tenth Frame Component -- frameExposureData (case arg (|drop| (if (and args (consp args)) - (|throwKeyedMsg| 'S2IZ0017 ; not a valid frame name + (|throwKeyedMsg| "%1 is not a valid frame name." (cons args nil)) (|closeInterpreterFrame| args))) (|import| (|importFromFrame| args)) @@ -368,7 +368,7 @@ Tenth Frame Component -- frameExposureData (|names| (|displayFrameNames|)) (|new| (if (and args (consp args)) - (|throwKeyedMsg| 'S2IZ0017 ; not a valid frame name + (|throwKeyedMsg| "%1 is not a valid frame name." (cons args nil)) (|addNewInterpreterFrame| args))) (|next| (|nextInterpreterFrame|)) @@ -664,12 +664,16 @@ this function will destructively change it to (2 3 1). "Add a New Interpreter Frame" (declare (special |$interpreterFrameRing|)) (if (null name) - (|throwKeyedMsg| 's2iz0018 nil) ; you must provide a name for new frame + (|throwKeyedMsg| "You must provide a name for the new frame." nil) (progn (|updateCurrentInterpreterFrame|) (dolist (f |$interpreterFrameRing|) (when (eq name (frameName f)) ; existing frame with same name - (|throwKeyedMsg| 's2iz0019 (list name)))) + (|throwKeyedMsg| + (format nil + " You cannot use the name %1 for a new frame because an existing ~ + frame already has that name.") + (list name)))) (|initHistList|) (setq |$interpreterFrameRing| (cons (|emptyInterpreterFrame| name) |$interpreterFrameRing|)) @@ -704,23 +708,42 @@ this function will destructively change it to (2 3 1). (declare (special |$interpreterFrameRing|)) (when (and args (atom args)) (setq args (cons args nil))) (if (null args) - (|throwKeyedMsg| 'S2IZ0073 nil) ; missing frame name + (|throwKeyedMsg| + (format nil ")frame import must be followed by the frame name. The names~ + of objects in that frame can then optionally follow the frame name.~ + For example,~ + %ceon )frame import calculus %ceoff ~ + imports all objects in the %b calculus %d frame, and ~ + %ceon )frame import calculus epsilon delta %ceoff ~ + imports the objects named epsilon and delta from the ~ + frame calculus. ~ + Please note that if the current frame contained any information ~ + about objects with these names, then that information would be ~ + cleared before the import took place.") + nil) (progn (setq temp1 args) (setq fname (car temp1)) (setq args (cdr temp1)) (cond ((null (|member| fname (|frameNames|))) - (|throwKeyedMsg| 'S2IZ0074 (cons fname nil))) ; not frame name + (|throwKeyedMsg| + (format nil " You cannot import anything from the frame %1 because ~ + that is not the name of an existing frame.") + (cons fname nil))) ((boot-equal fname (frameName (car |$interpreterFrameRing|))) - (|throwKeyedMsg| 'S2IZ0075 NIL)) ; cannot import from curr frame + (|throwKeyedMsg| + "You cannot import from the current frame (nor is there a need!)." + nil)) (t (setq fenv (|frameEnvironment| fname)) (cond ((null args) (setq x - (upcase (|queryUserKeyedMsg| 'S2IZ0076 (cons fname nil)))) - ; import everything? + (upcase (|queryUserKeyedMsg| + (format nil "Do you really want to import everything from the ~ + frame %1? If so, please enter y or yes :") + (cons fname nil)))) (cond ((member (string2id-n x 1) '(y yes)) (setq vars nil) @@ -748,7 +771,8 @@ this function will destructively change it to (2 3 1). (t (setq vars (cons v vars))))) (|importFromFrame| (cons fname vars))) (t - (|sayKeyedMsg| 'S2IZ0077 (cons fname nil))))) + (|sayKeyedMsg| "AXIOM will not import everything from frame %1." + (cons fname nil))))) (t (do ((tmp4 args (cdr tmp4)) (v nil)) ((or (atom tmp4) (progn (setq v (car tmp4)) nil)) nil) @@ -774,9 +798,14 @@ this function will destructively change it to (2 3 1). ((setq m (|get| '|--macros--| v fenv)) (|putHist| '|--macros--| v m |$InteractiveFrame|)) (t - (|sayKeyedMsg| 'S2IZ0079 ; frame not found + (|sayKeyedMsg| + (format nil "AXIOM cannot import %1 from frame %2 because ~ + it cannot be found.") (cons v (cons fname nil))))))))) - (|sayKeyedMsg| 'S2IZ0078 ; import complete + (|sayKeyedMsg| + (format nil "Import from frame %1 is complete. Please issue ~ + )display all if you wish to see the contents of ~ + the current frame.") (cons fname nil)))))))))) \end{chunk} @@ -796,9 +825,15 @@ this function will destructively change it to (2 3 1). (let (ifr found) (if (null (cdr |$interpreterFrameRing|)) (if (and name (not (equal name |$interpreterFrameName|))) - (|throwKeyedMsg| 's2iz0020 ; 1 frame left. not the correct name. + (|throwKeyedMsg| + (format nil "There is only one frame active and therefore that ~ + cannot be closed. Furthermore, the frame name you gave is not ~ + the name of the current frame. The current frame is called %1.") (cons |$interpreterFrameName| nil)) - (|throwKeyedMsg| 's2iz0021 nil)) ; only 1 frame left, not closed + (|throwKeyedMsg| + (format nil "The current frame is the only active one. Issue ~ + )clear all to clear its contents.") + nil)) (progn (if (null name) (setq |$interpreterFrameRing| (cdr |$interpreterFrameRing|)) @@ -810,7 +845,9 @@ this function will destructively change it to (2 3 1). (setq ifr (cons f ifr))) (setq found t)) (if (null found) - (|throwKeyedMsg| 's2iz0022 (cons name nil)) + (|throwKeyedMsg| + "There is no frame called %1. Your command cannot be processed." + (cons name nil)) (progn ($erase (|makeHistFileName| name)) (setq |$interpreterFrameRing| (nreverse ifr)))))) @@ -1694,290 +1731,2117 @@ Properties of r :: \end{chunk} -\chapter{Exposure groups} - -\section{Functions to manipulate exposure} - -\Defun{setExposeAddGroup}{Expose a group} -Note that \verb|$localExposureData| is a vector of lists. -It consists of [exposed groups,exposed constructors,hidden constructors] +\chapter{Tracing} -\calls{setExposeAddGroup}{object2String} -\calls{setExposeAddGroup}{qcar} -\calls{setExposeAddGroup}{setelt} -\calls{setExposeAddGroup}{displayExposedGroups} -\calls{setExposeAddGroup}{sayMSG} -\calls{setExposeAddGroup}{displayExposedConstructors} -\calls{setExposeAddGroup}{displayHiddenConstructors} -\calls{setExposeAddGroup}{clearClams} -\calls{setExposeAddGroup}{getalist} -\calls{setExposeAddGroup}{sayKeyedMsg} -\calls{setExposeAddGroup}{member} -\calls{setExposeAddGroup}{msort} -\calls{setExposeAddGroup}{centerAndHighlight} -\calls{setExposeAddGroup}{specialChar} -\calls{setExposeAddGroup}{namestring} -\calls{setExposeAddGroup}{pathname} -\calls{setExposeAddGroup}{sayAsManyPerLineAsPossible} -\usesdollar{setExposeAddGroup}{globalExposureGroupAlist} -\usesdollar{setExposeAddGroup}{localExposureData} -\usesdollar{setExposeAddGroup}{interpreterFrameName} -\usesdollar{setExposeAddGroup}{linelength} -\begin{chunk}{defun setExposeAddGroup} -(defun |setExposeAddGroup| (arg) - "Expose a group" - (declare (special |$globalExposureGroupAlist| |$localExposureData| - |$interpreterFrameName| $linelength)) - (if (null arg) - (progn - (|centerAndHighlight| - '|The group Option| $linelength (|specialChar| '|hbar|)) - (|displayExposedGroups|) - (|sayMSG| " ") - (|sayAsManyPerLineAsPossible| - (mapcar #'(lambda (x) (|object2String| (first x))) - |$globalExposureGroupAlist|))) - (dolist (x arg) - (when (consp x) (setq x (qcar x))) - (cond - ((eq x '|all|) - (setelt |$localExposureData| 0 - (mapcar #'first |$globalExposureGroupAlist|)) - (setelt |$localExposureData| 1 nil) - (setelt |$localExposureData| 2 nil) - (|displayExposedGroups|) - (|sayMSG| " ") - (|displayExposedConstructors|) - (|sayMSG| " ") - (|displayHiddenConstructors|) - (|clearClams|)) - ((null (getalist |$globalExposureGroupAlist| x)) - (|sayKeyedMsg| 's2iz0049h (cons x nil))) - ((|member| x (elt |$localExposureData| 0)) - (|sayKeyedMsg| 's2iz0049i (list x |$interpreterFrameName|))) - (t - (setelt |$localExposureData| 0 - (msort (cons x (elt |$localExposureData| 0)))) - (|sayKeyedMsg| 's2iz0049r (list x |$interpreterFrameName|)) - (|clearClams|)))))) +\defun{trace}{trace} +\calls{trace}{traceSpad2Cmd} +\begin{chunk}{defun trace} +(defun |trace| (l) + (|traceSpad2Cmd| l)) \end{chunk} -\Defun{setExpose}{The top level set expose command handler} -\calls{setExpose}{displayExposedGroups} -\calls{setExpose}{sayMSG} -\calls{setExpose}{displayExposedConstructors} -\calls{setExpose}{displayHiddenConstructors} -\calls{setExpose}{sayKeyedMsg} -\calls{setExpose}{namestring} -\calls{setExpose}{pathname} -\calls{setExpose}{qcar} -\calls{setExpose}{qcdr} -\calls{setExpose}{selectOptionLC} -\calls{setExpose}{setExposeAdd} -\calls{setExpose}{setExposeDrop} -\calls{setExpose}{setExpose} -\begin{chunk}{defun setExpose} -(defun |setExpose| (arg) - "The top level set expose command handler" - (let (fnargs fn) - (cond - ((eq arg '|%initialize%|)) - ((eq arg '|%display%|) "...") - ((or (null arg) (eq arg '|%describe%|) (eq (car arg) '?)) - (|displayExposedGroups|) - (|sayMSG| " ") - (|displayExposedConstructors|) - (|sayMSG| " ") - (|displayHiddenConstructors|) - (|sayMSG| " ")) - ((and (consp arg) - (progn (setq fn (qcar arg)) (setq fnargs (qcdr arg)) t) - (setq fn (|selectOptionLC| fn '(|add| |drop|) nil))) - (cond - ((eq fn '|add|) (|setExposeAdd| fnargs)) - ((eq fn '|drop|) (|setExposeDrop| fnargs)) - (t nil))) - (t (|setExpose| nil))))) +\defun{traceSpad2Cmd}{traceSpad2Cmd} +\calls{traceSpad2Cmd}{qcar} +\calls{traceSpad2Cmd}{qcdr} +\calls{traceSpad2Cmd}{getMapSubNames} +\calls{traceSpad2Cmd}{trace1} +\calls{traceSpad2Cmd}{augmentTraceNames} +\calls{traceSpad2Cmd}{traceReply} +\usesdollar{traceSpad2Cmd}{mapSubNameAlist} +\begin{chunk}{defun traceSpad2Cmd} +(defun |traceSpad2Cmd| (l) + (let (tmp1 l1) + (declare (special |$mapSubNameAlist|)) + (cond + ((and (consp l) + (eq (qcar l) '|Tuple|) + (progn + (setq tmp1 (qcdr l)) + (and (consp tmp1) + (eq (qcdr tmp1) nil) + (progn + (setq l1 (qcar tmp1)) + t)))) + (setq l l1))) + (setq |$mapSubNameAlist| (|getMapSubNames| l)) + (|trace1| (|augmentTraceNames| l)) + (|traceReply|))) \end{chunk} -\Defun{setExposeAdd}{The top level set expose add command handler} -\calls{setExposeAdd}{centerAndHighlight} -\calls{setExposeAdd}{specialChar} -\calls{setExposeAdd}{displayExposedGroups} -\calls{setExposeAdd}{sayMSG} -\calls{setExposeAdd}{displayExposedConstructors} -\calls{setExposeAdd}{sayKeyedMsg} -\calls{setExposeAdd}{qcar} -\calls{setExposeAdd}{qcdr} -\calls{setExposeAdd}{selectOptionLC} -\calls{setExposeAdd}{setExposeAddGroup} -\calls{setExposeAdd}{setExposeAddConstr} -\calls{setExposeAdd}{setExposeAdd} -\usesdollar{setExposeAdd}{linelength} -\begin{chunk}{defun setExposeAdd} -(defun |setExposeAdd| (arg) - "The top level set expose add command handler" - (declare (special $linelength)) - (let (fnargs fn) - (cond - ((null arg) - (|centerAndHighlight| - '|The add Option| $linelength (|specialChar| '|hbar|)) - (|displayExposedGroups|) - (|sayMSG| " ") - (|displayExposedConstructors|) - (|sayMSG| " ") - (|sayKeyedMsg| 's2iz0049e nil)) - ((and (consp arg) - (progn (setq fn (qcar arg)) (setq fnargs (qcdr arg)) t) - (setq fn (|selectOptionLC| fn '(|group| |constructor|) nil))) +\defun{trace1}{trace1} +\calls{trace1}{hasOption} +\calls{trace1}{throwKeyedMsg} +\calls{trace1}{unabbrev} +\calls{trace1}{isFunctor} +\calls{trace1}{getTraceOption} +\calls{trace1}{untraceDomainLocalOps} +\calls{trace1}{qslessp} +\calls{trace1}{poundsign} +\calls{trace1}{untrace} +\calls{trace1}{centerAndHighlight} +\calls{trace1}{ptimers} +\calls{trace1}{say} +\calls{trace1}{pcounters} +\calls{trace1}{selectOptionLC} +\calls{trace1}{resetSpacers} +\calls{trace1}{resetTimers} +\calls{trace1}{resetCounters} +\calls{trace1}{qcar} +\calls{trace1}{qcdr} +\calls{trace1}{vecp} +\calls{trace1}{sayKeyedMsg} +\calls{trace1}{devaluate} +\calls{trace1}{lassoc} +\calls{trace1}{trace1} +\calls{trace1}{delete} +\calls{trace1}{?t} +\calls{trace1}{seq} +\calls{trace1}{exit} +\calls{trace1}{transTraceItem} +\calls{trace1}{addassoc} +\calls{trace1}{getTraceOptions} +\calls{trace1}{/trace,0} +\calls{trace1}{saveMapSig} +\usesdollar{trace1}{traceNoisely} +\usesdollar{trace1}{options} +\usesdollar{trace1}{lastUntraced} +\usesdollar{trace1}{optionAlist} +\begin{chunk}{defun trace1} +(defun |trace1| (arg) + (prog (|$traceNoisely| constructor ops lops temp1 opt a + oldl newoptions domain tracelist optionlist domainlist + oplist y varlist argument) + (declare (special |$traceNoisely| |$options| |$lastUntraced| + |$optionAlist|)) + (return + (seq + (progn + (setq |$traceNoisely| nil) (cond - ((eq fn '|group|) (|setExposeAddGroup| fnargs)) - ((eq fn '|constructor|) (|setExposeAddConstr| fnargs)) - (t nil))) - (t (|setExposeAdd| nil))))) - -\end{chunk} - -\Defun{setExposeAddConstr}{The top level set expose add constructor handler} -\calls{setExposeAddConstr}{unabbrev} -\calls{setExposeAddConstr}{qcar} -\calls{setExposeAddConstr}{getdatabase} -\calls{setExposeAddConstr}{sayKeyedMsg} -\calls{setExposeAddConstr}{member} -\calls{setExposeAddConstr}{setelt} -\calls{setExposeAddConstr}{delete} -\calls{setExposeAddConstr}{msort} -\calls{setExposeAddConstr}{clearClams} -\calls{setExposeAddConstr}{centerAndHighlight} -\calls{setExposeAddConstr}{specialChar} -\calls{setExposeAddConstr}{displayExposedConstructors} -\usesdollar{setExposeAddConstr}{linelength} -\usesdollar{setExposeAddConstr}{localExposureData} -\usesdollar{setExposeAddConstr}{interpreterFrameName} -\begin{chunk}{defun setExposeAddConstr} -(defun |setExposeAddConstr| (arg) - "The top level set expose add constructor handler" - (declare (special $linelength |$localExposureData| |$interpreterFrameName|)) - (if (null arg) - (progn - (|centerAndHighlight| - '|The constructor Option| $linelength (|specialChar| '|hbar|)) - (|displayExposedConstructors|)) - (dolist (x arg) - (setq x (|unabbrev| x)) - (when (consp x) (setq x (qcar x))) + ((|hasOption| |$options| '|nonquietly|) + (setq |$traceNoisely| t))) (cond - ((null (getdatabase x 'constructorkind)) - (|sayKeyedMsg| 's2iz0049j (list x))) - ((|member| x (elt |$localExposureData| 1)) - (|sayKeyedMsg| 's2iz0049k (list x |$interpreterFrameName| ))) + ((|hasOption| |$options| '|off|) + (cond + ((or (setq ops (|hasOption| |$options| 'ops)) + (setq lops (|hasOption| |$options| '|local|))) + (cond + ((null arg) + (|throwKeyedMsg| + (format nil + "If you use the )off option for )trace and you also use the ~ + )local or )ops option, you must specify the name of a ~ + constructor. You have not done so.") + nil)) + (t + (setq constructor + (|unabbrev| + (cond + ((atom arg) arg) + ((null (cdr arg)) + (cond + ((atom (car arg)) (car arg)) + (t (car (car arg))))) + (t nil)))) + (cond + ((null (|isFunctor| constructor)) + (|throwKeyedMsg| + (format nil + "If you use the )off option for )trace and you also use ~ + the )local or )ops option, you must specify the name ~ + of a constructor. What you gave after )trace is not a ~ + valid constructor name.") + nil)) + (t + (cond (ops (setq ops (|getTraceOption| ops)) nil)) + (cond + (lops + (setq lops (cdr (|getTraceOption| lops))) + (|untraceDomainLocalOps|)) + (t nil))))))) + ((and (qslessp 1 (|#| |$options|)) + (null (|hasOption| |$options| '|nonquietly|))) + (|throwKeyedMsg| + (format nil + "If you use the )off option for )trace then the only other ~ + options you can use are )nonquietly, )ops and )local.") + nil)) + (t (|untrace| arg)))) + ((|hasOption| |$options| '|stats|) + (cond + ((qslessp 1 (|#| |$options|)) + (|throwKeyedMsg| "%1 can have no other options." + (cons ")trace ... )stats" nil))) + (t + (setq temp1 (car |$options|)) + (setq opt (cdr temp1)) + (cond + ((null opt) + (|centerAndHighlight| "Traced function execution times" 78 '-) + (|ptimers|) + (say " ") + (|centerAndHighlight| "Traced function execution counts" 78 '-) + (|pcounters|)) + (t + (|selectOptionLC| (car opt) '(|reset|) '|optionError|) + (|resetSpacers|) + (|resetTimers|) + (|resetCounters|) + (|throwKeyedMsg| + (format nil + "Trace facility timers, space counts and execution counts ~ + have been reset.") + nil)))))) + ((setq a (|hasOption| |$options| '|restore|)) + (unless (setq oldl |$lastUntraced|) + (setq newoptions (|delete| a |$options|)) + (if (null arg) + (|trace1| oldl) + (progn + (dolist (x arg) + (if (and (consp x) + (progn + (setq domain (qcar x)) + (setq oplist (qcdr x)) + t) + (vecp domain)) + (|sayKeyedMsg| "Please retrace the domain %1." + (cons (|devaluate| domain) nil)) + (progn + (setq |$options| (append newoptions (lassoc x |$optionAlist|))) + (|trace1| (list x))))))))) + ((null arg) nil) + ((and (consp arg) (eq (qcdr arg) nil) (eq (qcar arg) '?)) (|?t|)) (t - (when (|member| x (elt |$localExposureData| 2)) - (setelt |$localExposureData| 2 - (|delete| x (elt |$localExposureData| 2)))) - (setelt |$localExposureData| 1 - (msort (cons x (elt |$localExposureData| 1)))) - (|clearClams|) - (|sayKeyedMsg| 's2iz0049p (list x |$interpreterFrameName| ))))))) + (setq tracelist + (or + (prog (t1) + (setq t1 nil) + (return + (do ((t2 arg (cdr t2)) (x nil)) + ((or (atom t2) + (progn (setq x (car t2)) nil)) + (nreverse0 t1)) + (seq + (exit + (setq t1 (cons (|transTraceItem| x) t1))))))) + (return nil))) + (do ((t3 tracelist (cdr t3)) (x nil)) + ((or (atom t3) (progn (setq x (car t3)) nil)) nil) + (seq + (exit + (setq |$optionAlist| (addassoc x |$options| |$optionAlist|))))) + (setq optionlist (|getTraceOptions| |$options|)) + (setq argument + (cond + ((setq domainlist (lassoc '|of| optionlist)) + (cond + ((lassoc 'ops optionlist) + (|throwKeyedMsg| + ")ops and )of cannot both be options to )trace" + nil)) + (t + (setq oplist + (cond + (tracelist (list (cons 'ops tracelist))) + (t nil))) + (setq varlist + (cond + ((setq y (lassoc '|vars| optionlist)) + (list (cons '|vars| y))) + (t nil))) + (append domainlist (append oplist varlist))))) + (optionlist (append tracelist optionlist)) + (t tracelist))) + (|/TRACE,0| + (prog (t4) + (setq t4 nil) + (return + (do ((t5 argument (cdr t5)) (|funName| nil)) + ((or (atom t5) + (progn (setq |funName| (car t5)) nil)) + (nreverse0 t4)) + (seq + (exit + (setq t4 (cons |funName| t4)))))))) + (|saveMapSig| + (prog (t6) + (setq t6 nil) + (return + (do ((t7 argument (cdr t7)) (|funName| nil)) + ((or (atom t7) + (progn (setq |funName| (car t7)) nil)) + (nreverse0 t6)) + (seq + (exit + (setq t6 (cons |funName| t6))))))))))))))) \end{chunk} -\Defun{setExposeDrop}{The top level set expose drop handler} -\calls{setExposeDrop}{centerAndHighlight} -\calls{setExposeDrop}{specialChar} -\calls{setExposeDrop}{displayHiddenConstructors} -\calls{setExposeDrop}{sayMSG} -\calls{setExposeDrop}{sayKeyedMsg} -\calls{setExposeDrop}{qcar} -\calls{setExposeDrop}{qcdr} -\calls{setExposeDrop}{selectOptionLC} -\calls{setExposeDrop}{setExposeDropGroup} -\calls{setExposeDrop}{setExposeDropConstr} -\calls{setExposeDrop}{setExposeDrop} -\usesdollar{setExposeDrop}{linelength} -\begin{chunk}{defun setExposeDrop} -(defun |setExposeDrop| (arg) - "The top level set expose drop handler" - (declare (special $linelength)) - (let (fnargs fn) - (cond - ((null arg) - (|centerAndHighlight| - '|The drop Option| $linelength (|specialChar| '|hbar|)) - (|displayHiddenConstructors|) - (|sayMSG| " ") - (|sayKeyedMsg| 's2iz0049f nil)) - ((and (consp arg) - (progn (setq fn (qcar arg)) (setq fnargs (qcdr arg)) t) - (setq fn (|selectOptionLC| fn '(|group| |constructor|) nil))) +\defun{getTraceOptions}{getTraceOptions} +\calls{getTraceOptions}{throwKeyedMsg} +\calls{getTraceOptions}{throwListOfKeyedMsgs} +\calls{getTraceOptions}{poundsign} +\calls{getTraceOptions}{seq} +\calls{getTraceOptions}{exit} +\calls{getTraceOptions}{getTraceOption} +\usesdollar{getTraceOptions}{traceErrorStack} +\begin{chunk}{defun getTraceOptions} +(defun |getTraceOptions| (|options|) + (prog (|$traceErrorStack| optionlist temp1 key |parms|) + (declare (special |$traceErrorStack|)) + (return + (seq + (progn + (setq |$traceErrorStack| nil) + (setq optionlist + (prog (t0) + (setq t0 nil) + (return + (do ((t1 |options| (cdr t1)) (x nil)) + ((or (atom t1) (progn (setq x (car t1)) nil)) (nreverse0 t0)) + (seq + (exit + (setq t0 (cons (|getTraceOption| x) t0)))))))) (cond - ((eq fn '|group|) (|setExposeDropGroup| fnargs)) - ((eq fn '|constructor|) (|setExposeDropConstr| fnargs)) - (t nil))) - (t (|setExposeDrop| nil))))) + (|$traceErrorStack| + (cond + ((null (cdr |$traceErrorStack|)) + (setq temp1 (car |$traceErrorStack|)) + (setq key (car temp1)) + (setq |parms| (cadr temp1)) + (|throwKeyedMsg| key (cons "" |parms|))) + (t + (|throwListOfKeyedMsgs| + "There are %1 problems with your )trace system command:" + (cons (|#| |$traceErrorStack|) nil) + (nreverse |$traceErrorStack|))))) + (t optionlist))))))) \end{chunk} -\Defun{setExposeDropGroup}{The top level set expose drop group handler} -\calls{setExposeDropGroup}{qcar} -\calls{setExposeDropGroup}{setelt} -\calls{setExposeDropGroup}{displayExposedGroups} -\calls{setExposeDropGroup}{sayMSG} -\calls{setExposeDropGroup}{displayExposedConstructors} -\calls{setExposeDropGroup}{displayHiddenConstructors} -\calls{setExposeDropGroup}{clearClams} -\calls{setExposeDropGroup}{member} -\calls{setExposeDropGroup}{delete} -\calls{setExposeDropGroup}{sayKeyedMsg} -\calls{setExposeDropGroup}{getalist} -\calls{setExposeDropGroup}{centerAndHighlight} -\calls{setExposeDropGroup}{specialChar} -\usesdollar{setExposeDropGroup}{linelength} -\usesdollar{setExposeDropGroup}{localExposureData} -\usesdollar{setExposeDropGroup}{interpreterFrameName} -\usesdollar{setExposeDropGroup}{globalExposureGroupAlist} -\begin{chunk}{defun setExposeDropGroup} -(defun |setExposeDropGroup| (arg) - "The top level set expose drop group handler" - (declare (special $linelength |$localExposureData| |$interpreterFrameName| - |$globalExposureGroupAlist|)) - (if (null arg) - (progn - (|centerAndHighlight| - '|The group Option| $linelength (|specialChar| '|hbar|)) - (|sayKeyedMsg| 's2iz0049l nil) - (|sayMSG| " ") - (|displayExposedGroups|)) - (dolist (x arg) - (when (consp x) (setq x (qcar x))) - (cond - ((eq x '|all|) - (setelt |$localExposureData| 0 nil) - (setelt |$localExposureData| 1 nil) - (setelt |$localExposureData| 2 nil) - (|displayExposedGroups|) - (|sayMSG| " ") - (|displayExposedConstructors|) - (|sayMSG| " ") - (|displayHiddenConstructors|) - (|clearClams|)) - ((|member| x (elt |$localExposureData| 0)) - (setelt |$localExposureData| 0 - (|delete| x (elt |$localExposureData| 0))) - (|clearClams|) - (|sayKeyedMsg| 's2iz0049s (list x |$interpreterFrameName| ))) - ((getalist |$globalExposureGroupAlist| x) - (|sayKeyedMsg| 's2iz0049i (list x |$interpreterFrameName| ))) - (t (|sayKeyedMsg| 's2iz0049h (list x ))))))) +\defun{saveMapSig}{saveMapSig} +\calls{saveMapSig}{rassoc} +\calls{saveMapSig}{addassoc} +\calls{saveMapSig}{getMapSig} +\usesdollar{saveMapSig}{tracedMapSignatures} +\usesdollar{saveMapSig}{mapSubNameAlist} +\begin{chunk}{defun saveMapSig} +(defun |saveMapSig| (funnames) + (let (map) + (declare (special |$tracedMapSignatures| |$mapSubNameAlist|)) + (dolist (name funnames) + (when (setq map (|rassoc| name |$mapSubNameAlist|)) + (setq |$tracedMapSignatures| + (addassoc name (|getMapSig| map name) |$tracedMapSignatures|)))))) \end{chunk} -\Defun{setExposeDropConstr} -{The top level set expose drop constructor handler} -\calls{setExposeDropConstr}{unabbrev} +\defun{getMapSig}{getMapSig} +\calls{getMapSig}{get} +\calls{getMapSig}{boot-equal} +\usesdollar{getMapSig}{InteractiveFrame} +\begin{chunk}{defun getMapSig} +(defun |getMapSig| (mapname subname) + (let (lmms sig) + (declare (special |$InteractiveFrame|)) + (when (setq lmms (|get| mapname '|localModemap| |$InteractiveFrame|)) + (do ((t0 lmms (cdr t0)) (|mm| nil) (t1 nil sig)) + ((or (atom t0) (progn (setq |mm| (car t0)) nil) t1) nil) + (when (boot-equal (cadr |mm|) subname) (setq sig (cdar |mm|)))) + sig))) + +\end{chunk} + +\defun{getTraceOption,hn}{getTraceOption,hn} +\calls{getTraceOption,hn}{seq} +\calls{getTraceOption,hn}{exit} +\calls{getTraceOption,hn}{isDomainOrPackage} +\calls{getTraceOption,hn}{stackTraceOptionError} +\calls{getTraceOption,hn}{domainToGenvar} +\begin{chunk}{defun getTraceOption,hn} +(defun |getTraceOption,hn| (x) + (prog (g) + (return + (seq + (if (and (atom x) (null (upper-case-p (elt (princ-to-string x) 0)))) + (exit + (seq + (if (|isDomainOrPackage| (eval x)) (exit x)) + (exit + (|stackTraceOptionError| + (cons + (format nil + "%1 The )trace option )of should be followed by the name of a ~ + domain and %2 is not one.") + (cons (cons x nil) nil))))))) + (if (setq g (|domainToGenvar| x)) (exit g)) + (exit + (|stackTraceOptionError| + (cons + (format nil + "%1 The )trace option )of should be followed by the name of a ~ + domain and %2 is not one.") + (cons (cons x nil) nil)))))))) + +\end{chunk} + +\defun{getTraceOption}{getTraceOption} +\calls{getTraceOption}{seq} +\calls{getTraceOption}{exit} +\calls{getTraceOption}{selectOptionLC} +\calls{getTraceOption}{identp} +\calls{getTraceOption}{stackTraceOptionError} +\calls{getTraceOption}{concat} +\calls{getTraceOption}{object2String} +\calls{getTraceOption}{transOnlyOption} +\calls{getTraceOption}{qcdr} +\calls{getTraceOption}{qcar} +\calls{getTraceOption}{getTraceOption,hn} +\calls{getTraceOption}{isListOfIdentifiersOrStrings} +\calls{getTraceOption}{isListOfIdentifiers} +\calls{getTraceOption}{throwKeyedMsg} +\usesdollar{getTraceOption}{traceOptionList} +\begin{chunk}{defun getTraceOption} +(defun |getTraceOption| (arg) + (prog (l |opts| key a |n|) + (declare (special |$traceOptionList|)) + (return + (seq + (progn + (setq key (car arg)) + (setq l (cdr arg)) + (setq key + (|selectOptionLC| key |$traceOptionList| '|traceOptionError|)) + (setq arg (cons key l)) + (cond + ((member key '(|nonquietly| |timer| |nt|)) arg) + ((eq key '|break|) + (cond + ((null l) (cons '|break| (cons '|before| nil))) + (t + (setq |opts| + (prog (t0) + (setq t0 nil) + (return + (do ((t1 l (cdr t1)) (y nil)) + ((or (atom t1) + (progn (setq y (car t1)) nil)) + (nreverse0 t0)) + (seq + (exit + (setq t0 + (cons + (|selectOptionLC| y '(|before| |after|) nil) t0)))))))) + (cond + ((prog (t2) + (setq t2 t) + (return + (do ((t3 nil (null t2)) (t4 |opts| (cdr t4)) (y nil)) + ((or t3 (atom t4) (progn (setq y (car t4)) nil)) t2) + (seq + (exit + (setq t2 (and t2 (identp y)))))))) + (cons '|break| |opts|)) + (t + (|stackTraceOptionError| + (cons + (format nil + "%1 The )trace option )break can only have one or both of ~ + before and after as arguments.") + (cons nil nil)))))))) + ((eq key '|restore|) + (cond + ((null l) arg) + (t + (|stackTraceOptionError| + (cons "%1 The )trace option %2 can have no arguments." + (cons (cons (concat ")" (|object2String| key)) nil) nil)))))) + ((eq key '|only|) (cons '|only| (|transOnlyOption| l))) + ((eq key '|within|) + (cond + ((and (consp l) + (eq (qcdr l) nil) + (progn (setq a (qcar l)) t) + (identp a)) + arg) + (t + (|stackTraceOptionError| + (cons + "%1 The )trace option %2 takes exactly one name as an argument." + (cons (cons ")within" nil) nil)))))) + ((member key '(|cond| |before| |after|)) + (setq key + (cond + ((eq key '|cond|) '|when|) + (t key))) + (cond + ((and (consp l) + (eq (qcdr l) nil) + (progn (setq a (qcar l)) t)) + (cons key l)) + (t + (|stackTraceOptionError| + (cons + "%1 The )trace option %2 takes exactly one expression as an argument." + (cons + (cons (concat ")" + (|object2String| key)) nil) nil)))))) + ((eq key '|depth|) + (cond + ((and (consp l) + (eq (qcdr l) nil) + (progn (setq |n| (qcar l)) t) + (integerp |n|)) + arg) + (t + (|stackTraceOptionError| + (cons + "%1 The )trace option %2 takes exactly one integer argument." + (cons (cons ")depth" nil) nil)))))) + ((eq key '|count|) + (cond + ((or (null l) + (and (consp l) + (eq (qcdr l) nil) + (progn (setq |n| (qcar l)) t) + (integerp |n|))) + arg) + (t + (|stackTraceOptionError| + (cons + "%1 The )trace option %2 takes exactly one integer argument." + (cons (cons ")count" nil) nil)))))) + ((eq key '|of|) + (cons '|of| + (prog (t5) + (setq t5 nil) + (return + (do ((t6 l (cdr t6)) (y nil)) + ((or (atom t6) (progn (setq y (car t6)) nil)) (nreverse0 t5)) + (seq + (exit + (setq t5 (cons (|getTraceOption,hn| y) t5))))))))) + ((member key '(|local| ops |vars|)) + (cond + ((or (null l) + (and (consp l) (eq (qcdr l) nil) (eq (qcar l) '|all|))) + (cons key '|all|)) + ((|isListOfIdentifiersOrStrings| l) arg) + (t + (|stackTraceOptionError| + (cons + "%1 The )trace option %2 should be followed by a list of names." + (cons + (cons (concat ")" (|object2String| key)) nil) nil)))))) + ((eq key '|varbreak|) + (cond + ((or (null l) + (and (consp l) (eq (qcdr l) nil) (eq (qcar l) '|all|))) + (cons '|varbreak| '|all|)) + ((|isListOfIdentifiers| l) arg) + (t + (|stackTraceOptionError| + (cons + "%1 The )trace option %2 should be followed by a list of variable names." + (cons + (cons (concat ")" (|object2String| key)) nil) nil)))))) + ((eq key '|mathprint|) + (cond + ((null l) arg) + (t + (|stackTraceOptionError| + (cons "%1 The )trace option %2 can have no arguments." + (cons + (cons (concat ")" (|object2String| key)) nil) nil)))))) + (key (|throwKeyedMsg| "The %1 option is not implemented yet." + (cons key nil))))))))) + +\end{chunk} + +\defun{traceOptionError}{traceOptionError} +\calls{traceOptionError}{stackTraceOptionError} +\calls{traceOptionError}{commandAmbiguityError} +\begin{chunk}{defun traceOptionError} +(defun |traceOptionError| (opt keys) + (if (null keys) + (|stackTraceOptionError| + (cons + "%1 Axiom does not understand the )trace option %2 which you used." + (cons (cons opt nil) nil))) + (|commandAmbiguityError| '|trace option| opt keys))) + +\end{chunk} + +\defun{genDomainTraceName}{genDomainTraceName} +\calls{genDomainTraceName}{lassoc} +\calls{genDomainTraceName}{genvar} +\usesdollar{genDomainTraceName}{domainTraceNameAssoc} +\begin{chunk}{defun genDomainTraceName} +(defun |genDomainTraceName| (y) + (let (u g) + (declare (special |$domainTraceNameAssoc|)) + (if (setq u (lassoc y |$domainTraceNameAssoc|)) + u + (progn + (setq g (genvar)) + (setq |$domainTraceNameAssoc| (cons (cons y g) |$domainTraceNameAssoc|)) + g)))) + +\end{chunk} + +\defun{untrace}{untrace} +\calls{untrace}{copy} +\calls{untrace}{transTraceItem} +\calls{untrace}{/untrace,0} +\calls{untrace}{lassocSub} +\calls{untrace}{removeTracedMapSigs} +\usesdollar{untrace}{lastUntraced} +\usesdollar{untrace}{mapSubNameAlist} +\uses{untrace}{/tracenames} +\begin{chunk}{defun untrace} +(defun |untrace| (arg) + (let (untracelist) + (declare (special |$lastUntraced| /tracenames |$mapSubNameAlist|)) + (if arg + (setq |$lastUntraced| arg) + (setq |$lastUntraced| (copy /tracenames))) + (setq untracelist + (do ((t1 arg (cdr t1)) (x nil) (t0 nil)) + ((or (atom t1) (progn (setq x (car t1)) nil)) + (nreverse0 t0)) + (push (|transTraceItem| x) t0))) + (|/UNTRACE,0| + (do ((t3 untracelist (cdr t3)) (|funName| nil) (t2 nil)) + ((or (atom t3) (progn (setq |funName| (car t3)) nil)) + (nreverse0 t2)) + (push (|lassocSub| |funName| |$mapSubNameAlist|) t2))) + (|removeTracedMapSigs| untracelist))) + +\end{chunk} + +\defun{transTraceItem}{transTraceItem} +\calls{transTraceItem}{get} +\calls{transTraceItem}{member} +\calls{transTraceItem}{objMode} +\calls{transTraceItem}{objVal} +\calls{transTraceItem}{domainToGenvar} +\calls{transTraceItem}{unabbrev} +\calls{transTraceItem}{constructor?} +\calls{transTraceItem}{vecp} +\calls{transTraceItem}{transTraceItem} +\calls{transTraceItem}{devaluate} +\calls{transTraceItem}{throwKeyedMsg} +\usesdollar{transTraceItem}{doNotAddEmptyModeIfTrue} +\begin{chunk}{defun transTraceItem} +(defun |transTraceItem| (x) + (prog (|$doNotAddEmptyModeIfTrue| |value| y) + (declare (special |$doNotAddEmptyModeIfTrue|)) + (return + (progn + (setq |$doNotAddEmptyModeIfTrue| t) + (cond + ((atom x) + (cond + ((and (setq |value| (|get| x '|value| |$InteractiveFrame|)) + (|member| (|objMode| |value|) + '((|Mode|) (|Domain|) (|SubDomain| (|Domain|))))) + (setq x (|objVal| |value|)) + (cond + ((setq y (|domainToGenvar| x)) y) + (t x))) + ((upper-case-p (elt (princ-to-string x) 0)) + (setq y (|unabbrev| x)) + (cond + ((|constructor?| y) y) + ((and (consp y) (|constructor?| (car y))) (car y)) + ((setq y (|domainToGenvar| x)) y) + (t x))) + (t x))) + ((vecp (car x)) (|transTraceItem| (|devaluate| (car x)))) + ((setq y (|domainToGenvar| x)) y) + (t (|throwKeyedMsg| + "Axiom does not understand the use of %1 here." (cons x nil)))))))) + +\end{chunk} + +\defun{removeTracedMapSigs}{removeTracedMapSigs} +\usesdollar{removeTracedMapSigs}{tracedMapSignatures} +\begin{chunk}{defun removeTracedMapSigs} +(defun |removeTracedMapSigs| (untraceList) + (declare (special |$tracedMapSignatures|)) + (dolist (name untraceList) + (remprop name |$tracedMapSignatures|))) + +\end{chunk} + +\defun{coerceTraceArgs2E}{coerceTraceArgs2E} +\calls{coerceTraceArgs2E}{spadsysnamep} +\calls{coerceTraceArgs2E}{pname} +\calls{coerceTraceArgs2E}{coerceSpadArgs2E} +\calls{coerceTraceArgs2E}{objValUnwrap} +\calls{coerceTraceArgs2E}{coerceInteractive} +\calls{coerceTraceArgs2E}{mkObjWrap} +\usesdollar{coerceTraceArgs2E}{OutputForm} +\usesdollar{coerceTraceArgs2E}{mathTraceList} +\usesdollar{coerceTraceArgs2E}{tracedMapSignatures} +\begin{chunk}{defun coerceTraceArgs2E} +(defun |coerceTraceArgs2E| (tracename subname args) + (declare (ignore tracename)) + (let (name) + (declare (special |$OutputForm| |$mathTraceList| |$tracedMapSignatures|)) + (cond + ((member (setq name subname) |$mathTraceList|) + (if (spadsysnamep (pname name)) + (|coerceSpadArgs2E| (reverse (cdr (reverse args)))) + (do ((t1 '(|arg1| |arg2| |arg3| |arg4| |arg5| |arg6| |arg7| |arg8| + |arg9| |arg10| |arg11| |arg12| |arg13| |arg14| |arg15| + |arg16| |arg17| |arg18| |arg19|) (cdr t1)) + (name nil) + (t2 args (cdr t2)) + (arg nil) + (t3 (cdr (lassoc subname |$tracedMapSignatures|)) (cdr t3)) + (type nil) + (t0 nil)) + ((or (atom t1) + (progn (setq name (car t1)) nil) + (atom t2) + (progn (setq arg (car t2)) nil) + (atom t3) + (progn (setq type (car t3)) nil)) + (nreverse0 t0)) + (setq t0 + (cons + (list '= name + (|objValUnwrap| + (|coerceInteractive| + (mkObjWrap arg type) |$OutputForm|))) t0))))) + ((spadsysnamep (pname name)) (reverse (cdr (reverse args)))) + (t args)))) + +\end{chunk} + +\defun{coerceSpadArgs2E}{coerceSpadArgs2E} +\calls{coerceSpadArgs2E}{seq} +\calls{coerceSpadArgs2E}{exit} +\calls{coerceSpadArgs2E}{objValUnwrap} +\calls{coerceSpadArgs2E}{coerceInteractive} +\calls{coerceSpadArgs2E}{mkObjWrap} +\usesdollar{coerceSpadArgs2E}{streamCount} +\usesdollar{coerceSpadArgs2E}{OutputForm} +\usesdollar{coerceSpadArgs2E}{tracedSpadModemap} +\begin{chunk}{defun coerceSpadArgs2E} +(defun |coerceSpadArgs2E| (args) + (let ((|$streamCount| 0)) + (declare (special |$streamCount| |$OutputForm| |$tracedSpadModemap|)) + (do ((t1 '(|arg1| |arg2| |arg3| |arg4| |arg5| |arg6| |arg7| |arg8| + |arg9| |arg10| |arg11| |arg12| |arg13| |arg14| |arg15| + |arg16| |arg17| |arg18| |arg19|) (cdr t1)) + (name nil) + (t2 args (cdr t2)) + (arg nil) + (t3 (cdr |$tracedSpadModemap|) (cdr t3)) + (type nil) + (t0 nil)) + ((or (atom t1) + (progn (setq name (car t1)) nil) + (atom t2) + (progn (setq arg (car t2)) nil) + (atom t3) + (progn (setq type (car t3)) nil)) + (nreverse0 t0)) + (seq + (exit + (setq t0 + (cons + (cons '= + (cons name + (cons (|objValUnwrap| + (|coerceInteractive| + (mkObjWrap arg type) + |$OutputForm|)) nil))) + t0))))))) + +\end{chunk} + +\defun{coerceTraceFunValue2E}{coerceTraceFunValue2E} +\calls{coerceTraceFunValue2E}{spadsysnamep} +\calls{coerceTraceFunValue2E}{pname} +\calls{coerceTraceFunValue2E}{coerceSpadFunValue2E} +\calls{coerceTraceFunValue2E}{lassoc} +\calls{coerceTraceFunValue2E}{objValUnwrap} +\calls{coerceTraceFunValue2E}{coerceInteractive} +\calls{coerceTraceFunValue2E}{mkObjWrap} +\usesdollar{coerceTraceFunValue2E}{tracedMapSignatures} +\usesdollar{coerceTraceFunValue2E}{OutputForm} +\usesdollar{coerceTraceFunValue2E}{mathTraceList} +\begin{chunk}{defun coerceTraceFunValue2E} +(defun |coerceTraceFunValue2E| (tracename subname |value|) + (let (name u) + (declare (special |$tracedMapSignatures| |$OutputForm| |$mathTraceList|)) + (if (member (setq name subname) |$mathTraceList|) + (cond + ((spadsysnamep (pname tracename)) (|coerceSpadFunValue2E| |value|)) + ((setq u (lassoc subname |$tracedMapSignatures|)) + (|objValUnwrap| + (|coerceInteractive| (mkObjWrap |value| (car u)) |$OutputForm|))) + (t |value|)) + |value|))) + +\end{chunk} + +\defun{coerceSpadFunValue2E}{coerceSpadFunValue2E} +\calls{coerceSpadFunValue2E}{objValUnwrap} +\calls{coerceSpadFunValue2E}{coerceInteractive} +\calls{coerceSpadFunValue2E}{mkObjWrap} +\usesdollar{coerceSpadFunValue2E}{streamCount} +\usesdollar{coerceSpadFunValue2E}{tracedSpadModemap} +\usesdollar{coerceSpadFunValue2E}{OutputForm} +\begin{chunk}{defun coerceSpadFunValue2E} +(defun |coerceSpadFunValue2E| (|value|) + (let (|$streamCount|) + (declare (special |$streamCount| |$tracedSpadModemap| |$OutputForm|)) + (setq |$streamCount| 0) + (|objValUnwrap| + (|coerceInteractive| + (mkObjWrap |value| (car |$tracedSpadModemap|)) + |$OutputForm|)))) + +\end{chunk} + +\defun{getMapSubNames}{getMapSubNames} +\calls{getMapSubNames}{get} +\calls{getMapSubNames}{union} +\calls{getMapSubNames}{getPreviousMapSubNames} +\calls{getMapSubNames}{unionq} +\usesdollar{getMapSubNames}{lastUntraced} +\usesdollar{getMapSubNames}{InteractiveFrame} +\uses{getMapSubNames}{/tracenames} +\begin{chunk}{defun getMapSubNames} +(defun |getMapSubNames| (arg) + (let (lmm subs) + (declare (special /tracenames |$lastUntraced| |$InteractiveFrame|)) + (setq subs nil) + (dolist (mapname arg) + (when (setq lmm (|get| mapname '|localModemap| |$InteractiveFrame|)) + (setq subs + (append + (do ((t2 lmm (cdr t2)) (t1 nil) (|mm| nil)) + ((or (atom t2) + (progn (setq |mm| (CAR t2)) nil)) (nreverse0 t1)) + (setq t1 (cons (cons mapname (cadr |mm|)) t1))) + subs)))) + (|union| subs + (|getPreviousMapSubNames| (unionq /tracenames |$lastUntraced|))))) + +\end{chunk} + +\defun{augmentTraceNames}{augmentTraceNames} +\calls{augmentTraceNames}{get} +\usesdollar{augmentTraceNames}{InteractiveFrame} +\begin{chunk}{defun augmentTraceNames} +(defun |augmentTraceNames| (arg) + (let (mml res) + (declare (special |$InteractiveFrame|)) + (dolist (tracename arg) + (if (setq mml (|get| tracename '|localModemap| |$InteractiveFrame|)) + (setq res + (append + (prog (t1) + (setq t1 nil) + (return + (do ((t2 mml (cdr t2)) (|mm| nil)) + ((or (atom t2) + (progn (setq |mm| (CAR t2)) nil)) + (nreverse0 t1)) + (setq t1 (cons (cadr |mm|) t1))))) + res)) + (setq res (cons tracename res)))) + res)) + +\end{chunk} + +\defun{spadTrace,g}{spadTrace,g} +\begin{chunk}{defun spadTrace,g} +(defun |spadTrace,g| (x) + (if (stringp x) (intern x) x)) + +\end{chunk} + +\defun{spadTrace,isTraceable}{spadTrace,isTraceable} +\calls{spadTrace,isTraceable}{seq} +\calls{spadTrace,isTraceable}{exit} +\calls{spadTrace,isTraceable}{gensymp} +\calls{spadTrace,isTraceable}{reportSpadTrace} +\calls{spadTrace,isTraceable}{bpiname} +\begin{chunk}{defun spadTrace,isTraceable} +(defun |spadTrace,isTraceable| (x |domain|) + (prog (n |functionSlot|) + (return + (seq + (progn + (setq n (caddr x)) + x + (seq + (if (atom (elt |domain| n)) (exit nil)) + (setq |functionSlot| (car (elt |domain| n))) + (if (gensymp |functionSlot|) + (exit (seq (|reportSpadTrace| '|Already Traced| x) (exit nil)))) + (if (null (bpiname |functionSlot|)) + (exit + (seq + (|reportSpadTrace| '|No function for| x) + (exit nil)))) + (exit t))))))) + +\end{chunk} + +\defun{spadTrace}{spadTrace} +\calls{spadTrace}{refvecp} +\calls{spadTrace}{aldorTrace} +\calls{spadTrace}{isDomainOrPackage} +\calls{spadTrace}{userError} +\calls{spadTrace}{seq} +\calls{spadTrace}{exit} +\calls{spadTrace}{spadTrace,g} +\calls{spadTrace}{getOption} +\calls{spadTrace}{removeOption} +\calls{spadTrace}{opOf} +\calls{spadTrace}{assoc} +\calls{spadTrace}{kdr} +\calls{spadTrace}{flattenOperationAlist} +\calls{spadTrace}{getOperationAlistFromLisplib} +\calls{spadTrace}{spadTrace,isTraceable} +\calls{spadTrace}{as-insert} +\calls{spadTrace}{bpiname} +\calls{spadTrace}{spadTraceAlias} +\calls{spadTrace}{subTypes} +\calls{spadTrace}{constructSubst} +\calls{spadTrace}{bpitrace} +\calls{spadTrace}{rplac} +\calls{spadTrace}{printDashedLine} +\calls{spadTrace}{reportSpadTrace} +\calls{spadTrace}{setletprintflag} +\calls{spadTrace}{spadReply} +\usesdollar{spadTrace}{tracedModemap} +\usesdollar{spadTrace}{fromSpadTrace} +\usesdollar{spadTrace}{letAssoc} +\usesdollar{spadTrace}{reportSpadTrace} +\usesdollar{spadTrace}{traceNoisely} +\uses{spadTrace}{/tracenames} +\begin{chunk}{defun spadTrace} +(defun |spadTrace| (domain options) + (let (|$tracedModemap| listofoperations listofvariables + listofbreakvars anyiftrue domainid currententry + currentalist opstructurelist sig kind triple fn op + mm n alias tracename sigslotnumberalist) + (declare (special |$tracedModemap| /tracenames |$fromSpadTrace| |$letAssoc| + |$reportSpadtrace| |$traceNoisely|)) + (setq |$fromSpadTrace| t) + (setq |$tracedModemap| nil) + (cond + ((and (consp domain) + (refvecp (car domain)) + (eql (elt (car domain) 0) 0)) + (|aldorTrace| domain options)) + ((null (|isDomainOrPackage| domain)) + (|userError| "bad argument to trace")) + (t + (setq listofoperations + (prog (t0) + (setq t0 nil) + (return + (do ((t1 (|getOption| 'ops options) (cdr t1)) (x nil)) + ((or (atom t1) (progn (setq x (car t1)) nil)) (nreverse0 t0)) + (seq + (exit + (setq t0 (cons (|spadTrace,g| x) t0)))))))) + (cond + ((setq listofvariables (|getOption| 'vars options)) + (setq options (|removeOption| 'vars options)))) + (cond + ((setq listofbreakvars (|getOption| 'varbreak options)) + (setq options (|removeOption| 'varbreak options)))) + (setq anyiftrue (null listofoperations)) + (setq domainid (|opOf| (elt domain 0))) + (setq currententry (|assoc| domain /tracenames)) + (setq currentalist (kdr currententry)) + (setq opstructurelist + (|flattenOperationAlist| (|getOperationAlistFromLisplib| domainid))) + (setq sigslotnumberalist + (prog (t2) + (setq t2 nil) + (return + (do ((t3 opstructurelist (cdr t3)) (t4 nil)) + ((or (atom t3) + (progn (setq t4 (CAR t3)) nil) + (progn + (progn + (setq op (car t4)) + (setq sig (cadr t4)) + (setq n (caddr t4)) + (setq kind (car (cddddr t4))) t4) + nil)) + (nreverse0 t2)) + (seq + (exit + (cond + ((and (eq kind 'elt) + (or anyiftrue (member op listofoperations)) + (integerp n) + (|spadTrace,isTraceable| + (setq triple + (cons op (cons sig (cons n nil)))) domain)) + (setq t2 (cons triple t2)))))))))) + (cond + (listofvariables + (do ((t5 sigslotnumberalist (cdr t5)) (t6 nil)) + ((or (atom t5) + (progn (setq t6 (car t5)) nil) + (progn (progn (setq n (caddr t6)) t6) nil)) + nil) + (seq + (exit + (progn + (setq fn (car (elt domain n))) + (setq |$letAssoc| + (as-insert (bpiname fn) listofvariables |$letAssoc|)))))))) + (cond + (listofbreakvars + (do ((t7 sigslotnumberalist (cdr t7)) (t8 nil)) + ((or (atom t7) + (progn (setq t8 (car t7)) nil) + (progn (progn (setq n (caddr t8)) t8) nil)) + nil) + (seq + (exit + (progn + (setq fn (car (elt domain n))) + (setq |$letAssoc| + (as-insert (bpiname fn) + (cons (cons 'break listofbreakvars) nil) |$letAssoc|)))))))) + (do ((t9 sigslotnumberalist (cdr t9)) (|pair| nil)) + ((or (atom t9) + (progn (setq |pair| (car t9)) nil) + (progn + (progn + (setq op (car |pair|)) + (setq mm (cadr |pair|)) + (setq n (caddr |pair|)) + |pair|) + nil)) + nil) + (seq + (exit + (progn + (setq alias (|spadTraceAlias| domainid op n)) + (setq |$tracedModemap| + (|subTypes| mm (|constructSubst| (elt domain 0)))) + (setq tracename + (bpitrace (car (elt domain n)) alias options)) + (nconc |pair| + (cons listofvariables + (cons (car (elt domain n)) + (cons tracename (cons alias nil))))) + (rplac (car (elt domain n)) tracename))))) + (setq sigslotnumberalist + (prog (t10) + (setq t10 nil) + (return + (do ((t11 sigslotnumberalist (cdr t11)) (x nil)) + ((or (atom t11) (progn (setq x (car t11)) nil)) (nreverse0 t10)) + (seq + (exit + (cond ((cdddr x) (setq t10 (cons x t10)))))))))) + (cond + (|$reportSpadtrace| + (cond (|$traceNoisely| (|printDashedLine|))) + (do ((t12 (|orderBySlotNumber| sigslotnumberalist) (cdr t12)) + (x nil)) + ((or (atom t12) + (progn (setq x (car t12)) nil)) + nil) + (seq (exit (|reportSpadTrace| 'tracing x)))))) + (cond (|$letAssoc| (setletprintflag t))) + (cond + (currententry + (rplac (cdr currententry) + (append sigslotnumberalist currentalist))) + (t + (setq /tracenames + (cons (cons domain sigslotnumberalist) /tracenames)) + (|spadReply|))))))) + +\end{chunk} + +\defun{traceDomainLocalOps}{traceDomainLocalOps} +\calls{traceDomainLocalOps}{sayMSG} +\begin{chunk}{defun traceDomainLocalOps} +(defun |traceDomainLocalOps| () + (|sayMSG| '(" The )local option has been withdrawn")) + (|sayMSG| '(" Use )ltr to trace local functions."))) + +\end{chunk} + +\defun{untraceDomainLocalOps}{untraceDomainLocalOps} +\calls{untraceDomainLocalOps}{sayMSG} +\begin{chunk}{defun untraceDomainLocalOps} +(defun |untraceDomainLocalOps| () + (|sayMSG| '(" The )local option has been withdrawn")) + (|sayMSG| '(" Use )ltr to trace local functions."))) + +\end{chunk} + +\defun{traceDomainConstructor}{traceDomainConstructor} +\calls{traceDomainConstructor}{getOption} +\calls{traceDomainConstructor}{seq} +\calls{traceDomainConstructor}{exit} +\calls{traceDomainConstructor}{spadTrace} +\calls{traceDomainConstructor}{concat} +\calls{traceDomainConstructor}{embed} +\calls{traceDomainConstructor}{mkq} +\calls{traceDomainConstructor}{loadFunctor} +\calls{traceDomainConstructor}{traceDomainLocalOps} +\usesdollar{traceDomainConstructor}{ConstructorCache} +\begin{chunk}{defun traceDomainConstructor} +(defun |traceDomainConstructor| (domainConstructor options) + (prog (listOfLocalOps argl domain innerDomainConstructor) + (declare (special |$ConstructorCache|)) + (return + (seq + (progn + (|loadFunctor| domainConstructor) + (setq listOfLocalOps (|getOption| 'local options)) + (when listOfLocalOps (|traceDomainLocalOps|)) + (cond + ((and listOfLocalOps (null (|getOption| 'ops options))) nil) + (t + (do ((t2 (hget |$ConstructorCache| domainConstructor) (cdr t2)) + (t3 nil)) + ((or (atom t2) + (progn (setq t3 (car t2)) nil) + (progn + (progn + (setq argl (car t3)) + (setq domain (cddr t3)) t3) + nil)) + nil) + (seq + (exit + (|spadTrace| domain options)))) + (setq /tracenames (cons domainConstructor /tracenames)) + (setq innerDomainConstructor + (intern (concat domainConstructor ";"))) + (cond + ((fboundp innerDomainConstructor) + (setq domainConstructor innerDomainConstructor))) + (embed domainConstructor + (cons 'lambda + (cons + (cons '&rest + (cons 'args nil)) + (cons + (cons 'prog + (cons + (cons 'domain nil) + (cons + (cons 'setq + (cons 'domain + (cons + (cons 'apply (cons domainConstructor + (cons 'args nil))) nil))) + (cons + (cons '|spadTrace| + (cons 'domain + (cons (mkq options) nil))) + (cons (cons 'return (cons 'domain nil)) nil))))) + nil))))))))))) + +\end{chunk} + +\defun{untraceDomainConstructor,keepTraced?}{% +untraceDomainConstructor,keepTraced?} +\calls{untraceDomainConstructor,keepTraced?}{seq} +\calls{untraceDomainConstructor,keepTraced?}{qcar} +\calls{untraceDomainConstructor,keepTraced?}{isDomainOrPackage} +\calls{untraceDomainConstructor,keepTraced?}{boot-equal} +\calls{untraceDomainConstructor,keepTraced?}{kar} +\calls{untraceDomainConstructor,keepTraced?}{devaluate} +\calls{untraceDomainConstructor,keepTraced?}{exit} +\calls{untraceDomainConstructor,keepTraced?}{/untrace,0} +\begin{chunk}{defun untraceDomainConstructor,keepTraced?} +(defun |untraceDomainConstructor,keepTraced?| (df domainConstructor) + (prog (dc) + (return + (seq + (if (and + (and + (and (consp df) (progn (setq dc (qcar df)) t)) + (|isDomainOrPackage| dc)) + (boot-equal (kar (|devaluate| dc)) domainConstructor)) + (exit (seq (|/UNTRACE,0| (cons dc nil)) (exit nil)))) + (exit t))))) + +\end{chunk} + +\defun{untraceDomainConstructor}{untraceDomainConstructor} +\calls{untraceDomainConstructor}{untraceDomainConstructor,keepTraced?} +\calls{untraceDomainConstructor}{unembed} +\calls{untraceDomainConstructor}{seq} +\calls{untraceDomainConstructor}{exit} +\calls{untraceDomainConstructor}{concat} +\calls{untraceDomainConstructor}{delete} +\uses{untraceDomainConstructor}{/tracenames} +\begin{chunk}{defun untraceDomainConstructor} +(defun |untraceDomainConstructor| (domainConstructor) + (prog (innerDomainConstructor) + (declare (special /tracenames)) + (return + (seq + (progn + (setq /tracenames + (prog (t0) + (setq t0 nil) + (return + (do ((t1 /tracenames (cdr t1)) (df nil)) + ((or (atom t1) (progn (setq df (car t1)) nil)) (nreverse0 t0)) + (seq + (exit + (cond ((|untraceDomainConstructor,keepTraced?| + df domainConstructor) + (setq t0 (cons df t0)))))))))) + (setq innerDomainConstructor + (intern (concat domainConstructor ";"))) + (cond + ((fboundp innerDomainConstructor) (unembed innerDomainConstructor)) + (t (unembed domainConstructor))) + (setq /tracenames (|delete| domainConstructor /tracenames))))))) + +\end{chunk} + +\defun{mapLetPrint}{mapLetPrint} +\calls{mapLetPrint}{getAliasIfTracedMapParameter} +\calls{mapLetPrint}{getBpiNameIfTracedMap} +\calls{mapLetPrint}{letPrint} +\begin{chunk}{defun mapLetPrint} +(defun |mapLetPrint| (x val currentFunction) + (setq x (|getAliasIfTracedMapParameter| x currentFunction)) + (setq currentFunction (|getBpiNameIfTracedMap| currentFunction)) + (|letPrint| x val currentFunction)) + +\end{chunk} + +\defun{getAliasIfTracedMapParameter}{getAliasIfTracedMapParameter} +\calls{getAliasIfTracedMapParameter}{isSharpVarWithNum} +\calls{getAliasIfTracedMapParameter}{get} +\calls{getAliasIfTracedMapParameter}{exit} +\calls{getAliasIfTracedMapParameter}{spaddifference} +\calls{getAliasIfTracedMapParameter}{string2pint-n} +\calls{getAliasIfTracedMapParameter}{substring} +\calls{getAliasIfTracedMapParameter}{pname} +\calls{getAliasIfTracedMapParameter}{seq} +\usesdollar{getAliasIfTracedMapParameter}{InteractiveFrame} +\begin{chunk}{defun getAliasIfTracedMapParameter} +(defun |getAliasIfTracedMapParameter| (x |currentFunction|) + (prog (|aliasList|) + (declare (special |$InteractiveFrame|)) + (return + (seq + (cond + ((|isSharpVarWithNum| x) + (cond + ((setq |aliasList| + (|get| |currentFunction| 'alias |$InteractiveFrame|)) + (exit + (elt |aliasList| + (spaddifference + (string2pint-n (substring (pname x) 1 nil) 1) 1)))))) + (t x)))))) + +\end{chunk} + +\defun{getBpiNameIfTracedMap}{getBpiNameIfTracedMap} +\calls{getBpiNameIfTracedMap}{get} +\calls{getBpiNameIfTracedMap}{exit} +\calls{getBpiNameIfTracedMap}{seq} +\usesdollar{getBpiNameIfTracedMap}{InteractiveFrame} +\uses{getBpiNameIfTracedMap}{/tracenames} +\begin{chunk}{defun getBpiNameIfTracedMap} +(defun |getBpiNameIfTracedMap| (name) + (prog (lmm bpiName) + (declare (special |$InteractiveFrame| /tracenames)) + (return + (seq + (cond + ((setq lmm (|get| name '|localModemap| |$InteractiveFrame|)) + (cond + ((member (setq bpiName (cadar lmm)) /tracenames) + (exit bpiName)))) + (t name)))))) + +\end{chunk} + +\defun{spadTraceAlias}{spadTraceAlias} +\calls{spadTraceAlias}{internl} +\begin{chunk}{defun spadTraceAlias} +(defun |spadTraceAlias| (domainid op n) + (internl domainid (intern "." "boot") op '|,| (princ-to-string n))) + +\end{chunk} + +\defun{reportSpadTrace}{reportSpadTrace} +\calls{reportSpadTrace}{qcar} +\calls{reportSpadTrace}{sayBrightly} +\usesdollar{reportSpadTrace}{traceNoisely} +\begin{chunk}{defun reportSpadTrace} +(defun |reportSpadTrace| (|header| t0) + (prog (op sig n |t| |msg| |namePart| y |tracePart|) + (declare (special |$traceNoisely|)) + (return + (progn + (setq op (car t0)) + (setq sig (cadr t0)) + (setq n (caddr t0)) + (setq |t| (cdddr t0)) + (cond + ((null |$traceNoisely|) nil) + (t + (setq |msg| + (cons |header| + (cons '|%b| + (cons op + (cons '|:| + (cons '|%d| + (cons (CDR sig) + (cons '| -> | + (cons (car sig) + (cons '| in slot | + (cons n nil))))))))))) + (setq |namePart| nil) + (setq |tracePart| + (cond + ((and (consp |t|) (progn (setq y (qcar |t|)) t) (null (null y))) + (cond + ((eq y '|all|) + (cons '|%b| (cons '|all| (cons '|%d| (cons '|vars| nil))))) + (t (cons '| vars: | (cons y nil))))) + (t nil))) + (|sayBrightly| (append |msg| (append |namePart| |tracePart|))))))))) + +\end{chunk} + +\defun{/tracereply}{/tracereply} +\calls{/tracereply}{qcar} +\calls{/tracereply}{isDomainOrPackage} +\calls{/tracereply}{devaluate} +\calls{/tracereply}{seq} +\calls{/tracereply}{exit} +\uses{/tracereply}{/tracenames} +\begin{chunk}{defun /tracereply} +(defun /tracereply () + (prog (|d| domainlist |functionList|) + (declare (special /tracenames)) + (return + (seq + (cond + ((null /tracenames) " Nothing is traced.") + (t + (do ((t0 /tracenames (cdr t0)) (x nil)) + ((or (atom t0) (progn (setq x (car t0)) nil)) nil) + (seq + (exit + (cond + ((and (consp x) + (progn (setq |d| (qcar x)) t) + (|isDomainOrPackage| |d|)) + (setq domainlist (cons (|devaluate| |d|) domainlist))) + (t + (setq |functionList| (cons x |functionList|))))))) + (append |functionList| + (append domainlist (cons '|traced| nil))))))))) + +\end{chunk} + +\defun{spadUntrace}{spadUntrace} +\calls{spadUntrace}{isDomainOrPackage} +\calls{spadUntrace}{userError} +\calls{spadUntrace}{getOption} +\calls{spadUntrace}{devaluate} +\calls{spadUntrace}{assoc} +\calls{spadUntrace}{sayMSG} +\calls{spadUntrace}{bright} +\calls{spadUntrace}{prefix2String} +\calls{spadUntrace}{bpiname} +\calls{spadUntrace}{remover} +\calls{spadUntrace}{setletprintflag} +\calls{spadUntrace}{bpiuntrace} +\calls{spadUntrace}{rplac} +\calls{spadUntrace}{seq} +\calls{spadUntrace}{exit} +\calls{spadUntrace}{delasc} +\calls{spadUntrace}{spadReply} +\usesdollar{spadUntrace}{letAssoc} +\uses{spadUntrace}{/tracenames} +\begin{chunk}{defun spadUntrace} +(defun |spadUntrace| (domain options) + (prog (anyiftrue listofoperations domainid |pair| sigslotnumberalist + op sig n |lv| |bpiPointer| tracename alias |assocPair| + |newSigSlotNumberAlist|) + (declare (special |$letAssoc| /tracenames)) + (return + (seq + (cond + ((null (|isDomainOrPackage| domain)) + (|userError| "bad argument to untrace")) + (t + (setq anyiftrue (null options)) + (setq listofoperations (|getOption| '|ops:| options)) + (setq domainid (|devaluate| domain)) + (cond + ((null (setq |pair| (|assoc| domain /tracenames))) + (|sayMSG| + (cons " No functions in" + (append + (|bright| (|prefix2String| domainid)) + (cons "are now traced." nil))))) + (t + (setq sigslotnumberalist (cdr |pair|)) + (do ((t0 sigslotnumberalist (cdr t0)) (|pair| nil)) + ((or (atom t0) + (progn (setq |pair| (car t0)) nil) + (progn + (progn + (setq op (car |pair|)) + (setq sig (cadr |pair|)) + (setq n (caddr |pair|)) + (setq |lv| (cadddr |pair|)) + (setq |bpiPointer| (car (cddddr |pair|))) + (setq tracename (cadr (cddddr |pair|))) + (setq alias (caddr (cddddr |pair|))) + |pair|) + nil)) + nil) + (seq + (exit + (cond + ((or anyiftrue (member op listofoperations)) + (progn + (bpiuntrace tracename alias) + (rplac (car (elt domain n)) |bpiPointer|) + (rplac (cdddr |pair|) nil) + (cond + ((setq |assocPair| + (|assoc| (bpiname |bpiPointer|) |$letAssoc|)) + (setq |$letAssoc| (remover |$letAssoc| |assocPair|)) + (cond + ((null |$letAssoc|) (setletprintflag nil)) + (t nil))) + (t nil)))))))) + (setq |newSigSlotNumberAlist| + (prog (t1) + (setq t1 nil) + (return + (do ((t2 sigslotnumberalist (cdr t2)) (x nil)) + ((or (atom t2) (progn (setq x (car t2)) nil)) (nreverse0 t1)) + (seq + (exit + (cond ((cdddr x) (setq t1 (cons x t1)))))))))) + (cond + (|newSigSlotNumberAlist| + (rplac (cdr |pair|) |newSigSlotNumberAlist|)) + (t + (setq /tracenames (delasc domain /tracenames)) + (|spadReply|))))))))))) + +\end{chunk} + +\defun{prTraceNames,fn}{prTraceNames,fn} +\calls{prTraceNames,fn}{seq} +\calls{prTraceNames,fn}{qcar} +\calls{prTraceNames,fn}{qcdr} +\calls{prTraceNames,fn}{isDomainOrPackage} +\calls{prTraceNames,fn}{exit} +\calls{prTraceNames,fn}{devaluate} +\begin{chunk}{defun prTraceNames,fn} +(defun |prTraceNames,fn| (x) + (prog (|d| |t|) + (return + (seq + (if (and (and (consp x) + (progn (setq |d| (qcar x)) (setq |t| (qcdr x)) t)) + (|isDomainOrPackage| |d|)) + (exit (cons (|devaluate| |d|) |t|))) + (exit x))))) + +\end{chunk} + +\defun{prTraceNames}{prTraceNames} +\calls{prTraceNames}{seq} +\calls{prTraceNames}{exit} +\calls{prTraceNames}{prTraceNames,fn} +\uses{prTraceNames}{/tracenames} +\begin{chunk}{defun prTraceNames} +(defun |prTraceNames| () + (declare (special /tracenames)) + (seq + (progn + (do ((t0 /tracenames (cdr t0)) (x nil)) + ((or (atom t0) (progn (setq x (car t0)) nil)) nil) + (seq + (exit + (print (|prTraceNames,fn| x))))) nil))) + +\end{chunk} + +\defun{traceReply}{traceReply} +\calls{traceReply}{sayMessage} +\calls{traceReply}{sayBrightly} +\calls{traceReply}{qcar} +\calls{traceReply}{isDomainOrPackage} +\calls{traceReply}{addTraceItem} +\calls{traceReply}{isFunctor} +\calls{traceReply}{isgenvar} +\calls{traceReply}{userError} +\calls{traceReply}{seq} +\calls{traceReply}{exit} +\calls{traceReply}{isSubForRedundantMapName} +\calls{traceReply}{rassocSub} +\calls{traceReply}{poundsign} +\calls{traceReply}{sayMSG} +\calls{traceReply}{sayBrightlyLength} +\calls{traceReply}{flowSegmentedMsg} +\calls{traceReply}{concat} +\calls{traceReply}{prefix2String} +\calls{traceReply}{abbreviate} +\usesdollar{traceReply}{domains} +\usesdollar{traceReply}{packages} +\usesdollar{traceReply}{constructors} +\usesdollar{traceReply}{linelength} +\uses{traceReply}{/tracenames} +\begin{chunk}{defun traceReply} +(defun |traceReply| () + (prog (|$domains| |$packages| |$constructors| |d| |functionList| + |displayList|) + (declare (special |$domains| |$packages| |$constructors| /tracenames + $linelength)) + (return + (seq + (progn + (setq |$domains| nil) + (setq |$packages| nil) + (setq |$constructors| nil) + (cond + ((null /tracenames) (|sayMessage| " Nothing is traced now.")) + (t + (|sayBrightly| " ") + (do ((t0 /tracenames (cdr t0)) (x nil)) + ((or (atom t0) (progn (setq x (car t0)) nil)) nil) + (seq + (exit + (cond + ((and (consp x) + (progn (setq |d| (qcar x)) t) (|isDomainOrPackage| |d|)) + (|addTraceItem| |d|)) + ((atom x) + (cond + ((|isFunctor| x) (|addTraceItem| x)) + ((isgenvar x) (|addTraceItem| (EVAL x))) + (t (setq |functionList| (cons x |functionList|))))) + (t (|userError| "bad argument to trace")))))) + (setq |functionList| + (prog (t1) + (setq t1 nil) + (return + (do ((t2 |functionList| (cdr t2)) (x nil)) + ((or (atom t2) (progn (setq x (car t2)) nil)) t1) + (seq + (exit + (cond + ((null (|isSubForRedundantMapName| x)) + (setq t1 + (append t1 + (cons (|rassocSub| x |$mapSubNameAlist|) + (cons " " nil)))))))))))) + (cond + (|functionList| + (cond + ((eql 2 (|#| |functionList|)) + (|sayMSG| (cons '| Function traced: | |functionList|))) + ((<= (+ 22 (|sayBrightlyLength| |functionList|)) $linelength) + (|sayMSG| (cons '| Functions traced: | |functionList|))) + (t + (|sayBrightly| " Functions traced:") + (|sayBrightly| + (|flowSegmentedMsg| |functionList| $linelength 6)))))) + (cond + (|$domains| + (setq |displayList| + (|concat| + (|prefix2String| (CAR |$domains|)) + (prog (t3) + (setq t3 nil) + (return + (do ((t4 (cdr |$domains|) (cdr t4)) (x nil)) + ((or (atom t4) (progn (setq x (car t4)) nil)) t3) + (seq + (exit + (setq t3 + (append t3 (|concat| "," " " (|prefix2String| x))))))))))) + (cond + ((atom |displayList|) + (setq |displayList| (cons |displayList| nil)))) + (|sayBrightly| " Domains traced: ") + (|sayBrightly| (|flowSegmentedMsg| |displayList| $linelength 6)))) + (cond + (|$packages| + (setq |displayList| + (|concat| + (|prefix2String| (CAR |$packages|)) + (prog (t5) + (setq t5 nil) + (return + (do ((t6 (cdr |$packages|) (cdr t6)) (x nil)) + ((or (atom t6) (progn (setq x (car t6)) nil)) t5) + (seq + (exit + (setq t5 + (append t5 (|concat| '|, | (|prefix2String| x))))))))))) + (cond ((atom |displayList|) + (setq |displayList| (cons |displayList| nil)))) + (|sayBrightly| " Packages traced: ") + (|sayBrightly| (|flowSegmentedMsg| |displayList| $linelength 6)))) + (cond + (|$constructors| + (setq |displayList| + (|concat| + (|abbreviate| (CAR |$constructors|)) + (prog (t7) + (setq t7 nil) + (return + (do ((t8 (cdr |$constructors|) (cdr t8)) (x nil)) + ((or (atom t8) (progn (setq x (car t8)) nil)) t7) + (seq + (exit + (setq t7 + (append t7 (|concat| '|, | (|abbreviate| x))))))))))) + (cond ((atom |displayList|) + (setq |displayList| (cons |displayList| nil)))) + (|sayBrightly| " Parameterized constructors traced:") + (|sayBrightly| (|flowSegmentedMsg| |displayList| $linelength 6))) + (t nil))))))))) + +\end{chunk} + +\defun{addTraceItem}{addTraceItem} +\calls{addTraceItem}{constructor?} +\calls{addTraceItem}{isDomain} +\calls{addTraceItem}{devaluate} +\calls{addTraceItem}{isDomainOrPackage} +\usesdollar{addTraceItem}{constructors} +\usesdollar{addTraceItem}{domains} +\usesdollar{addTraceItem}{packages} +\begin{chunk}{defun addTraceItem} +(defun |addTraceItem| (|d|) + (declare (special |$constructors| |$domains| |$packages|)) + (cond + ((|constructor?| |d|) + (setq |$constructors| (cons |d| |$constructors|))) + ((|isDomain| |d|) + (setq |$domains| (cons (|devaluate| |d|) |$domains|))) + ((|isDomainOrPackage| |d|) + (setq |$packages| (cons (|devaluate| |d|) |$packages|))))) + +\end{chunk} + +\defun{?t}{?t} +\calls{?t}{isgenvar} +\calls{?t}{get} +\calls{?t}{sayMSG} +\calls{?t}{bright} +\calls{?t}{rassocSub} +\calls{?t}{qcar} +\calls{?t}{qcdr} +\calls{?t}{isDomainOrPackage} +\calls{?t}{isDomain} +\calls{?t}{reportSpadTrace} +\calls{?t}{take} +\calls{?t}{sayBrightly} +\calls{?t}{devaluate} +\usesdollar{?t}{mapSubNameAlist} +\usesdollar{?t}{InteractiveFrame} +\uses{?t}{/tracenames} +\begin{chunk}{defun ?t} +(defun |?t| () + (let (llm d suffix l) + (declare (special /tracenames |$InteractiveFrame| |$mapSubNameAlist|)) + (if (null /tracenames) + (|sayMSG| (|bright| "nothing is traced")) + (progn + (dolist (x /tracenames) + (cond + ((and (atom x) (null (isgenvar x))) + (progn + (cond + ((setq llm (|get| x '|localModemap| |$InteractiveFrame|)) + (setq x (list (cadar llm))))) + (|sayMSG| + `("Function" ,@(|bright| (|rassocSub| x |$mapSubNameAlist|)) + "traced")))))) + (dolist (x /tracenames) + (cond + ((and (consp x) + (progn (setq d (qcar x)) (setq l (qcdr x)) t) + (|isDomainOrPackage| d)) + (progn + (setq suffix (cond ((|isDomain| d) "domain") (t "package"))) + (|sayBrightly| + `(" Functions traced in " ,suffix |%b| ,(|devaluate| d) |%d| ":")) + (dolist (x (|orderBySlotNumber| l)) + (|reportSpadTrace| '| | (TAKE 4 x))) + (terpri))))))))) + +\end{chunk} +\defun{tracelet}{tracelet} +\calls{tracelet}{gensymp} +\calls{tracelet}{stupidIsSpadFunction} +\calls{tracelet}{bpiname} +\calls{tracelet}{lassoc} +\calls{tracelet}{union} +\calls{tracelet}{setletprintflag} +\calls{tracelet}{isgenvar} +\calls{tracelet}{compileBoot} +\calls{tracelet}{delete} +\usesdollar{tracelet}{traceletflag} +\usesdollar{tracelet}{QuickLet} +\usesdollar{tracelet}{letAssoc} +\usesdollar{tracelet}{traceletFunctions} +\begin{chunk}{defun tracelet} +(defun |tracelet| (fn |vars|) + (prog ($traceletflag |$QuickLet| l) + (declare (special $traceletflag |$QuickLet| |$letAssoc| + |$traceletFunctions|)) + (return + (progn + (cond + ((and (gensymp fn) (|stupidIsSpadFunction| (eval fn))) + (setq fn (eval fn)) + (cond + ((compiled-function-p fn) (setq fn (bpiname fn))) + (t nil)))) + (cond + ((eq fn '|Undef|) nil) + (t + (setq |vars| + (cond + ((eq |vars| '|all|) '|all|) + ((setq l (lassoc fn |$letAssoc|)) (|union| |vars| l)) + (t |vars|))) + (setq |$letAssoc| (cons (cons fn |vars|) |$letAssoc|)) + (cond (|$letAssoc| (setletprintflag t))) + (setq $traceletflag t) + (setq |$QuickLet| nil) + (cond + ((and (null (member fn |$traceletFunctions|)) + (null (isgenvar fn)) + (compiled-function-p (symbol-function fn)) + (null (|stupidIsSpadFunction| fn)) + (null (gensymp fn))) + (progn + (setq |$traceletFunctions| (cons fn |$traceletFunctions|)) + (|compileBoot| fn) + (setq |$traceletFunctions| + (|delete| fn |$traceletFunctions|))))))))))) + +\end{chunk} + +\defun{breaklet}{breaklet} +\calls{breaklet}{gensymp} +\calls{breaklet}{stupidIsSpadFunction} +\calls{breaklet}{bpiname} +\calls{breaklet}{lassoc} +\calls{breaklet}{assoc} +\calls{breaklet}{union} +\calls{breaklet}{setletprintflag} +\calls{breaklet}{compileBoot} +\calls{breaklet}{delete} +\usesdollar{breaklet}{QuickLet} +\usesdollar{breaklet}{letAssoc} +\usesdollar{breaklet}{traceletFunctions} +\begin{chunk}{defun breaklet} +(defun |breaklet| (fn |vars|) + (prog (|$QuickLet| |fnEntry| |pair|) + (declare (special |$QuickLet| |$letAssoc| |$traceletFunctions|)) + (return + (progn + (cond + ((and (gensymp fn) (|stupidIsSpadFunction| (eval fn))) + (setq fn (eval fn)) + (cond + ((compiled-function-p fn) (setq fn (bpiname fn))) + (t nil)))) + (cond + ((eq fn '|Undef|) nil) + (t + (setq |fnEntry| (lassoc fn |$letAssoc|)) + (setq |vars| + (cond + ((setq |pair| (|assoc| 'break |fnEntry|)) + (|union| |vars| (cdr |pair|))) + (t |vars|))) + (setq |$letAssoc| + (cond + ((null |fnEntry|) + (cons (cons fn (list (cons 'break |vars|))) |$letAssoc|)) + (|pair| (rplacd |pair| |vars|) |$letAssoc|))) + (cond (|$letAssoc| (setletprintflag t))) + (setq |$QuickLet| nil) + (cond + ((and (null (member fn |$traceletFunctions|)) + (null (|stupidIsSpadFunction| fn)) + (null (gensymp fn))) + (progn + (setq |$traceletFunctions| (cons fn |$traceletFunctions|)) + (|compileBoot| fn) + (setq |$traceletFunctions| + (|delete| fn |$traceletFunctions|))))))))))) + +\end{chunk} + +\defun{break}{break} +\calls{break}{MONITOR,EVALTRAN} +\calls{break}{enable-backtrace} +\calls{break}{sayBrightly} +\calls{break}{interrupt} +\uses{break}{/breakcondition} +\begin{chunk}{defun break} +(defun |break| (msg) + (prog (condition) + (declare (special /breakcondition)) + (return + (progn + (setq condition (|MONITOR,EVALTRAN| /breakcondition nil)) + (when (eval condition) + (|sayBrightly| msg) + (interrupt)))))) + +\end{chunk} + +\chapter{Exposure groups} + +\section{Functions to manipulate exposure} + +\Defun{setExposeAddGroup}{Expose a group} +Note that \verb|$localExposureData| is a vector of lists. +It consists of [exposed groups,exposed constructors,hidden constructors] + +\calls{setExposeAddGroup}{object2String} +\calls{setExposeAddGroup}{qcar} +\calls{setExposeAddGroup}{setelt} +\calls{setExposeAddGroup}{displayExposedGroups} +\calls{setExposeAddGroup}{sayMSG} +\calls{setExposeAddGroup}{displayExposedConstructors} +\calls{setExposeAddGroup}{displayHiddenConstructors} +\calls{setExposeAddGroup}{clearClams} +\calls{setExposeAddGroup}{getalist} +\calls{setExposeAddGroup}{sayKeyedMsg} +\calls{setExposeAddGroup}{member} +\calls{setExposeAddGroup}{msort} +\calls{setExposeAddGroup}{centerAndHighlight} +\calls{setExposeAddGroup}{specialChar} +\calls{setExposeAddGroup}{namestring} +\calls{setExposeAddGroup}{pathname} +\calls{setExposeAddGroup}{sayAsManyPerLineAsPossible} +\usesdollar{setExposeAddGroup}{globalExposureGroupAlist} +\usesdollar{setExposeAddGroup}{localExposureData} +\usesdollar{setExposeAddGroup}{interpreterFrameName} +\usesdollar{setExposeAddGroup}{linelength} +\begin{chunk}{defun setExposeAddGroup} +(defun |setExposeAddGroup| (arg) + "Expose a group" + (declare (special |$globalExposureGroupAlist| |$localExposureData| + |$interpreterFrameName| $linelength)) + (if (null arg) + (progn + (|centerAndHighlight| + '|The group Option| $linelength (|specialChar| '|hbar|)) + (|displayExposedGroups|) + (|sayMSG| " ") + (|sayAsManyPerLineAsPossible| + (mapcar #'(lambda (x) (|object2String| (first x))) + |$globalExposureGroupAlist|))) + (dolist (x arg) + (when (consp x) (setq x (qcar x))) + (cond + ((eq x '|all|) + (setelt |$localExposureData| 0 + (mapcar #'first |$globalExposureGroupAlist|)) + (setelt |$localExposureData| 1 nil) + (setelt |$localExposureData| 2 nil) + (|displayExposedGroups|) + (|sayMSG| " ") + (|displayExposedConstructors|) + (|sayMSG| " ") + (|displayHiddenConstructors|) + (|clearClams|)) + ((null (getalist |$globalExposureGroupAlist| x)) + (|sayKeyedMsg| "%1 is not a known exposure group name." (cons x nil))) + ((|member| x (elt |$localExposureData| 0)) + (|sayKeyedMsg| "%1 is already an exposure group for frame %2" + (list x |$interpreterFrameName|))) + (t + (setelt |$localExposureData| 0 + (msort (cons x (elt |$localExposureData| 0)))) + (|sayKeyedMsg| "%1 is now an exposure group for frame %2" + (list x |$interpreterFrameName|)) + (|clearClams|)))))) + +\end{chunk} + +\Defun{setExpose}{The top level set expose command handler} +\calls{setExpose}{displayExposedGroups} +\calls{setExpose}{sayMSG} +\calls{setExpose}{displayExposedConstructors} +\calls{setExpose}{displayHiddenConstructors} +\calls{setExpose}{sayKeyedMsg} +\calls{setExpose}{namestring} +\calls{setExpose}{pathname} +\calls{setExpose}{qcar} +\calls{setExpose}{qcdr} +\calls{setExpose}{selectOptionLC} +\calls{setExpose}{setExposeAdd} +\calls{setExpose}{setExposeDrop} +\calls{setExpose}{setExpose} +\begin{chunk}{defun setExpose} +(defun |setExpose| (arg) + "The top level set expose command handler" + (let (fnargs fn) + (cond + ((eq arg '|%initialize%|)) + ((eq arg '|%display%|) "...") + ((or (null arg) (eq arg '|%describe%|) (eq (car arg) '?)) + (|displayExposedGroups|) + (|sayMSG| " ") + (|displayExposedConstructors|) + (|sayMSG| " ") + (|displayHiddenConstructors|) + (|sayMSG| " ")) + ((and (consp arg) + (progn (setq fn (qcar arg)) (setq fnargs (qcdr arg)) t) + (setq fn (|selectOptionLC| fn '(|add| |drop|) nil))) + (cond + ((eq fn '|add|) (|setExposeAdd| fnargs)) + ((eq fn '|drop|) (|setExposeDrop| fnargs)) + (t nil))) + (t (|setExpose| nil))))) + +\end{chunk} + +\Defun{setExposeAdd}{The top level set expose add command handler} +\calls{setExposeAdd}{centerAndHighlight} +\calls{setExposeAdd}{specialChar} +\calls{setExposeAdd}{displayExposedGroups} +\calls{setExposeAdd}{sayMSG} +\calls{setExposeAdd}{displayExposedConstructors} +\calls{setExposeAdd}{sayKeyedMsg} +\calls{setExposeAdd}{qcar} +\calls{setExposeAdd}{qcdr} +\calls{setExposeAdd}{selectOptionLC} +\calls{setExposeAdd}{setExposeAddGroup} +\calls{setExposeAdd}{setExposeAddConstr} +\calls{setExposeAdd}{setExposeAdd} +\usesdollar{setExposeAdd}{linelength} +\begin{chunk}{defun setExposeAdd} +(defun |setExposeAdd| (arg) + "The top level set expose add command handler" + (declare (special $linelength)) + (let (fnargs fn) + (cond + ((null arg) + (|centerAndHighlight| + '|The add Option| $linelength (|specialChar| '|hbar|)) + (|displayExposedGroups|) + (|sayMSG| " ") + (|displayExposedConstructors|) + (|sayMSG| " ") + (|sayKeyedMsg| + (format nil + "When )set expose add is followed by no arguments, the information ~ + you now see is displayed. ~ + The arguments group and constructor are used to specify ~ + exposure groups or an explicit constructor to be added to the local ~ + frame exposure data. Issue ~ + %ceon )set expose add group %ceoff or ~ + %ceon )set expose add constructor %ceoff ~ + for more information.") + nil)) + ((and (consp arg) + (progn (setq fn (qcar arg)) (setq fnargs (qcdr arg)) t) + (setq fn (|selectOptionLC| fn '(|group| |constructor|) nil))) + (cond + ((eq fn '|group|) (|setExposeAddGroup| fnargs)) + ((eq fn '|constructor|) (|setExposeAddConstr| fnargs)) + (t nil))) + (t (|setExposeAdd| nil))))) + +\end{chunk} + +\Defun{setExposeAddConstr}{The top level set expose add constructor handler} +\calls{setExposeAddConstr}{unabbrev} +\calls{setExposeAddConstr}{qcar} +\calls{setExposeAddConstr}{getdatabase} +\calls{setExposeAddConstr}{sayKeyedMsg} +\calls{setExposeAddConstr}{member} +\calls{setExposeAddConstr}{setelt} +\calls{setExposeAddConstr}{delete} +\calls{setExposeAddConstr}{msort} +\calls{setExposeAddConstr}{clearClams} +\calls{setExposeAddConstr}{centerAndHighlight} +\calls{setExposeAddConstr}{specialChar} +\calls{setExposeAddConstr}{displayExposedConstructors} +\usesdollar{setExposeAddConstr}{linelength} +\usesdollar{setExposeAddConstr}{localExposureData} +\usesdollar{setExposeAddConstr}{interpreterFrameName} +\begin{chunk}{defun setExposeAddConstr} +(defun |setExposeAddConstr| (arg) + "The top level set expose add constructor handler" + (declare (special $linelength |$localExposureData| |$interpreterFrameName|)) + (if (null arg) + (progn + (|centerAndHighlight| + '|The constructor Option| $linelength (|specialChar| '|hbar|)) + (|displayExposedConstructors|)) + (dolist (x arg) + (setq x (|unabbrev| x)) + (when (consp x) (setq x (qcar x))) + (cond + ((null (getdatabase x 'constructorkind)) + (|sayKeyedMsg| + (format nil "%1 is not a known constructor. ~ + You can make the constructor known to the system by loading it.") + (list x))) + ((|member| x (elt |$localExposureData| 1)) + (|sayKeyedMsg| "%1 is already explicitly exposed in frame %2" + (list x |$interpreterFrameName| ))) + (t + (when (|member| x (elt |$localExposureData| 2)) + (setelt |$localExposureData| 2 + (|delete| x (elt |$localExposureData| 2)))) + (setelt |$localExposureData| 1 + (msort (cons x (elt |$localExposureData| 1)))) + (|clearClams|) + (|sayKeyedMsg| "%1 is now explicitly exposed in frame %2" + (list x |$interpreterFrameName| ))))))) + +\end{chunk} + +\Defun{setExposeDrop}{The top level set expose drop handler} +\calls{setExposeDrop}{centerAndHighlight} +\calls{setExposeDrop}{specialChar} +\calls{setExposeDrop}{displayHiddenConstructors} +\calls{setExposeDrop}{sayMSG} +\calls{setExposeDrop}{sayKeyedMsg} +\calls{setExposeDrop}{qcar} +\calls{setExposeDrop}{qcdr} +\calls{setExposeDrop}{selectOptionLC} +\calls{setExposeDrop}{setExposeDropGroup} +\calls{setExposeDrop}{setExposeDropConstr} +\calls{setExposeDrop}{setExposeDrop} +\usesdollar{setExposeDrop}{linelength} +\begin{chunk}{defun setExposeDrop} +(defun |setExposeDrop| (arg) + "The top level set expose drop handler" + (declare (special $linelength)) + (let (fnargs fn) + (cond + ((null arg) + (|centerAndHighlight| + '|The drop Option| $linelength (|specialChar| '|hbar|)) + (|displayHiddenConstructors|) + (|sayMSG| " ") + (|sayKeyedMsg| + (format nil "When )set expose drop is followed by no arguments, the ~ + information you now see is displayed. The arguments group and ~ + constructor are used to specify exposure groups or an explicit ~ + constructor to be dropped from the local frame exposure data. Issue ~ + %ceon )set expose drop group %ceoff or %ceon )set expose drop ~ + constructor %ceoff for more information.") + nil)) + ((and (consp arg) + (progn (setq fn (qcar arg)) (setq fnargs (qcdr arg)) t) + (setq fn (|selectOptionLC| fn '(|group| |constructor|) nil))) + (cond + ((eq fn '|group|) (|setExposeDropGroup| fnargs)) + ((eq fn '|constructor|) (|setExposeDropConstr| fnargs)) + (t nil))) + (t (|setExposeDrop| nil))))) + +\end{chunk} + +\Defun{setExposeDropGroup}{The top level set expose drop group handler} +\calls{setExposeDropGroup}{qcar} +\calls{setExposeDropGroup}{setelt} +\calls{setExposeDropGroup}{displayExposedGroups} +\calls{setExposeDropGroup}{sayMSG} +\calls{setExposeDropGroup}{displayExposedConstructors} +\calls{setExposeDropGroup}{displayHiddenConstructors} +\calls{setExposeDropGroup}{clearClams} +\calls{setExposeDropGroup}{member} +\calls{setExposeDropGroup}{delete} +\calls{setExposeDropGroup}{sayKeyedMsg} +\calls{setExposeDropGroup}{getalist} +\calls{setExposeDropGroup}{centerAndHighlight} +\calls{setExposeDropGroup}{specialChar} +\usesdollar{setExposeDropGroup}{linelength} +\usesdollar{setExposeDropGroup}{localExposureData} +\usesdollar{setExposeDropGroup}{interpreterFrameName} +\usesdollar{setExposeDropGroup}{globalExposureGroupAlist} +\begin{chunk}{defun setExposeDropGroup} +(defun |setExposeDropGroup| (arg) + "The top level set expose drop group handler" + (declare (special $linelength |$localExposureData| |$interpreterFrameName| + |$globalExposureGroupAlist|)) + (if (null arg) + (progn + (|centerAndHighlight| + '|The group Option| $linelength (|specialChar| '|hbar|)) + (|sayKeyedMsg| + (format nil "When followed by one or more exposure group names, this ~ + option allows you to remove those groups from the local ~ + frame exposure data.") + nil) + (|sayMSG| " ") + (|displayExposedGroups|)) + (dolist (x arg) + (when (consp x) (setq x (qcar x))) + (cond + ((eq x '|all|) + (setelt |$localExposureData| 0 nil) + (setelt |$localExposureData| 1 nil) + (setelt |$localExposureData| 2 nil) + (|displayExposedGroups|) + (|sayMSG| " ") + (|displayExposedConstructors|) + (|sayMSG| " ") + (|displayHiddenConstructors|) + (|clearClams|)) + ((|member| x (elt |$localExposureData| 0)) + (setelt |$localExposureData| 0 + (|delete| x (elt |$localExposureData| 0))) + (|clearClams|) + (|sayKeyedMsg| "%1 is no longer an exposure group for frame %2" + (list x |$interpreterFrameName| ))) + ((getalist |$globalExposureGroupAlist| x) + (|sayKeyedMsg| "%1 is already an exposure group for frame %2" + (list x |$interpreterFrameName| ))) + (t (|sayKeyedMsg| "%1 is not a known exposure group name." (list x ))))))) + +\end{chunk} + +\Defun{setExposeDropConstr} +{The top level set expose drop constructor handler} +\calls{setExposeDropConstr}{unabbrev} \calls{setExposeDropConstr}{qcar} \calls{setExposeDropConstr}{getdatabase} \calls{setExposeDropConstr}{sayKeyedMsg} @@ -2002,7 +3866,10 @@ It consists of [exposed groups,exposed constructors,hidden constructors] (progn (|centerAndHighlight| '|The constructor Option| $linelength (|specialChar| '|hbar|)) - (|sayKeyedMsg| 's2iz0049n nil) + (|sayKeyedMsg| + (format nil "When followed by one or more constructor names, this option ~ + allows you to explicitly hide constructors in this frame.") + nil) (|sayMSG| " ") (|displayExposedConstructors|) (|sayMSG| " ") @@ -2012,9 +3879,13 @@ It consists of [exposed groups,exposed constructors,hidden constructors] (when (consp x) (setq x (qcar x))) (cond ((null (getdatabase x 'constructorkind)) - (|sayKeyedMsg| 's2iz0049j (list x))) + (|sayKeyedMsg| + (format nil "%1 is not a known constructor. ~ + You can make the constructor known to the system by loading it.") + (list x))) ((|member| x (elt |$localExposureData| 2)) - (|sayKeyedMsg| 's2iz0049o (list x |$interpreterFrameName|))) + (|sayKeyedMsg| "%1 is already explicitly hidden in frame %2" + (list x |$interpreterFrameName|))) (t (when (|member| x (elt |$localExposureData| 1)) (setelt |$localExposureData| 1 @@ -2022,7 +3893,8 @@ It consists of [exposed groups,exposed constructors,hidden constructors] (setelt |$localExposureData| 2 (msort (cons x (elt |$localExposureData| 2)))) (|clearClams|) - (|sayKeyedMsg| 's2iz0049q (list x |$interpreterFrameName|))))))) + (|sayKeyedMsg| "%1 is now explicitly hidden in frame %2" + (list x |$interpreterFrameName|))))))) \end{chunk} @@ -2035,7 +3907,10 @@ It consists of [exposed groups,exposed constructors,hidden constructors] (defun |displayExposedGroups| () "Display exposed groups" (declare (special |$interpreterFrameName| |$localExposureData|)) - (|sayKeyedMsg| 's2iz0049a (list |$interpreterFrameName|)) + (|sayKeyedMsg| + (format nil "The following groups are explicitly exposed in the current ~ + frame (called %1 ):") + (list |$interpreterFrameName|)) (if (null (elt |$localExposureData| 0)) (|centerAndHighlight| "there are no exposed groups") (dolist (c (elt |$localExposureData| 0)) @@ -2051,7 +3926,9 @@ It consists of [exposed groups,exposed constructors,hidden constructors] (defun |displayExposedConstructors| () "Display exposed constructors" (declare (special |$localExposureData|)) - (|sayKeyedMsg| 's2iz0049b nil) + (|sayKeyedMsg| + "The following constructors are explicitly exposed in the current frame:" + nil) (if (null (elt |$localExposureData| 1)) (|centerAndHighlight| "there are no explicitly exposed constructors") (dolist (c (elt |$localExposureData| 1)) @@ -2067,7 +3944,9 @@ It consists of [exposed groups,exposed constructors,hidden constructors] (defun |displayHiddenConstructors| () "Display hidden constructors" (declare (special |$localExposureData|)) - (|sayKeyedMsg| 's2iz0049c nil) + (|sayKeyedMsg| + "The following constructors are explicitly hidden in the current frame:" + nil) (if (null (elt |$localExposureData| 2)) (|centerAndHighlight| "there are no explicitly hidden constructors") (dolist (c (elt |$localExposureData| 2)) @@ -8536,9 +10415,9 @@ and the empty string. <12 (|putHist| ((((% (|value| (|PositiveInteger|) . 1)))))) 12> (|printTypeAndTime| 1 (|PositiveInteger|)) 13> (|printTypeAndTimeNormal| 1 (|PositiveInteger|)) - 14> (|sayKeyedMsg| S2GL0012 ((|PositiveInteger|))) - 15> (|sayKeyedMsgLocal| S2GL0012 ((|PositiveInteger|))) - 17> (|fetchKeyedMsg| S2GL0012 NIL) + 14> (|sayKeyedMsg| "%rjon Type: %1p %rjoff" ((|PositiveInteger|))) + 15> (|sayKeyedMsgLocal| "%rjon Type: %1p %rjoff" ((|PositiveInteger|))) + 17> (|fetchKeyedMsg| "%rjon Type: %1p %rjoff" NIL) <17 (|fetchKeyedMsg| " %rjon Type: %1p %rjoff" T) 16> (|segmentKeyedMsg| " %rjon Type: %1p %rjoff") <16 (|segmentKeyedMsg| ("%rjon" "Type:" "%1p" "%rjoff")) @@ -9032,11 +10911,14 @@ do not want to reset all of the user variables. *build-version*)) (when (> $linelength 60) (setq bar (|fillerSpaces| $linelength (|specialChar| '|hbar|))) - (|sayKeyedMsg| 'S2GL0001 (list *build-version* *yearweek*)) + (|sayKeyedMsg| + (format nil "%ceon AXIOM Computer Algebra System %l Version: %1 %l ~ + Timestamp: %2 %ceoff") + (list *build-version* *yearweek*)) (|sayMSG| bar) - (|sayKeyedMsg| 'S2GL0018C nil) - (|sayKeyedMsg| 'S2GL0018D nil) - (|sayKeyedMsg| 'S2GL0003B (list |$opSysName|)) + (say " Issue )copyright to view copyright notices.") + (say " Issue )summary for a summary of useful system commands.") + (say " Issue )quit to leave AXIOM and return to shell.") (say " Visit http://axiom-developer.org for more information") (|sayMSG| bar) (setq |$msgAlist| nil) @@ -9336,15 +11218,6 @@ variable \verb|$systemCommandFunction| which has the default function \verb|InterpExecuteSpadSystemCommand|. Thus, when a system command is entered this function is called. -The \verb|$promptMsg| variable is set to the constant S2CTP023. This -constant points to a message in src/doc/msgs/s2-us.msgs. This message -does nothing but print the argument value. -\defdollar{promptMsg} -\begin{chunk}{initvars} -(defvar |$promptMsg| 'S2CTP023) - -\end{chunk} - \defun{cmpnote}{GCL cmpnote function} GCL keeps noting the fact that the compiler is performing tail-recursion. Bill Schelter added this as a debugging tool for Axiom and it was never @@ -9372,7 +11245,6 @@ with this hack and will try to convince the GCL crowd to fix this. \calls{SpadInterpretStream}{mkprompt} \calls{SpadInterpretStream}{intloopReadConsole} \calls{SpadInterpretStream}{intloopInclude} -\usesdollar{SpadInterpretStream}{promptMsg} \usesdollar{SpadInterpretStream}{systemCommandFunction} \usesdollar{SpadInterpretStream}{ncMsgList} \usesdollar{SpadInterpretStream}{erMsgToss} @@ -9386,11 +11258,11 @@ with this hack and will try to convince the GCL crowd to fix this. \label{SpadInterpretStream} \begin{chunk}{defun SpadInterpretStream} (defun |SpadInterpretStream| (str source interactive?) - (let (|$promptMsg| |$systemCommandFunction| + (let (|$systemCommandFunction| |$ncMsgList| |$erMsgToss| |$lastPos| |$inclAssertions| |$okToExecuteMachineCode| |$newcompErrorCount| |$libQuiet|) - (declare (special |$promptMsg| + (declare (special |$systemCommandFunction| |$ncMsgList| |$erMsgToss| |$lastPos| |$inclAssertions| |$okToExecuteMachineCode| |$newcompErrorCount| |$libQuiet| |$nopos|)) @@ -9402,7 +11274,6 @@ with this hack and will try to convince the GCL crowd to fix this. (setq |$erMsgToss| nil) (setq |$ncMsgList| nil) (setq |$systemCommandFunction| #'|InterpExecuteSpadSystemCommand|) - (setq |$promptMsg| 's2ctp023) (if interactive? (progn (princ (mkprompt)) @@ -10496,7 +12367,9 @@ modeset otherwise. It creates the attributed tree. ((and argVal (setq val (|getValue| node))) (|interpret2| val newRootMode posnForm)) (t - (|keyedSystemError| 'S2IS0053 (list x)))))))) + (|keyedSystemError| + "Interpreter code generation failed for expression %1s" + (list x)))))))) \end{chunk} @@ -10642,7 +12515,7 @@ It is controlled with the {\tt )se me any} command. (defun |printStatisticsSummary| () (declare (special |$collectOutput|)) (unless |$collectOutput| - (|sayKeyedMsg| 'S2GL0017 (list (|statisticsSummary|))))) + (|sayKeyedMsg| "%rjon Summary: %1 %rjoff" (list (|statisticsSummary|))))) \end{chunk} @@ -10656,7 +12529,7 @@ It is controlled with the {\tt )se me any} command. (declare (special |$interpreterTimedClasses| |$collectOutput| |$interpreterTimedNames|)) (unless |$collectOutput| - (|sayKeyedMsg| 'S2GL0016 + (|sayKeyedMsg| "%rjon Storage: %1 %rjoff" (list (|makeLongSpaceString| |$interpreterTimedNames| @@ -10718,14 +12591,17 @@ It is controlled with the {\tt )se me any} command. (cond ((and |$printTimeIfTrue| |$printTypeIfTrue|) (if |$collectOutput| - (push (|msgText| 'S2GL0012 (list m)) |$outputLines|) - (|sayKeyedMsg| 'S2GL0014 (list m timeString )))) + (push (|msgText| "%rjon Type: %1p %rjoff" (list m)) |$outputLines|) + (|sayKeyedMsg| "%rjon Type: %1p %l Time: %2 %rjoff" + (list m timeString )))) (|$printTimeIfTrue| - (unless |$collectOutput| (|sayKeyedMsg| 'S2GL0013 (list timeString)))) + (unless |$collectOutput| + (|sayKeyedMsg| "%rjon Time: %1 %rjoff" (list timeString)))) (|$printTypeIfTrue| (if |$collectOutput| - (push (|justifyMyType| (|msgText| 'S2GL0012 (list m))) |$outputLines|) - (|sayKeyedMsg| 'S2GL0012 (list m))))))) + (push (|justifyMyType| + (|msgText| "%rjon Type: %1p %rjoff" (list m))) |$outputLines|) + (|sayKeyedMsg| "%rjon Type: %1p %rjoff" (list m))))))) \end{chunk} @@ -11022,7 +12898,7 @@ carrier[lines,messages,..]-> carrier[lines,messages,..] ((eql nerr 0) 'ok) (t (|processMsgList| msgs lines) - (|sayKeyedMsg| 'S2CTP010 (list nerr)) + (|sayKeyedMsg| "%1 error(s) parsing " (list nerr)) 'ok)))))) \end{chunk} @@ -11840,7 +13716,11 @@ and constructs a call to \bfref{Delay}. \calls{inclmsgPrematureEOF}{theorigin} \begin{chunk}{defun inclmsgPrematureEOF 0} (defun |inclmsgPrematureEOF| (ufo) - (list 'S2CI0002 (list (|theorigin| ufo)))) + (list + (format nil + "File %1f ended where at least one )endif was still needed. + An appropriate number of )endif lines has been assumed.") + (list (|theorigin| ufo)))) \end{chunk} @@ -11899,7 +13779,7 @@ and constructs a call to \bfref{Delay}. \calls{inclmsgSay}{theid} \begin{chunk}{defun inclmsgSay} (defun |inclmsgSay| (str) - (list 'S2CI0001 (list (|theid| str)))) + (list "%1f" (list (|theid| str)))) \end{chunk} @@ -11922,7 +13802,7 @@ and constructs a call to \bfref{Delay}. \calls{inclmsgNoSuchFile}{thefname} \begin{chunk}{defun inclmsgNoSuchFile} (defun |inclmsgNoSuchFile| (fn) - (list 'S2CI0010 (list (|thefname| fn)))) + (list "The )include file %b %1f %d does not exist." (list (|thefname| fn)))) \end{chunk} @@ -11953,7 +13833,8 @@ and constructs a call to \bfref{Delay}. \calls{inclmsgCannotRead}{thefname} \begin{chunk}{defun inclmsgCannotRead} (defun |inclmsgCannotRead| (fn) - (list 'S2CI0011 (list (|thefname| fn)))) + (list "The )include file %1f exists, but cannot be read." + (list (|thefname| fn)))) \end{chunk} @@ -11973,7 +13854,7 @@ and constructs a call to \bfref{Delay}. ; flist := [porigin n for n in reverse ufos] ; f1 := porigin fn ; cycle := [:[:[n,'"==>"] for n in flist], f1] -; ['S2CI0004, [%id cycle, %id f1] ] +; ['SCI0004, [%id cycle, %id f1] ] \end{verbatim} \calls{inclmsgFileCycle}{porigin} @@ -12004,7 +13885,11 @@ and constructs a call to \bfref{Delay}. (setq Var9 (cdr Var9)))) nil flist nil) (cons f1 nil))) - (list 'S2CI0004 (list (|theid| cycle) (|theid| f1))))) + (list + (format nil + "There is a cycle in the )include files: %i %l %1f %u %l. ~ + The inner occurrence of %2f has not been included.") + (list (|theid| cycle) (|theid| f1))))) \end{chunk} @@ -12021,7 +13906,13 @@ and constructs a call to \bfref{Delay}. \calls{inclmsgConActive}{theid} \begin{chunk}{defun inclmsgConActive} (defun |inclmsgConActive| (n) - (list 'S2CI0006 (list (|theid| n)))) + (list + (format nil + "%1f other )console commands are currently active. ~ + While this new )console command is reading input the others ~ + will have to wait. ! + Remember, each )console command will need a separate )fin.") + (list (|theid| n)))) \end{chunk} @@ -12038,7 +13929,11 @@ and constructs a call to \bfref{Delay}. \calls{inclmsgConStill}{theid} \begin{chunk}{defun inclmsgConStill} (defun |inclmsgConStill| (n) - (list 'S2CI0007 (list (|theid| n)))) + (list + (format nil + "The current )console command has finished reading. ~ + %1f are still active. Remember, each will need a separate )fin.") + (list (|theid| n)))) \end{chunk} @@ -12054,7 +13949,7 @@ and constructs a call to \bfref{Delay}. \defun{inclmsgConsole}{inclmsgConsole} \begin{chunk}{defun inclmsgConsole 0} (defun |inclmsgConsole| () - (list 'S2CI0005 nil)) + (list "Including source lines from console. Type )fin when done." nil)) \end{chunk} @@ -12071,7 +13966,11 @@ and constructs a call to \bfref{Delay}. \defun{inclmsgFinSkipped}{inclmsgFinSkipped} \begin{chunk}{defun inclmsgFinSkipped 0} (defun |inclmsgFinSkipped| () - (list 'S2CI0008 nil)) + (list + (format nil + "A )fin command was skipped ~ + (along with everything else) in a false branch of an )if...)endif.") + nil)) \end{chunk} @@ -12089,7 +13988,12 @@ and constructs a call to \bfref{Delay}. \calls{inclmsgPrematureFin}{theorigin} \begin{chunk}{defun inclmsgPrematureFin} (defun |inclmsgPrematureFin| (ufo) - (list 'S2CI0003 (list (|theorigin| ufo)))) + (list + (format nil + "A )fin command has been given in %1f where at least one )endif ~ + was still needed. ~ + An appropriate number of )endif lines have been assumed.") + (list (|theorigin| ufo)))) \end{chunk} @@ -12136,9 +14040,11 @@ and constructs a call to \bfref{Delay}. \begin{chunk}{defun inclmsgIfSyntax} (defun |inclmsgIfSyntax| (ufo found context) (setq found (concat ")" found)) - (list 'S2CI0009 (list (|theid| found) - (|theid| context) - (|theorigin| ufo)))) + (list + (format nil + "Incorrect )if...)endif syntax. A %b %1f %d was found %2f. ~ + The processing of the source from %3f has been abandoned.") + (list (|theid| found) (|theid| context) (|theorigin| ufo)))) \end{chunk} @@ -12154,7 +14060,7 @@ and constructs a call to \bfref{Delay}. \defun{inclmsgIfBug}{inclmsgIfBug} \begin{chunk}{defun inclmsgIfBug 0} (defun |inclmsgIfBug| () - (list 'S2CB0002 nil)) + (list "Unexpected state in )if...)endif." nil)) \end{chunk} @@ -12170,7 +14076,7 @@ and constructs a call to \bfref{Delay}. \defun{inclmsgCmdBug}{inclmsgCmdBug} \begin{chunk}{defun inclmsgCmdBug 0} (defun |inclmsgCmdBug| () - (list 'S2CB0003 nil)) + (list "Unexpected command in source inclusion." nil)) \end{chunk} @@ -13390,7 +15296,8 @@ NOTE: do not replace ``lyne'' with ``line'' (cond ((not (< |$n| |$sz|)) (|ncSoftError| - (cons |$linepos| (+ (|lnExtraBlanks| |$linepos|) |$n|)) 'S2CN0001 nil) "") + (cons |$linepos| (+ (|lnExtraBlanks| |$linepos|) |$n|)) + "Quote added at end of line." nil) "") (t (setq n |$n|) (setq strsym (or (strpos "\"" |$ln| |$n| nil) |$sz|)) @@ -13400,7 +15307,8 @@ NOTE: do not replace ``lyne'' with ``line'' ((equal mn |$sz|) (setq |$n| |$sz|) (|ncSoftError| - (cons |$linepos| (+ (|lnExtraBlanks| |$linepos|) |$n|)) 'S2CN0001 nil) + (cons |$linepos| (+ (|lnExtraBlanks| |$linepos|) |$n|)) + "Quote added at end of line." nil) (substring |$ln| n nil)) ((equal mn strsym) (setq |$n| (+ mn 1)) @@ -13531,7 +15439,8 @@ NOTE: do not replace ``lyne'' with ``line'' ((or (null a) (not (< a r))) (|ncSoftError| (cons |$linepos| (+ (- (+ (|lnExtraBlanks| |$linepos|) |$n|) ns) i)) - 'S2CN0002 (list (elt w i))))))) + "The character %1 is greater than the radix." + (list (elt w i))))))) (setq i (+ i 1)))) (- ns 1) 0))) @@ -13564,7 +15473,8 @@ NOTE: do not replace ``lyne'' with ``line'' (setq |$n| (+ |$n| 1)) (|ncSoftError| (cons |$linepos| (+ (|lnExtraBlanks| |$linepos|) |$n|)) - 'S2CN0003 (list (elt |$ln| n))) + "The character %1 is not an AXIOM character." + (list (elt |$ln| n))) (|lferror| (elt |$ln| n)))) \end{chunk} @@ -13784,15 +15694,16 @@ This function is used to build the scanKeyTable (setq found (catch 'trappoint (|npItem|))) (cond ((eq found 'trapped) - (|ncSoftError| (|tokPosn| |$stok|) 's2cy0006 nil) + (|ncSoftError| (|tokPosn| |$stok|) "syntax error at top level" nil) (|pfWrong| (|pfDocument| "top level syntax error") (|pfListOf| nil))) ((null (null |$inputStream|)) - (|ncSoftError| (|tokPosn| |$stok|) 's2cy0002 nil) + (|ncSoftError| (|tokPosn| |$stok|) "Improper syntax." nil) (|pfWrong| (|pfDocument| (list "input stream not exhausted")) (|pfListOf| nil))) ((null |$stack|) - (|ncSoftError| (|tokPosn| |$stok|) 's2cy0009 nil) + (|ncSoftError| (|tokPosn| |$stok|) + "System error while parsing, stack is empty." nil) (|pfWrong| (|pfDocument| (list "stack empty")) (|pfListOf| nil))) (t (car |$stack|))))) @@ -14160,7 +16071,7 @@ and the current token (\$ttok) \begin{chunk}{defun npMissing} (defun |npMissing| (s) (declare (special |$stok|)) - (|ncSoftError| (|tokPosn| |$stok|) 'S2CY0007 (list (pname s))) + (|ncSoftError| (|tokPosn| |$stok|) "Possibly missing a %1" (list (pname s))) (throw 'trappoint 'trapped)) \end{chunk} @@ -15665,10 +17576,10 @@ fn must transform the head of the stack (defun |syIgnoredFromTo| (pos1 pos2) (cond ((equal (|pfGlobalLinePosn| pos1) (|pfGlobalLinePosn| pos2)) - (|ncSoftError| (|FromTo| pos1 pos2) 'S2CY0005 nil)) + (|ncSoftError| (|FromTo| pos1 pos2) "Ignored." nil)) (t - (|ncSoftError| (|From| pos1) 'S2CY0003 nil) - (|ncSoftError| (|To| pos2) 'S2CY0004 nil)))) + (|ncSoftError| (|From| pos1) "Ignored from here" nil) + (|ncSoftError| (|To| pos2) "to here." nil)))) \end{chunk} @@ -15676,7 +17587,7 @@ fn must transform the head of the stack \calls{syGeneralErrorHere}{sySpecificErrorHere} \begin{chunk}{defun syGeneralErrorHere} (defun |syGeneralErrorHere| () - (|sySpecificErrorHere| 'S2CY0002 nil)) + (|sySpecificErrorHere| "Improper syntax." nil)) \end{chunk} @@ -16421,7 +18332,7 @@ This was rewritten by NAG to remove flet. \begin{chunk}{defun npTrap} (defun |npTrap| () (declare (special |$stok|)) - (|ncSoftError| (|tokPosn| |$stok|) 'S2CY0002 nil) + (|ncSoftError| (|tokPosn| |$stok|) "Improper syntax." nil) (throw 'trappoint 'trapped)) \end{chunk} @@ -16441,7 +18352,7 @@ This was rewritten by NAG to remove flet. (|syGeneralErrorHere|) (throw 'trappoint 'trapped)) (t - (|ncSoftError| (|tokPosn| a) 'S2CY0002 nil) + (|ncSoftError| (|tokPosn| a) "Improper syntax." nil) (throw 'trappoint 'trapped))))) \end{chunk} @@ -16539,7 +18450,7 @@ This was rewritten by NAG to remove flet. \calls{npMissingMate}{npMissing} \begin{chunk}{defun npMissingMate} (defun |npMissingMate| (close open) - (|ncSoftError| (|tokPosn| open) 'S2CY0008 nil) + (|ncSoftError| (|tokPosn| open) "Missing mate." nil) (|npMissing| close)) \end{chunk} @@ -16960,7 +18871,8 @@ carrier[ptree,...] -> carrier[ptree, ptreePremacro,...] (cond ((not (eql (length args) (length params))) (setq pos (|pfSourcePosition| opf)) - (|ncHardError| pos 'S2CM0003 (list (length params) (length args)))) + (|ncHardError| pos "Expected %1 arguments, but received %2." + (list (length params) (length args)))) (t ((lambda (parms p arrgs a) ; for p in params for a in args repeat (loop @@ -16974,7 +18886,8 @@ carrier[ptree,...] -> carrier[ptree, ptreePremacro,...] (cond ((null (|pfId?| p)) (setq pos (|pfSourcePosition| opf)) - (|ncHardError| pos 'S2CM0004 (list (|%pform| p)))) + (|ncHardError| pos "Macro parameter %1f is not an id." + (list (|%pform| p)))) (t (|mac0Define| (|pfIdSymbol| p) '|mparam| a))))) (setq parms (cdr parms)) @@ -17019,7 +18932,8 @@ carrier[ptree,...] -> carrier[ptree, ptreePremacro,...] (setq tmp1 (mapcar #'|mac0InfiniteExpansion,name| blist)) (setq fname (car tmp1)) ;[fname, :rnames] := [name b for b in blist] (setq rnames (cdr tmp1)) - (|ncSoftError| posn 'S2CM0005 + (|ncSoftError| posn + "noRep Cycle in macro expansion: %l %1y %2 %l. Left as: %3f" (list (dolist (n (reverse rnames) (nreverse result)) (setq result (append (reverse (list n "==>")) result))) @@ -17191,7 +19105,9 @@ the original Macro pform. (setq rhs (|pfMacroRhs| pf)) (cond ((null (|pfId?| lhs)) - (|ncSoftError| (|pfSourcePosition| lhs) 'S2CM0001 (list (|%pform| lhs))) + (|ncSoftError| (|pfSourcePosition| lhs) + "%1 is improper for macro definition. Ignored." + (list (|%pform| lhs))) pf) (t (setq sy (|pfIdSymbol| lhs)) @@ -19591,7 +21507,8 @@ output is an old-parser-style s-expression. ((|pfWhile?| pf) (list 'while (|pf2Sex1| (|pfWhileCond| pf)))) ((|pfSuchthat?| pf) (if (eq |$insideRule| '|left|) - (|keyedSystemError| "S2GE0017" (list "pf2Sex1: pfSuchThat")) + (|keyedSystemError| "Unexpected error in call to system function %1" + (list "pf2Sex1: pfSuchThat")) (list '|\|| (|pf2Sex1| (|pfSuchthatCond| pf))))) ((|pfDo?| pf) (|pf2Sex1| (|pfDoBody| pf))) ((|pfTyped?| pf) @@ -19638,7 +21555,8 @@ output is an old-parser-style s-expression. ; -- up in expressions. This just passes it through as a string for ; -- the user to figure out what happened. ((eq (|pfAbSynOp| pf) '|command|) (|tokPart| pf)) - (t (|keyedSystemError| "S2GE0017" (list "pf2Sex1")))))) + (t (|keyedSystemError| "Unexpected error in call to system function %1" + (list "pf2Sex1")))))) \end{chunk} @@ -19668,7 +21586,8 @@ output is an old-parser-style s-expression. (|pfSymbolSymbol| pf))) ((eq type '|expression|) (list 'quote (|pfLeafToken| pf))) (t - (|keyedSystemError| 'S2GE0017 (list "pfLiteral2Sex: unexpected form")))))) + (|keyedSystemError| "Unexpected error in call to system function %1" + (list "pfLiteral2Sex: unexpected form")))))) \end{chunk} @@ -21157,7 +23076,6 @@ Give message and throw to a recovery point. \calls{getStFromMsg}{getPosStL} \calls{getStFromMsg}{getMsgKey?} \calls{getStFromMsg}{pname} -\calls{getStFromMsg}{getMsgLitSym} \calls{getStFromMsg}{tabbing} \begin{chunk}{defun getStFromMsg} (defun |getStFromMsg| (msg) @@ -21171,11 +23089,10 @@ Give message and throw to a recovery point. (setq posStL (|getPosStL| msg)) (setq st (cons posStL - (cons (|getMsgLitSym| msg) - (cons "" + (cons " " (append preStL (cons (|tabbing| msg) - (|getMsgText| msg))))))))))) + (|getMsgText| msg)))))))))) \end{chunk} @@ -21438,14 +23355,6 @@ org prints out the word noposition or console \end{chunk} -\defun{getMsgLitSym}{getMsgLitSym} -\calls{getMsgLitSym}{getMsgKey?} -\begin{chunk}{defun getMsgLitSym} -(defun |getMsgLitSym| (msg) - (if (|getMsgKey?| msg) " " "*")) - -\end{chunk} - \defun{tabbing}{tabbing} \calls{tabbing}{getMsgPrefix?} \usesdollar{tabbing}{preLength} @@ -23536,12 +25445,12 @@ Pick off the tag \begin{chunk}{defun ncTag} (defun |ncTag| (x) (cond - ((null (consp x)) (|ncBug| 's2cb0031 nil)) + ((null (consp x)) (|ncBug| "bad object" nil)) (t (setq x (qcar x)) (cond ((identp x) x) - ((null (consp x)) (|ncBug| 's2cb0031 nil)) + ((null (consp x)) (|ncBug| "bad object" nil)) (t (qcar x)))))) \end{chunk} @@ -23555,12 +25464,12 @@ Pick off the property list \begin{chunk}{defun ncAlist} (defun |ncAlist| (x) (cond - ((null (consp x)) (|ncBug| 's2cb0031 nil)) + ((null (consp x)) (|ncBug| "bad object" nil)) (t (setq x (qcar x)) (cond ((identp x) nil) - ((null (consp x)) (|ncBug| 's2cb0031 nil)) + ((null (consp x)) (|ncBug| "bad object" nil)) (t (qcdr x)))))) \end{chunk} @@ -23576,7 +25485,7 @@ Get the entry for key k on x's association list (let (r) (setq r (qassq k (|ncAlist| x))) (cond - ((null r) (|ncBug| 's2cb0007 (list k))) + ((null r) (|ncBug| "Association list search failed on %1" (list k))) (t (cdr r))))) \end{chunk} @@ -24052,7 +25961,8 @@ signature sig under substitution sl. (or (eq (qcar cond) 'or) (eq (qcar cond) '|or|))) (|hasSigOr| (qcdr cond) s0 sl)) (t - (|keyedSystemError| 'S2GE0016 + (|keyedSystemError| + "Unexpected error or improper call to system function %1: %2" (list "hasSig" "unexpected condition for signature"))))) (unless (eq s '|failed|) (setq s (|unifyStruct| (|subCopy| x s0) sig s)))) @@ -24129,7 +26039,8 @@ needs s0 similar to hasSig. (|subCopy| (qcaddr cls) s0) (copy sl))) (t - (|keyedSystemError| 'S2GE0016 + (|keyedSystemError| + "Unexpected error or improper call to system function %1: %2" (list "hasSigAnd" "unexpected condition for signature"))))) (when (eq sa '|failed|) (setq dead t))) sa)) @@ -24159,7 +26070,8 @@ needs s0 similar to hasSig. (or (eq (qcar cls) 'and) (eq (qcar cls) '|and|))) (|hasSigAnd| (qcdr cls) s0 sl)) (t - (|keyedSystemError| 'S2GE0016 + (|keyedSystemError| + "Unexpected error or improper call to system function %1: %2" (list "hasSigOr" "unexpected condition for signature"))))) (unless (eq sa '|failed|) (setq found t))) sa)) @@ -24187,7 +26099,8 @@ The result is an augmented SL, if d has x, 'failed otherwise. (consp (qcdr y)) (consp (qcddr y)) (eq (qcdddr y) nil)) (|hasSig| d (qcadr y) (qcaddr y) sl)) (t - (|keyedSystemError| 'S2GE0016 + (|keyedSystemError| + "Unexpected error or improper call to system function %1: %2" (list "hasAttSig" "unexpected form of unnamed category")))))) sl) @@ -24235,7 +26148,8 @@ The result is an augmented SL, if d has x, 'failed otherwise. (consp (qcdr cond)) (consp (qcddr cond)) (eq (qcdddr cond) nil)) (|hasCate| (qcadr cond) (qcaddr cond) sl)) (t - (|keyedSystemError| 'S2GE0016 + (|keyedSystemError| + "Unexpected error or improper call to system function %1: %2" (list "hasSig" "unexpected condition for attribute")))))) \end{chunk} @@ -24442,7 +26356,8 @@ SL is augmented, if cond is true, otherwise the result is 'failed (t (|hasCaty1| x (copy sl)))))) s) (t - (|keyedSystemError| 'S2GE0016 + (|keyedSystemError| + "Unexpected error or improper call to system function %1: %2" (list "hasCaty1" "unexpected condition from category table")))))) \end{chunk} @@ -25054,7 +26969,7 @@ valid for this level. (if u (|commandAmbiguityError| kind x u) (progn - (|sayKeyedMsg| 'S2IZ0008 (list kind x)) + (|sayKeyedMsg| "No %1 begins with %2 ." (list kind x)) (|terminateSystemCommand|)))) \end{chunk} @@ -25086,7 +27001,9 @@ valid for this level. (if u (|commandAmbiguityError| kind x u) (progn - (|sayKeyedMsg| 'S2IZ0007 (list |$UserLevel| kind)) + (|sayKeyedMsg| + "Your %1 is ambiguous. The following are abbreviated by %2 :" + (list |$UserLevel| kind)) (|terminateSystemCommand|)))) \end{chunk} @@ -25144,7 +27061,9 @@ valid for this level. \calls{commandAmbiguityError}{terminateSystemCommand} \begin{chunk}{defun commandAmbiguityError} (defun |commandAmbiguityError| (kind x u) - (|sayKeyedMsg| 's2iz0009 (list kind x)) + (|sayKeyedMsg| + "Your %1 is ambiguous. The following are abbreviated by %2 :" + (list kind x)) (dolist (a u) (|sayMSG| (cons " " (|bright| a)))) (|terminateSystemCommand|)) @@ -25578,12 +27497,14 @@ The \verb|$msgdbPrims| variable is set to: (null vl)) (setq vl (msort (append (|getWorkspaceNames|) macros)))) (when |$frameMessages| - (|sayKeyedMsg| 'S2IZ0065 (cons |$interpreterFrameName| nil))) + (|sayKeyedMsg| "The name of the current frame is %1 ." + (cons |$interpreterFrameName| nil))) (cond ((null vl) (if (null |$frameMessages|) - (|sayKeyedMsg| 'S2IZ0066 nil)) - (|sayKeyedMsg| 'S2IZ0067 (cons |$interpreterFrameName| nil))) + (|sayKeyedMsg| "The workspace is empty." nil)) + (|sayKeyedMsg| "The current frame, %1 , is empty." + (cons |$interpreterFrameName| nil))) (t (|interpFunctionDepAlists|) (do ((G166440 vl (cdr G166440)) (v nil)) @@ -25671,7 +27592,8 @@ The \verb|$msgdbPrims| variable is set to: (|sayMSG| (list " " prop ": " val)) (setq propsSeen (cons prop propsSeen)))))))))))))) (t - (|sayKeyedMsg| 'S2IZ0068 (cons option nil))))))))) + (|sayKeyedMsg| "There is nothing to display for option %1 ." + (cons option nil))))))))) (|terminateSystemCommand|))))) \end{chunk} @@ -25920,15 +27842,15 @@ The \verb|$msgdbPrims| variable is set to: ((eq unab '|lisp|) (if spaceindex (|nplisp| (|stripLisp| string)) - (|sayKeyedMsg| 's2iv0005 nil))) + (|sayKeyedMsg| "Your argument list is not valid." nil))) ((eq unab '|boot|) (if spaceindex (|npboot| (subseq string (1+ spaceindex))) - (|sayKeyedMsg| 's2iv0005 nil))) + (|sayKeyedMsg| "Your argument list is not valid." nil))) ((eq unab '|system|) (if spaceindex (|npsystem| unab string) - (|sayKeyedMsg| 's2iv0005 nil))) + (|sayKeyedMsg| "Your argument list is not valid." nil))) ((eq unab '|synonym|) (if spaceindex (|npsynonym| unab (subseq string (1+ spaceindex))) @@ -25936,7 +27858,7 @@ The \verb|$msgdbPrims| variable is set to: ((null spaceindex) (funcall unab)) ((|member| unab '(|quit| |fin| |pquit| |credits| |copyright| |trademark|)) - (|sayKeyedMsg| 's2iv0005 nil)) + (|sayKeyedMsg| "Your argument list is not valid." nil)) (t (setq funname (intern (concat "np" (string unab)))) (funcall funname (subseq string (1+ spaceindex))))))) @@ -25990,12 +27912,12 @@ in practice. (let (spaceIndex sysPart) (setq spaceIndex (search " " str)) (cond - ((null spaceIndex) (|sayKeyedMsg| 'S2IZ0080 (list str))) + ((null spaceIndex) (|sayKeyedMsg| "Unknown system command: %1" (list str))) (t (setq sysPart (subseq str 0 spaceIndex)) (if (search sysPart (string unab)) (obey (subseq str (1+ spaceIndex))) - (|sayKeyedMsg| 'S2IZ0080 (list sysPart))))))) + (|sayKeyedMsg| "Unknown system command: %1" (list sysPart))))))) \end{chunk} @@ -26440,7 +28362,11 @@ o )compile ((eq type '|remove|) (deldatabase key 'abbreviation)) ((oddp (size al)) - (|sayKeyedMsg| 's2iz0002 (list type))) + (|sayKeyedMsg| + (format nil + "%1 must be followed by an alternating list of abbreviation(s) ~ + and name(s). Issue )abbrev ? for more information.") + (list type))) (t (do () (nil nil) (seq @@ -26456,7 +28382,8 @@ o )compile (setdatabase b 'abbreviation a) (setdatabase b 'constructorkind type)))))) (unless quiet - (|sayKeyedMsg| 's2iz0001 (list a type (|opOf| b))))))))))) + (|sayKeyedMsg| "%1 abbreviates % %2 %3 %" + (list a type (|opOf| b))))))))))) \end{chunk} @@ -26469,13 +28396,24 @@ o )compile \begin{chunk}{defun listConstructorAbbreviations} (defun |listConstructorAbbreviations| () (let (x) - (setq x (upcase (|queryUserKeyedMsg| 's2iz0056 nil))) + (setq x + (upcase + (|queryUserKeyedMsg| + (format nil + "You have requested that all abbreviations be displayed. As there are ~ + several hundred abbreviations, please confirm your request by ~ + typing y or yes and then pressing Enter :") + nil))) (if (member (string2id-n x 1) '(Y YES)) (progn (|whatSpad2Cmd| '(|categories|)) (|whatSpad2Cmd| '(|domains|)) (|whatSpad2Cmd| '(|packages|))) - (|sayKeyedMsg| 's2iz0057 nil)))) + (|sayKeyedMsg| + (format nil + "Since you did not respond with y or yes the list of abbreviations ~ + will not be displayed.") + nil)))) \end{chunk} @@ -26946,7 +28884,13 @@ TPDHERE: Note that this function also seems to parse out )except (do ((t5 |$clearOptions| (cdr t5)) (x nil)) ((or (atom t5) (progn (setq x (car t5)) nil)) t4) (setq t4 (append t4 `(|%l| " " ,x))))))) - (|sayKeyedMsg| 's2iz0010 (list optlist))) + (|sayKeyedMsg| + (format nil + "Use )clear all to clear everything in the workspace. Use )clear ~ + completely to clear everything in the workspace and internal ~ + tables. Other )clear keyword arguments are %1 %l or abbreviations ~ + thereof. Issue )clear ? for more information.") + (list optlist))) (t (setq arg (|selectOptionLC| (car l) '(|all| |completely| |scaches|) nil)) @@ -27000,7 +28944,8 @@ TPDHERE: Note that this function also seems to parse out )except (t nil)) (cond ((null fn) - (|keyedSystemError| 'S2NR0001 + (|keyedSystemError| + "The function %1 with signature %2 is missing from domain %3" (list op (|formatSignature| sig) (elt dollar 0)))) (t fn)))) @@ -27043,13 +28988,14 @@ TPDHERE: Note that this function also seems to parse out )except (setq |$JoinOfDomDatabase| nil) (setq |$attributeDb| nil) (setq |$functionTable| nil) - (|sayKeyedMsg| 's2iz0013 nil) + (|sayKeyedMsg| "All )browse facility databases have been cleared." nil) (|clearClams|) (|clearConstructorCaches|) (setq |$existingFiles| (make-hash-table :test #'equal)) - (|sayKeyedMsg| 's2iz0014 nil) + (|sayKeyedMsg| + "Internally cached functions and constructors have been cleared." nil) (reclaim) - (|sayKeyedMsg| 's2iz0015 nil)) + (|sayKeyedMsg| ")clear completely is finished." nil)) \end{chunk} @@ -27091,8 +29037,13 @@ TPDHERE: Note that this function also seems to parse out )except (setq |$currentLine| ")clear all") (|clearMacroTable|) (when |$frameMessages| - (|sayKeyedMsg| 's2iz0011 (list |$interpreterFrameName|)) - (|sayKeyedMsg| 's2iz0012 nil))) + (|sayKeyedMsg| + (format nil + "All user variables and function definitions have been cleared in ~ + the current frame ( %1 ).") + (list |$interpreterFrameName|)) + (|sayKeyedMsg| + "All user variables and function definitions have been cleared." nil))) \end{chunk} @@ -27163,7 +29114,11 @@ Clear all the options except the argument. (|values| '|value|) (t option))) (if (null vl) - (|sayKeyedMsg| 's2iz0055 nil) + (|sayKeyedMsg| + (format nil + "After the property you wish to clear you must give one or more ~ + identifiers or specify all to clear that property from everything.") + nil) (progn (setq pmacs (|getParserMacroNames|)) (setq imacs (|getInterpMacroNames|)) @@ -27296,7 +29251,7 @@ Returns the number of active scratchpad clients (declare (special |$SpadServer| |$SessionManager| |$CloseClient| |$currentFrameNum| |$options|)) (if (null |$SpadServer|) - (|throwKeyedMsg| 's2iz0071 nil)) + (|throwKeyedMsg| "You cannot close this Axiom session." nil)) (progn (setq numClients (|queryClients|)) (cond @@ -27318,7 +29273,11 @@ Returns the number of active scratchpad clients (|sockSendInt| |$SessionManager| |$currentFrameNum|) (|closeInterpreterFrame| nil)) (t - (setq x (upcase (|queryUserKeyedMsg| 's2iz0072 nil))) + (setq x + (upcase + (|queryUserKeyedMsg| + "This is the last Axiom session. Do you want to kill Axiom?" + nil))) (when (member (string2id-n x 1) '(yes y)) (bye))))))))) \end{chunk} @@ -28124,11 +30083,15 @@ and tell the user what options are available. (let (abb) (cond ((setq abb (getdatabase x 'abbreviation)) - (|sayKeyedMsg| 's2iz0001 (list abb (getdatabase x 'constructorkind) x))) + (|sayKeyedMsg| "%1 abbreviates %2 %3" + (list abb (getdatabase x 'constructorkind) x))) ((setq abb (getdatabase x 'constructor)) - (|sayKeyedMsg| 's2iz0001 (list x (getdatabase abb 'constructorkind) abb))) + (|sayKeyedMsg| "%1 abbreviates %2 %3" + (list x (getdatabase abb 'constructorkind) abb))) (t - (|sayKeyedMsg| 's2iz0003 (list x)))))) + (|sayKeyedMsg| + "%1 is neither a constructor name nor a constructor abbreviation." + (list x)))))) \end{chunk} \defun{displayOperations}{displayOperations} @@ -28145,7 +30108,11 @@ we print the information for the requested symbols. (dolist (op l) (|reportOpSymbol| op)) (if (yesanswer) (dolist (op (|allOperations|)) (|reportOpSymbol| op)) - (|sayKeyedMsg| 's2iz0059 nil)))) + (|sayKeyedMsg| + (format nil + "Since you did not respond with y or yes the list of operations will ~ + not be displayed.") + nil)))) \end{chunk} \defun{yesanswer}{yesanswer} @@ -28160,7 +30127,15 @@ displayed. If the answer is either Y or YES we return true else nil. \begin{chunk}{defun yesanswer} (defun yesanswer () (member - (string2id-n (upcase (|queryUserKeyedMsg| 's2iz0058 nil)) 1) '(y yes))) + (string2id-n + (upcase + (|queryUserKeyedMsg| + (format nil + "You have requested that all information about all Axiom operations ~ + (functions) be displayed. As there are several hundred operations, ~ + please confirm your request by typing y or yes and then pressing ~ + Enter :") + nil)) 1) '(y yes))) \end{chunk} @@ -28708,7 +30683,12 @@ Available algebra help topics are: (defun |helpSpad2Cmd| (args) "The top level help command handler" (unless (|newHelpSpad2Cmd| args) - (|sayKeyedMsg| 's2iz0025 (cons args nil)))) + (|sayKeyedMsg| + (format nil + "If the system command or synonym %1 exists, help information is not ~ + available for it. Issue )what commands or )what synonyms to ~ + determine is %1 is a valid name.") + (cons args nil)))) \end{chunk} @@ -28732,7 +30712,8 @@ Available algebra help topics are: (declare (special $syscommands |$useFullScreenHelp|)) (when (null args) (setq args (list '?))) (if (> (|#| args) 1) - (|sayKeyedMsg| 's2iz0026 nil) + (|sayKeyedMsg| "The )help system command supports at most one argument." + nil) (progn (setq sarg (pname (car args))) (cond @@ -29049,7 +31030,11 @@ environment to \verb|$HistList| and \verb|$HistRecord|. "The top level history command" (declare (special |$options|)) (if (or l (null |$options|)) - (|sayKeyedMsg| 's2ih0006 nil) ; syntax error + (|sayKeyedMsg| + (format nil + "You have not used the correct syntax for the history command. ~ + Issue )help history for more information.") + nil) (|historySpad2Cmd|))) \end{chunk} @@ -29125,32 +31110,38 @@ environment to \verb|$HistList| and \verb|$HistRecord|. ((|member| opt '(|on| |yes|)) (cond (|$HiFiAccess| - (|sayKeyedMsg| 'S2IH0007 nil)) ; history already on + (|sayKeyedMsg| "The history facility is already on." nil)) ((eql |$IOindex| 1) (setq |$HiFiAccess| t) (|initHistList|) - (|sayKeyedMsg| 'S2IH0008 nil)) ; history now on + (|sayKeyedMsg| "The history facility is now on." nil)) (t (setq x ; really want to turn history on? - (upcase (|queryUserKeyedMsg| 'S2IH0009 nil))) + (upcase + (|queryUserKeyedMsg| + (format nil + "Turning on the history facility will clear the contents ~ + of the workspace. Please enter y or yes if you really ~ + want to do this:") + nil))) (cond ((member (string2id-n x 1) '(Y YES)) (|histFileErase| (|histFileName|)) (setq |$HiFiAccess| t) (setq |$options| nil) (|clearSpad2Cmd| '(|all|)) - (|sayKeyedMsg| 'S2IH0008 nil) ; history now on + (|sayKeyedMsg| "The history facility is now on." nil) (|initHistList|)) (t - (|sayKeyedMsg| 'S2IH0010 nil)))))) ; history still off + (|sayKeyedMsg| "The history facility is still off." nil)))))) ((|member| opt '(|off| |no|)) (cond ((null |$HiFiAccess|) - (|sayKeyedMsg| 'S2IH0011 nil)) ; history already off + (|sayKeyedMsg| "The history facility is already off." nil)) (t (setq |$HiFiAccess| nil) (|disableHist|) - (|sayKeyedMsg| 'S2IH0012 nil)))) ; history now off + (|sayKeyedMsg| "The history facility is now off." nil)))) ((eq opt '|file|) (|setHistoryCore| nil)) ((eq opt '|memory|) (|setHistoryCore| t)) ((eq opt '|reset|) (|resetInCoreHist|)) @@ -29182,7 +31173,12 @@ environment to \verb|$HistList| and \verb|$HistRecord|. (setq |$evalTimePrint| 0) (setq |$printTimeSum| 0) (cond - ((null |$HiFiAccess|) (|sayKeyedMsg| 'S2IH0026 (list '|show|))) + ((null |$HiFiAccess|) + (|sayKeyedMsg| + (format nil + "The history facility command %1 cannot be performed because the ~ + history facility is not on.") + (list '|show|))) (t (setq showInputOrBoth '|input|) (setq n 20) @@ -29256,13 +31252,29 @@ file and then write the in-memory history to a new file (cond ((boot-equal inCore |$useInternalHistoryTable|) (if inCore - (|sayKeyedMsg| 's2ih0030 nil) ; memory history already in use - (|sayKeyedMsg| 's2ih0029 nil))) ; file history already in use + (|sayKeyedMsg| + (format nil + "History information is already being maintained in memory (and ~ + not in an external file).") + nil) + (|sayKeyedMsg| + (format nil + "History information is already being maintained in an external ~ + file (and not in memory).") + nil))) ; file history already in use ((null |$HiFiAccess|) (setq |$useInternalHistoryTable| inCore) (if inCore - (|sayKeyedMsg| 's2ih0032 nil) ; use memory history - (|sayKeyedMsg| 's2ih0031 nil))) ; use file history + (|sayKeyedMsg| + (format nil + "When the history facility is active, history information will be ~ + maintained in memory (and not in an external file).") + nil) + (|sayKeyedMsg| + (format nil + "When the history facility is active, history information will be ~ + maintained in a file (and not in an internal table).") + nil))) (inCore (setq |$internalHistoryTable| nil) (cond @@ -29275,7 +31287,11 @@ file and then write the in-memory history to a new file (cons (cons i vec) |$internalHistoryTable|))) (|histFileErase| (|histFileName|)))) (setq |$useInternalHistoryTable| t) - (|sayKeyedMsg| 'S2IH0032 nil)) ; use memory history + (|sayKeyedMsg| + (format nil + "When the history facility is active, history information will be ~ + maintained in memory (and not in an external file).") + nil)) (t (setq |$HiFiAccess| nil) (|histFileErase| (|histFileName|)) @@ -29304,7 +31320,11 @@ file and then write the in-memory history to a new file (setq |$HiFiAccess| t) (setq |$internalHistoryTable| nil) (setq |$useInternalHistoryTable| nil) - (|sayKeyedMsg| 's2ih0031 nil))))) ; use file history + (|sayKeyedMsg| + (format nil + "When the history facility is active, history information will be ~ + maintained in a file (and not in an internal table).") + nil))))) \end{chunk} \defdollar{underbar} @@ -29335,8 +31355,15 @@ Also used in the output routines. (let (maxn breakChars vecl k svec done n lineList file inp) (declare (special underbar |$HiFiAccess| |$IOindex|)) (cond - ((null |$HiFiAccess|) (|sayKeyedMsg| 's2ih0013 nil)) ; history is not on - ((null fn) (|throwKeyedMsg| 's2ih0038 nil)) ; missing file name + ((null |$HiFiAccess|) + (|sayKeyedMsg| + (format nil + "The history facility is not on, so the .input file containing your ~ + user input cannot be created.") + nil)) + ((null fn) + (|throwKeyedMsg| + "You must specify a file name to the history write command" nil)) (t (setq maxn 72) (setq breakChars (cons '| | (cons '+ nil))) @@ -29372,7 +31399,7 @@ Also used in the output routines. (write-line x inp)) (cond ((not (eq fn '|redo|)) - (|sayKeyedMsg| 's2ih0014 ; edit this file to see input lines + (|sayKeyedMsg| "Edit %1 to see the saved input lines." (list (|namestring| file))))) (shut inp) nil)))) @@ -29403,7 +31430,11 @@ Also used in the output routines. (let (dif l) (declare (special |$HistListLen| |$HistList| |$HistListAct|)) (if (null (integerp n)) - (|sayKeyedMsg| 's2ih0015 (list n)) ; only positive integers + (|sayKeyedMsg| + (format nil + "The argument n for )history )change n must be a nonnegative integer ~ + and your argument, %1 , is not one.") + (list n)) ; only positive integers (progn (setq dif (spaddifference n |$HistListLen|)) (setq |$HistListLen| n) @@ -29568,7 +31599,9 @@ Also used in the output routines. (setq p (assq '% vec)) (setq p1 (assq '|value| (cdr p))) (cdr p1)))) - (|sayKeyedMsg| 's2ih0019 (cons n nil)))) ; no history file + (|sayKeyedMsg| + "There is no history file, so value of step %1 is undefined." + (cons n nil)))) ; no history file (setq |$InteractiveFrame| (|putHist| '% '|value| val |$InteractiveFrame|)) (|updateHist|))) @@ -29678,12 +31711,16 @@ Also used in the output routines. (setq |$seen| (make-hash-table :test #'eq)) (cond ((null |$HiFiAccess|) - (|sayKeyedMsg| 's2ih0016 nil)) ; the history file is not on + (|sayKeyedMsg| + "The history facility is not on, so no information can be saved." + nil)) ; the history file is not on ((and (null |$useInternalHistoryTable|) (null (makeInputFilename (|histFileName|)))) - (|sayKeyedMsg| 's2ih0022 nil)) ; no history saved yet + (|sayKeyedMsg| "No history information had been saved yet." nil)) ((null fn) - (|throwKeyedMsg| 's2ih0037 nil)) ; need to specify a history filename + (|throwKeyedMsg| + "You must specify a file name to the history save command" + nil)) (t (setq savefile (|makeHistFileName| fn)) (setq inputfile (|histInputFileName| fn)) @@ -29707,10 +31744,13 @@ Also used in the output routines. nil) (setq val (spadrwrite0 (|object2Identifier| n) rec saveStr)) (when (eq val '|writifyFailed|) - (|sayKeyedMsg| 's2ih0035 ; can't save the value of step + (|sayKeyedMsg| + (format nil + "Can't save the value of step number %1. You can re-generate ~ + this value by running the input file %2.") (list n inputfile)))) (rshut saveStr)) - (|sayKeyedMsg| 's2ih0018 ; saved history file is + (|sayKeyedMsg| "The saved history file is %1 ." (cons (|namestring| savefile) nil)) nil)))) @@ -29757,11 +31797,15 @@ Also used in the output routines. t) (identp fnq)) (setq fnq fnq)) - (t (|throwKeyedMsg| 's2ih0023 (cons fnq nil)))) ; invalid filename + (t (|throwKeyedMsg| "%1 is not a valid filename for the history file." + (cons fnq nil)))) ; invalid filename (setq restfile (|makeHistFileName| fnq)) (if (null (makeInputFilename restfile)) - (|sayKeyedMsg| 's2ih0024 ; file does not exist - (cons (|namestring| restfile) nil)) + (|sayKeyedMsg| + (format nil + "History information cannot be restored from %1 because the file does ~ + not exist.") + (cons (|namestring| restfile) nil)) (progn (setq |$options| nil) (|clearSpad2Cmd| '(|all|)) @@ -29806,7 +31850,8 @@ Also used in the output routines. (|rempropI| a '|mapBody|))) (setq |$IOindex| (1+ l)) (setq |$useInternalHistoryTable| oldInternal) - (|sayKeyedMsg| 'S2IH0025 ; workspace restored + (|sayKeyedMsg| + "The workspace has been successfully restored from the history file %1 ." (cons (|namestring| restfile) nil)) (|clearCmdSortedCaches|) nil)))) @@ -29889,9 +31934,13 @@ Also used in the output routines. (t n))) (cond ((>= n |$IOindex|) - (|throwKeyedMsg| 'S2IH0001 (cons n nil))) ; no step n yet + (|throwKeyedMsg| + "You have not reached step %1, and so its value cannot be supplied." + (cons n nil))) ((> 1 n) - (|throwKeyedMsg| 's2ih0002 (cons n nil))) ; only nonzero steps + (|throwKeyedMsg| + "Cannot supply value for step %1b because 1 is the first step." + (cons n nil))) ; only nonzero steps (t (setq vec (unwind-protect (|readHiFi| n) (|disableHist|))) (cond @@ -29900,9 +31949,11 @@ Also used in the output routines. ((setq val (cdr (assq '|value| (cdr Alist)))) val) (t - (|throwKeyedMsg| 's2ih0003 (cons n nil))))) ; no step value - (t (|throwKeyedMsg| 's2ih0003 (cons n nil))))))) ; no step value - (t (|throwKeyedMsg| 's2ih0004 nil))))) ; history not on + (|throwKeyedMsg| "Step %1 has no value." (cons n nil))))) + (t (|throwKeyedMsg| "Step %1 has no value." (cons n nil))))))) + (t (|throwKeyedMsg| + "The history facility is not on, so you cannot use %%." + nil))))) ; history not on \end{chunk} \defunsec{readHiFi}{Read the history file using index n} @@ -29925,7 +31976,7 @@ Also used in the output routines. (progn (setq pair (|assoc| n |$internalHistoryTable|)) (if (atom pair) - (|keyedSystemError| 's2ih0034 nil) ; missing element + (|keyedSystemError| "Missing element in internal history table." nil) (setq vec (qcdr pair)))) (progn (setq HiFi @@ -30052,7 +32103,7 @@ These functions transform an object to a writable form and back. (let (val) (setq val (spadrwrite0 vec item stream)) (if (eq val '|writifyFailed|) - (|throwKeyedMsg| 's2ih0036 nil) ; cannot save value to file + (|throwKeyedMsg| "The value specified cannot be saved to a file." nil) item))) \end{chunk} @@ -30103,7 +32154,12 @@ back. (declare (special |$writifyComplained|)) (unless |$writifyComplained| (setq |$writifyComplained| t) - (|sayKeyedMsg| 's2ih0027 (list s)))) ; cannot save value + (|sayKeyedMsg| + (format nil + "A value containing a %1 is being saved in a history file or a ~ + compiled input file INLIB. This type is not yet usable in other ~ + history operations. You might want to issue )history )off") + (list s)))) ; cannot save value \end{chunk} \defun{safeWritify}{safeWritify} @@ -30579,91 +32635,6 @@ back. \end{chunk} -\begin{chunk}{History File Messages} -S2IH0001 - You have not reached step %1b yet, and so its value cannot be - supplied. -S2IH0002 - Cannot supply value for step %1b because 1 is the first step. -S2IH0003 - Step %1b has no value. -S2IH0004 - The history facility is not on, so you cannot use %b %% %d . -S2IH0006 - You have not used the correct syntax for the %b history %d command. - Issue %b )help history %d for more information. -S2IH0007 - The history facility is already on. -S2IH0008 - The history facility is now on. -S2IH0009 - Turning on the history facility will clear the contents of the - workspace. - Please enter %b y %d or %b yes %d if you really want to do this: -S2IH0010 - The history facility is still off. -S2IH0011 - The history facility is already off. -S2IH0012 - The history facility is now off. -S2IH0013 - The history facility is not on, so the .input file containing your user input - cannot be created. -S2IH0014 - Edit %b %1 %d to see the saved input lines. -S2IH0015 - The argument %b n %d for %b )history )change n must be a nonnegative - integer and your argument, %1b , is not one. -S2IH0016 - The history facility is not on, so no information can be saved. -S2IH0018 - The saved history file is %1b . -S2IH0019 - There is no history file, so value of step %1b is - undefined. -S2IH0022 - No history information had been saved yet. -S2IH0023 - %1b is not a valid filename for the history file. -S2IH0024 - History information cannot be restored from %1b because the file does - not exist. -S2IH0025 - The workspace has been successfully restored from the history file - %1b . -S2IH0026 - The history facility command %1b cannot be performed because the - history facility is not on. -S2IH0027 - A value containing a %1b is being saved in a history file or a - compiled input file INLIB. This type - is not yet usable in other history operations. You might want to issue - %b )history )off %d -S2IH0029 - History information is already being maintained in an external file - (and not in memory). -S2IH0030 - History information is already being maintained in memory (and not - in an external file). -S2IH0031 - When the history facility is active, history information will be - maintained in a file (and not in an internal table). -S2IH0032 - When the history facility is active, history information will be - maintained in memory (and not in an external file). -S2IH0034 - Missing element in internal history table. -S2IH0035 - Can't save the value of step number %1b. You can re-generate this value - by running the input file %2b. -S2IH0036 - The value specified cannot be saved to a file. -S2IH0037 - You must specify a file name to the history save command -S2IH0038 - You must specify a file name to the history write command -\end{chunk} - \newpage %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \cmdhead{include} @@ -31054,9 +33025,16 @@ o )system (declare (special |$quitCommandType|)) (if (eq |$quitCommandType| '|protected|) (let (x) - (setq x (upcase (|queryUserKeyedMsg| 's2iz0031 nil))) + (setq x + (upcase + (|queryUserKeyedMsg| + (format nil + "Please enter y or yes if you really want to leave the interactive ~ + environment and return to the operating system:") + nil))) (when (member (string2id-n x 1) '(y yes)) (|leaveScratchpad|)) - (|sayKeyedMsg| 's2iz0032 nil) + (|sayKeyedMsg| + "You have chosen to remain in the Axiom interactive environment." nil) (tersyscommand)) (|leaveScratchpad|))) @@ -31176,7 +33154,8 @@ o )history (unless ll (if ifthere (return nil) - (|throwKeyedMsg| 'S2IL0003 (list (|namestring| arg))))) + (|throwKeyedMsg| "The file %1 is needed but does not exist." + (list (|namestring| arg))))) (setq ll (|pathname| ll)) (setq ft (|pathnameType| ll)) (setq upft (upcase ft)) @@ -31184,8 +33163,18 @@ o )history ((null (|member| upft fileTypes)) (setq fs (|namestring| arg)) (if (|member| upft devFTs) - (|throwKeyedMsg| 'S2IZ0033 (list fs)) - (|throwKeyedMsg| 'S2IZ0034 (list fs)))) + (|throwKeyedMsg| + (format nil + "You cannot )read the file %1 because your user-level is not is ~ + not high enough. For more information about your user-level, issue ~ + )set userlevel.") + (list fs)) + (|throwKeyedMsg| + (format nil + "You cannot )read the file %1 because it is not suitable for ~ + reading by Axiom. Note that files with file extension .spad ~ + can now only be compiled with the )compile system command.") + (list fs)))) (t (setq /editfile ll) (when (string= upft "BOOT") (setq |$InteractiveMode| nil)) @@ -32716,7 +34705,7 @@ recurrence specially compile recurrence relations on (progn (setq l (qcdr tmp1)) t)))) (dolist (x l) (if (null (identp x)) - (|sayKeyedMsg| 's2if0007 (list x)) + (|sayKeyedMsg| "%1 is not a valid function name." (list x)) (progn (setq |$cacheAlist| (|insertAlist| x n |$cacheAlist|)) (setq cachecountname (internl x ";COUNT")) @@ -34873,7 +36862,11 @@ The current setting is: On:CONSOLE (progn (setq fn (qcar arg)) t)) (cond ((|member| (upcase fn) '(y n ye o of)) - (|sayKeyedMsg| 's2iv0002 '(|algebra| |algebra|))) + (|sayKeyedMsg| + (format nil + "To toggle %1 printing on and off, specify %l )set output %2 ~ + yes/no/on/off %l Yes, no, on and off cannot be abbreviated.") + '(|algebra| |algebra|))) ((|member| (upcase fn) '(no off)) (setq |$algebraFormat| nil)) ((|member| (upcase fn) '(yes on)) (setq |$algebraFormat| t)) ((eq (upcase fn) 'console) @@ -34907,15 +36900,21 @@ The current setting is: On:CONSOLE (setq filename ($filep fn ft fm)) (cond ((null filename) - (|sayKeyedMsg| 's2iv0003 (list fn ft fm))) + (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm))) ((setq teststream (make-outstream filename 255 0)) (shut |$algebraOutputStream|) (setq |$algebraOutputStream| teststream) (setq |$algebraOutputFile| (|object2String| filename)) - (|sayKeyedMsg| 's2iv0004 (list "Algebra" |$algebraOutputFile|))) - (t (|sayKeyedMsg| 's2iv0003 (list fn ft fm))))) + (|sayKeyedMsg| + "%1 output will be written to file %2 ." + (list "Algebra" |$algebraOutputFile|))) + (t (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm))))) (t - (|sayKeyedMsg| 's2iv0005 nil) + (|sayKeyedMsg| "Your argument list is not valid." nil) (|describeSetOutputAlgebra|))))))) \end{chunk} @@ -35193,7 +37192,11 @@ The current setting is: Off:CONSOLE ((and (consp arg) (eq (qcdr arg) nil) (progn (setq fn (qcar arg)) t)) (cond ((|member| (upcase fn) '(y n ye o of)) - (|sayKeyedMsg| 's2iv0002 '(fortran |fortran|))) + (|sayKeyedMsg| + (format nil + "To toggle %1 printing on and off, specify %l )set output %2 ~ + yes/no/on/off %l Yes, no, on and off cannot be abbreviated.") + '(fortran |fortran|))) ((|member| (upcase fn) '(no off)) (setq |$fortranFormat| nil)) ((|member| (upcase fn) '(yes on)) (setq |$fortranFormat| t)) ((eq (upcase fn) 'console) @@ -35227,18 +37230,24 @@ The current setting is: Off:CONSOLE (setq filename ($filep fn ft fm)) (cond ((null filename) - (|sayKeyedMsg| 'S2IV0003 (list fn ft fm))) + (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm))) ((setq teststream (|makeStream| append filename 255 0)) (SHUT |$fortranOutputStream|) (setq |$fortranOutputStream| teststream) (setq |$fortranOutputFile| (|object2String| filename)) (unless quiet - (|sayKeyedMsg| 'S2IV0004 (list 'fortran |$fortranOutputFile|)))) + (|sayKeyedMsg| + "%1 output will be written to file %2 ." + (list 'fortran |$fortranOutputFile|)))) ((null quiet) - (|sayKeyedMsg| 'S2IV0003 (list fn ft fm))) + (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm))) (t nil))) (t - (unless quiet (|sayKeyedMsg| 'S2IV0005 nil)) + (unless quiet (|sayKeyedMsg| "Your argument list is not valid." nil)) (|describeSetOutputFortran|))))))) \end{chunk} @@ -35431,7 +37440,11 @@ The current setting is: Off:CONSOLE (progn (setq fn (qcar arg)) t)) (cond ((|member| (upcase fn) '(y n ye o of)) - (|sayKeyedMsg| 's2iv0002 '(|HTML| |html|))) + (|sayKeyedMsg| + (format nil + "To toggle %1 printing on and off, specify %l )set output %2 ~ + yes/no/on/off %l Yes, no, on and off cannot be abbreviated.") + '(|HTML| |html|))) ((|member| (upcase fn) '(no off)) (setq |$htmlFormat| nil)) ((|member| (upcase fn) '(yes on)) (setq |$htmlFormat| t)) ((eq (upcase fn) 'console) @@ -35466,15 +37479,22 @@ The current setting is: Off:CONSOLE (unless fm (setq fm 'a)) (setq filename ($filep fn ft fm)) (cond - ((null filename) (|sayKeyedMsg| 's2iv0003 (list fn ft fm))) + ((null filename) + (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm))) ((setq teststream (make-outstream filename 255 0)) (shut |$htmlOutputStream|) (setq |$htmlOutputStream| teststream) (setq |$htmlOutputFile| (|object2String| filename)) - (|sayKeyedMsg| 's2iv0004 (list "HTML" |$htmlOutputFile|))) - (t (|sayKeyedMsg| 's2iv0003 (list fn ft fm))))) + (|sayKeyedMsg| + "%1 output will be written to file %2 ." + (list "HTML" |$htmlOutputFile|))) + (t (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm))))) (t - (|sayKeyedMsg| 's2iv0005 nil) + (|sayKeyedMsg| "Your argument list is not valid." nil) (|describeSetOutputHtml|))))))) \end{chunk} @@ -35668,7 +37688,11 @@ The current setting is: Off:CONSOLE (progn (setq fn (qcar arg)) t)) (cond ((|member| (upcase fn) '(y n ye o of)) - (|sayKeyedMsg| 's2iv0002 '(|MathML| |mathml|))) + (|sayKeyedMsg| + (format nil + "To toggle %1 printing on and off, specify %l )set output %2 ~ + yes/no/on/off %l Yes, no, on and off cannot be abbreviated.") + '(|MathML| |mathml|))) ((|member| (upcase fn) '(no off)) (setq |$mathmlFormat| nil)) ((|member| (upcase fn) '(yes on)) (setq |$mathmlFormat| t)) ((eq (upcase fn) 'console) @@ -35703,15 +37727,22 @@ The current setting is: Off:CONSOLE (unless fm (setq fm 'a)) (setq filename ($filep fn ft fm)) (cond - ((null filename) (|sayKeyedMsg| 's2iv0003 (list fn ft fm))) + ((null filename) + (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm))) ((setq teststream (make-outstream filename 255 0)) (shut |$mathmlOutputStream|) (setq |$mathmlOutputStream| teststream) (setq |$mathmlOutputFile| (|object2String| filename)) - (|sayKeyedMsg| 's2iv0004 (list "MathML" |$mathmlOutputFile|))) - (t (|sayKeyedMsg| 's2iv0003 (list fn ft fm))))) + (|sayKeyedMsg| + "%1 output will be written to file %2 ." + (list "MathML" |$mathmlOutputFile|))) + (t (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm))))) (t - (|sayKeyedMsg| 's2iv0005 nil) + (|sayKeyedMsg| "Your argument list is not valid." nil) (|describeSetOutputMathml|))))))) \end{chunk} @@ -35871,7 +37902,11 @@ The current setting is: Off:CONSOLE (progn (setq fn (qcar arg)) t)) (cond ((|member| (upcase fn) '(y n ye o of)) - (|sayKeyedMsg| 's2iv0002 '(|OpenMath| |openmath|))) + (|sayKeyedMsg| + (format nil + "To toggle %1 printing on and off, specify %l )set output %2 ~ + yes/no/on/off %l Yes, no, on and off cannot be abbreviated.") + '(|OpenMath| |openmath|))) ((|member| (upcase fn) '(no off)) (setq |$openMathFormat| nil)) ((|member| (upcase fn) '(yes on)) (setq |$openMathFormat| t)) ((eq (upcase fn) 'console) @@ -35903,16 +37938,22 @@ The current setting is: Off:CONSOLE (setq filename ($filep fn ft fm)) (cond ((null filename) - (|sayKeyedMsg| 's2iv0003 (list fn ft fm))) + (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm))) ((setq teststream (make-outstream filename 255 0)) (shut |$openMathOutputStream|) (setq |$openMathOutputStream| teststream) (setq |$openMathOutputFile| (|object2String| filename)) - (|sayKeyedMsg| 's2iv0004 (list "OpenMath" |$openMathOutputFile|))) + (|sayKeyedMsg| + "%1 output will be written to file %2 ." + (list "OpenMath" |$openMathOutputFile|))) (t - (|sayKeyedMsg| 's2iv0003 (list fn ft fm))))) + (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm))))) (t - (|sayKeyedMsg| 's2iv0005 nil) + (|sayKeyedMsg| "Your argument list is not valid." nil) (|describeSetOutputOpenMath|))))))) \end{chunk} @@ -36075,7 +38116,11 @@ The current setting is: Off:CONSOLE (progn (setq fn (qcar arg)) t)) (cond ((|member| (upcase fn) '(y n ye o of)) - (|sayKeyedMsg| 's2iv0002 '(|script| |script|))) + (|sayKeyedMsg| + (format nil + "To toggle %1 printing on and off, specify %l )set output %2 ~ + yes/no/on/off %l Yes, no, on and off cannot be abbreviated.") + '(|script| |script|))) ((|member| (upcase fn) '(no off)) (setq |$formulaFormat| nil)) ((|member| (upcase fn) '(yes on)) (setq |$formulaFormat| t)) ((eq (upcase fn) 'console) @@ -36106,17 +38151,23 @@ The current setting is: Off:CONSOLE (unless fm (setq fm 'a)) (setq filename ($filep fn ft fm)) (cond - ((null filename) (|sayKeyedMsg| 's2iv0003 (list fn ft fm))) + ((null filename) + (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm))) ((setq teststream (make-outstream filename 255 0)) (shut |$formulaOutputStream|) (setq |$formulaOutputStream| teststream) (setq |$formulaOutputFile| (|object2String| filename)) - (|sayKeyedMsg| 's2iv0004 + (|sayKeyedMsg| + "%1 output will be written to file %2 ." (list "IBM Script formula" |$formulaOutputFile| ))) (t - (|sayKeyedMsg| 's2iv0003 (list fn ft fm))))) + (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm))))) (t - (|sayKeyedMsg| 's2iv0005 nil) + (|sayKeyedMsg| '"Your argument list is not valid." nil) (|describeSetOutputFormula|))))))) \end{chunk} @@ -36336,7 +38387,11 @@ The current setting is: Off:CONSOLE (progn (setq fn (qcar arg)) t)) (cond ((|member| (upcase fn) '(y n ye o of)) - (|sayKeyedMsg| 's2iv0002 '(|TeX| |tex|))) + (|sayKeyedMsg| + (format nil + "To toggle %1 printing on and off, specify %l )set output %2 ~ + yes/no/on/off %l Yes, no, on and off cannot be abbreviated.") + '(|TeX| |tex|))) ((|member| (upcase fn) '(no off)) (setq |$texFormat| nil)) ((|member| (upcase fn) '(yes on)) (setq |$texFormat| t)) ((eq (upcase fn) 'console) @@ -36366,15 +38421,22 @@ The current setting is: Off:CONSOLE (unless fm (setq fm 'A)) (setq filename ($filep fn ft fm)) (cond - ((null filename) (|sayKeyedMsg| 's2iv0003 (list fn ft fm ))) + ((null filename) + (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm ))) ((setq teststream (make-outstream filename 255 0)) (shut |$texOutputStream|) (setq |$texOutputStream| teststream) (setq |$texOutputFile| (|object2String| filename)) - (|sayKeyedMsg| 's2iv0004 (list "TeX" |$texOutputFile|))) - (t (|sayKeyedMsg| 'S2IV0003 (list fn ft fm ))))) + (|sayKeyedMsg| + "%1 output will be written to file %2 ." + (list "TeX" |$texOutputFile|))) + (t (|sayKeyedMsg| + "It is not possible to open or create a file called %1 %2 %3 ." + (list fn ft fm ))))) (t - (|sayKeyedMsg| 's2iv0005 nil) + (|sayKeyedMsg| "Your argument list is not valid." nil) (|describeSetOutputTex|))))))) \end{chunk} @@ -36538,7 +38600,13 @@ showall display all stream elements computed off \begin{chunk}{defun describeSetStreamsCalculate} (defun |describeSetStreamsCalculate| () (declare (special |$streamCount|)) - (|sayKeyedMsg| 's2iv0001 (list |$streamCount|))) + (|sayKeyedMsg| + (format nil + ")set streams calculate is used to tell Axiom how many elements of a ~ + stream to calculate when a computation uses the stream. The value ~ + given after calculate must either be the word all or a positive ~ + integer. %l %l The current setting is %1 .") + (list |$streamCount|))) \end{chunk} @@ -36833,7 +38901,9 @@ printLoadMessages, which gets called with \verb|%describe%| (setq setdata (cons arg (lassoc arg settree))) (cond ((null (|satisfiesUserLevel| (third setdata))) - (|sayKeyedMsg| 's2iz0007 (list |$UserLevel| "set option" nil))) + (|sayKeyedMsg| + "Your %1 is ambiguous. The following are abbreviated by %2 :" + (list |$UserLevel| "set option" nil))) ((eql 1 (|#| l)) (|displaySetOptionInformation| arg setdata)) (t (setq st (fourth setdata)) @@ -37015,16 +39085,73 @@ o )what ((|member| constr '(|Union| |Record| |Mapping|)) (cond ((eq constr '|Record|) - (|sayKeyedMsg| 'S2IZ0044R + (|sayKeyedMsg| + (format nil + "Record(a:A,...,b:B) %l Record takes any number of ~ + selector-domain pairs as arguments: %i %l a, a selector, an ~ + element of domain Symbol %l A, a domain of category ~ + SetCategory %l ... %l b, a selector, an element of domain ~ + Symbol %l B, a domain of category SetCategory %u %l ~ + This constructor is a primitive in Axiom. ~ + The selectors a,...,b of a Record type must be distinct. %l %l ~ + In order for more information to be displayed about %1 , ~ + you must give it specific arguments. For example: %2 %l ~ + You can also use the HyperDoc Browser.") (list constr ")show Record(a: Integer, b: String)" ))) - ((eq constr '|Mapping|) (|sayKeyedMsg| 'S2IZ0044M nil)) + ((eq constr '|Mapping|) + (|sayKeyedMsg| + (format nil + "Mapping(T, S, ...) %l Mapping takes any number of arguments ~ + of the form: %i %l T, a domain of category SetCategory %l ~ + S, a domain of category SetCategory %l ... %u %l ~ + Mapping(T, S, ...) denotes the class of objects which are ~ + mappings from a source domain (S, ...) into a target domain T. ~ + The Mapping constructor can take any number of arguments. ~ + All but the first argument is regarded as part of a source ~ + tuple for the mapping. For example, Mapping(T, A, B) denotes ~ + the class of mappings from (A, B) into T. %l ~ + This constructor is a primitive in Axiom. ~ + For more information, use the HyperDoc Browser.") + nil)) (t - (|sayKeyedMsg| 'S2IZ0045T + (|sayKeyedMsg| + (format nil + "Tagged union: Union(a:A, ..., b:B) %l Union takes any number ~ + of 'tag'-domain pairs of arguments: %i %l a, a tag, an ~ + element of domain Symbol %l A, a domain of category ~ + SetCategory %l ... %l b, a tag, an element of domain ~ + Symbol %l B, a domain of category SetCategory %u %l ~ + This constructor is a primitive in Axiom. ~ + In this tagged Union, tags a, ..., b must be distinct. %l %l ~ + In order for more information to be displayed about %1 , ~ + you must give it specific arguments. For example: %2 %l ~ + You can also use the HyperDoc Browser.") (list constr ")show Union(a: Integer, b: String)" ))) - (|sayKeyedMsg| 'S2IZ0045U + (|sayKeyedMsg| + (format nil + "Untagged union: Union(A, ..., B) %l Union takes any number ~ + of domain arguments: %i %l A, a domain of category ~ + SetCategory %l ... %l B, a domain of category SetCategory %u %l ~ + In this untagged form of Union, domains A, ..., B must be ~ + distinct. In order for more information to be displayed about ~ + %1 , you must give it specific arguments. For example: %2 %l ~ + You can also use the HyperDoc Browser.") (list constr ")show Union(Integer, String)" )))) ((and (consp constr) (eq (qcar constr) '|Mapping|)) - (|sayKeyedMsg| 'S2IZ0044M nil)) + (|sayKeyedMsg| + (format nil + "Mapping(T, S, ...) %l Mapping takes any number of arguments ~ + of the form: %i %l T, a domain of category SetCategory %l ~ + S, a domain of category SetCategory %l ... %u %l ~ + Mapping(T, S, ...) denotes the class of objects which are ~ + mappings from a source domain (S, ...) into a target domain T. ~ + The Mapping constructor can take any number of arguments. ~ + All but the first argument is regarded as part of a source ~ + tuple for the mapping. For example, Mapping(T, A, B) denotes ~ + the class of mappings from (A, B) into T. %l ~ + This constructor is a primitive in Axiom. ~ + For more information, use the HyperDoc Browser.") + nil)) (t (|reportOperations| constr constr)))) (t (|reportOperations| arg arg))))))) @@ -37066,8 +39193,17 @@ o )what (|sayBrightly| (cons " mode denotes" (append (|bright| "any") (list '|type|))))) ((eq u '%) - (|sayKeyedMsg| 'S2IZ0063 nil) - (|sayKeyedMsg| 'S2IZ0064 nil)) + (|sayKeyedMsg| + (format nil + "The )show system command is used to display information about ~ + types or partial types. For example, )show Integer will show ~ + information about Integer.") + nil) + (|sayKeyedMsg| + (format nil + "%l %% is a special variable holding the result of the last ~ + computation. Issue )display properties %% to see this value.") + nil)) ((and (null (and (consp u) (eq (qcar u) '|Record|))) (null (and (consp u) (eq (qcar u) '|Union|))) (null (|isNameOfType| u)) @@ -37077,9 +39213,19 @@ o )what (setq tmp1 (qcdr u)) (and (consp tmp1) (eq (qcdr tmp1) nil)))))) (when (atom oldArg) (setq oldArg (list oldArg))) - (|sayKeyedMsg| 'S2IZ0063 nil) + (|sayKeyedMsg| + (format nil + "The )show system command is used to display information about ~ + types or partial types. For example, )show Integer will show ~ + information about Integer.") + nil) (dolist (op oldArg) - (|sayKeyedMsg| 'S2IZ0062 (list (|opOf| op))))) + (|sayKeyedMsg| + (format nil + "%l %1 is not the name of a known type constructor. If you want ~ + to see information about any operations named %1, issue ~ + %ceon )display operations %1 %ceoff") + (list (|opOf| op))))) ((setq v (|isDomainValuedVariable| u)) (|reportOpsFromUnitDirectly0| v)) (t (if (atom u) @@ -37092,7 +39238,11 @@ o )what (setq tree (|mkAtree| (|removeZeroOneDestructively| unitForm))) (if (setq unitFormp (|isType| tree)) (|reportOpsFromUnitDirectly0| unitFormp) - (|sayKeyedMsg| 'S2IZ0041 (list unitForm)))))))))) + (|sayKeyedMsg| + (format nil + "It is not known what %1p is, so no information about it can be ~ + displayed.") + (list unitForm)))))))))) \end{chunk} @@ -37171,7 +39321,7 @@ o )what (declare (special $linelength |$showOptions| |$options| |$FormalMapVariableList|)) (if (null (setq fn (|constructor?| op))) - (|sayKeyedMsg| 'S2IZ0054 (list u)) + (|sayKeyedMsg| "%1 is unknown, so no information is available." (list u)) (progn (setq argml (when (setq s (|getConstructorSignature| op)) (kdr s))) (setq typ (getdatabase op 'constructorkind)) @@ -38090,539 +40240,49 @@ The following are the options for tracing constructors, domains and packages. Also See: o )boot o )lisp -o )ltrace - -\end{chunk} -\footnote{ -\fnref{boot} -\fnref{lisp} -\fnref{ltrace}} - -\subsection{The trace global variables} -This decides when to give trace and untrace messages. -\defdollar{traceNoisely} -\begin{chunk}{initvars} -(defvar |$traceNoisely| nil) - -\end{chunk} - -\defdollar{reportSpadtrace} -This reports the traced functions -\begin{chunk}{initvars} -(defvar |$reportSpadtrace| nil) - -\end{chunk} - -\defdollar{optionAlist} -\begin{chunk}{initvars} -(defvar |$optionAlist| nil) - -\end{chunk} - -\defdollar{tracedMapSignatures} -\begin{chunk}{initvars} -(defvar |$tracedMapSignatures| nil) - -\end{chunk} - -\defdollar{traceOptionList} -\begin{chunk}{initvars} -(defvar |$traceOptionList| - '(|after| |before| |break| |cond| |count| |depth| |local| |mathprint| - |nonquietly| |nt| |of| |only| |ops| |restore| |timer| |varbreak| - |vars| |within|)) - -\end{chunk} - -\defun{trace}{trace} -\calls{trace}{traceSpad2Cmd} -\begin{chunk}{defun trace} -(defun |trace| (l) - (|traceSpad2Cmd| l)) - -\end{chunk} - -\defun{traceSpad2Cmd}{traceSpad2Cmd} -\calls{traceSpad2Cmd}{qcar} -\calls{traceSpad2Cmd}{qcdr} -\calls{traceSpad2Cmd}{getMapSubNames} -\calls{traceSpad2Cmd}{trace1} -\calls{traceSpad2Cmd}{augmentTraceNames} -\calls{traceSpad2Cmd}{traceReply} -\usesdollar{traceSpad2Cmd}{mapSubNameAlist} -\begin{chunk}{defun traceSpad2Cmd} -(defun |traceSpad2Cmd| (l) - (let (tmp1 l1) - (declare (special |$mapSubNameAlist|)) - (cond - ((and (consp l) - (eq (qcar l) '|Tuple|) - (progn - (setq tmp1 (qcdr l)) - (and (consp tmp1) - (eq (qcdr tmp1) nil) - (progn - (setq l1 (qcar tmp1)) - t)))) - (setq l l1))) - (setq |$mapSubNameAlist| (|getMapSubNames| l)) - (|trace1| (|augmentTraceNames| l)) - (|traceReply|))) - -\end{chunk} - -\defun{trace1}{trace1} -\calls{trace1}{hasOption} -\calls{trace1}{throwKeyedMsg} -\calls{trace1}{unabbrev} -\calls{trace1}{isFunctor} -\calls{trace1}{getTraceOption} -\calls{trace1}{untraceDomainLocalOps} -\calls{trace1}{qslessp} -\calls{trace1}{poundsign} -\calls{trace1}{untrace} -\calls{trace1}{centerAndHighlight} -\calls{trace1}{ptimers} -\calls{trace1}{say} -\calls{trace1}{pcounters} -\calls{trace1}{selectOptionLC} -\calls{trace1}{resetSpacers} -\calls{trace1}{resetTimers} -\calls{trace1}{resetCounters} -\calls{trace1}{qcar} -\calls{trace1}{qcdr} -\calls{trace1}{vecp} -\calls{trace1}{sayKeyedMsg} -\calls{trace1}{devaluate} -\calls{trace1}{lassoc} -\calls{trace1}{trace1} -\calls{trace1}{delete} -\calls{trace1}{?t} -\calls{trace1}{seq} -\calls{trace1}{exit} -\calls{trace1}{transTraceItem} -\calls{trace1}{addassoc} -\calls{trace1}{getTraceOptions} -\calls{trace1}{/trace,0} -\calls{trace1}{saveMapSig} -\usesdollar{trace1}{traceNoisely} -\usesdollar{trace1}{options} -\usesdollar{trace1}{lastUntraced} -\usesdollar{trace1}{optionAlist} -\begin{chunk}{defun trace1} -(defun |trace1| (arg) - (prog (|$traceNoisely| constructor ops lops temp1 opt a - oldl newoptions domain tracelist optionlist domainlist - oplist y varlist argument) - (declare (special |$traceNoisely| |$options| |$lastUntraced| - |$optionAlist|)) - (return - (seq - (progn - (setq |$traceNoisely| nil) - (cond - ((|hasOption| |$options| '|nonquietly|) - (setq |$traceNoisely| t))) - (cond - ((|hasOption| |$options| '|off|) - (cond - ((or (setq ops (|hasOption| |$options| 'ops)) - (setq lops (|hasOption| |$options| '|local|))) - (cond - ((null arg) (|throwKeyedMsg| 's2it0019 nil)) - (t - (setq constructor - (|unabbrev| - (cond - ((atom arg) arg) - ((null (cdr arg)) - (cond - ((atom (car arg)) (car arg)) - (t (car (car arg))))) - (t nil)))) - (cond - ((null (|isFunctor| constructor)) - (|throwKeyedMsg| 's2it0020 nil)) - (t - (cond (ops (setq ops (|getTraceOption| ops)) nil)) - (cond - (lops - (setq lops (cdr (|getTraceOption| lops))) - (|untraceDomainLocalOps|)) - (t nil))))))) - ((and (qslessp 1 (|#| |$options|)) - (null (|hasOption| |$options| '|nonquietly|))) - (|throwKeyedMsg| 's2it0021 nil)) - (t (|untrace| arg)))) - ((|hasOption| |$options| '|stats|) - (cond - ((qslessp 1 (|#| |$options|)) - (|throwKeyedMsg| 's2it0001 (cons ")trace ... )stats" nil))) - (t - (setq temp1 (car |$options|)) - (setq opt (cdr temp1)) - (cond - ((null opt) - (|centerAndHighlight| "Traced function execution times" 78 '-) - (|ptimers|) - (say " ") - (|centerAndHighlight| "Traced function execution counts" 78 '-) - (|pcounters|)) - (t - (|selectOptionLC| (car opt) '(|reset|) '|optionError|) - (|resetSpacers|) - (|resetTimers|) - (|resetCounters|) - (|throwKeyedMsg| 's2it0002 nil)))))) - ((setq a (|hasOption| |$options| '|restore|)) - (unless (setq oldl |$lastUntraced|) - (setq newoptions (|delete| a |$options|)) - (if (null arg) - (|trace1| oldl) - (progn - (dolist (x arg) - (if (and (consp x) - (progn - (setq domain (qcar x)) - (setq oplist (qcdr x)) - t) - (vecp domain)) - (|sayKeyedMsg| 's2it0003 (cons (|devaluate| domain) nil)) - (progn - (setq |$options| (append newoptions (lassoc x |$optionAlist|))) - (|trace1| (list x))))))))) - ((null arg) nil) - ((and (consp arg) (eq (qcdr arg) nil) (eq (qcar arg) '?)) (|?t|)) - (t - (setq tracelist - (or - (prog (t1) - (setq t1 nil) - (return - (do ((t2 arg (cdr t2)) (x nil)) - ((or (atom t2) - (progn (setq x (car t2)) nil)) - (nreverse0 t1)) - (seq - (exit - (setq t1 (cons (|transTraceItem| x) t1))))))) - (return nil))) - (do ((t3 tracelist (cdr t3)) (x nil)) - ((or (atom t3) (progn (setq x (car t3)) nil)) nil) - (seq - (exit - (setq |$optionAlist| (addassoc x |$options| |$optionAlist|))))) - (setq optionlist (|getTraceOptions| |$options|)) - (setq argument - (cond - ((setq domainlist (lassoc '|of| optionlist)) - (cond - ((lassoc 'ops optionlist) - (|throwKeyedMsg| 's2it0004 nil)) - (t - (setq oplist - (cond - (tracelist (list (cons 'ops tracelist))) - (t nil))) - (setq varlist - (cond - ((setq y (lassoc '|vars| optionlist)) - (list (cons '|vars| y))) - (t nil))) - (append domainlist (append oplist varlist))))) - (optionlist (append tracelist optionlist)) - (t tracelist))) - (|/TRACE,0| - (prog (t4) - (setq t4 nil) - (return - (do ((t5 argument (cdr t5)) (|funName| nil)) - ((or (atom t5) - (progn (setq |funName| (car t5)) nil)) - (nreverse0 t4)) - (seq - (exit - (setq t4 (cons |funName| t4)))))))) - (|saveMapSig| - (prog (t6) - (setq t6 nil) - (return - (do ((t7 argument (cdr t7)) (|funName| nil)) - ((or (atom t7) - (progn (setq |funName| (car t7)) nil)) - (nreverse0 t6)) - (seq - (exit - (setq t6 (cons |funName| t6))))))))))))))) - -\end{chunk} - -\defun{getTraceOptions}{getTraceOptions} -\calls{getTraceOptions}{throwKeyedMsg} -\calls{getTraceOptions}{throwListOfKeyedMsgs} -\calls{getTraceOptions}{poundsign} -\calls{getTraceOptions}{seq} -\calls{getTraceOptions}{exit} -\calls{getTraceOptions}{getTraceOption} -\usesdollar{getTraceOptions}{traceErrorStack} -\begin{chunk}{defun getTraceOptions} -(defun |getTraceOptions| (|options|) - (prog (|$traceErrorStack| optionlist temp1 key |parms|) - (declare (special |$traceErrorStack|)) - (return - (seq - (progn - (setq |$traceErrorStack| nil) - (setq optionlist - (prog (t0) - (setq t0 nil) - (return - (do ((t1 |options| (cdr t1)) (x nil)) - ((or (atom t1) (progn (setq x (car t1)) nil)) (nreverse0 t0)) - (seq - (exit - (setq t0 (cons (|getTraceOption| x) t0)))))))) - (cond - (|$traceErrorStack| - (cond - ((null (cdr |$traceErrorStack|)) - (setq temp1 (car |$traceErrorStack|)) - (setq key (car temp1)) - (setq |parms| (cadr temp1)) - (|throwKeyedMsg| key (cons "" |parms|))) - (t - (|throwListOfKeyedMsgs| 's2it0017 - (cons (|#| |$traceErrorStack|) nil) - (nreverse |$traceErrorStack|))))) - (t optionlist))))))) - -\end{chunk} - -\defun{saveMapSig}{saveMapSig} -\calls{saveMapSig}{rassoc} -\calls{saveMapSig}{addassoc} -\calls{saveMapSig}{getMapSig} -\usesdollar{saveMapSig}{tracedMapSignatures} -\usesdollar{saveMapSig}{mapSubNameAlist} -\begin{chunk}{defun saveMapSig} -(defun |saveMapSig| (funnames) - (let (map) - (declare (special |$tracedMapSignatures| |$mapSubNameAlist|)) - (dolist (name funnames) - (when (setq map (|rassoc| name |$mapSubNameAlist|)) - (setq |$tracedMapSignatures| - (addassoc name (|getMapSig| map name) |$tracedMapSignatures|)))))) +o )ltrace + +\end{chunk} +\footnote{ +\fnref{boot} +\fnref{lisp} +\fnref{ltrace}} + +\subsection{The trace global variables} +This decides when to give trace and untrace messages. +\defdollar{traceNoisely} +\begin{chunk}{initvars} +(defvar |$traceNoisely| nil) \end{chunk} -\defun{getMapSig}{getMapSig} -\calls{getMapSig}{get} -\calls{getMapSig}{boot-equal} -\usesdollar{getMapSig}{InteractiveFrame} -\begin{chunk}{defun getMapSig} -(defun |getMapSig| (mapname subname) - (let (lmms sig) - (declare (special |$InteractiveFrame|)) - (when (setq lmms (|get| mapname '|localModemap| |$InteractiveFrame|)) - (do ((t0 lmms (cdr t0)) (|mm| nil) (t1 nil sig)) - ((or (atom t0) (progn (setq |mm| (car t0)) nil) t1) nil) - (when (boot-equal (cadr |mm|) subname) (setq sig (cdar |mm|)))) - sig))) +\defdollar{reportSpadtrace} +This reports the traced functions +\begin{chunk}{initvars} +(defvar |$reportSpadtrace| nil) \end{chunk} -\defun{getTraceOption,hn}{getTraceOption,hn} -\calls{getTraceOption,hn}{seq} -\calls{getTraceOption,hn}{exit} -\calls{getTraceOption,hn}{isDomainOrPackage} -\calls{getTraceOption,hn}{stackTraceOptionError} -\calls{getTraceOption,hn}{domainToGenvar} -\begin{chunk}{defun getTraceOption,hn} -(defun |getTraceOption,hn| (x) - (prog (g) - (return - (seq - (if (and (atom x) (null (upper-case-p (elt (princ-to-string x) 0)))) - (exit - (seq - (if (|isDomainOrPackage| (eval x)) (exit x)) - (exit - (|stackTraceOptionError| - (cons 's2it0013 (cons (cons x nil) nil))))))) - (if (setq g (|domainToGenvar| x)) (exit g)) - (exit - (|stackTraceOptionError| (cons 's2it0013 (cons (cons x nil) nil)))))))) +\defdollar{optionAlist} +\begin{chunk}{initvars} +(defvar |$optionAlist| nil) \end{chunk} -\defun{getTraceOption}{getTraceOption} -\calls{getTraceOption}{seq} -\calls{getTraceOption}{exit} -\calls{getTraceOption}{selectOptionLC} -\calls{getTraceOption}{identp} -\calls{getTraceOption}{stackTraceOptionError} -\calls{getTraceOption}{concat} -\calls{getTraceOption}{object2String} -\calls{getTraceOption}{transOnlyOption} -\calls{getTraceOption}{qcdr} -\calls{getTraceOption}{qcar} -\calls{getTraceOption}{getTraceOption,hn} -\calls{getTraceOption}{isListOfIdentifiersOrStrings} -\calls{getTraceOption}{isListOfIdentifiers} -\calls{getTraceOption}{throwKeyedMsg} -\usesdollar{getTraceOption}{traceOptionList} -\begin{chunk}{defun getTraceOption} -(defun |getTraceOption| (arg) - (prog (l |opts| key a |n|) - (declare (special |$traceOptionList|)) - (return - (seq - (progn - (setq key (car arg)) - (setq l (cdr arg)) - (setq key - (|selectOptionLC| key |$traceOptionList| '|traceOptionError|)) - (setq arg (cons key l)) - (cond - ((member key '(|nonquietly| |timer| |nt|)) arg) - ((eq key '|break|) - (cond - ((null l) (cons '|break| (cons '|before| nil))) - (t - (setq |opts| - (prog (t0) - (setq t0 nil) - (return - (do ((t1 l (cdr t1)) (y nil)) - ((or (atom t1) - (progn (setq y (car t1)) nil)) - (nreverse0 t0)) - (seq - (exit - (setq t0 - (cons - (|selectOptionLC| y '(|before| |after|) nil) t0)))))))) - (cond - ((prog (t2) - (setq t2 t) - (return - (do ((t3 nil (null t2)) (t4 |opts| (cdr t4)) (y nil)) - ((or t3 (atom t4) (progn (setq y (car t4)) nil)) t2) - (seq - (exit - (setq t2 (and t2 (identp y)))))))) - (cons '|break| |opts|)) - (t - (|stackTraceOptionError| (cons 's2it0008 (cons nil nil)))))))) - ((eq key '|restore|) - (cond - ((null l) arg) - (t - (|stackTraceOptionError| - (cons 's2it0009 - (cons (cons (concat ")" (|object2String| key)) nil) nil)))))) - ((eq key '|only|) (cons '|only| (|transOnlyOption| l))) - ((eq key '|within|) - (cond - ((and (consp l) - (eq (qcdr l) nil) - (progn (setq a (qcar l)) t) - (identp a)) - arg) - (t - (|stackTraceOptionError| - (cons 's2it0010 (cons (cons ")within" nil) nil)))))) - ((member key '(|cond| |before| |after|)) - (setq key - (cond - ((eq key '|cond|) '|when|) - (t key))) - (cond - ((and (consp l) - (eq (qcdr l) nil) - (progn (setq a (qcar l)) t)) - (cons key l)) - (t - (|stackTraceOptionError| - (cons 's2it0011 - (cons - (cons (concat ")" - (|object2String| key)) nil) nil)))))) - ((eq key '|depth|) - (cond - ((and (consp l) - (eq (qcdr l) nil) - (progn (setq |n| (qcar l)) t) - (integerp |n|)) - arg) - (t - (|stackTraceOptionError| - (cons 's2it0012 (cons (cons ")depth" nil) nil)))))) - ((eq key '|count|) - (cond - ((or (null l) - (and (consp l) - (eq (qcdr l) nil) - (progn (setq |n| (qcar l)) t) - (integerp |n|))) - arg) - (t - (|stackTraceOptionError| - (cons 's2it0012 (cons (cons ")count" nil) nil)))))) - ((eq key '|of|) - (cons '|of| - (prog (t5) - (setq t5 nil) - (return - (do ((t6 l (cdr t6)) (y nil)) - ((or (atom t6) (progn (setq y (car t6)) nil)) (nreverse0 t5)) - (seq - (exit - (setq t5 (cons (|getTraceOption,hn| y) t5))))))))) - ((member key '(|local| ops |vars|)) - (cond - ((or (null l) - (and (consp l) (eq (qcdr l) nil) (eq (qcar l) '|all|))) - (cons key '|all|)) - ((|isListOfIdentifiersOrStrings| l) arg) - (t - (|stackTraceOptionError| - (cons 's2it0015 - (cons - (cons (concat ")" (|object2String| key)) nil) nil)))))) - ((eq key '|varbreak|) - (cond - ((or (null l) - (and (consp l) (eq (qcdr l) nil) (eq (qcar l) '|all|))) - (cons '|varbreak| '|all|)) - ((|isListOfIdentifiers| l) arg) - (t - (|stackTraceOptionError| - (cons 's2it0016 - (cons - (cons (concat ")" (|object2String| key)) nil) nil)))))) - ((eq key '|mathprint|) - (cond - ((null l) arg) - (t - (|stackTraceOptionError| - (cons 's2it0009 - (cons - (cons (concat ")" (|object2String| key)) nil) nil)))))) - (key (|throwKeyedMsg| 's2it0005 (cons key nil))))))))) +\defdollar{tracedMapSignatures} +\begin{chunk}{initvars} +(defvar |$tracedMapSignatures| nil) \end{chunk} -\defun{traceOptionError}{traceOptionError} -\calls{traceOptionError}{stackTraceOptionError} -\calls{traceOptionError}{commandAmbiguityError} -\begin{chunk}{defun traceOptionError} -(defun |traceOptionError| (opt keys) - (if (null keys) - (|stackTraceOptionError| (cons 's2it0007 (cons (cons opt nil) nil))) - (|commandAmbiguityError| '|trace option| opt keys))) +\defdollar{traceOptionList} +\begin{chunk}{initvars} +(defvar |$traceOptionList| + '(|after| |before| |break| |cond| |count| |depth| |local| |mathprint| + |nonquietly| |nt| |of| |only| |ops| |restore| |timer| |varbreak| + |vars| |within|)) -\end{chunk} +\end{chunk} \defun{resetTimers}{resetTimers} \calls{resetTimers}{concat} @@ -38724,7 +40384,10 @@ This reports the traced functions ((integerp n) (cons n (|transOnlyOption| y))) ((member (setq n (upcase n)) '(v a c)) (cons n (|transOnlyOption| y))) (t - (|stackTraceOptionError| (cons 's2it0006 (list (list n)))) + (|stackTraceOptionError| + (cons + "%1 The )trace option )only does not permit %2 as a legal option." + (list (list n)))) (|transOnlyOption| y)))))) \end{chunk} @@ -38773,196 +40436,6 @@ This reports the traced functions \end{chunk} -\defun{genDomainTraceName}{genDomainTraceName} -\calls{genDomainTraceName}{lassoc} -\calls{genDomainTraceName}{genvar} -\usesdollar{genDomainTraceName}{domainTraceNameAssoc} -\begin{chunk}{defun genDomainTraceName} -(defun |genDomainTraceName| (y) - (let (u g) - (declare (special |$domainTraceNameAssoc|)) - (if (setq u (lassoc y |$domainTraceNameAssoc|)) - u - (progn - (setq g (genvar)) - (setq |$domainTraceNameAssoc| (cons (cons y g) |$domainTraceNameAssoc|)) - g)))) - -\end{chunk} - -\defun{untrace}{untrace} -\calls{untrace}{copy} -\calls{untrace}{transTraceItem} -\calls{untrace}{/untrace,0} -\calls{untrace}{lassocSub} -\calls{untrace}{removeTracedMapSigs} -\usesdollar{untrace}{lastUntraced} -\usesdollar{untrace}{mapSubNameAlist} -\uses{untrace}{/tracenames} -\begin{chunk}{defun untrace} -(defun |untrace| (arg) - (let (untracelist) - (declare (special |$lastUntraced| /tracenames |$mapSubNameAlist|)) - (if arg - (setq |$lastUntraced| arg) - (setq |$lastUntraced| (copy /tracenames))) - (setq untracelist - (do ((t1 arg (cdr t1)) (x nil) (t0 nil)) - ((or (atom t1) (progn (setq x (car t1)) nil)) - (nreverse0 t0)) - (push (|transTraceItem| x) t0))) - (|/UNTRACE,0| - (do ((t3 untracelist (cdr t3)) (|funName| nil) (t2 nil)) - ((or (atom t3) (progn (setq |funName| (car t3)) nil)) - (nreverse0 t2)) - (push (|lassocSub| |funName| |$mapSubNameAlist|) t2))) - (|removeTracedMapSigs| untracelist))) - -\end{chunk} - -\defun{transTraceItem}{transTraceItem} -\calls{transTraceItem}{get} -\calls{transTraceItem}{member} -\calls{transTraceItem}{objMode} -\calls{transTraceItem}{objVal} -\calls{transTraceItem}{domainToGenvar} -\calls{transTraceItem}{unabbrev} -\calls{transTraceItem}{constructor?} -\calls{transTraceItem}{vecp} -\calls{transTraceItem}{transTraceItem} -\calls{transTraceItem}{devaluate} -\calls{transTraceItem}{throwKeyedMsg} -\usesdollar{transTraceItem}{doNotAddEmptyModeIfTrue} -\begin{chunk}{defun transTraceItem} -(defun |transTraceItem| (x) - (prog (|$doNotAddEmptyModeIfTrue| |value| y) - (declare (special |$doNotAddEmptyModeIfTrue|)) - (return - (progn - (setq |$doNotAddEmptyModeIfTrue| t) - (cond - ((atom x) - (cond - ((and (setq |value| (|get| x '|value| |$InteractiveFrame|)) - (|member| (|objMode| |value|) - '((|Mode|) (|Domain|) (|SubDomain| (|Domain|))))) - (setq x (|objVal| |value|)) - (cond - ((setq y (|domainToGenvar| x)) y) - (t x))) - ((upper-case-p (elt (princ-to-string x) 0)) - (setq y (|unabbrev| x)) - (cond - ((|constructor?| y) y) - ((and (consp y) (|constructor?| (car y))) (car y)) - ((setq y (|domainToGenvar| x)) y) - (t x))) - (t x))) - ((vecp (car x)) (|transTraceItem| (|devaluate| (car x)))) - ((setq y (|domainToGenvar| x)) y) - (t (|throwKeyedMsg| 's2it0018 (cons x nil)))))))) - -\end{chunk} - -\defun{removeTracedMapSigs}{removeTracedMapSigs} -\usesdollar{removeTracedMapSigs}{tracedMapSignatures} -\begin{chunk}{defun removeTracedMapSigs} -(defun |removeTracedMapSigs| (untraceList) - (declare (special |$tracedMapSignatures|)) - (dolist (name untraceList) - (remprop name |$tracedMapSignatures|))) - -\end{chunk} - -\defun{coerceTraceArgs2E}{coerceTraceArgs2E} -\calls{coerceTraceArgs2E}{spadsysnamep} -\calls{coerceTraceArgs2E}{pname} -\calls{coerceTraceArgs2E}{coerceSpadArgs2E} -\calls{coerceTraceArgs2E}{objValUnwrap} -\calls{coerceTraceArgs2E}{coerceInteractive} -\calls{coerceTraceArgs2E}{mkObjWrap} -\usesdollar{coerceTraceArgs2E}{OutputForm} -\usesdollar{coerceTraceArgs2E}{mathTraceList} -\usesdollar{coerceTraceArgs2E}{tracedMapSignatures} -\begin{chunk}{defun coerceTraceArgs2E} -(defun |coerceTraceArgs2E| (tracename subname args) - (declare (ignore tracename)) - (let (name) - (declare (special |$OutputForm| |$mathTraceList| |$tracedMapSignatures|)) - (cond - ((member (setq name subname) |$mathTraceList|) - (if (spadsysnamep (pname name)) - (|coerceSpadArgs2E| (reverse (cdr (reverse args)))) - (do ((t1 '(|arg1| |arg2| |arg3| |arg4| |arg5| |arg6| |arg7| |arg8| - |arg9| |arg10| |arg11| |arg12| |arg13| |arg14| |arg15| - |arg16| |arg17| |arg18| |arg19|) (cdr t1)) - (name nil) - (t2 args (cdr t2)) - (arg nil) - (t3 (cdr (lassoc subname |$tracedMapSignatures|)) (cdr t3)) - (type nil) - (t0 nil)) - ((or (atom t1) - (progn (setq name (car t1)) nil) - (atom t2) - (progn (setq arg (car t2)) nil) - (atom t3) - (progn (setq type (car t3)) nil)) - (nreverse0 t0)) - (setq t0 - (cons - (list '= name - (|objValUnwrap| - (|coerceInteractive| - (mkObjWrap arg type) |$OutputForm|))) t0))))) - ((spadsysnamep (pname name)) (reverse (cdr (reverse args)))) - (t args)))) - -\end{chunk} - -\defun{coerceSpadArgs2E}{coerceSpadArgs2E} -\calls{coerceSpadArgs2E}{seq} -\calls{coerceSpadArgs2E}{exit} -\calls{coerceSpadArgs2E}{objValUnwrap} -\calls{coerceSpadArgs2E}{coerceInteractive} -\calls{coerceSpadArgs2E}{mkObjWrap} -\usesdollar{coerceSpadArgs2E}{streamCount} -\usesdollar{coerceSpadArgs2E}{OutputForm} -\usesdollar{coerceSpadArgs2E}{tracedSpadModemap} -\begin{chunk}{defun coerceSpadArgs2E} -(defun |coerceSpadArgs2E| (args) - (let ((|$streamCount| 0)) - (declare (special |$streamCount| |$OutputForm| |$tracedSpadModemap|)) - (do ((t1 '(|arg1| |arg2| |arg3| |arg4| |arg5| |arg6| |arg7| |arg8| - |arg9| |arg10| |arg11| |arg12| |arg13| |arg14| |arg15| - |arg16| |arg17| |arg18| |arg19|) (cdr t1)) - (name nil) - (t2 args (cdr t2)) - (arg nil) - (t3 (cdr |$tracedSpadModemap|) (cdr t3)) - (type nil) - (t0 nil)) - ((or (atom t1) - (progn (setq name (car t1)) nil) - (atom t2) - (progn (setq arg (car t2)) nil) - (atom t3) - (progn (setq type (car t3)) nil)) - (nreverse0 t0)) - (seq - (exit - (setq t0 - (cons - (cons '= - (cons name - (cons (|objValUnwrap| - (|coerceInteractive| - (mkObjWrap arg type) - |$OutputForm|)) nil))) - t0))))))) - -\end{chunk} - \defun{subTypes}{subTypes} \calls{subTypes}{lassoc} \calls{subTypes}{seq} @@ -38988,51 +40461,6 @@ This reports the traced functions \end{chunk} -\defun{coerceTraceFunValue2E}{coerceTraceFunValue2E} -\calls{coerceTraceFunValue2E}{spadsysnamep} -\calls{coerceTraceFunValue2E}{pname} -\calls{coerceTraceFunValue2E}{coerceSpadFunValue2E} -\calls{coerceTraceFunValue2E}{lassoc} -\calls{coerceTraceFunValue2E}{objValUnwrap} -\calls{coerceTraceFunValue2E}{coerceInteractive} -\calls{coerceTraceFunValue2E}{mkObjWrap} -\usesdollar{coerceTraceFunValue2E}{tracedMapSignatures} -\usesdollar{coerceTraceFunValue2E}{OutputForm} -\usesdollar{coerceTraceFunValue2E}{mathTraceList} -\begin{chunk}{defun coerceTraceFunValue2E} -(defun |coerceTraceFunValue2E| (tracename subname |value|) - (let (name u) - (declare (special |$tracedMapSignatures| |$OutputForm| |$mathTraceList|)) - (if (member (setq name subname) |$mathTraceList|) - (cond - ((spadsysnamep (pname tracename)) (|coerceSpadFunValue2E| |value|)) - ((setq u (lassoc subname |$tracedMapSignatures|)) - (|objValUnwrap| - (|coerceInteractive| (mkObjWrap |value| (car u)) |$OutputForm|))) - (t |value|)) - |value|))) - -\end{chunk} - -\defun{coerceSpadFunValue2E}{coerceSpadFunValue2E} -\calls{coerceSpadFunValue2E}{objValUnwrap} -\calls{coerceSpadFunValue2E}{coerceInteractive} -\calls{coerceSpadFunValue2E}{mkObjWrap} -\usesdollar{coerceSpadFunValue2E}{streamCount} -\usesdollar{coerceSpadFunValue2E}{tracedSpadModemap} -\usesdollar{coerceSpadFunValue2E}{OutputForm} -\begin{chunk}{defun coerceSpadFunValue2E} -(defun |coerceSpadFunValue2E| (|value|) - (let (|$streamCount|) - (declare (special |$streamCount| |$tracedSpadModemap| |$OutputForm|)) - (setq |$streamCount| 0) - (|objValUnwrap| - (|coerceInteractive| - (mkObjWrap |value| (car |$tracedSpadModemap|)) - |$OutputForm|)))) - -\end{chunk} - \defun{isListOfIdentifiers}{isListOfIdentifiers} \calls{isListOfIdentifiers}{seq} \calls{isListOfIdentifiers}{exit} @@ -39073,33 +40501,6 @@ This reports the traced functions \end{chunk} -\defun{getMapSubNames}{getMapSubNames} -\calls{getMapSubNames}{get} -\calls{getMapSubNames}{union} -\calls{getMapSubNames}{getPreviousMapSubNames} -\calls{getMapSubNames}{unionq} -\usesdollar{getMapSubNames}{lastUntraced} -\usesdollar{getMapSubNames}{InteractiveFrame} -\uses{getMapSubNames}{/tracenames} -\begin{chunk}{defun getMapSubNames} -(defun |getMapSubNames| (arg) - (let (lmm subs) - (declare (special /tracenames |$lastUntraced| |$InteractiveFrame|)) - (setq subs nil) - (dolist (mapname arg) - (when (setq lmm (|get| mapname '|localModemap| |$InteractiveFrame|)) - (setq subs - (append - (do ((t2 lmm (cdr t2)) (t1 nil) (|mm| nil)) - ((or (atom t2) - (progn (setq |mm| (CAR t2)) nil)) (nreverse0 t1)) - (setq t1 (cons (cons mapname (cadr |mm|)) t1))) - subs)))) - (|union| subs - (|getPreviousMapSubNames| (unionq /tracenames |$lastUntraced|))))) - -\end{chunk} - \defun{getPreviousMapSubNames}{getPreviousMapSubNames} \calls{getPreviousMapSubNames}{get} \calls{getPreviousMapSubNames}{exit} @@ -39172,43 +40573,19 @@ This reports the traced functions \end{chunk} -\defun{isInterpOnlyMap}{isInterpOnlyMap} -\calls{isInterpOnlyMap}{get} -\usesdollar{isInterpOnlyMap}{InteractiveFrame} -\begin{chunk}{defun isInterpOnlyMap} -(defun |isInterpOnlyMap| (map) - (let (x) - (declare (special |$InteractiveFrame|)) - (when (setq x (|get| map '|localModemap| |$InteractiveFrame|)) - (eq (caaar x) '|interpOnly|)))) - -\end{chunk} - -\defun{augmentTraceNames}{augmentTraceNames} -\calls{augmentTraceNames}{get} -\usesdollar{augmentTraceNames}{InteractiveFrame} -\begin{chunk}{defun augmentTraceNames} -(defun |augmentTraceNames| (arg) - (let (mml res) - (declare (special |$InteractiveFrame|)) - (dolist (tracename arg) - (if (setq mml (|get| tracename '|localModemap| |$InteractiveFrame|)) - (setq res - (append - (prog (t1) - (setq t1 nil) - (return - (do ((t2 mml (cdr t2)) (|mm| nil)) - ((or (atom t2) - (progn (setq |mm| (CAR t2)) nil)) - (nreverse0 t1)) - (setq t1 (cons (cadr |mm|) t1))))) - res)) - (setq res (cons tracename res)))) - res)) +\defun{isInterpOnlyMap}{isInterpOnlyMap} +\calls{isInterpOnlyMap}{get} +\usesdollar{isInterpOnlyMap}{InteractiveFrame} +\begin{chunk}{defun isInterpOnlyMap} +(defun |isInterpOnlyMap| (map) + (let (x) + (declare (special |$InteractiveFrame|)) + (when (setq x (|get| map '|localModemap| |$InteractiveFrame|)) + (eq (caaar x) '|interpOnly|)))) \end{chunk} + \defun{isSubForRedundantMapName}{isSubForRedundantMapName} \calls{isSubForRedundantMapName}{rassocSub} \calls{isSubForRedundantMapName}{member} @@ -39304,364 +40681,6 @@ This reports the traced functions \end{chunk} -\defun{spadTrace,g}{spadTrace,g} -\begin{chunk}{defun spadTrace,g} -(defun |spadTrace,g| (x) - (if (stringp x) (intern x) x)) - -\end{chunk} - -\defun{spadTrace,isTraceable}{spadTrace,isTraceable} -\calls{spadTrace,isTraceable}{seq} -\calls{spadTrace,isTraceable}{exit} -\calls{spadTrace,isTraceable}{gensymp} -\calls{spadTrace,isTraceable}{reportSpadTrace} -\calls{spadTrace,isTraceable}{bpiname} -\begin{chunk}{defun spadTrace,isTraceable} -(defun |spadTrace,isTraceable| (x |domain|) - (prog (n |functionSlot|) - (return - (seq - (progn - (setq n (caddr x)) - x - (seq - (if (atom (elt |domain| n)) (exit nil)) - (setq |functionSlot| (car (elt |domain| n))) - (if (gensymp |functionSlot|) - (exit (seq (|reportSpadTrace| '|Already Traced| x) (exit nil)))) - (if (null (bpiname |functionSlot|)) - (exit - (seq - (|reportSpadTrace| '|No function for| x) - (exit nil)))) - (exit t))))))) - -\end{chunk} - -\defun{spadTrace}{spadTrace} -\calls{spadTrace}{refvecp} -\calls{spadTrace}{aldorTrace} -\calls{spadTrace}{isDomainOrPackage} -\calls{spadTrace}{userError} -\calls{spadTrace}{seq} -\calls{spadTrace}{exit} -\calls{spadTrace}{spadTrace,g} -\calls{spadTrace}{getOption} -\calls{spadTrace}{removeOption} -\calls{spadTrace}{opOf} -\calls{spadTrace}{assoc} -\calls{spadTrace}{kdr} -\calls{spadTrace}{flattenOperationAlist} -\calls{spadTrace}{getOperationAlistFromLisplib} -\calls{spadTrace}{spadTrace,isTraceable} -\calls{spadTrace}{as-insert} -\calls{spadTrace}{bpiname} -\calls{spadTrace}{spadTraceAlias} -\calls{spadTrace}{subTypes} -\calls{spadTrace}{constructSubst} -\calls{spadTrace}{bpitrace} -\calls{spadTrace}{rplac} -\calls{spadTrace}{printDashedLine} -\calls{spadTrace}{reportSpadTrace} -\calls{spadTrace}{setletprintflag} -\calls{spadTrace}{spadReply} -\usesdollar{spadTrace}{tracedModemap} -\usesdollar{spadTrace}{fromSpadTrace} -\usesdollar{spadTrace}{letAssoc} -\usesdollar{spadTrace}{reportSpadTrace} -\usesdollar{spadTrace}{traceNoisely} -\uses{spadTrace}{/tracenames} -\begin{chunk}{defun spadTrace} -(defun |spadTrace| (domain options) - (let (|$tracedModemap| listofoperations listofvariables - listofbreakvars anyiftrue domainid currententry - currentalist opstructurelist sig kind triple fn op - mm n alias tracename sigslotnumberalist) - (declare (special |$tracedModemap| /tracenames |$fromSpadTrace| |$letAssoc| - |$reportSpadtrace| |$traceNoisely|)) - (setq |$fromSpadTrace| t) - (setq |$tracedModemap| nil) - (cond - ((and (consp domain) - (refvecp (car domain)) - (eql (elt (car domain) 0) 0)) - (|aldorTrace| domain options)) - ((null (|isDomainOrPackage| domain)) - (|userError| "bad argument to trace")) - (t - (setq listofoperations - (prog (t0) - (setq t0 nil) - (return - (do ((t1 (|getOption| 'ops options) (cdr t1)) (x nil)) - ((or (atom t1) (progn (setq x (car t1)) nil)) (nreverse0 t0)) - (seq - (exit - (setq t0 (cons (|spadTrace,g| x) t0)))))))) - (cond - ((setq listofvariables (|getOption| 'vars options)) - (setq options (|removeOption| 'vars options)))) - (cond - ((setq listofbreakvars (|getOption| 'varbreak options)) - (setq options (|removeOption| 'varbreak options)))) - (setq anyiftrue (null listofoperations)) - (setq domainid (|opOf| (elt domain 0))) - (setq currententry (|assoc| domain /tracenames)) - (setq currentalist (kdr currententry)) - (setq opstructurelist - (|flattenOperationAlist| (|getOperationAlistFromLisplib| domainid))) - (setq sigslotnumberalist - (prog (t2) - (setq t2 nil) - (return - (do ((t3 opstructurelist (cdr t3)) (t4 nil)) - ((or (atom t3) - (progn (setq t4 (CAR t3)) nil) - (progn - (progn - (setq op (car t4)) - (setq sig (cadr t4)) - (setq n (caddr t4)) - (setq kind (car (cddddr t4))) t4) - nil)) - (nreverse0 t2)) - (seq - (exit - (cond - ((and (eq kind 'elt) - (or anyiftrue (member op listofoperations)) - (integerp n) - (|spadTrace,isTraceable| - (setq triple - (cons op (cons sig (cons n nil)))) domain)) - (setq t2 (cons triple t2)))))))))) - (cond - (listofvariables - (do ((t5 sigslotnumberalist (cdr t5)) (t6 nil)) - ((or (atom t5) - (progn (setq t6 (car t5)) nil) - (progn (progn (setq n (caddr t6)) t6) nil)) - nil) - (seq - (exit - (progn - (setq fn (car (elt domain n))) - (setq |$letAssoc| - (as-insert (bpiname fn) listofvariables |$letAssoc|)))))))) - (cond - (listofbreakvars - (do ((t7 sigslotnumberalist (cdr t7)) (t8 nil)) - ((or (atom t7) - (progn (setq t8 (car t7)) nil) - (progn (progn (setq n (caddr t8)) t8) nil)) - nil) - (seq - (exit - (progn - (setq fn (car (elt domain n))) - (setq |$letAssoc| - (as-insert (bpiname fn) - (cons (cons 'break listofbreakvars) nil) |$letAssoc|)))))))) - (do ((t9 sigslotnumberalist (cdr t9)) (|pair| nil)) - ((or (atom t9) - (progn (setq |pair| (car t9)) nil) - (progn - (progn - (setq op (car |pair|)) - (setq mm (cadr |pair|)) - (setq n (caddr |pair|)) - |pair|) - nil)) - nil) - (seq - (exit - (progn - (setq alias (|spadTraceAlias| domainid op n)) - (setq |$tracedModemap| - (|subTypes| mm (|constructSubst| (elt domain 0)))) - (setq tracename - (bpitrace (car (elt domain n)) alias options)) - (nconc |pair| - (cons listofvariables - (cons (car (elt domain n)) - (cons tracename (cons alias nil))))) - (rplac (car (elt domain n)) tracename))))) - (setq sigslotnumberalist - (prog (t10) - (setq t10 nil) - (return - (do ((t11 sigslotnumberalist (cdr t11)) (x nil)) - ((or (atom t11) (progn (setq x (car t11)) nil)) (nreverse0 t10)) - (seq - (exit - (cond ((cdddr x) (setq t10 (cons x t10)))))))))) - (cond - (|$reportSpadtrace| - (cond (|$traceNoisely| (|printDashedLine|))) - (do ((t12 (|orderBySlotNumber| sigslotnumberalist) (cdr t12)) - (x nil)) - ((or (atom t12) - (progn (setq x (car t12)) nil)) - nil) - (seq (exit (|reportSpadTrace| 'tracing x)))))) - (cond (|$letAssoc| (setletprintflag t))) - (cond - (currententry - (rplac (cdr currententry) - (append sigslotnumberalist currentalist))) - (t - (setq /tracenames - (cons (cons domain sigslotnumberalist) /tracenames)) - (|spadReply|))))))) - -\end{chunk} - -\defun{traceDomainLocalOps}{traceDomainLocalOps} -\calls{traceDomainLocalOps}{sayMSG} -\begin{chunk}{defun traceDomainLocalOps} -(defun |traceDomainLocalOps| () - (|sayMSG| '(" The )local option has been withdrawn")) - (|sayMSG| '(" Use )ltr to trace local functions."))) - -\end{chunk} - -\defun{untraceDomainLocalOps}{untraceDomainLocalOps} -\calls{untraceDomainLocalOps}{sayMSG} -\begin{chunk}{defun untraceDomainLocalOps} -(defun |untraceDomainLocalOps| () - (|sayMSG| '(" The )local option has been withdrawn")) - (|sayMSG| '(" Use )ltr to trace local functions."))) - -\end{chunk} - -\defun{traceDomainConstructor}{traceDomainConstructor} -\calls{traceDomainConstructor}{getOption} -\calls{traceDomainConstructor}{seq} -\calls{traceDomainConstructor}{exit} -\calls{traceDomainConstructor}{spadTrace} -\calls{traceDomainConstructor}{concat} -\calls{traceDomainConstructor}{embed} -\calls{traceDomainConstructor}{mkq} -\calls{traceDomainConstructor}{loadFunctor} -\calls{traceDomainConstructor}{traceDomainLocalOps} -\usesdollar{traceDomainConstructor}{ConstructorCache} -\begin{chunk}{defun traceDomainConstructor} -(defun |traceDomainConstructor| (domainConstructor options) - (prog (listOfLocalOps argl domain innerDomainConstructor) - (declare (special |$ConstructorCache|)) - (return - (seq - (progn - (|loadFunctor| domainConstructor) - (setq listOfLocalOps (|getOption| 'local options)) - (when listOfLocalOps (|traceDomainLocalOps|)) - (cond - ((and listOfLocalOps (null (|getOption| 'ops options))) nil) - (t - (do ((t2 (hget |$ConstructorCache| domainConstructor) (cdr t2)) - (t3 nil)) - ((or (atom t2) - (progn (setq t3 (car t2)) nil) - (progn - (progn - (setq argl (car t3)) - (setq domain (cddr t3)) t3) - nil)) - nil) - (seq - (exit - (|spadTrace| domain options)))) - (setq /tracenames (cons domainConstructor /tracenames)) - (setq innerDomainConstructor - (intern (concat domainConstructor ";"))) - (cond - ((fboundp innerDomainConstructor) - (setq domainConstructor innerDomainConstructor))) - (embed domainConstructor - (cons 'lambda - (cons - (cons '&rest - (cons 'args nil)) - (cons - (cons 'prog - (cons - (cons 'domain nil) - (cons - (cons 'setq - (cons 'domain - (cons - (cons 'apply (cons domainConstructor - (cons 'args nil))) nil))) - (cons - (cons '|spadTrace| - (cons 'domain - (cons (mkq options) nil))) - (cons (cons 'return (cons 'domain nil)) nil))))) - nil))))))))))) - -\end{chunk} - -\defun{untraceDomainConstructor,keepTraced?}{% -untraceDomainConstructor,keepTraced?} -\calls{untraceDomainConstructor,keepTraced?}{seq} -\calls{untraceDomainConstructor,keepTraced?}{qcar} -\calls{untraceDomainConstructor,keepTraced?}{isDomainOrPackage} -\calls{untraceDomainConstructor,keepTraced?}{boot-equal} -\calls{untraceDomainConstructor,keepTraced?}{kar} -\calls{untraceDomainConstructor,keepTraced?}{devaluate} -\calls{untraceDomainConstructor,keepTraced?}{exit} -\calls{untraceDomainConstructor,keepTraced?}{/untrace,0} -\begin{chunk}{defun untraceDomainConstructor,keepTraced?} -(defun |untraceDomainConstructor,keepTraced?| (df domainConstructor) - (prog (dc) - (return - (seq - (if (and - (and - (and (consp df) (progn (setq dc (qcar df)) t)) - (|isDomainOrPackage| dc)) - (boot-equal (kar (|devaluate| dc)) domainConstructor)) - (exit (seq (|/UNTRACE,0| (cons dc nil)) (exit nil)))) - (exit t))))) - -\end{chunk} - -\defun{untraceDomainConstructor}{untraceDomainConstructor} -\calls{untraceDomainConstructor}{untraceDomainConstructor,keepTraced?} -\calls{untraceDomainConstructor}{unembed} -\calls{untraceDomainConstructor}{seq} -\calls{untraceDomainConstructor}{exit} -\calls{untraceDomainConstructor}{concat} -\calls{untraceDomainConstructor}{delete} -\uses{untraceDomainConstructor}{/tracenames} -\begin{chunk}{defun untraceDomainConstructor} -(defun |untraceDomainConstructor| (domainConstructor) - (prog (innerDomainConstructor) - (declare (special /tracenames)) - (return - (seq - (progn - (setq /tracenames - (prog (t0) - (setq t0 nil) - (return - (do ((t1 /tracenames (cdr t1)) (df nil)) - ((or (atom t1) (progn (setq df (car t1)) nil)) (nreverse0 t0)) - (seq - (exit - (cond ((|untraceDomainConstructor,keepTraced?| - df domainConstructor) - (setq t0 (cons df t0)))))))))) - (setq innerDomainConstructor - (intern (concat domainConstructor ";"))) - (cond - ((fboundp innerDomainConstructor) (unembed innerDomainConstructor)) - (t (unembed domainConstructor))) - (setq /tracenames (|delete| domainConstructor /tracenames))))))) - -\end{chunk} - \defun{flattenOperationAlist}{flattenOperationAlist} \calls{flattenOperationAlist}{seq} \calls{flattenOperationAlist}{exit} @@ -39696,18 +40715,6 @@ untraceDomainConstructor,keepTraced?} \end{chunk} -\defun{mapLetPrint}{mapLetPrint} -\calls{mapLetPrint}{getAliasIfTracedMapParameter} -\calls{mapLetPrint}{getBpiNameIfTracedMap} -\calls{mapLetPrint}{letPrint} -\begin{chunk}{defun mapLetPrint} -(defun |mapLetPrint| (x val currentFunction) - (setq x (|getAliasIfTracedMapParameter| x currentFunction)) - (setq currentFunction (|getBpiNameIfTracedMap| currentFunction)) - (|letPrint| x val currentFunction)) - -\end{chunk} - \defun{letPrint}{letPrint} \calls{letPrint}{lassoc} \calls{letPrint}{isgenvar} @@ -39755,6 +40762,7 @@ untraceDomainConstructor,keepTraced?} |val|)))) \end{chunk} + \defun{isSharpVarWithNum}{Identifier beginning with a sharpsign-number?} This tests if x is an identifier beginning with \verb|#| followed by a number. @@ -39803,7 +40811,6 @@ This tests if x is an identifier beginning with \verb|#| \end{chunk} - \defun{letPrint2}{letPrint2} \catches{letPrint2}{letPrint2} \calls{letPrint2}{lassoc} @@ -39917,55 +40924,6 @@ to convert the data into type "Expression" x)))) \end{chunk} -\defun{getAliasIfTracedMapParameter}{getAliasIfTracedMapParameter} -\calls{getAliasIfTracedMapParameter}{isSharpVarWithNum} -\calls{getAliasIfTracedMapParameter}{get} -\calls{getAliasIfTracedMapParameter}{exit} -\calls{getAliasIfTracedMapParameter}{spaddifference} -\calls{getAliasIfTracedMapParameter}{string2pint-n} -\calls{getAliasIfTracedMapParameter}{substring} -\calls{getAliasIfTracedMapParameter}{pname} -\calls{getAliasIfTracedMapParameter}{seq} -\usesdollar{getAliasIfTracedMapParameter}{InteractiveFrame} -\begin{chunk}{defun getAliasIfTracedMapParameter} -(defun |getAliasIfTracedMapParameter| (x |currentFunction|) - (prog (|aliasList|) - (declare (special |$InteractiveFrame|)) - (return - (seq - (cond - ((|isSharpVarWithNum| x) - (cond - ((setq |aliasList| - (|get| |currentFunction| 'alias |$InteractiveFrame|)) - (exit - (elt |aliasList| - (spaddifference - (string2pint-n (substring (pname x) 1 nil) 1) 1)))))) - (t x)))))) - -\end{chunk} - -\defun{getBpiNameIfTracedMap}{getBpiNameIfTracedMap} -\calls{getBpiNameIfTracedMap}{get} -\calls{getBpiNameIfTracedMap}{exit} -\calls{getBpiNameIfTracedMap}{seq} -\usesdollar{getBpiNameIfTracedMap}{InteractiveFrame} -\uses{getBpiNameIfTracedMap}{/tracenames} -\begin{chunk}{defun getBpiNameIfTracedMap} -(defun |getBpiNameIfTracedMap| (name) - (prog (lmm bpiName) - (declare (special |$InteractiveFrame| /tracenames)) - (return - (seq - (cond - ((setq lmm (|get| name '|localModemap| |$InteractiveFrame|)) - (cond - ((member (setq bpiName (cadar lmm)) /tracenames) - (exit bpiName)))) - (t name)))))) - -\end{chunk} \defun{hasPair}{hasPair} \calls{hasPair}{qcar} @@ -39999,14 +40957,6 @@ to convert the data into type "Expression" \end{chunk} -\defun{spadTraceAlias}{spadTraceAlias} -\calls{spadTraceAlias}{internl} -\begin{chunk}{defun spadTraceAlias} -(defun |spadTraceAlias| (domainid op n) - (internl domainid (intern "." "boot") op '|,| (princ-to-string n))) - -\end{chunk} - \defun{getOption}{getOption} \calls{getOption}{assoc} \begin{chunk}{defun getOption} @@ -40016,47 +40966,6 @@ to convert the data into type "Expression" \end{chunk} -\defun{reportSpadTrace}{reportSpadTrace} -\calls{reportSpadTrace}{qcar} -\calls{reportSpadTrace}{sayBrightly} -\usesdollar{reportSpadTrace}{traceNoisely} -\begin{chunk}{defun reportSpadTrace} -(defun |reportSpadTrace| (|header| t0) - (prog (op sig n |t| |msg| |namePart| y |tracePart|) - (declare (special |$traceNoisely|)) - (return - (progn - (setq op (car t0)) - (setq sig (cadr t0)) - (setq n (caddr t0)) - (setq |t| (cdddr t0)) - (cond - ((null |$traceNoisely|) nil) - (t - (setq |msg| - (cons |header| - (cons '|%b| - (cons op - (cons '|:| - (cons '|%d| - (cons (CDR sig) - (cons '| -> | - (cons (car sig) - (cons '| in slot | - (cons n nil))))))))))) - (setq |namePart| nil) - (setq |tracePart| - (cond - ((and (consp |t|) (progn (setq y (qcar |t|)) t) (null (null y))) - (cond - ((eq y '|all|) - (cons '|%b| (cons '|all| (cons '|%d| (cons '|vars| nil))))) - (t (cons '| vars: | (cons y nil))))) - (t nil))) - (|sayBrightly| (append |msg| (append |namePart| |tracePart|))))))))) - -\end{chunk} - \defun{orderBySlotNumber}{orderBySlotNumber} \calls{orderBySlotNumber}{seq} \calls{orderBySlotNumber}{assocright} @@ -40083,38 +40992,6 @@ to convert the data into type "Expression" \end{chunk} -\defun{/tracereply}{/tracereply} -\calls{/tracereply}{qcar} -\calls{/tracereply}{isDomainOrPackage} -\calls{/tracereply}{devaluate} -\calls{/tracereply}{seq} -\calls{/tracereply}{exit} -\uses{/tracereply}{/tracenames} -\begin{chunk}{defun /tracereply} -(defun /tracereply () - (prog (|d| domainlist |functionList|) - (declare (special /tracenames)) - (return - (seq - (cond - ((null /tracenames) " Nothing is traced.") - (t - (do ((t0 /tracenames (cdr t0)) (x nil)) - ((or (atom t0) (progn (setq x (car t0)) nil)) nil) - (seq - (exit - (cond - ((and (consp x) - (progn (setq |d| (qcar x)) t) - (|isDomainOrPackage| |d|)) - (setq domainlist (cons (|devaluate| |d|) domainlist))) - (t - (setq |functionList| (cons x |functionList|))))))) - (append |functionList| - (append domainlist (cons '|traced| nil))))))))) - -\end{chunk} - \defun{spadReply,printName}{spadReply,printName} \calls{spadReply,printName}{seq} \calls{spadReply,printName}{qcar} @@ -40155,99 +41032,6 @@ to convert the data into type "Expression" \end{chunk} -\defun{spadUntrace}{spadUntrace} -\calls{spadUntrace}{isDomainOrPackage} -\calls{spadUntrace}{userError} -\calls{spadUntrace}{getOption} -\calls{spadUntrace}{devaluate} -\calls{spadUntrace}{assoc} -\calls{spadUntrace}{sayMSG} -\calls{spadUntrace}{bright} -\calls{spadUntrace}{prefix2String} -\calls{spadUntrace}{bpiname} -\calls{spadUntrace}{remover} -\calls{spadUntrace}{setletprintflag} -\calls{spadUntrace}{bpiuntrace} -\calls{spadUntrace}{rplac} -\calls{spadUntrace}{seq} -\calls{spadUntrace}{exit} -\calls{spadUntrace}{delasc} -\calls{spadUntrace}{spadReply} -\usesdollar{spadUntrace}{letAssoc} -\uses{spadUntrace}{/tracenames} -\begin{chunk}{defun spadUntrace} -(defun |spadUntrace| (domain options) - (prog (anyiftrue listofoperations domainid |pair| sigslotnumberalist - op sig n |lv| |bpiPointer| tracename alias |assocPair| - |newSigSlotNumberAlist|) - (declare (special |$letAssoc| /tracenames)) - (return - (seq - (cond - ((null (|isDomainOrPackage| domain)) - (|userError| "bad argument to untrace")) - (t - (setq anyiftrue (null options)) - (setq listofoperations (|getOption| '|ops:| options)) - (setq domainid (|devaluate| domain)) - (cond - ((null (setq |pair| (|assoc| domain /tracenames))) - (|sayMSG| - (cons " No functions in" - (append - (|bright| (|prefix2String| domainid)) - (cons "are now traced." nil))))) - (t - (setq sigslotnumberalist (cdr |pair|)) - (do ((t0 sigslotnumberalist (cdr t0)) (|pair| nil)) - ((or (atom t0) - (progn (setq |pair| (car t0)) nil) - (progn - (progn - (setq op (car |pair|)) - (setq sig (cadr |pair|)) - (setq n (caddr |pair|)) - (setq |lv| (cadddr |pair|)) - (setq |bpiPointer| (car (cddddr |pair|))) - (setq tracename (cadr (cddddr |pair|))) - (setq alias (caddr (cddddr |pair|))) - |pair|) - nil)) - nil) - (seq - (exit - (cond - ((or anyiftrue (member op listofoperations)) - (progn - (bpiuntrace tracename alias) - (rplac (car (elt domain n)) |bpiPointer|) - (rplac (cdddr |pair|) nil) - (cond - ((setq |assocPair| - (|assoc| (bpiname |bpiPointer|) |$letAssoc|)) - (setq |$letAssoc| (remover |$letAssoc| |assocPair|)) - (cond - ((null |$letAssoc|) (setletprintflag nil)) - (t nil))) - (t nil)))))))) - (setq |newSigSlotNumberAlist| - (prog (t1) - (setq t1 nil) - (return - (do ((t2 sigslotnumberalist (cdr t2)) (x nil)) - ((or (atom t2) (progn (setq x (car t2)) nil)) (nreverse0 t1)) - (seq - (exit - (cond ((cdddr x) (setq t1 (cons x t1)))))))))) - (cond - (|newSigSlotNumberAlist| - (rplac (cdr |pair|) |newSigSlotNumberAlist|)) - (t - (setq /tracenames (delasc domain /tracenames)) - (|spadReply|))))))))))) - -\end{chunk} - \defun{remover}{remover} \calls{remover}{remover} \begin{chunk}{defun remover} @@ -40263,362 +41047,12 @@ to convert the data into type "Expression" \end{chunk} -\defun{prTraceNames,fn}{prTraceNames,fn} -\calls{prTraceNames,fn}{seq} -\calls{prTraceNames,fn}{qcar} -\calls{prTraceNames,fn}{qcdr} -\calls{prTraceNames,fn}{isDomainOrPackage} -\calls{prTraceNames,fn}{exit} -\calls{prTraceNames,fn}{devaluate} -\begin{chunk}{defun prTraceNames,fn} -(defun |prTraceNames,fn| (x) - (prog (|d| |t|) - (return - (seq - (if (and (and (consp x) - (progn (setq |d| (qcar x)) (setq |t| (qcdr x)) t)) - (|isDomainOrPackage| |d|)) - (exit (cons (|devaluate| |d|) |t|))) - (exit x))))) - -\end{chunk} - -\defun{prTraceNames}{prTraceNames} -\calls{prTraceNames}{seq} -\calls{prTraceNames}{exit} -\calls{prTraceNames}{prTraceNames,fn} -\uses{prTraceNames}{/tracenames} -\begin{chunk}{defun prTraceNames} -(defun |prTraceNames| () - (declare (special /tracenames)) - (seq - (progn - (do ((t0 /tracenames (cdr t0)) (x nil)) - ((or (atom t0) (progn (setq x (car t0)) nil)) nil) - (seq - (exit - (print (|prTraceNames,fn| x))))) nil))) - -\end{chunk} - \defdollar{constructors} \begin{chunk}{initvars} (defvar |$constructors| nil) \end{chunk} -\defun{traceReply}{traceReply} -\calls{traceReply}{sayMessage} -\calls{traceReply}{sayBrightly} -\calls{traceReply}{qcar} -\calls{traceReply}{isDomainOrPackage} -\calls{traceReply}{addTraceItem} -\calls{traceReply}{isFunctor} -\calls{traceReply}{isgenvar} -\calls{traceReply}{userError} -\calls{traceReply}{seq} -\calls{traceReply}{exit} -\calls{traceReply}{isSubForRedundantMapName} -\calls{traceReply}{rassocSub} -\calls{traceReply}{poundsign} -\calls{traceReply}{sayMSG} -\calls{traceReply}{sayBrightlyLength} -\calls{traceReply}{flowSegmentedMsg} -\calls{traceReply}{concat} -\calls{traceReply}{prefix2String} -\calls{traceReply}{abbreviate} -\usesdollar{traceReply}{domains} -\usesdollar{traceReply}{packages} -\usesdollar{traceReply}{constructors} -\usesdollar{traceReply}{linelength} -\uses{traceReply}{/tracenames} -\begin{chunk}{defun traceReply} -(defun |traceReply| () - (prog (|$domains| |$packages| |$constructors| |d| |functionList| - |displayList|) - (declare (special |$domains| |$packages| |$constructors| /tracenames - $linelength)) - (return - (seq - (progn - (setq |$domains| nil) - (setq |$packages| nil) - (setq |$constructors| nil) - (cond - ((null /tracenames) (|sayMessage| " Nothing is traced now.")) - (t - (|sayBrightly| " ") - (do ((t0 /tracenames (cdr t0)) (x nil)) - ((or (atom t0) (progn (setq x (car t0)) nil)) nil) - (seq - (exit - (cond - ((and (consp x) - (progn (setq |d| (qcar x)) t) (|isDomainOrPackage| |d|)) - (|addTraceItem| |d|)) - ((atom x) - (cond - ((|isFunctor| x) (|addTraceItem| x)) - ((isgenvar x) (|addTraceItem| (EVAL x))) - (t (setq |functionList| (cons x |functionList|))))) - (t (|userError| "bad argument to trace")))))) - (setq |functionList| - (prog (t1) - (setq t1 nil) - (return - (do ((t2 |functionList| (cdr t2)) (x nil)) - ((or (atom t2) (progn (setq x (car t2)) nil)) t1) - (seq - (exit - (cond - ((null (|isSubForRedundantMapName| x)) - (setq t1 - (append t1 - (cons (|rassocSub| x |$mapSubNameAlist|) - (cons " " nil)))))))))))) - (cond - (|functionList| - (cond - ((eql 2 (|#| |functionList|)) - (|sayMSG| (cons '| Function traced: | |functionList|))) - ((<= (+ 22 (|sayBrightlyLength| |functionList|)) $linelength) - (|sayMSG| (cons '| Functions traced: | |functionList|))) - (t - (|sayBrightly| " Functions traced:") - (|sayBrightly| - (|flowSegmentedMsg| |functionList| $linelength 6)))))) - (cond - (|$domains| - (setq |displayList| - (|concat| - (|prefix2String| (CAR |$domains|)) - (prog (t3) - (setq t3 nil) - (return - (do ((t4 (cdr |$domains|) (cdr t4)) (x nil)) - ((or (atom t4) (progn (setq x (car t4)) nil)) t3) - (seq - (exit - (setq t3 - (append t3 (|concat| "," " " (|prefix2String| x))))))))))) - (cond - ((atom |displayList|) - (setq |displayList| (cons |displayList| nil)))) - (|sayBrightly| " Domains traced: ") - (|sayBrightly| (|flowSegmentedMsg| |displayList| $linelength 6)))) - (cond - (|$packages| - (setq |displayList| - (|concat| - (|prefix2String| (CAR |$packages|)) - (prog (t5) - (setq t5 nil) - (return - (do ((t6 (cdr |$packages|) (cdr t6)) (x nil)) - ((or (atom t6) (progn (setq x (car t6)) nil)) t5) - (seq - (exit - (setq t5 - (append t5 (|concat| '|, | (|prefix2String| x))))))))))) - (cond ((atom |displayList|) - (setq |displayList| (cons |displayList| nil)))) - (|sayBrightly| " Packages traced: ") - (|sayBrightly| (|flowSegmentedMsg| |displayList| $linelength 6)))) - (cond - (|$constructors| - (setq |displayList| - (|concat| - (|abbreviate| (CAR |$constructors|)) - (prog (t7) - (setq t7 nil) - (return - (do ((t8 (cdr |$constructors|) (cdr t8)) (x nil)) - ((or (atom t8) (progn (setq x (car t8)) nil)) t7) - (seq - (exit - (setq t7 - (append t7 (|concat| '|, | (|abbreviate| x))))))))))) - (cond ((atom |displayList|) - (setq |displayList| (cons |displayList| nil)))) - (|sayBrightly| " Parameterized constructors traced:") - (|sayBrightly| (|flowSegmentedMsg| |displayList| $linelength 6))) - (t nil))))))))) - -\end{chunk} - -\defun{addTraceItem}{addTraceItem} -\calls{addTraceItem}{constructor?} -\calls{addTraceItem}{isDomain} -\calls{addTraceItem}{devaluate} -\calls{addTraceItem}{isDomainOrPackage} -\usesdollar{addTraceItem}{constructors} -\usesdollar{addTraceItem}{domains} -\usesdollar{addTraceItem}{packages} -\begin{chunk}{defun addTraceItem} -(defun |addTraceItem| (|d|) - (declare (special |$constructors| |$domains| |$packages|)) - (cond - ((|constructor?| |d|) - (setq |$constructors| (cons |d| |$constructors|))) - ((|isDomain| |d|) - (setq |$domains| (cons (|devaluate| |d|) |$domains|))) - ((|isDomainOrPackage| |d|) - (setq |$packages| (cons (|devaluate| |d|) |$packages|))))) - -\end{chunk} - -\defun{?t}{?t} -\calls{?t}{isgenvar} -\calls{?t}{get} -\calls{?t}{sayMSG} -\calls{?t}{bright} -\calls{?t}{rassocSub} -\calls{?t}{qcar} -\calls{?t}{qcdr} -\calls{?t}{isDomainOrPackage} -\calls{?t}{isDomain} -\calls{?t}{reportSpadTrace} -\calls{?t}{take} -\calls{?t}{sayBrightly} -\calls{?t}{devaluate} -\usesdollar{?t}{mapSubNameAlist} -\usesdollar{?t}{InteractiveFrame} -\uses{?t}{/tracenames} -\begin{chunk}{defun ?t} -(defun |?t| () - (let (llm d suffix l) - (declare (special /tracenames |$InteractiveFrame| |$mapSubNameAlist|)) - (if (null /tracenames) - (|sayMSG| (|bright| "nothing is traced")) - (progn - (dolist (x /tracenames) - (cond - ((and (atom x) (null (isgenvar x))) - (progn - (cond - ((setq llm (|get| x '|localModemap| |$InteractiveFrame|)) - (setq x (list (cadar llm))))) - (|sayMSG| - `("Function" ,@(|bright| (|rassocSub| x |$mapSubNameAlist|)) - "traced")))))) - (dolist (x /tracenames) - (cond - ((and (consp x) - (progn (setq d (qcar x)) (setq l (qcdr x)) t) - (|isDomainOrPackage| d)) - (progn - (setq suffix (cond ((|isDomain| d) "domain") (t "package"))) - (|sayBrightly| - `(" Functions traced in " ,suffix |%b| ,(|devaluate| d) |%d| ":")) - (dolist (x (|orderBySlotNumber| l)) - (|reportSpadTrace| '| | (TAKE 4 x))) - (terpri))))))))) - -\end{chunk} -\defun{tracelet}{tracelet} -\calls{tracelet}{gensymp} -\calls{tracelet}{stupidIsSpadFunction} -\calls{tracelet}{bpiname} -\calls{tracelet}{lassoc} -\calls{tracelet}{union} -\calls{tracelet}{setletprintflag} -\calls{tracelet}{isgenvar} -\calls{tracelet}{compileBoot} -\calls{tracelet}{delete} -\usesdollar{tracelet}{traceletflag} -\usesdollar{tracelet}{QuickLet} -\usesdollar{tracelet}{letAssoc} -\usesdollar{tracelet}{traceletFunctions} -\begin{chunk}{defun tracelet} -(defun |tracelet| (fn |vars|) - (prog ($traceletflag |$QuickLet| l) - (declare (special $traceletflag |$QuickLet| |$letAssoc| - |$traceletFunctions|)) - (return - (progn - (cond - ((and (gensymp fn) (|stupidIsSpadFunction| (eval fn))) - (setq fn (eval fn)) - (cond - ((compiled-function-p fn) (setq fn (bpiname fn))) - (t nil)))) - (cond - ((eq fn '|Undef|) nil) - (t - (setq |vars| - (cond - ((eq |vars| '|all|) '|all|) - ((setq l (lassoc fn |$letAssoc|)) (|union| |vars| l)) - (t |vars|))) - (setq |$letAssoc| (cons (cons fn |vars|) |$letAssoc|)) - (cond (|$letAssoc| (setletprintflag t))) - (setq $traceletflag t) - (setq |$QuickLet| nil) - (cond - ((and (null (member fn |$traceletFunctions|)) - (null (isgenvar fn)) - (compiled-function-p (symbol-function fn)) - (null (|stupidIsSpadFunction| fn)) - (null (gensymp fn))) - (progn - (setq |$traceletFunctions| (cons fn |$traceletFunctions|)) - (|compileBoot| fn) - (setq |$traceletFunctions| - (|delete| fn |$traceletFunctions|))))))))))) - -\end{chunk} -\defun{breaklet}{breaklet} -\calls{breaklet}{gensymp} -\calls{breaklet}{stupidIsSpadFunction} -\calls{breaklet}{bpiname} -\calls{breaklet}{lassoc} -\calls{breaklet}{assoc} -\calls{breaklet}{union} -\calls{breaklet}{setletprintflag} -\calls{breaklet}{compileBoot} -\calls{breaklet}{delete} -\usesdollar{breaklet}{QuickLet} -\usesdollar{breaklet}{letAssoc} -\usesdollar{breaklet}{traceletFunctions} -\begin{chunk}{defun breaklet} -(defun |breaklet| (fn |vars|) - (prog (|$QuickLet| |fnEntry| |pair|) - (declare (special |$QuickLet| |$letAssoc| |$traceletFunctions|)) - (return - (progn - (cond - ((and (gensymp fn) (|stupidIsSpadFunction| (eval fn))) - (setq fn (eval fn)) - (cond - ((compiled-function-p fn) (setq fn (bpiname fn))) - (t nil)))) - (cond - ((eq fn '|Undef|) nil) - (t - (setq |fnEntry| (lassoc fn |$letAssoc|)) - (setq |vars| - (cond - ((setq |pair| (|assoc| 'break |fnEntry|)) - (|union| |vars| (cdr |pair|))) - (t |vars|))) - (setq |$letAssoc| - (cond - ((null |fnEntry|) - (cons (cons fn (list (cons 'break |vars|))) |$letAssoc|)) - (|pair| (rplacd |pair| |vars|) |$letAssoc|))) - (cond (|$letAssoc| (setletprintflag t))) - (setq |$QuickLet| nil) - (cond - ((and (null (member fn |$traceletFunctions|)) - (null (|stupidIsSpadFunction| fn)) - (null (gensymp fn))) - (progn - (setq |$traceletFunctions| (cons fn |$traceletFunctions|)) - (|compileBoot| fn) - (setq |$traceletFunctions| - (|delete| fn |$traceletFunctions|))))))))))) - -\end{chunk} \defun{stupidIsSpadFunction}{stupidIsSpadFunction} \calls{stupidIsSpadFunction}{strpos} \calls{stupidIsSpadFunction}{pname} @@ -40628,24 +41062,6 @@ to convert the data into type "Expression" \end{chunk} -\defun{break}{break} -\calls{break}{MONITOR,EVALTRAN} -\calls{break}{enable-backtrace} -\calls{break}{sayBrightly} -\calls{break}{interrupt} -\uses{break}{/breakcondition} -\begin{chunk}{defun break} -(defun |break| (msg) - (prog (condition) - (declare (special /breakcondition)) - (return - (progn - (setq condition (|MONITOR,EVALTRAN| /breakcondition nil)) - (when (eval condition) - (|sayBrightly| msg) - (interrupt)))))) - -\end{chunk} \defun{compileBoot}{compileBoot} \calls{compileBoot}{/D,1} \begin{chunk}{defun compileBoot} @@ -41028,8 +41444,13 @@ conditions of its modemap. ((|constructor?| form) (if (atom form) (|evaluateType| (list form)) - (|throwEvalTypeMsg| 'S2IE0003 (list form form)))) - (t (|throwEvalTypeMsg| 'S2IE0004 (list form)))))))) + (|throwEvalTypeMsg| + (format nil + "Although %1 is the name of a constructor, a full type must be ~ + specified in the context you have used it. Issue )show %2 ~ + for more information.") + (list form form)))) + (t (|throwEvalTypeMsg| "%1p is not a valid type." (list form)))))))) \end{chunk} @@ -41066,13 +41487,19 @@ Evaluates the arguments passed to a constructor. ((|constructor?| op) (cond ((null (setq sig (|getConstructorSignature| form))) - (|throwEvalTypeMsg| 'S2IE0005 (list form))) + (|throwEvalTypeMsg| + "You cannot now use %1p in the context you have it." (list form))) (t (setq ml (cdr sig)) (setq ml (|replaceSharps| ml form)) (cond ((not (eql (|#| argl) (|#| ml))) - (|throwEvalTypeMsg| 'S2IE0003 (list form form))) + (|throwEvalTypeMsg| + (format nil + "Although %1 is the name of a constructor, a full type must be ~ + specified in the context you have used it. Issue )show %2 ~ + for more information.") + (list form form))) (t (loop for x in argl for m in ml do @@ -41083,7 +41510,8 @@ Evaluates the arguments passed to a constructor. (setq m (|evaluateType| (subst x '$ m))) (if (|evalCategory| (setq xp (|evaluateType| x)) m) xp - (|throwEvalTypeMsg| 'S2IE0004 (list form)))) + (|throwEvalTypeMsg| "%1p is not a valid type." + (list form)))) (t (setq m (|evaluateType| m)) (cond @@ -41103,11 +41531,14 @@ Evaluates the arguments passed to a constructor. (|throwKeyedMsgCannotCoerceWithValue| zv zt m))) (t (when (equal x |$EmptyMode|) (setq x |$quadSymbol|)) - (|throwEvalTypeMsg| 'S2IE0006 + (|throwEvalTypeMsg| + "Cannot convert the %1 argument of %3p to the type %2p ." (list (|makeOrdinal| (incf argnum)) m form)))))) typeList))) (cons op (nreverse typeList))))))) - (t (|throwEvalTypeMsg| 'S2IE0007 (list op)))))) + (t (|throwEvalTypeMsg| + "Category, domain or package constructor %1 is not available." + (list op)))))) \end{chunk} @@ -41521,7 +41952,15 @@ o )show (setq args (cdr arg)) (setq key (|selectOptionLC| |key0| |$whatOptions| nil)) (cond - ((null key) (|sayKeyedMsg| 's2iz0043 nil)) + ((null key) + (|sayKeyedMsg| + (format nil + "Your argument is not valid for the )what system command. %l %l ~ + Use the )show system command to display the operations for a ~ + constructor. Use the )display operations system command to see ~ + information about an operation. These may be abbreviated to ~ + )sh and )d op, respectively.") + nil)) (t (setq args (prog (t0) @@ -41612,7 +42051,15 @@ o )show (when ell (|sayAsManyPerLineAsPossible| ell) (say " ")) - (unless patterns (|sayKeyedMsg| 's2iz0046 nil)))) + (unless patterns + (|sayKeyedMsg| + (format nil + "For more information about individual commands, use the )help ~ + system command followed by the command name or the command name ~ + followed by a question mark. Some commands (such as )lisp ) may ~ + require the )help lisp format. For example, issue )help help or ~ + )help %x1 ? to find out more about the help command itself.") + nil)))) \end{chunk} @@ -41772,7 +42219,11 @@ This displays all operation names containing these fragments. (ops (|sayMessage| "Operations whose names satisfy the above pattern(s):") (|sayAsManyPerLineAsPossible| (msort ops)) - (|sayKeyedMsg| 's2if0011 (cons (car ops) nil))) + (|sayKeyedMsg| + (format nil + "%l To get more information about an operation such as %1, issue ~ + the command )display op %1") + (cons (car ops) nil))) (t (|sayMessage| " There are no operations containing those patterns") nil))))))) @@ -41813,7 +42264,13 @@ This displays all operation names containing these fragments. (let (deleteflag type flist type1 fl) (declare (special |$options| |$sourceFiles| $linelength)) (cond - (args (|throwKeyedMsg| 's2iz0047 nil)) + (args + (|throwKeyedMsg| + (format nil + "Arguments are not allowed for the )workfiles system command. ~ + The )boot, )lisp, )meta and )delete options may be used with this ~ + command, however. Issue )help workfiles for more information.") + nil)) (t (setq deleteflag nil) (do ((t0 |$options| (cdr t0)) (t1 nil)) @@ -41824,7 +42281,13 @@ This displays all operation names containing these fragments. (setq type1 (|selectOptionLC| type '(|boot| |lisp| |meta| |delete|) nil)) (cond - ((null type1) (|throwKeyedMsg| 's2iz0048 (cons type nil))) + ((null type1) + (|throwKeyedMsg| + (format nil + "%1 is not an allowable option for the )workfiles system command. ~ + The )boot, )lisp, )meta and )delete options may be used with this ~ + command, however. Issue )help workfiles for more information.") + (cons type nil))) ((eq type1 '|delete|) (setq deleteflag t)))) (do ((t2 |$options| (cdr t2)) (t3 nil)) ((or (atom t2) @@ -41843,7 +42306,11 @@ This displays all operation names containing these fragments. (deleteflag (setq |$sourceFiles| (|delete| fl |$sourceFiles|))) ((null (makeInputFilename fl)) - (|sayKeyedMsg| 's2iz0035 (list (|namestring| fl)))) + (|sayKeyedMsg| + (format nil + "The file %1 will not be added to the list of working source ~ + files because the file does not exist.") + (list (|namestring| fl)))) (t (|updateSourceFiles| fl)))))) (say " ") (|centerAndHighlight| @@ -43896,7 +44363,9 @@ nrlib/index.kaf (setq options (lisp::delete dir options :test #'equal)) (setq dir (second dir)) (when (null dir) - (|sayKeyedMsg| 'S2IU0002 nil) )) + (|sayKeyedMsg| + "Ignoring )dir because an explicit directory was not given after )dir." + nil))) (when (setq noexpose (assoc '|noexpose| options)) (setq options (lisp::delete noexpose options :test #'equal)) (setq noexpose 't) ) @@ -44030,7 +44499,8 @@ nrlib/index.kaf (|startTimingProcess| '|load|) (|loadLibNoUpdate| key key object)) ; used to be cname key (apply key args))) - (|sayKeyedMsg| 'S2IU0001 (list key object)))))) + (|sayKeyedMsg| "%1 will be automatically loaded when needed from %2" + (list key object)))))) \end{chunk} @@ -44795,7 +45265,8 @@ database format. (t (setq kind (getdatabase cname 'constructorkind)) (when |$printLoadMsgs| - (|sayKeyedMsg| 'S2IL0002 (list (|namestring| fullLibName) kind cname))) + (|sayKeyedMsg| "Loading %1 for %2 %3" + (list (|namestring| fullLibName) kind cname))) (load fullLibName) (|clearConstructorCache| cname) (|updateDatabase| cname cname systemdir?) @@ -44843,7 +45314,8 @@ database format. (declare (special |$CategoryFrame| |$InteractiveMode| |$printLoadMsgs|)) (setq kind (getdatabase cname 'constructorkind)) (when |$printLoadMsgs| - (|sayKeyedMsg| 'S2IL0002 (list (|namestring| fullLibName) kind cname))) + (|sayKeyedMsg| "Loading %1 for %2 %3" + (list (|namestring| fullLibName) kind cname))) (cond ((equal (catch 'versioncheck (load fullLibName)) (- 1)) (princ " wrong library version...recompile ") @@ -45714,8 +46186,10 @@ Given a form, $u$, we try to recover the input line that created it. (defun |spad2BootCoerce| (x source target) (let (xp) (cond - ((null (|isValidType| source)) (|throwKeyedMsg| 'S2IE0004 (list source))) - ((null (|isValidType| target)) (|throwKeyedMsg| 'S2IE0004 (list target))) + ((null (|isValidType| source)) + (|throwKeyedMsg| "%1p is not a valid type." (list source))) + ((null (|isValidType| target)) + (|throwKeyedMsg| "%1p is not a valid type." (list target))) ((setq xp (|coerceInteractive| (mkObjWrap x source) target)) (|objValUnwrap| xp)) (t @@ -60393,7 +60867,6 @@ digits in TechExplorer. Since Saturn is gone we can remove it. \getchunk{defun getMsgCatAttr} \getchunk{defun getMsgFTTag?} \getchunk{defun getMsgInfoFromKey} -\getchunk{defun getMsgLitSym} \getchunk{defun getMsgPos} \getchunk{defun getMsgPos2} \getchunk{defun getMsgToWhere} diff --git a/books/bookvol9.pamphlet b/books/bookvol9.pamphlet index 27d64f5..fb6683d 100644 --- a/books/bookvol9.pamphlet +++ b/books/bookvol9.pamphlet @@ -2863,9 +2863,7 @@ abbreviation and the {\bf .nrlib} file extension. For example, the directory containing the compiled code for the {\tt MATRIX} constructor is called {\bf MATRIX.nrlib.} The {\tt )nolibrary} option says that such files should not be created. The default is -{\tt )library.} Note that the semantics of {\tt )library} and -{\tt )nolibrary} for the new Aldor compiler and for the old system -compiler are completely different. +{\tt )library.} The {\tt )vartrace} option causes the compiler to generate extra code for the constructor to support conditional tracing of variable @@ -22744,8 +22742,7 @@ The default call chain looks like: \begin{verbatim} 1> (|compiler| ...) 2> (|compileSpad2Cmd| ...) - Compiling AXIOM source code from file /tmp/A.spad using old system - compiler. + Compiling AXIOM source code from file /tmp/A.spad 3> (|compilerDoit| ...) 4> (|/RQ,LIB|) 5> (/RF-1 ...) @@ -23129,8 +23126,7 @@ The trace of the functions in this routines is: 3> (|pathname| ("/tmp/EQ.spad")) <3 (|pathname| #p"/tmp/EQ.spad") <2 (|namestring| "/tmp/EQ.spad") - Compiling AXIOM source code from file /tmp/EQ.spad using old system - compiler. + Compiling AXIOM source code from file /tmp/EQ.spad \end{verbatim} Again we find a lot of redundant work. We finally end up calling @@ -23192,9 +23188,7 @@ Again we find a lot of redundant work. We finally end up calling (t (setq /editfile path) (|updateSourceFiles| path) - (|sayKeyedMsg| - (format nil "Compiling AXIOM source code from ~ - file %1 using old system compiler.") + (|sayKeyedMsg| "Compiling AXIOM source code from %1" (list (|namestring| args))) (setq optlist '(|break| |constructor| |functions| |library| |lisp| |new| |old| |nobreak| |nolibrary| |noquiet| |vartrace| |quiet| diff --git a/changelog b/changelog index daf3ec1..d9ddd11 100644 --- a/changelog +++ b/changelog @@ -1,3 +1,22 @@ +20150407 tpd src/axiom-website/patches.html 20150407.01.tpd.patch +20150407 tpd books/bookvol5 inline msgs, add trace chapter head +20150407 tpd books/bookvol9 inline msgs +20150407 tpd src/doc/msgs/s2-us.msgs inline and remove unused msgs +20150407 tpd src/input/cachedf.input fix test case msg syntax +20150407 tpd src/input/clements.input fix test case msg syntax +20150407 tpd src/input/cmds.input fix test case msg syntax +20150407 tpd src/input/davis.input fix test case msg syntax +20150407 tpd src/input/ico.input fix test case msg syntax +20150407 tpd src/input/ifthenelse.input fix test case msg syntax +20150407 tpd src/input/iprntpk.input fix test case msg syntax +20150407 tpd src/input/lodof.input fix test case msg syntax +20150407 tpd src/input/op1.input fix test case msg syntax +20150407 tpd src/input/r21bugs.input fix test case msg syntax +20150407 tpd src/input/setcmd.input fix test case msg syntax +20150407 tpd src/input/sqmatrix.input fix test case msg syntax +20150407 tpd src/input/tuplebug.input fix test case msg syntax +20150407 tpd src/input/unittest1.input fix test case msg syntax +20150407 tpd src/input/unittest2.input fix test case msg syntax 20150405 tpd src/axiom-website/patches.html 20150405.02.tpd.patch 20150405 tpd src/doc/s2-us.msgs inline of message text 20150405 tpd books/bookvol9 inline all error messages diff --git a/patch b/patch index a1651f2..9b95470 100644 --- a/patch +++ b/patch @@ -1,6 +1,9 @@ -books/bookvol9 inline all error messages +books/bookvol5 inline all error messages + +Inlining message text and removing s2-us.msgs. +Add new chapter header for tracing. +Update test cases to reflect minor spacing syntax changes. -This is a startup test for inlining message text and removing s2-us.msgs. diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html index 37c6956..1293707 100644 --- a/src/axiom-website/patches.html +++ b/src/axiom-website/patches.html @@ -5002,6 +5002,8 @@ books/bookvol5 remove getKeyedMsg function
src/doc/s2-us.msgs start inline of message text
20150405.02.tpd.patch books/bookvol9 inline all error messages
+20150407.01.tpd.patch +books/bookvol5 inline msgs, add trace chapter head
diff --git a/src/doc/msgs/s2-us.msgs b/src/doc/msgs/s2-us.msgs index c5c6135..7700bf9 100755 --- a/src/doc/msgs/s2-us.msgs +++ b/src/doc/msgs/s2-us.msgs @@ -107,14 +107,6 @@ S2IC0014 The type %1bp is not branch of %2bp S2IC0015 Generated code is incorrect for %b equation %d -S2ID0004 - Cannot locate %1 for %2b . -S2ID0014 - %1b depends on the unknown constructor %2b . -S2ID0015 - There is no %2 for the constructor %1b . -S2ID0022 - %b %1 %2 %d has the following missing or incorrect keys: %3b S2IE0001 You cannot use %1b in the manner you have because it has no value. S2IE0002 @@ -126,12 +118,6 @@ S2IE0003 information. S2IE0004 %1bp is not a valid type. -S2IE0005 - You cannot now use %1bp in the context you have it. -S2IE0006 - Cannot convert the %1 argument of %3p to the type %2p . -S2IE0007 - Category, domain or package constructor %1b is not available. S2IE0008 Cannot find an applicable defined function %1b for the given arguments. S2IE0009 @@ -164,8 +150,6 @@ S2IF0004 The function %1b cannot be found in %2bp . S2IF0006 Skipping function with unimplemented form %1b . -S2IF0007 - %1b is not a valid function name. S2IF0008 The function %1b is not defined in the domain %2bp . S2IF0009 @@ -174,103 +158,14 @@ S2IF0010 %1b is not a known function. AXIOM will try to list its functions which contain %1b in their names. This is the same output you would get by issuing %ceon %b )what operations %1 %d %ceoff -S2IF0011 - %l To get more information about an operation such as %1b, issue the - command %b )display op %1 %d S2IF0012 %1b is not the name of a system function. -S2IH0001 - You have not reached step %1b yet, and so its value cannot be - supplied. -S2IH0002 - Cannot supply value for step %1b because 1 is the first step. -S2IH0003 - Step %1b has no value. -S2IH0004 - The history facility is not on, so you cannot use %b %% %d . -S2IH0006 - You have not used the correct syntax for the %b history %d command. - Issue %b )help history %d for more information. -S2IH0007 - The history facility is already on. -S2IH0008 - The history facility is now on. -S2IH0009 - Turning on the history facility will clear the contents of the - workspace. - Please enter %b y %d or %b yes %d if you really want to do this: -S2IH0010 - The history facility is still off. -S2IH0011 - The history facility is already off. -S2IH0012 - The history facility is now off. -S2IH0013 - The history facility is not on, so the .input file containing your user input - cannot be created. -S2IH0014 - Edit %b %1 %d to see the saved input lines. -S2IH0015 - The argument %b n %d for %b )history )change n must be a nonnegative - integer and your argument, %1b , is not one. -S2IH0016 - The history facility is not on, so no information can be saved. -S2IH0018 - The saved history file is %1b . -S2IH0019 - There is no history file, so value of step %1b is - undefined. -S2IH0022 - No history information had been saved yet. -S2IH0023 - %1b is not a valid filename for the history file. -S2IH0024 - History information cannot be restored from %1b because the file does - not exist. -S2IH0025 - The workspace has been successfully restored from the history file - %1b . -S2IH0026 - The history facility command %1b cannot be performed because the - history facility is not on. -S2IH0027 - A value containing a %1b is being saved in a history file or a - compiled input file INLIB. This type - is not yet usable in other history operations. You might want to issue - %b )history )off %d -S2IH0029 - History information is already being maintained in an external file - (and not in memory). -S2IH0030 - History information is already being maintained in memory (and not - in an external file). -S2IH0031 - When the history facility is active, history information will be - maintained in a file (and not in an internal table). -S2IH0032 - When the history facility is active, history information will be - maintained in memory (and not in an external file). -S2IH0034 - Missing element in internal history table. -S2IH0035 - Can't save the value of step number %1b. You can re-generate this value - by running the input file %2b. -S2IH0036 - The value specified cannot be saved to a file. -S2IH0037 - You must specify a file name to the history save command -S2IH0038 - You must specify a file name to the history write command S2II0001 The attributed tree form %1s is not a vector. S2II0002 Unknown form of attributed tree: %1s S2II0003 Improper use of %1b with argument %2s: %3 -S2IL0001 - The file %1b cannot be found and so will not be loaded. -S2IL0002 - Loading %1 for %2 %3b S2IL0003 The file %1b is needed but does not exist. S2IL0004 @@ -310,8 +205,6 @@ S2IL0019 %1b is not known to be a valid abbreviation for a constructor. If necessary, use the %b )abbreviation %d system command to create an abbreviation. Issue %b )abbreviation ? %d for more information. -S2IL0020 - An existing file %1b cannot be located. S2IL0021 Category abbreviations must have 7 or fewer characters and should be uppercase. @@ -323,14 +216,6 @@ S2IL0024A The operation %1b with type %2b does not exist in domain %3bp . S2IL0026 Cannot locate operation alist for constructor %1b -S2IL0027 - The directory %1 could not be created. The file %2 was not compiled. -S2IL0028 - Could not unarchive contents of %2 into directory %1. - The file %2 was not compiled. -S2IL0029 - No .ao files were found when %2 was unarchived into directory %1. - The file %2 was not compiled. S2IM0001 The previous declaration of %1b as %2bp is incompatible with its new use as a function. If you do not want the old value, issue %b )clear prop @@ -344,8 +229,6 @@ S2IM0003 S2IM0004 Partial types are not allowed in the declarations of function arguments or return types. -S2IM0005 - Invalid type expression %1b in function definition. S2IM0006 Function declaration %1 has been added to workspace. S2IM0007 @@ -365,8 +248,6 @@ S2IM0012 AXIOM cannot determine the type of %1b because it cannot analyze the non-recursive part, if that exists. This may be remedied by declaring the function. -S2IM0013 - You cannot use the free variable %1b before its assignment in %2bp . S2IM0014 Compiling body of rule %1bp to compute value of type %2b S2IM0015 @@ -385,20 +266,12 @@ S2IM0020 S2IM0027 No arguments are allowed on the left had side of a rule definition and you supplied %1b for rule %2b -S2IP0001 - The left-hand side of a %b => %d form must be a symbol. S2IP0003 Argument number %1b of %2bp must have type %3bp . -S2IP0004 - %1 macro %2b . S2IP0005 %1b is not a valid identifier to use in AXIOM. -S2IR0001 - Cannot resolve all the types in the list to be created. S2IR0002 AXIOM cannot handle %b [ ] %d here. -S2IR0003 - The types that cannot be resolved are: %1b S2IR0004 AXIOM is confused by what you input. It cannot resolve the type %1bp with the partial type %2bp . @@ -524,8 +397,6 @@ S2IS0051 S2IS0052 You cannot declare %1b to be of type %2bp because either the declared type of %1b or the type of the value of %1b is different from %2bp . -S2IS0053 - Interpreter code generation failed for expression %1s S2IS0054 Argument number %1b to %2b must be a Boolean. S2IS0055 @@ -553,81 +424,6 @@ S2IS0060 The form on the left hand side of an assignment must be a single variable, a Tuple of variables or a reference to an entry in an object supporting the setelt operation. -S2IT0001 - %1b can have no other options. -S2IT0002 - Trace facility timers, space counts and execution counts have been - reset. -S2IT0003 - Please retrace the domain %1b. -S2IT0004 - %b )ops %d and %b )of %d cannot both be options to %b )trace %d -S2IT0005 - The %1b option is not implemented yet. -S2IT0006 - %1 The %b )trace %d option %b )only %d does not permit %2b as a legal - option. -S2IT0007 - %1 AXIOM does not understand the %b )trace %d option %2b which you used. -S2IT0008 - %1 The %b )trace %d option %b )break %d can only have one or both of - %b before %d and %b after %d as arguments. -S2IT0009 - %1 The %b )trace %d option %2b can have no arguments. -S2IT0010 - %1 The %b )trace %d option %2b takes exactly one name as an argument. -S2IT0011 - %1 The %b )trace %d option %2b takes exactly one expression as an - argument. -S2IT0012 - %1 The %b )trace %d option %2b takes exactly one integer argument. -S2IT0013 - %1 The %b )trace %d option %b )of %d should be followed by the name of a - domain and %2b is not one. -S2IT0015 - %1 The %b )trace %d option %2b should be followed by a list of names. -S2IT0016 - %1 The %b )trace %d option %2b should be followed by a list of variable - names. -S2IT0017 - There are %1b problems with your %b )trace %d system command: -S2IT0018 - AXIOM does not understand the use of %1b here. -S2IT0019 - If you use the %b )off %d option for %b )trace %d and you also use - the %b )local %d or %b )ops %d option, you must specify the name - of a constructor. You have not done so. -S2IT0020 - If you use the %b )off %d option for %b )trace %d and you also use - the %b )local %d or %b )ops %d option, you must specify the name - of a constructor. What you gave after %b )trace %d is not a valid - constructor name. -S2IT0021 - If you use the %b )off %d option for %b )trace %d then the only other - options you can use are %b )nonquietly, )ops %d and %b )local. %d -S2IU0001 - %1 will be automatically loaded when needed from %2 -S2IU0002 - Ignoring )dir because an explicit directory was not given after )dir. -S2IU0003 - The %b )load %d system command is obsolete. Please use the %b )library %d - command instead. -S2IV0001 - %b )set streams calculate %d is used to tell AXIOM - how many elements of a stream to calculate when a - computation uses the stream. The value given after %b calculate %d must - either be the word %b all %d or a positive integer. %l %l The current - setting is %1b . -S2IV0002 - To toggle %1 printing on and off, specify %l - %b )set output %2 yes/no/on/off %d %l - Yes, no, on and off cannot be abbreviated. -S2IV0003 - It is not possible to open or create a file called %b %1 %2 %3 %d . -S2IV0004 - %1 output will be written to file %2b . -S2IV0005 - Your argument list is not valid. S2IX0001 Compiling function %1bp as a recurrence relation. S2IX0002 @@ -648,231 +444,6 @@ S2IX0008 S2IX0009 The system cannot print your result. It will be lisp pretty-printed: %l -S2IZ0001 - %1b abbreviates %b %2 %3 %d -S2IZ0002 - %1b must be followed by an alternating list of abbreviation(s) and - name(s). - Issue %b )abbrev ? %d for more information. -S2IZ0003 - %1b is neither a constructor name nor a constructor abbreviation. -S2IZ0004 - Removing %1b as the abbreviation for %2b will also remove %3 %2b from - the system. Enter %b yes %d or %b y %d if this is what you want, or - anything else to abort the removal. -S2IZ0005 - Issue %b )abbrev ? %d for more information. -S2IZ0006 - Abbreviation %1b and %2 %3b %4 been deleted from the system. -S2IZ0007 - Your user access level is %1b and this %2 is therefore not available. - See the %b )set userlevel %d command for more information. -S2IZ0008 - No %1 begins with %2b . -S2IZ0009 - Your %1 is ambiguous. The following are abbreviated by %2b : -S2IZ0010 - Use %b )clear all %d to clear everything in the workspace. Use %b - )clear completely %d to clear everything in the workspace and internal - tables. Other %b )clear %d keyword arguments are %1 %l or abbreviations - thereof. Issue %b )clear ? %d for more information. -S2IZ0011 - All user variables and function definitions have been cleared in - the current frame ( %1b ). -S2IZ0012 - All user variables and function definitions have been cleared. -S2IZ0013 - All %b )browse %d facility databases have been cleared. -S2IZ0014 - Internally cached functions and constructors have been cleared. -S2IZ0015 - %b )clear completely %d is finished. -S2IZ0016 - The %1b system command takes arguments but no options. -S2IZ0017 - %1b is not a valid frame name. -S2IZ0018 - You must provide a name for the new frame. -S2IZ0019 - You cannot use the name %1b for a new frame because an existing - frame already has that name. -S2IZ0020 - There is only one frame active and therefore that cannot be closed. - Furthermore, the frame name you gave is not the name of the current frame. - The current frame is called %1b . -S2IZ0021 - The current frame is the only active one. Issue %b )clear all %d to - clear its contents. -S2IZ0022 - There is no frame called %1b and so your command cannot be - processed. -S2IZ0024 - The names of the existing frames are: %1 %l - The current frame is the first one listed. -S2IZ0025 - If the system command or synonym %1b exists, help information is not - available for it. Issue %b )what commands %d or %b )what synonyms %d to - determine is %1b is a valid name. -S2IZ0026 - The %b )help %d system command supports at most one argument. -S2IZ0028 - library %1b has been loaded. -S2IZ0029 - library %1b has not been loaded. -S2IZ0031 - Please enter %b y %d or %b yes %d if you really want to leave the - interactive environment and return to the operating system: -S2IZ0032 - You have chosen to remain in the %b AXIOM %d - interactive environment. -S2IZ0033 - You cannot %b )read %d the file %1b because your user-level is not is - not high enough. For more information about your user-level, issue %b - )set userlevel %d . -S2IZ0034 - You cannot %b )read %d the file %1b because it is not suitable for - reading by AXIOM. Note that files with file extension %b .spad %d - and %b .as %d can now only be compiled with the %b )compile %d system command. -S2IZ0035 - The file %1b will not be added to the list of working source files - because the file does not exist. -S2IZ0038A - Compiling AXIOM source code from file %1b using AXIOM-XL compiler and - options %b %ceon %2 %ceoff %d - Use the system command %b )set compiler args %d to change these options. -S2IZ0041 - It is not known what %1bp is, so no information about it can be - displayed. -S2IZ0043 - Your argument is not valid for the %b )what %d system command. %l %l - Use the %b )show %d system command to display the operations for a - constructor. Use the %b )display operations %d system command to see - information about an operation. These may be abbreviated to %b )sh %d - and %b )d op %d , respectively. -S2IZ0044M - Mapping(T, S, ...) %l - %b Mapping %d takes any number of arguments of the form: %i %l - T, a domain of category SetCategory %l - S, a domain of category SetCategory %l - ... %u %l - Mapping(T, S, ...) denotes the class of objects which are - mappings from a source domain (S, ...) into a target domain T. - The Mapping constructor can take any number of arguments. - All but the first argument is regarded as part of a source tuple - for the mapping. - For example, Mapping(T, A, B) denotes the - class of mappings from (A, B) into T. %l - This constructor is a primitive in AXIOM. - For more information, use the HyperDoc Browser. -S2IZ0044R - Record(a:A,...,b:B) %l - %b Record %d takes any number of selector-domain pairs as arguments: %i %l - a, a selector, an element of domain Symbol %l - A, a domain of category SetCategory %l - ... %l - b, a selector, an element of domain Symbol %l - B, a domain of category SetCategory %u %l - This constructor is a primitive in AXIOM. - The selectors a,...,b of a Record type must be distinct. %l %l - In order for more information to be displayed about %1b , - you must give it specific arguments. For example: %2b %l - You can also use the HyperDoc Browser. -S2IZ0045T - Tagged union: Union(a:A, ..., b:B) %l - %b Union %d takes any number of "tag"-domain pairs of arguments: %i %l - a, a tag, an element of domain Symbol %l - A, a domain of category SetCategory %l - ... %l - b, a tag, an element of domain Symbol %l - B, a domain of category SetCategory %u %l - This constructor is a primitive in AXIOM. - In this tagged Union, tags a, ..., b must be distinct. %l %l - In order for more information to be displayed about %1b , - you must give it specific arguments. For example: %2b %l - You can also use the HyperDoc Browser. -S2IZ0045U - Untagged union: Union(A, ..., B) %l - %b Union %d takes any number of domain arguments: %i %l - A, a domain of category SetCategory %l - ... %l - B, a domain of category SetCategory %u %l - In this untagged form of Union, domains A, ..., B must be distinct. - In order for more information to be displayed about %1b , - you must give it specific arguments. For example: %2b %l - You can also use the HyperDoc Browser. -S2IZ0046 - For more information about individual commands, use the %b )help %d - system command followed by the command name or the command name followed - by a question mark. Some commands (such as %b )lisp %d ) may require - the %b )help lisp %d format. For example, issue %b )help help %d or %b - )help %x1 ? %d to find out more about the help command itself. -S2IZ0047 - Arguments are not allowed for the %b )workfiles %d system command. - The %b )boot, )lisp, )meta %d and %b )delete %d options may be used - with this command, however. Issue %b )help workfiles %d for more - information. -S2IZ0048 - %1b is not an allowable option for the %b )workfiles %d system command. - The %b )boot, )lisp, )meta %d and %b )delete %d options may be used - with this command, however. Issue %b )help workfiles %d for more - information. -S2IZ0049A - The following groups are explicitly exposed in the current frame - (called %1b ): -S2IZ0049B - The following constructors are explicitly exposed in the current frame: -S2IZ0049C - The following constructors are explicitly hidden in the current frame: -S2IZ0049E - When %b )set expose add %d is followed by no arguments, the information - you now see is displayed. - The arguments %b group %d and %b constructor %d are used to specify - exposure groups or an explicit constructor to be added to the local - frame exposure data. Issue - %ceon %b )set expose add group %d %ceoff or - %ceon %b )set expose add constructor %d %ceoff - for more information. -S2IZ0049F - When %b )set expose drop %d is followed by no arguments, the information - you now see is displayed. - The arguments %b group %d and %b constructor %d are used to specify - exposure groups or an explicit constructor to be dropped from the local - frame exposure data. Issue - %ceon %b )set expose drop group %d %ceoff or - %ceon %b )set expose drop constructor %d %ceoff - for more information. -S2IZ0049G - When %b )set expose add group %d is followed by no arguments, the - information you now see is displayed. Otherwise, the words following - %b group %d must be valid names of exposure groups defined in - %1b . The group %b all %d is special: using this group name causes - all known constructors to be exposed. The known exposure group - names are: -S2IZ0049H - %1b is not a known exposure group name. -S2IZ0049I - %1b is already an exposure group for frame %2b -S2IZ0049J - %1b is not a known constructor. - You can make the constructor known to the system by loading it. -S2IZ0049K - %1b is already explicitly exposed in frame %2b -S2IZ0049L - When followed by one or more exposure group names, this option allows - you to remove those groups from the local frame exposure data. -S2IZ0049N - When followed by one or more constructor names, this option allows you - to explicitly hide constructors in this frame. -S2IZ0049O - %1b is already explicitly hidden in frame %2b -S2IZ0049P - %1b is now explicitly exposed in frame %2b -S2IZ0049Q - %1b is now explicitly hidden in frame %2b -S2IZ0049R - %1b is now an exposure group for frame %2b -S2IZ0049S - %1b is no longer an exposure group for frame %2b S2IZ0050 There is an error in the %1b file you are using. S2IZ0051 @@ -881,27 +452,6 @@ S2IZ0052 It is mostly likely a %b )set %d command. Please inspect the file. S2IZ0053 AXIOM initialization: %1b -S2IZ0054 - %1b is unknown to us, so no information is available. -S2IZ0055 - After the property you wish to clear you must give one or more - identifiers or specify %b all %d to clear that property from - everything. -S2IZ0056 - You have requested that all abbreviations be displayed. As there are - several hundred abbreviations, please confirm your request by - typing %b y %d or %b yes %d and then pressing %b Enter %d : -S2IZ0057 - Since you did not respond with %b y %d or %b yes %d the list of - abbreviations will not be displayed. -S2IZ0058 - You have requested that all information about all AXIOM - operations (functions) be displayed. As there are several hundred - operations, please confirm your request by typing %b y %d or %b yes %d - and then pressing %b Enter %d : -S2IZ0059 - Since you did not respond with %b y %d or %b yes %d the list of - operations will not be displayed. S2IZ0060 %l There are possibly a great many operation names containing the substring %1b . Please confirm your request to have these listed by @@ -909,115 +459,10 @@ S2IZ0060 S2IZ0061 Since you did not respond with %b y %d or %b yes %d the list of operation names containing %1b will not be displayed. -S2IZ0062 - %l %1b is not the name of a known type constructor. If you want - to see information about any operations named %1b, issue - %ceon %b )display operations %1 %d %ceoff -S2IZ0063 - The %b )show %d system command is used to display information about - types or partial types. For example, %b )show Integer %d will show - information about %b Integer %d . -S2IZ0064 - %l %b %% %d is a special variable holding the result of the last - computation. Issue %b )display properties %% %d to see this value. -S2IZ0065 - The name of the current frame is %1b . -S2IZ0066 - The workspace is empty. -S2IZ0067 - The current frame, %1b , is empty. -S2IZ0068 - There is nothing to display for option %1b . -S2IZ0069A - Bad file format in file %1b : constructor name %2b encountered before - an exposure group was defined. -S2IZ0069B - Bad file format in file %1b : line with constructor name %2b should - be of format %ceon %b constructor-name library-file-name %d %ceoff -S2IZ0069C - Bad file format in file %1b : a group name should not contain blanks. - The improper group name is %2b S2IZ0070 The current AXIOM default directory is %1b -S2IZ0071 - You cannot close this AXIOM session. -S2IZ0072 - This is the last AXIOM session. Do you want to kill AXIOM? -S2IZ0073 - %b )frame import %d must be followed by the frame name. The names - of objects in that frame can then optionally follow the frame name. - For example, - %ceon %b )frame import calculus %d %ceoff - imports all objects in the %b calculus %d frame, and - %ceon %b )frame import calculus epsilon delta %d %ceoff - imports the objects named %b epsilon %d and %b delta %d from the - frame %b calculus %d . - Please note that if the current frame contained any information - about objects with these names, then that information would be - cleared before the import took place. -S2IZ0074 - You cannot import anything from the frame %1b because that is not - the name of an existing frame. -S2IZ0075 - You cannot import from the current frame (nor is there a need!). -S2IZ0076 - User verification required: - do you really want to import everything from the frame %1b ? - If so, please enter %b y %d or %b yes %d : -S2IZ0077 - On your request, AXIOM will not import everything from frame %1b . -S2IZ0078 - Import from frame %1b is complete. Please issue %b )display all %d - if you wish to see the contents of the current frame. -S2IZ0079 - AXIOM cannot import %1b from frame %2b because it cannot be found. -S2IZ0080 - Unknown system command: %1b -S2IZ0083 - The AXIOM-XL compiler cannot compile files with file extensions ".as" or - ".ao". -S2IZ0085 - Warning: translation of an old-style source code ".spad" file to a new-style - ".as" file changes the old system compiler. If you wish to use the old - system compiler for regular compilation, you must exit and re-enter - AXIOM. -S2IZ0086 - Cannot write to file with name %b %1 %d . -S2IZ0087 - Cannot write to file with name %b %1 %d . Terminating attempt to translate - ".spad" file to ".as" file. -S2IZ0088 - Creating output file with name %b %1 %d . S2GE0000 Internal Error -S2GE0001 - You have attempted to set or extract an element of an object with an - index that is out of bounds. Please check forms of the type %b m.2.3 := - 7 %d and %b l.9 %d in any list, vector, matrix or other aggregate - expression where you are using a period (.) to reference elements. -S2GE0002 - You have exhausted the storage available for computation. - Some possible courses of action are: %l %l - 1. Issue %b )display prop %d and then use %b )clear prop %d to remove - values from variables that are no longer needed. Repeat the calculation - that caused you to exhaust storage. %l %l - 2. Use %b )history )write %d to get a record of your calculations then - use %b )quit %d , re-enter the system via %b axiom %d and then %b )read - initial.input %d to restore your environment by repeating the - calculations. %l %l - 3. Issue %b )history )save MYCALCS, %d exit the system via %b )quit, %d - start a new system by using %b axiom %d and then issue %b )history - )restore MYCALCS %d . Then perform the calculation on which you ran out - of storage. %l %l - 4. If you have done many calculations that are not germane to the - problem on which you exhausted storage and your calculation consists of - very little input, exit the system via %b )quit, %d use %b axiom %d to - start a fresh system and then restart your computation. %l %l - Note that you simply may not be able to perform your calculation in the - amount of storage you have available to you. Ask your system - administrator if it is possible for you to run %b AXIOM %d in a - larger virtual machine. %l %l - If you have questions, contact an AXIOM consultant. S2GE0003 The cache for %1b cannot be cleared because that function is not privately clammed. @@ -1051,61 +496,12 @@ S2GE0013 %1b has the wrong format: the reference counts are missing. S2GE0014 %1b is too large -S2GE0015 - S2GE0016 Unexpected error or improper call to system function %1b: %2 S2GE0017 Unexpected error in call to system function %1b -S2GL0001 - %ceon - %b AXIOM Computer Algebra System %d %l - Version: %1 %l - Timestamp: %2 - %ceoff -S2GL0003A - Issue %b )hd %d to start the Hyperdoc help system. -S2GL0003B - Issue %b )quit %d to leave AXIOM and return to %1 . -S2GL0003C - Issue %b )help %x1 ? %d to see information about the %b )help %d command. -S2GL0004 - Issue %b )set message time on %d to have computation time data - displayed. -S2GL0005 - Issue %b )set message type on %d to have the computation result type - displayed. -S2GL0006 - Issue %b )set message storage on %d to have storage use data displayed. -S2GL0007 - Issue %b )set message set on %d to show %b )set %d values after - assignment. -S2GL0008 - Issue %b )set history on %d to turn on the workspace history facility. -S2GL0009 - Workspace: %3b Segment: %4b Release: %b %1 - %2 %d -S2GL0010 - Created: %1b Updated: %2b -S2GL0012 - %rjon Type: %1p %rjoff -S2GL0013 - %rjon Time: %1 %rjoff -S2GL0014 - %rjon Type: %1p %l Time: %2 %rjoff S2GL0015 Internal timings are not balanced: timing classes are %1b and %2b -S2GL0016 - %rjon Storage: %1 %rjoff -S2GL0017 - %rjon Summary: %1 %rjoff -S2GL0018A - Issue %b )cd "directory" %d to reset the current directory. -S2GL0018B - Issue %b )spool "filename" %d to save output in the given file. -S2GL0018C - Issue %b )copyright %d to view copyright notices. -S2GL0018D - Issue %b )summary %d for a summary of useful system commands. S2GL0019 Type %b (resume) %d to return to AXIOM and continue with the next statement. Type %b (toplevel) %d to abort all input files and continue @@ -1122,161 +518,4 @@ S2OR0001 Category or domain %1b not known. S2OR0002 Unknown implementation: %1s - -S2CY0002 - Improper syntax. -S2CY0003 - Ignored from here -S2CY0004 - to here. -S2CY0005 - Ignored. -S2CY0006 - syntax error at top level -S2CY0007 - Possibly missing a %b %1 %d -S2CY0008 - Missing mate. -S2CY0009 - System error while parsing, stack is empty. -S2CTP010 - %b %1 error(s) parsing %d -S2CTP023 - %l - -S2CI0001 - %1f - -S2CI0002 - File %1f ended where at least one )endif was still needed. - An appropriate number of )endif lines has been assumed. - -S2CI0003 - A )fin command has been given in %1f where at least one )endif - was still needed. - An appropriate number of )endif lines have been assumed. - -S2CI0004 - There is a cycle in the )include files: %i %l %1f %u %l. - The inner occurrence of %2f has not been included. - -S2CI0005 - Including source lines from console. Type %b )fin %d when done. - -S2CI0006 - %1f other )console commands are currently active. - While this new )console command is reading input the others - will have to wait. - Remember, each )console command will need a separate )fin. - -S2CI0007 - The current )console command has finished reading. - %1f are still active. Remember, each will need a separate )fin. - -S2CI0008 - A )fin command was skipped - (along with everything else) in a false branch of an )if...)endif. - -S2CI0009 - Incorrect )if...)endif syntax. A %b %1f %d was found %2f. - The processing of the source from %3f has been abandoned. - -S2CI0010 - The )include file %b %1f %d does not exist. - -S2CI0011 - The )include file %b %1f %d exists, but cannot be read. - -S2CN0001 - Quote added at end of line. - -S2CN0002 - The character %b %1 %d is greater than the radix. - -S2CN0003 - The character %b %1 %d is not an AXIOM character. - -S2CY0002 - Improper syntax. - -S2CY0003 - Ignored from here - -S2CY0004 - to here. - -S2CY0005 - Ignored. - -S2CY0006 - syntax error at top level - -S2CY0007 - Possibly missing a %b %1 %d - -S2CY0008 - Missing mate. - -S2CY0009 - System error while parsing, stack is empty. - -S2CM0001 - %1 is improper for macro definition. Ignored. -S2CM0003 - Expected %1b arguments, but received %2b. -S2CM0004 - Macro parameter %1f is not an id. -S2CM0005 noRep - Cycle in macro expansion: %l %1y %2 %l. Left as: %3f - -S2CZ0003 - Gathering list of library items - -S2CU0002 - Get export message - -S2CU0003 - unexpected case in 'sayLength - -S2CB0002 - Unexpected state in )if...)endif. - -S2CB0003 - Unexpected command in source inclusion. - -S2CB0004 - Should not be calling getExport - -S2CB0005 - List should have length = 1 - -S2CB0006 - Unknown literal style. - -S2CB0007 - Association list search failed on %1 - -S2CB0031 - bad object - -S2CTP003 trace - Parse tree: %U %1fl - -S2CTP007 trace - Macro expanded: %U %1fl - -S2CTP010 - %b %1 error(s) parsing %d - -S2CTP021 - %1 ... - -S2CTP023 - %l - -S2CAS001 - Cannot convert a %1 to a builtin index. - -S2CAS002 - Improper argument *** This line must be here diff --git a/src/input/cachedf.input.pamphlet b/src/input/cachedf.input.pamphlet index e9628c4..da89deb 100644 --- a/src/input/cachedf.input.pamphlet +++ b/src/input/cachedf.input.pamphlet @@ -58,7 +58,7 @@ CachedFunction(A: SetCategory, B:SetCategory): Exports == Implementation where --S 1 of 8 )co cachedf --R ---R Compiling AXIOM source code from file +--R Compiling AXIOM source code from --I /research/test/int/input/cachedf.spad using old system compiler. --R CACHEDF abbreviates domain CachedFunction --R processing macro definition Exports ==> -- the constructor category diff --git a/src/input/clements.input.pamphlet b/src/input/clements.input.pamphlet index 7f1a9ae..25fd45a 100644 --- a/src/input/clements.input.pamphlet +++ b/src/input/clements.input.pamphlet @@ -43,7 +43,7 @@ OrderedKeyEntry(Key:OrderedSet,Entry:SetCategory): --S 1 of 6 )co clements --R ---R Compiling AXIOM source code from file +--R Compiling AXIOM source code from --I /root/axiom/int/input/clements.spad using old system compiler. --R ORDKE abbreviates domain OrderedKeyEntry --R------------------------------------------------------------------------ diff --git a/src/input/cmds.input.pamphlet b/src/input/cmds.input.pamphlet index b33f511..bedd789 100644 --- a/src/input/cmds.input.pamphlet +++ b/src/input/cmds.input.pamphlet @@ -43,19 +43,19 @@ --S 5 of 20 )abbreviation query LIST --R ---R LIST abbreviates domain List +--R LIST abbreviates domain List --E 5 --S 6 of 20 )abbreviation query List --R ---R LIST abbreviates domain List +--R LIST abbreviates domain List --E 6 --S 7 of 20 )abbreviation query TIMD --R ---R TIMD abbreviates domain TimDalyDomain +--R TIMD abbreviates domain TimDalyDomain --E 7 --S 8 of 20 @@ -72,7 +72,7 @@ --S 10 of 20 )abbreviation query TimDalyPackage --R ---R TIMP abbreviates package TimDalyPackage +--R TIMP abbreviates package TimDalyPackage --E 10 --S 11 of 20 @@ -83,7 +83,7 @@ --S 12 of 20 )abbreviation query TimDalyPackage --R ---R TIMP abbreviates package TimDalyPackage +--R TIMP abbreviates package TimDalyPackage --E 12 --S 13 of 20 diff --git a/src/input/davis.input.pamphlet b/src/input/davis.input.pamphlet index b8bcd88..50dc540 100644 --- a/src/input/davis.input.pamphlet +++ b/src/input/davis.input.pamphlet @@ -15,6 +15,7 @@ Academic Press 1984 \eject \begin{chunk}{*} )set break resume +)sys rm -f davis.output )spool davis.output )set message test on )set message auto off @@ -428,16 +429,6 @@ db154:=integrate(fb154,x=0..2*%pi) --S 36 of 101 ab154:=2*%pi^3*J(1,2*%pi*n) -- J(n,m) is the Bessel function --R ---R Line 406: --R ---R Line 407: --R ---R Line 408: --R (31) potentialPole ---R Line 409: --R Type: Union(pole: potentialPole,...) ---R Line 410: --E 35 ---R Line 411: ---R Line 412: --S 36 of 101 ---R Line 413: ab154:=2*%pi^3*J(1,2*%pi*n) -- J(n,m) is the Bessel function ---R Error : Quote added at end of line. ---R 1 error(s) parsing --R There are no library operations named J --R Use HyperDoc Browse or issue --R )what op J @@ -454,7 +445,7 @@ ab154:=2*%pi^3*J(1,2*%pi*n) -- J(n,m) is the Bessel function --E 36 --S 37 of 101 -rb154:="singularity at x=2*%pi +rb154:="singularity at x=2*%pi" --R --R --R (32) "singularity at x=2*%pi" diff --git a/src/input/ico.input.pamphlet b/src/input/ico.input.pamphlet index e2a7c9f..0309ccc 100644 --- a/src/input/ico.input.pamphlet +++ b/src/input/ico.input.pamphlet @@ -25,7 +25,7 @@ )se exp add con InnerTrigonometricManipulations --R --R InnerTrigonometricManipulations is now explicitly exposed in frame ---R initial +--R initial --E 1 --S 2 of 65 diff --git a/src/input/ifthenelse.input.pamphlet b/src/input/ifthenelse.input.pamphlet index 2adff07..d71f51f 100644 --- a/src/input/ifthenelse.input.pamphlet +++ b/src/input/ifthenelse.input.pamphlet @@ -123,9 +123,9 @@ for i in 2..2 repeat --R ....A........................B --R Error A: Improper syntax. --R Error A: (from #\A up to #\B) Ignored. ---R Error B: Possibly missing a then +--R Error B: Possibly missing a then --R Error B: (up to #\B) to here. ---R 7 error(s) parsing +--R 7 error(s) parsing --E 6 --S 7 of 20 @@ -162,7 +162,7 @@ for i in 2..2 repeat --R ....A --R Error A: (from #\A up to ) Ignored. --R Error A: Improper syntax. ---R 2 error(s) parsing +--R 2 error(s) parsing --E 8 --S 9 of 20 diff --git a/src/input/iprntpk.input.pamphlet b/src/input/iprntpk.input.pamphlet index ad69eb2..2816051 100644 --- a/src/input/iprntpk.input.pamphlet +++ b/src/input/iprntpk.input.pamphlet @@ -26,7 +26,7 @@ the stream. \begin{chunk}{*} --S 1 of 3 )set expose add constructor IPRNTPK ---R InternalPrintPackage is now explicitly exposed in frame initial +--R InternalPrintPackage is now explicitly exposed in frame initial --E 1 --S 2 of 3 diff --git a/src/input/lodof.input.pamphlet b/src/input/lodof.input.pamphlet index bef41a9..2021829 100644 --- a/src/input/lodof.input.pamphlet +++ b/src/input/lodof.input.pamphlet @@ -24,7 +24,7 @@ )expose LODOF --R --R LinearOrdinaryDifferentialOperatorFactorizer is now explicitly ---R exposed in frame initial +--R exposed in frame initial --E 1 --S 2 of 16 diff --git a/src/input/op1.input.pamphlet b/src/input/op1.input.pamphlet index f58f8a4..8ff81b8 100644 --- a/src/input/op1.input.pamphlet +++ b/src/input/op1.input.pamphlet @@ -39,7 +39,7 @@ t := operator("tilde") :: OP(R) --S 3 of 21 )set expose add constructor Operator --R ---R Operator is now explicitly exposed in frame initial +--R Operator is now explicitly exposed in frame initial --E 3 --S 4 of 21 diff --git a/src/input/r21bugs.input.pamphlet b/src/input/r21bugs.input.pamphlet index 9bf60fb..718927c 100644 --- a/src/input/r21bugs.input.pamphlet +++ b/src/input/r21bugs.input.pamphlet @@ -34,7 +34,7 @@ $U_n(x) - x U_{n-1}(x) = T_n(x)$ )set expose add constructor PolynomialNumberTheoryFunctions --R --R PolynomialNumberTheoryFunctions is now explicitly exposed in frame ---R initial +--R initial --E 1 --S 2 of 95 diff --git a/src/input/setcmd.input.pamphlet b/src/input/setcmd.input.pamphlet index b1c199b..198b54b 100644 --- a/src/input/setcmd.input.pamphlet +++ b/src/input/setcmd.input.pamphlet @@ -1275,12 +1275,12 @@ --R --R Description: specify number of elements to calculate --R ---R )set streams calculate is used to tell AXIOM how many elements of a +--R )set streams calculate is used to tell Axiom how many elements of a --R stream to calculate when a computation uses the stream. The value --R given after calculate must either be the word all or a positive --R integer. --R ---R The current setting is 10 . +--R The current setting is 10. --E 80 --S 81 of 143 diff --git a/src/input/sqmatrix.input.pamphlet b/src/input/sqmatrix.input.pamphlet index 8ec619c..e94463c 100644 --- a/src/input/sqmatrix.input.pamphlet +++ b/src/input/sqmatrix.input.pamphlet @@ -23,7 +23,7 @@ --S 1 of 6 )set expose add constructor SquareMatrix --R ---R SquareMatrix is now explicitly exposed in frame initial +--R SquareMatrix is now explicitly exposed in frame initial --E 1 --S 2 of 6 diff --git a/src/input/tuplebug.input.pamphlet b/src/input/tuplebug.input.pamphlet index b163112..69be15b 100644 --- a/src/input/tuplebug.input.pamphlet +++ b/src/input/tuplebug.input.pamphlet @@ -29,7 +29,7 @@ Bug(R:Ring): with --S 1 of 1 )co tuplebug --R ---R Compiling AXIOM source code from file +--R Compiling AXIOM source code from --I /research/test/int/input/tuplebug.spad using old system compiler. --R BUG abbreviates package Bug --R------------------------------------------------------------------------ diff --git a/src/input/unittest1.input.pamphlet b/src/input/unittest1.input.pamphlet index 41b349f..a3daea2 100644 --- a/src/input/unittest1.input.pamphlet +++ b/src/input/unittest1.input.pamphlet @@ -401,9 +401,9 @@ Unit test the user level commands --R you now see is displayed. The arguments group and constructor are --R used to specify exposure groups or an explicit constructor to be --R added to the local frame exposure data. Issue ---R )set expose add group +--R )set expose add group --R or ---R )set expose add constructor +--R )set expose add constructor --R for more information. --E 30 @@ -418,9 +418,9 @@ Unit test the user level commands --R you now see is displayed. The arguments group and constructor are --R used to specify exposure groups or an explicit constructor to be --R dropped from the local frame exposure data. Issue ---R )set expose drop group +--R )set expose drop group --R or ---R )set expose drop constructor +--R )set expose drop constructor --R for more information. --E 31 @@ -700,9 +700,9 @@ Unit test the user level commands --R you now see is displayed. The arguments group and constructor are --R used to specify exposure groups or an explicit constructor to be --R added to the local frame exposure data. Issue ---R )set expose add group +--R )set expose add group --R or ---R )set expose add constructor +--R )set expose add constructor --R for more information. --E 39 @@ -928,7 +928,7 @@ Unit test the user level commands --R --R You have requested that all abbreviations be displayed. As there are --R several hundred abbreviations, please confirm your request by ---R typing y or yes and then pressing Enter : +--R typing y or yes and then pressing Enter: --R --R >> System error: --R %.EOF is not of type SEQUENCE. @@ -1002,10 +1002,10 @@ Unit test the user level commands --S 54 of 97 )display operations --R ---R You have requested that all information about all AXIOM operations +--R You have requested that all information about all Axiom operations --R (functions) be displayed. As there are several hundred --R operations, please confirm your request by typing y or yes and ---R then pressing Enter : +--R then pressing Enter: --R --R >> System error: --R %.EOF is not of type SEQUENCE. @@ -1063,12 +1063,12 @@ Unit test the user level commands --S 58 of 97 )display abb DHMATRIX ---R DHMATRIX abbreviates domain DenavitHartenbergMatrix +--R DHMATRIX abbreviates domain DenavitHartenbergMatrix --E 58 --S 59 of 97 )display abb DenavitHartenbergMatrix ---R DHMATRIX abbreviates domain DenavitHartenbergMatrix +--R DHMATRIX abbreviates domain DenavitHartenbergMatrix --E 59 --S 60 of 97 diff --git a/src/input/unittest2.input.pamphlet b/src/input/unittest2.input.pamphlet index ccf09e2..b5c3b3d 100644 --- a/src/input/unittest2.input.pamphlet +++ b/src/input/unittest2.input.pamphlet @@ -1256,10 +1256,8 @@ This generates non-printing characters --RValue = NIL --E 203 ---S 204 of 235 -)lisp (identity |$promptMsg|) ---R ---RValue = S2CTP023 +--S 204 of 235 removed, promptMsg is never used and was deleted +--)lisp (identity |$promptMsg|) --E 204 --S 205 of 235 -- 1.7.5.4