diff --git a/books/bookvol5.pamphlet b/books/bookvol5.pamphlet index feaedb0..a2fe0cf 100644 --- a/books/bookvol5.pamphlet +++ b/books/bookvol5.pamphlet @@ -119,6 +119,40 @@ \index{{#2}}}% %% +%% calls marks a call from this function to another +%% +\newcommand{\calls}[2]{% e.g. \calls{thisfunc}{thatfunc} +[#2 p\pageref{#2}]\\% +\index{#2!{calledby #1}}% +\index{#1!{calls #2}}}% + +%% +%% uses marks a special variable use +%% +\newcommand{\uses}[2]{% e.g. \calls{thisfunc}{specialvar} +[#2 p\pageref{#2}]\\% +\index{#2!{usedby #1}}% +\index{#1!{uses #2}}}% + +%% +%% calls marks a call from this function to another +%% if the called function starts with dollar we need to fake it +%% +\newcommand{\callsdollar}[2]{% e.g. \calls{thisfunc}{thatfunc} +[\$#2 p\pageref{#2}]\\% +\index{\$#2!{calledby \$#1}}% +\index{#1!{calls \$#2}}}% + +%% +%% uses marks a special variable use +%% if the special variable starts with dollar we need to fake it +%% +\newcommand{\usesdollar}[2]{% e.g. \calls{thisfunc}{specialvar} +[\$#2 p\pageref{#2}]\\% +\index{\${#2}!{usedby #1}}% +\index{#1!{uses \${#2}}}}% + +%% %% pagepic adds an image and an index entry %% \newcommand{\pagepic}[3]{% e.g. \pagepic{pathandfile}{abb}{scale} @@ -265,6 +299,7 @@ Axiom has a very long history and many people have contributed to the effort, some in large ways and some in small ways. Any and all effort deserves recognition. There is no other criteria than contribution of effort. We would like to acknowledge and thank the following people: +\defvar{credits} <>= (defvar credits '( "An alphabetical listing of contributors to AXIOM:" @@ -448,6 +483,29 @@ used to collect statistics. Currently, only the garbage collector information is initialized. +\calls{restart}{init-memory-config} +\calls{restart}{getenviron} +\calls{restart}{initroot} +\calls{restart}{openserver} +\calls{restart}{makeInitialModemapFrame} +\calls{restart}{get-current-directory} +\calls{restart}{loadExposureGroupData} +\calls{restart}{statisticsInitialization} +\calls{restart}{initHist} +\calls{restart}{initializeInterpreterFrameRing} +\calls{restart}{spadStartUpMsgs} +\calls{restart}{restart0} +\calls{restart}{readSpadProfileIfThere} +\calls{restart}{spad} +\usesdollar{restart}{openServerIfTrue} +\usesdollar{restart}{SpadServername} +\usesdollar{restart}{SpadServer} +\usesdollar{restart}{IOindex} +\usesdollar{restart}{InteractiveFrame} +\usesdollar{restart}{printLoadMsgs} +\usesdollar{restart}{current-directory} +\usesdollar{restart}{displayStartMsgs} +\usesdollar{restart}{currentLine} <>= (defun restart () (declare (special $openServerIfTrue $SpadServerName |$SpadServer| @@ -484,6 +542,10 @@ information is initialized. @ \defunsec{spad}{Starts the interpreter but do not read in profiles} +\calls{spad}{setOutputAlgebra} +\calls{spad}{runspad} +\usesdollar{spad}{PrintCompilerMessageIfTrue} +\usesdollar{spad}{inLispVM} <>= (defun |spad| () "Starts the interpreter but do not read in profiles" @@ -502,6 +564,11 @@ information is initialized. @ \defun{runspad}{runspad} +\calls{runspad}{seq} +\calls{runspad}{exit} +\calls{runspad}{resetStackLimits} +\calls{runspad}{ncTopLevel} +\usesdollar{runspad}{quitTag} <>= (defun |runspad| () (prog (mode) @@ -522,6 +589,7 @@ information is initialized. @ \defun{resetStackLimits}{Reset the stack limits} +\calls{resetStackLimits}{reset-stack-limits} <>= (defun |resetStackLimits| () "Reset the stack limits" @@ -578,6 +646,15 @@ While not using the ``dollar'' convention this variable is still ``global''. \defunsec{ncTopLevel}{Top-level read-parse-eval-print loop} Top-level read-parse-eval-print loop for the interpreter. Uses the Bill Burge's parser. +\calls{ncTopLevel}{ncIntLoop} +\usesdollar{ncTopLevel}{e} +\usesdollar{ncTopLevel}{spad} +\usesdollar{ncTopLevel}{newspad} +\usesdollar{ncTopLevel}{boot} +\usesdollar{ncTopLevel}{InteractiveMode} +\usesdollar{ncTopLevel}{InteractiveFrame} +\uses{ncTopLevel}{*eof*} +\uses{ncTopLevel}{in-stream} <>= (defun |ncTopLevel| () "Top-level read-parse-eval-print loop" @@ -595,6 +672,9 @@ the Bill Burge's parser. @ \defun{ncIntLoop}{ncIntLoop} +\calls{ncIntLoop}{intloop} +\uses{ncIntLoop}{curinstream} +\uses{ncIntLoop}{curoutstream} <>= (defun |ncIntLoop| () (let ((curinstream *standard-output*) @@ -607,6 +687,10 @@ the Bill Burge's parser. Note that the SpadInterpretStream function uses a list of three strings as an argument. The values in the list seem to have no use and can eventually be removed. +\calls{intloop}{SpadInterpretStream} +\calls{intloop}{resetStackLimits} +\usesdollar{intloop}{intTopLevel} +\usesdollar{intloop}{intRestart} <>= (defun |intloop| () (prog (mode) @@ -653,6 +737,21 @@ does nothing but print the argument value. @ +\calls{SpadInterpretStream}{mkprompt} +\calls{SpadInterpretStream}{intloopReadConsole} +\calls{SpadInterpretStream}{intloopInclude} +\usesdollar{SpadInterpretStream}{promptMsg} +\usesdollar{SpadInterpretStream}{systemCommandFunction} +\usesdollar{SpadInterpretStream}{ncMsgList} +\usesdollar{SpadInterpretStream}{erMsgToss} +\usesdollar{SpadInterpretStream}{lastPos} +\usesdollar{SpadInterpretStream}{inclAssertions} +\usesdollar{SpadInterpretStream}{okToExecuteMachineCode} +\usesdollar{SpadInterpretStream}{newcompErrorCount} +\usesdollar{SpadInterpretStream}{newcompMode} +\usesdollar{SpadInterpretStream}{libQuiet} +\usesdollar{SpadInterpretStream}{fn} +\usesdollar{SpadInterpretStream}{nopos} <>= (defun |SpadInterpretStream| (str source interactive?) (let (|$promptMsg| |$systemCommandFunction| @@ -713,6 +812,18 @@ caution. \end{itemize} Notice that all but two paths (a null input or a ``)fi'' or a ``)fin'') will end up as a recursive call to ourselves. +\calls{intloopReadConsole}{serverReadLine} +\calls{intloopReadConsole}{leaveScratchpad} +\calls{intloopReadConsole}{mkprompt} +\calls{intloopReadConsole}{intloopReadConsole} +\calls{intloopReadConsole}{intloopPrefix?} +\calls{intloopReadConsole}{intnplisp} +\calls{intloopReadConsole}{setCurrentLine} +\calls{intloopReadConsole}{ncloopCommand} +\calls{intloopReadConsole}{concat} +\calls{intloopReadConsole}{ncloopEscaped} +\calls{intloopReadConsole}{intloopProcessString} +\usesdollar{intloopReadConsole}{dalymode} <>= (defun |intloopReadConsole| (b n) (declare (special $dalymode)) @@ -744,6 +855,7 @@ will end up as a recursive call to ourselves. @ \section{Helper Functions} \defunsec{getenviron}{Get the value of an evironment variable} +\calls{getenviron}{getenv} <>= (defun getenviron (var) "Get the value of an evironment variable" @@ -761,6 +873,9 @@ will end up as a recursive call to ourselves. @ \defun{InterpExecuteSpadSystemCommand}{InterpExecuteSpadSystemCommand} +\calls{InterpExecuteSpadSystemCommand}{ExecuteInterpSystemCommand} +\usesdollar{InterpExecuteSpadSystemCommand}{intSpadReader} +\usesdollar{InterpExecuteSpadSystemCommand}{intCoerceFailure} <>= (defun |InterpExecuteSpadSystemCommand| (string) (declare (special |$intSpadReader| |$intCoerceFailure|)) @@ -771,6 +886,10 @@ will end up as a recursive call to ourselves. @ \defun{ExecuteInterpSystemCommand}{ExecuteInterpSystemCommand} +\calls{ExecuteInterpSystemCommand}{intProcessSynonyms} +\calls{ExecuteInterpSystemCommand}{substring} +\calls{ExecuteInterpSystemCommand}{doSystemCommand} +\usesdollar{ExecuteInterpSystemCommand}{currentLine} <>= (defun |ExecuteInterpSystemCommand| (string) (let (|$currentLine|) @@ -786,6 +905,10 @@ will end up as a recursive call to ourselves. Austin-Kyoto Common Lisp (AKCL), now known as Gnu Common Lisp (GCL) requires some changes to the default memory setup to run Axiom efficently. This function performs those setup commands. +\calls{init-memory-config}{allocate} +\calls{init-memory-config}{allocate-contiguous-pages} +\calls{init-memory-config}{allocate-relocatable-pages} +\calls{init-memory-config}{set-hole-size} <>= (defun init-memory-config (&key (cons 500) @@ -821,7 +944,8 @@ Sets up the system to use the {\bf AXIOM} shell variable if we can and default to the {\bf \$spadroot} variable (which was the value of the {\bf AXIOM} shell variable at build time) if we can't. -Called from \fnref{restart}. +\calls{initroot}{reroot} +\usesdollar{initroot}{spadroot} <>= (defun initroot (&optional (newroot (getenviron "AXIOM"))) "Set spadroot to be the AXIOM shell variable" @@ -859,6 +983,7 @@ minus any leading spaces. @ \defunsec{make-absolute-filename}{Prepend the absolute path to a filename} Prefix a filename with the {\bf AXIOM} shell variable. +\usesdollar{make-absolute-filename}{spadroot} <>= (defun make-absolute-filename (name) "Prepend the absolute path to a filename" @@ -868,6 +993,8 @@ Prefix a filename with the {\bf AXIOM} shell variable. @ \defunsec{makeInitialModemapFrame}{Make the initial modemap frame} +\calls{makeInitialModemapFrame}{copy} +\usesdollar{makeInitialModemapFrame}{InitialModemapFrame} <>= (defun |makeInitialModemapFrame| () "Make the initial modemap frame" @@ -890,6 +1017,10 @@ character. Otherwise, it returns nil. @ \defun{intloopProcessString}{intloopProcessString} +\calls{intloopProcessString}{setCurrentLine} +\calls{intloopProcessString}{intloopProcess} +\calls{intloopProcessString}{next} +\calls{intloopProcessString}{incString} <>= (defun |intloopProcessString| (s n) (|setCurrentLine| s) @@ -900,6 +1031,9 @@ character. Otherwise, it returns nil. @ \defun{ncloopParse}{ncloopParse} +\calls{ncloopParse}{ncloopDQlines} +\calls{ncloopParse}{npParse} +\calls{ncloopParse}{dqToList} <>= (defun |ncloopParse| (s) (let (cudr lines stream dq t1) @@ -914,6 +1048,8 @@ character. Otherwise, it returns nil. @ \defun{next}{next} +\calls{next}{Delay} +\calls{next}{next1} <>= (defun |next| (f s) (|Delay| (function |next1|) (list f s))) @@ -921,6 +1057,9 @@ character. Otherwise, it returns nil. @ \defun{next1}{next1} +\calls{next1}{StreamNull} +\calls{next1}{incAppend} +\calls{next1}{next} <>= (defun |next1| (&rest z) (let (h s f) @@ -935,6 +1074,9 @@ character. Otherwise, it returns nil. @ \defun{incString}{incString} +\calls{incString}{incRenumber} +\calls{incString}{incLude} +\uses{incString}{Top} <>= (defun |incString| (s) (declare (special |Top|)) @@ -985,6 +1127,15 @@ before compiling this file. A correct call looks like: (reroot "/spad/mnt/${SYS}") \end{verbatim} where the \verb|${SYS}| variable is the same one set at build time. +\calls{reroot}{make-absolute-filename} +\usesdollar{reroot}{spadroot} +\usesdollar{reroot}{directory-list} +\usesdollar{reroot}{relative-directory-list} +\usesdollar{reroot}{library-directory-list} +\usesdollar{reroot}{relative-library-directory-list} +\usesdollar{reroot}{defaultMsgDatabaseName} +\usesdollar{reroot}{msgDatabaseName} +\usesdollar{reroot}{current-directory} <>= (defun reroot (dir) (declare (special $spadroot $directory-list $relative-directory-list @@ -1015,6 +1166,7 @@ Remember the current line. The cases are: Note I suspect the last two cases do not occur in practice since they result in a dotted pair if the input is not a cons. However, this is what the current code does so I won't change it. +\usesdollar{setCurrentLine}{currentLine} <>= (defun |setCurrentLine| (s) (declare (special |$currentLine|)) @@ -1030,6 +1182,12 @@ this is what the current code does so I won't change it. @ \defunsec{mkprompt}{Show the Axiom prompt} +\calls{mkprompt}{concat} +\calls{mkprompt}{substring} +\calls{mkprompt}{currenttime} +\usesdollar{mkprompt}{inputPromptType} +\usesdollar{mkprompt}{IOindex} +\usesdollar{mkprompt}{interpreterFrameName} <>= (defun mkprompt () "Show the Axiom prompt" @@ -1079,6 +1237,45 @@ this is what the current code does so I won't change it. @ \defunsec{serverReadLine}{READ-LINE in an Axiom server system} +\calls{serverReadLine}{read-line} +\calls{serverReadLine}{addNewInterpreterFrame} +\calls{serverReadLine}{sockSendInt} +\calls{serverReadLine}{plus} +\calls{serverReadLine}{sockSendString} +\calls{serverReadLine}{mkprompt} +\calls{serverReadLine}{sockGetInt} +\calls{serverReadLine}{lassoc} +\calls{serverReadLine}{changeToNamedInterpreterFrame} +\calls{serverReadLine}{sockGetString} +\calls{serverReadLine}{unescapeStringsInForm} +\calls{serverReadLine}{protectedEVAL} +\calls{serverReadLine}{executeQuietCommand} +\calls{serverReadLine}{parseAndInterpret} +\calls{serverReadLine}{is-console} +\calls{serverReadLine}{serverSwitch} +\usesdollar{serverReadLine}{KillLispSystem} +\usesdollar{serverReadLine}{NonSmanSession} +\usesdollar{serverReadLine}{SpadCommand} +\usesdollar{serverReadLine}{QuietSpadCommand} +\usesdollar{serverReadLine}{MenuServer} +\usesdollar{serverReadLine}{sockBufferLength} +\usesdollar{serverReadLine}{LispCommand} +\usesdollar{serverReadLine}{EndServerSession} +\usesdollar{serverReadLine}{EndSession} +\usesdollar{serverReadLine}{SwitchFrames} +\usesdollar{serverReadLine}{CreateFrameAnswer} +\usesdollar{serverReadLine}{currentFrameNum} +\usesdollar{serverReadLine}{frameNumber} +\usesdollar{serverReadLine}{frameAlist} +\usesdollar{serverReadLine}{CreateFrame} +\usesdollar{serverReadLine}{CallInterp} +\usesdollar{serverReadLine}{EndOfOutput} +\usesdollar{serverReadLine}{SessionManager} +\usesdollar{serverReadLine}{NeedToSignalSessionManager} +\usesdollar{serverReadLine}{EndServerSession} +\usesdollar{serverReadLine}{SpadServer} +\uses{serverReadLine}{*eof*} +\uses{serverReadLine}{in-stream} <>= (defun |serverReadLine| (stream) "used in place of READ-LINE in a Axiom server system." @@ -1153,6 +1350,8 @@ this is what the current code does so I won't change it. @ \defunsec{intloopInclude}{Include a file into the stream} +\calls{intloopInclude}{ST} +\calls{intloopInclude}{intloopInclude0} <>= (defun |intloopInclude| (name n) "Include a file into the stream" @@ -1161,6 +1360,13 @@ this is what the current code does so I won't change it. @ \defun{intloopInclude0}{intloopInclude0} +\calls{intloopInclude0}{incStream} +\calls{intloopInclude0}{intloopProcess} +\calls{intloopInclude0}{next} +\calls{intloopInclude0}{intloopEchoParse} +\calls{intloopInclude0}{insertpile} +\calls{intloopInclude0}{lineoftoks} +\usesdollar{intloopInclude0}{lines} <>= (defun |intloopInclude0| (|st| |name| |n|) (let (|$lines|) @@ -1175,6 +1381,14 @@ this is what the current code does so I won't change it. @ \defun{intloopProcess}{intloopProcess} +\calls{intloopProcess}{StreamNull} +\calls{intloopProcess}{pfAbSynOp?} +\calls{intloopProcess}{setCurrentLine} +\calls{intloopProcess}{tokPart} +\calls{intloopProcess}{intloopProcess} +\calls{intloopProcess}{intloopSpadProcess} +\callsdollar{intloopProcess}{systemCommandFunction} +\usesdollar{intloopProcess}{systemCommandFunction} <>= (defun |intloopProcess| (n interactive s) (let (ptree lines t1) @@ -1198,6 +1412,18 @@ this is what the current code does so I won't change it. @ \defun{intloopSpadProcess}{intloopSpadProcess} +\calls{intloopSpadProcess}{ncPutQ} +\calls{intloopSpadProcess}{CatchAsCan} +\calls{intloopSpadProcess}{Catch} +\calls{intloopSpadProcess}{intloopSpadProcess,interp} +\calls{intloopSpadProcess}{intSetNeedToSignalSessionManager} +\usesdollar{intloopSpadProcess}{currentCarrier} +\usesdollar{intloopSpadProcess}{ncMsgList} +\usesdollar{intloopSpadProcess}{intCoerceFailure} +\usesdollar{intloopSpadProcess}{intSpadReader} +\usesdollar{intloopSpadProcess}{prevCarrier} +\usesdollar{intloopSpadProcess}{stepNo} +\uses{intloopSpadProcess}{flung} <>= (defun |intloopSpadProcess| (stepNo lines ptree interactive?) (let (|$stepNo| result cc) @@ -1226,6 +1452,9 @@ this is what the current code does so I won't change it. @ \defun{intloopSpadProcess,interp}{intloopSpadProcess,interp} +\calls{intloopSpadProcess,interp}{ncConversationPhase} +\calls{intloopSpadProcess,interp}{ncEltQ} +\calls{intloopSpadProcess,interp}{ncError} <>= (defun |intloopSpadProcess,interp| (cc ptree interactive?) (|ncConversationPhase| #'|phParse| (list cc ptree)) @@ -1240,6 +1469,11 @@ this is what the current code does so I won't change it. \begin{verbatim} phParse: carrier[tokens,...] -> carrier[ptree, tokens,...] \end{verbatim} +\calls{phParse}{phBegin} +\calls{phParse}{intSayKeyedMsg} +\calls{phParse}{pform} +\calls{phParse}{ncPutQ} +\usesdollar{phParse}{ncmParse} <>= (defun |phParse| (carrier ptree) (declare (special |$ncmParse|)) @@ -1254,6 +1488,13 @@ phParse: carrier[tokens,...] -> carrier[ptree, tokens,...] \begin{verbatim} carrier[ptree,...] -> carrier[ptree, ptreePremacro,...] \end{verbatim} +\calls{phMacro}{phBegin} +\calls{phMacro}{ncEltQ} +\calls{phMacro}{ncPutQ} +\calls{phMacro}{macroExpanded} +\calls{phMacro}{intSayKeyedMsg} +\calls{phMacro}{pform} +\usesdollar{phMacro}{ncmMacro} <>= (defun |phMacro| (carrier) (let (ptree) @@ -1272,6 +1513,11 @@ carrier[ptree,...] -> carrier[ptree, ptreePremacro,...] \begin{verbatim} carrier[lines,messages,..]-> carrier[lines,messages,..] \end{verbatim} +\calls{phIntReportMsgs}{ncEltQ} +\calls{phIntReportMsgs}{ncPutQ} +\calls{phIntReportMsgs}{processMsgList} +\calls{phIntReportMsgs}{intSayKeyedMsg} +\usesdollar{phIntReportMsgs}{erMsgToss} <>= (defun |phIntReportMsgs| (carrier interactive?) (let (nerr msgs lines) @@ -1293,6 +1539,9 @@ carrier[lines,messages,..]-> carrier[lines,messages,..] @ \defun{phInterpret}{phInterpret} +\calls{phInterpret}{ncEltQ} +\calls{phInterpret}{intInterpretPform} +\calls{phInterpret}{ncPutQ} <>= (defun |phInterpret| (carrier) (let (val ptree) @@ -1303,6 +1552,9 @@ carrier[lines,messages,..]-> carrier[lines,messages,..] @ \defun{phBegin}{phBegin} +\calls{phBegin}{intSayKeyedMsg} +\usesdollar{phBegin}{ncmPhase} +\usesdollar{phBegin}{convPhase} <>= (defun |phBegin| (id) (declare (special |$ncmPhase| |$convPhase|)) @@ -1312,6 +1564,9 @@ carrier[lines,messages,..]-> carrier[lines,messages,..] @ \defun{ncConversationPhase}{ncConversationPhase} +\calls{ncConversationPhase}{ncConversationPhase,wrapup} +\usesdollar{ncConversationPhase}{convPhase} +\usesdollar{ncConversationPhase}{ncMsgList} <>= (defun |ncConversationPhase| (fn args) (let (|$convPhase| |$ncMsgList| carrier) @@ -1326,6 +1581,7 @@ carrier[lines,messages,..]-> carrier[lines,messages,..] @ \defun{ncConversationPhase,wrapup}{ncConversationPhase,wrapup} +\usesdollar{ncConversationPhase,wrapup}{ncMsgList} <>= (defun |ncConversationPhase,wrapup| (carrier) (declare (special |$ncMsgList|)) @@ -1349,6 +1605,14 @@ carrier[lines,messages,..]-> carrier[lines,messages,..] @ \defun{intloopEchoParse}{intloopEchoParse} +\calls{intloopEchoParse}{ncloopDQlines} +\calls{intloopEchoParse}{setCurrentLine} +\calls{intloopEchoParse}{mkLineList} +\calls{intloopEchoParse}{ncloopPrintLines} +\calls{intloopEchoParse}{npParse} +\calls{intloopEchoParse}{dqToList} +\usesdollar{intloopEchoParse}{EchoLines} +\usesdollar{intloopEchoParse}{lines} <>= (defun |intloopEchoParse| (s) (let (cudr lines stream dq t1) @@ -1409,7 +1673,7 @@ carrier[lines,messages,..]-> carrier[lines,messages,..] nil lines nil)) (cond ((eql (length l) 1) (car l)) - (t l)))))) + (t l)))) @ @@ -1441,6 +1705,10 @@ carrier[lines,messages,..]-> carrier[lines,messages,..] @ \defun{ncloopDQlines}{ncloopDQlines} +\calls{ncloopDQlines}{StreamNull} +\calls{ncloopDQlines}{poGlobalLinePosn} +\calls{ncloopDQlines}{tokPosn} +\calls{ncloopDQlines}{streamChop} <>= (defun |ncloopDQlines| (dq stream) (let (b a) @@ -1455,6 +1723,9 @@ carrier[lines,messages,..]-> carrier[lines,messages,..] Note that changing the name ``lyne'' to ``line'' will break the system. I do not know why. The symptom shows up when there is a file with a large contiguous comment spanning enough lines to overflow the stack. +\calls{streamChop}{StreamNull} +\calls{streamChop}{streamChop} +\calls{streamChop}{ncloopPrefix?} <>= (defun |streamChop| (n s) (let (d c lyne b a tmp1) @@ -1473,6 +1744,13 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{ncloopInclude0}{ncloopInclude0} +\calls{ncloopInclude0}{incStream} +\calls{ncloopInclude0}{ncloopProcess} +\calls{ncloopInclude0}{next} +\calls{ncloopInclude0}{ncloopEchoParse} +\calls{ncloopInclude0}{insertpile} +\calls{ncloopInclude0}{lineoftoks} +\usesdollar{ncloopInclude0}{lines} <>= (defun |ncloopInclude0| (st name n) (let (|$lines|) @@ -1487,6 +1765,10 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incStream}{incStream} +\calls{incStream}{incRenumber} +\calls{incStream}{incLude} +\calls{incStream}{incRgen} +\uses{incStream}{Top} <>= (defun |incStream| (st fn) (declare (special |Top|)) @@ -1495,6 +1777,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incRenumber}{incRenumber} +\calls{incRenumber}{incZip} +\calls{incRenumber}{incIgen} <>= (defun |incRenumber| (ssx) (|incZip| #'|incRenumberLine| ssx (|incIgen| 0))) @@ -1502,6 +1786,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incZip}{incZip} +\calls{incZip}{Delay} +\calls{incZip}{incZip1} <>= (defun |incZip| (g f1 f2) (|Delay| (function |incZip1|) (list g f1 f2))) @@ -1509,6 +1795,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incZip1}{incZip1} +\calls{incZip1}{StreamNull} +\calls{incZip1}{incZip} <>= (defun |incZip1| (&rest z) (let (f2 f1 g) @@ -1526,6 +1814,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incIgen}{incIgen} +\calls{incIgen}{Delay} +\calls{incIgen}{incIgen1} <>= (defun |incIgen| (n) (|Delay| (function |incIgen1|) (list n))) @@ -1533,6 +1823,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incIgen1}{incIgen1} +\calls{incIgen1}{incIgen} <>= (defun |incIgen1| (&rest z) (let (n) @@ -1543,6 +1834,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incRenumberLine}{incRenumberLine} +\calls{incRenumberLine}{incRenumberItem} +\calls{incRenumberLine}{incHandleMessage} <>= (defun |incRenumberLine| (xl gno) (let (l) @@ -1552,6 +1845,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incRenumberItem}{incRenumberItem} +\calls{incRenumberItem}{lnSetGlobalNum} <>= (defun |incRenumberItem| (f i) (let (l) @@ -1561,6 +1855,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incHandleMessage}{incHandleMessage} +\calls{incHandleMessage}{ncSoftError} +\calls{incHandleMessage}{ncBug} <>= (defun |incHandleMessage| (x) "Message handling for the source includer" @@ -1579,6 +1875,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incLude}{incLude} +\calls{incLude}{Delay} +\calls{include}{incLude1} <>= (defun |incLude| (eb ss ln ufos states) (|Delay| (function |incLude1|) (list eb ss ln ufos states))) @@ -1640,6 +1938,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defvar{Top?} +\calls{Top?}{quotient} <>= (defun |Top?| (|st|) "used in incLude1 for parsing" @@ -1647,6 +1946,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defvar{If?} +\calls{If?}{quotient} <>= (defun |If?| (|st|) "used in incLude1 for parsing" @@ -1654,6 +1954,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defvar{Elseif?} +\calls{Elseif?}{QUOTIENT} <>= (defun |Elseif?| (|st|) "used in incLude1 for parsing" @@ -1661,6 +1962,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defvar{Else?} +\calls{Else?}{QUOTIENT} <>= (defun |Else?| (|st|) "used in incLude1 for parsing" @@ -1668,6 +1970,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defvar{SkipEnd?} +\calls{SkipEnd?}{remainder} <>= (defun |SkipEnd?| (|st|) "used in incLude1 for parsing" @@ -1675,6 +1978,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defvar{KeepPart?} +\calls{KeepPart?}{remainder} <>= (defun |KeepPart?| (|st|) "used in incLude1 for parsing" @@ -1682,6 +1986,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defvar{SkipPart?} +\calls{SkipPart?}{remainder} <>= (defun |SkipPart?| (|st|) "used in incLude1 for parsing" @@ -1689,6 +1994,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defvar{Skipping?} +\calls{Skipping?}{KeepPart?} <>= (defun |Skipping?| (|st|) "used in incLude1 for parsing" @@ -1697,6 +2003,44 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incLude1}{incLude1} +\calls{incLude1}{StreamNull} +\calls{incLude1}{Top?} +\calls{incLude1}{xlPrematureEOF} +\calls{incLude1}{Skipping?} +\calls{incLude1}{xlSkip} +\calls{incLude1}{Rest} +\calls{incLude1}{xlOK} +\calls{incLude1}{xlOK1} +\calls{incLude1}{concat} +\calls{incLude1}{incCommandTail} +\calls{incLude1}{xlSay} +\calls{incLude1}{xlNoSuchFile} +\calls{incLude1}{xlCannotRead} +\calls{incLude1}{incActive?} +\calls{incLude1}{xlFileCycle} +\calls{incLude1}{incLude} +\calls{incLude1}{incFileInput} +\calls{incLude1}{incAppend} +\calls{incLude1}{inclFname} +\calls{incLude1}{xlConActive} +\calls{incLude1}{xlConStill} +\calls{incLude1}{incConsoleInput} +\calls{incLude1}{incNConsoles} +\calls{incLude1}{xlConsole} +\calls{incLude1}{xlSkippingFin} +\calls{incLude1}{xlPrematureFin} +\calls{incLude1}{assertCond} +\calls{incLude1}{ifCond} +\calls{incLude1}{If?} +\calls{incLude1}{Elseif?} +\calls{incLude1}{xlIfSyntax} +\calls{incLude1}{SkipEnd?} +\calls{incLude1}{KeepPart?} +\calls{incLude1}{SkipPart?} +\calls{incLude1}{xlIfBug} +\calls{incLude1}{xlCmdBug} +\calls{incLude1}{expand-tabs} +\calls{incLude1}{incClassify} <>= (defun |incLude1| (&rest z) (let (pred s1 n tail head includee fn1 info str state lno states @@ -1869,6 +2213,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlPrematureEOF}{xlPrematureEOF} +\calls{xlPrematureEOF}{xlMsg} +\calls{xlPrematureEOF}{inclmsgPrematureEOF} <>= (defun |xlPrematureEOF| (eb str lno ufos) (|xlMsg| eb str lno (elt ufos 0) @@ -1877,6 +2223,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlMsg}{xlMsg} +\calls{xlMsg}{incLine} <>= (defun |xlMsg| (eb str lno ufo mess) (list (|incLine| eb str (- 1) lno ufo) mess)) @@ -1884,6 +2231,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlOK}{xlOK} +\calls{xlOK}{incLine} <>= (defun |xlOK| (eb str lno ufo) (list (|incLine| eb str -1 lno ufo) (list nil '|none|))) @@ -1891,6 +2239,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlOK1}{xlOK1} +\calls{xlOK1}{incLine1} <>= (defun |xlOK1| (eb str str1 lno ufo) (list (|incLine1| eb str str1 -1 lno ufo) (list nil '|none|))) @@ -1898,6 +2247,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incAppend}{incAppend} +\calls{incAppend}{Delay} +\calls{incAppend}{incAppend1} <>= (defun |incAppend| (x y) (|Delay| (function |incAppend1|) (list x y))) @@ -1905,6 +2256,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incAppend1}{incAppend1} +\calls{incAppend1}{StreamNull} +\calls{incAppend1}{incAppend} <>= (defun |incAppend1| (&rest z) (let (y x) @@ -1919,6 +2272,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{incLine1}{incLine1} +\calls{incLine1}{lnCreate} <>= (defun |incLine1| (eb str str1 gno lno ufo) (cons (cons (|lnCreate| eb str gno lno ufo) 1) str1)) @@ -1926,13 +2280,15 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{inclmsgPrematureEOF}{inclmsgPrematureEOF} +\calls{inclmsgPrematureEOF}{origin} <>= (defun |inclmsgPrematureEOF| (ufo) - (list 'S2CI0002 (list (|%origin| ufo)))))) + (list 'S2CI0002 (list (|%origin| ufo)))) @ \defun{incLine}{incLine} +\calls{incLine}{lnCreate} <>= (defun |incLine| (eb str gno lno ufo) (cons (cons (|lnCreate| eb str gno lno ufo) 1) str)) @@ -1940,17 +2296,23 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{ifCond}{ifCond} +\calls{ifCond}{MakeSymbol} +\calls{ifCond}{incCommandTail} +\calls{ifCond}{ListMemberQ?} +\usesdollar{ifCond}{inclAssertions} <>= (defun |ifCond| (s info) (let (word) (declare (special |$inclAssertions|)) (setq word (|MakeSymbol| (string-trim *whitespace* (|incCommandTail| s info)))) - (|ListMemberQ?| word |$inclAssertions|))))) + (|ListMemberQ?| word |$inclAssertions|))) @ \defun{xlSkip}{xlSkip} +\calls{xlSkip}{incLine} +\calls{xlSkip}{CONCAT} <>= (defun |xlSkip| (eb str lno ufo) (list @@ -1960,6 +2322,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlSay}{xlSay} +\calls{xlSay}{xlMsg} +\calls{xlSay}{inclmsgSay} <>= (defun |xlSay| (eb str lno ufos x) (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgSay| x) '|say|))) @@ -1967,6 +2331,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{inclmsgSay}{inclmsgSay} +\calls{inclmsgSay}{id} <>= (defun |inclmsgSay| (str) (list 'S2CI0001 (list (|%id| str)))) @@ -1974,6 +2339,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlNoSuchFile}{xlNoSuchFile} +\calls{xlNoSuchFile}{xlMsg} +\calls{xlNoSuchFile}{inclmsgNoSuchFile} <>= (defun |xlNoSuchFile| (eb str lno ufos fn) (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgNoSuchFile| fn) '|error|))) @@ -1981,6 +2348,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{inclmsgNoSuchFile}{inclmsgNoSuchFile} +\calls{inclmsgNoSuchFile}{fname} <>= (defun |inclmsgNoSuchFile| (fn) (list 'S2CI0010 (list (|%fname| fn)))) @@ -1988,6 +2356,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlCannotRead}{xlCannotRead} +\calls{xlCannotRead}{xlMsg} +\calls{xlCannotRead}{inclmsgCannotRead} <>= (defun |xlCannotRead| (eb str lno ufos fn) (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgCannotRead| fn) '|error|))) @@ -1995,6 +2365,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{inclmsgCannotRead}{inclmsgCannotRead} +\calls{inclmsgCannotRead}{fname} <>= (defun |inclmsgCannotRead| (fn) (list 'S2CI0011 (list (|%fname| fn)))) @@ -2002,6 +2373,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlFileCycle}{xlFileCycle} +\calls{xlFileCycle}{xlMsg} +\calls{xlFileCycle}{inclmsgFileCycle} <>= (defun |xlFileCycle| (eb str lno ufos fn) (|xlMsg| eb str lno (elt ufos 0) @@ -2015,9 +2388,11 @@ contiguous comment spanning enough lines to overflow the stack. ; flist := [porigin n for n in reverse ufos] ; f1 := porigin fn ; cycle := [:[:[n,'"==>"] for n in flist], f1] -; ['S2CI0004, [%id cycle, %id f1]] +; ['S2CI0004, [%id cycle, %id f1] ] \end{verbatim} +\calls{inclmsgFileCycle}{porigin} +\calls{inclmsgFileCycle}{id} <>= (defun |inclmsgFileCycle| (ufos fn) (let (cycle f1 flist) @@ -2049,6 +2424,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlConActive}{xlConActive} +\calls{xlConActive}{xlMsg} +\calls{xlConActive}{inclmsgConActive} <>= (defun |xlConActive| (eb str lno ufos n) (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgConActive| n) '|warning|))) @@ -2056,6 +2433,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{inclmsgConActive}{inclmsgConActive} +\calls{inclmsgConActive}{id} <>= (defun |inclmsgConActive| (n) (list 'S2CI0006 (list (|%id| n)))) @@ -2063,6 +2441,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlConStill}{xlConStill} +\calls{xlConStill}{xlMsg} +\calls{xlConStill}{inclmsgConStill} <>= (defun |xlConStill| (eb str lno ufos n) (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgConStill| n) '|say|))) @@ -2070,6 +2450,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{inclmsgConStill}{inclmsgConStill} +\calls{inclmsgConStill}{id} <>= (defun |inclmsgConStill| (n) (list 'S2CI0007 (list (|%id| n)))) @@ -2077,6 +2458,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlConsole}{xlConsole} +\calls{xlConsole}{xlMsg} +\calls{xlConsole}{inclmsgConsole} <>= (defun |xlConsole| (eb str lno ufos) (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgConsole|) '|say|))) @@ -2091,6 +2474,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlSkippingFin}{xlSkippingFin} +\calls{xlSkippingFin}{xlMsg} +\calls{xlSkippingFin}{inclmsgFinSkipped} <>= (defun |xlSkippingFin| (eb str lno ufos) (|xlMsg| eb str lno (elt ufos 0) @@ -2106,6 +2491,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlPrematureFin}{xlPrematureFin} +\calls{xlPrematureFin}{xlMsg} +\calls{xlPrematureFin}{inclmsgPrematureFin} <>= (defun |xlPrematureFin| (eb str lno ufos) (|xlMsg| eb str lno (elt ufos 0) @@ -2114,6 +2501,7 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{inclmsgPrematureFin}{inclmsgPrematureFin} +\calls{inclmsgPrematureFin}{origin} <>= (defun |inclmsgPrematureFin| (ufo) (list 'S2CI0003 (list (|%origin| ufo)))) @@ -2121,6 +2509,11 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{assertCond}{assertCond} +\calls{assertCond}{MakeSymbol} +\calls{assertCond}{incCommandTail} +\calls{assertCond}{ListMemberQ?} +\usesdollar{assertCond}{inclAssertions} +\uses{assertCond}{*whitespace*} <>= (defun |assertCond| (s info) (let (word) @@ -2133,6 +2526,10 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlIfSyntax}{xlIfSyntax} +\calls{xlIfSyntax}{Top?} +\calls{xlIfSyntax}{Else?} +\calls{xlIfSyntax}{xlMsg} +\calls{xlIfSyntax}{inclmsgIfSyntax} <>= (defun |xlIfSyntax| (eb str lno ufos info sts) (let (context found st) @@ -2149,6 +2546,9 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{inclmsgIfSyntax}{inclmsgIfSyntax} +\calls{inclmsgIfSyntax}{concat} +\calls{inclmsgIfSyntax}{id} +\calls{inclmsgIfSyntax}{origin} <>= (defun |inclmsgIfSyntax| (ufo found context) (setq found (concat ")" found)) @@ -2157,6 +2557,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlIfBug}{xlIfBug} +\calls{xlIfBug}{xlMsg} +\calls{xlIfBug}{inclmsgIfBug} <>= (defun |xlIfBug| (eb str lno ufos) (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgIfBug|) '|bug|))) @@ -2171,6 +2573,8 @@ contiguous comment spanning enough lines to overflow the stack. @ \defun{xlCmdBug}{xlCmdBug} +\calls{xlCmdBug}{xlMsg} +\calls{xlCmdBug}{inclmsgCmdBug} <>= (defun |xlCmdBug| (eb str lno ufos) (|xlMsg| eb str lno (elt ufos 0) (list (|inclmsgCmdBug|) '|bug|))) @@ -2184,6 +2588,7 @@ contiguous comment spanning enough lines to overflow the stack. @ +\defvar{incCommands} This is a list of commands that can be in an include file <>= (eval-when (eval load) @@ -2192,6 +2597,19 @@ This is a list of commands that can be in an include file @ +\defdollar{pfMacros} +User-defined macros are maintained in a stack of definitions. This is the +stack sequence resulting from the command lines: +\begin{verbatim} +a ==> 3 +a ==> 4 +b ==> 7 +( + (|b| |mbody| ((|integer| (|posn| (0 "b ==> 7" 1 1 "strings") . 6)) . "7")) + (|a| |mbody| ((|integer| (|posn| (0 "a ==> 4" 1 1 "strings") . 6)) . "4")) + (|a| |mbody| ((|integer| (|posn| (0 "a ==> 3" 1 1 "strings") . 6)) . "3")) +) +\end{verbatim} <>= (eval-when (eval load) (setq |$pfMacros| nil)) @@ -2199,7 +2617,7 @@ This is a list of commands that can be in an include file @ \defun{incClassify}{incClassify} -\being{verbatim} +\begin{verbatim} ;incClassify(s) == ; not incCommand? s => [false,0, '""] ; i := 1; n := #s @@ -2213,6 +2631,7 @@ This is a list of commands that can be in an include file ; p1 :=p ; if bad then [true,0,'"other"] else [true,eb,p1] \end{verbatim} +\calls{incClassify}{incCommand?} <>= (defun |incClassify| (|s|) (let (|p1| |bad| |eb| |n| |i|) @@ -2255,6 +2674,7 @@ This is a list of commands that can be in an include file @ \defun{incCommand?}{incCommand?} +\calls{incCommand?}{char} <>= (defun |incCommand?| (s) "does this start with a close paren?" @@ -2291,6 +2711,7 @@ This is a list of commands that can be in an include file @ \defun{incCommandTail}{incCommandTail} +\calls{incCommandTail}{incDrop} <>= (defun |incCommandTail| (s info) (let ((start (elt info 1))) @@ -2300,6 +2721,7 @@ This is a list of commands that can be in an include file @ \defun{incDrop}{incDrop} +\calls{incDrop}{substring} <>= (defun |incDrop| (n b) (if (>= n (length b)) @@ -2309,6 +2731,8 @@ This is a list of commands that can be in an include file @ \defun{inclFname}{inclFname} +\calls{inclFname}{incFileName} +\calls{inclFname}{incCommandTail} <>= (defun |inclFname| (s info) (|incFileName| (|incCommandTail| s info))) @@ -2316,6 +2740,8 @@ This is a list of commands that can be in an include file @ \defun{incFileInput}{incFileInput} +\calls{incFileInput}{incRgen} +\calls{incFileInput}{make-instream} <>= (defun |incFileInput| (fn) (|incRgen| (make-instream fn))) @@ -2323,6 +2749,8 @@ This is a list of commands that can be in an include file @ \defun{incConsoleInput}{incConsoleInput} +\calls{incConsoleInput}{incRgen} +\calls{incConsoleInput}{make-instream} <>= (defun |incConsoleInput| () (|incRgen| (make-instream 0))) @@ -2330,6 +2758,7 @@ This is a list of commands that can be in an include file @ \defun{incNConsoles}{incNConsoles} +\calls{incNConsoles}{incNConsoles} <>= (defun |incNConsoles| (ufos) (let ((a (member "console" ufos))) @@ -2348,6 +2777,8 @@ This is a list of commands that can be in an include file \defun{incRgen}{incRgen} Note that incRgen1 recursively calls this function. +\calls{incRgen}{Delay} +\calls{incRgen}{incRgen1} <>= (defun |incRgen| (s) (|Delay| (function |incRgen1|) (list s))) @@ -2366,6 +2797,7 @@ Note that incRgen1 recursively calls this function. @ +\defvar{StreamNil} <>= (eval-when (eval load) (setq |StreamNil| (list '|nullstream|))) @@ -2376,6 +2808,9 @@ Note that incRgen1 recursively calls this function. This function reads a line from the stream and then conses it up with a recursive call to incRgen. Note that incRgen recursively wraps this function in a delay list. +\calls{incRgen1}{shoeread-line} +\calls{incRgen1}{incRgen} +\uses{incRgen1}{StreamNil} <>= (defun |incRgen1| (&rest z) (let (a s) @@ -2392,67 +2827,91 @@ Note that incRgen recursively wraps this function in a delay list. \chapter{The Token Scanner} +\defvar{space} <>= (eval-when (eval load) (defvar space (qenum " " 0))) @ +\defvar{escape} <>= (eval-when (eval load) (defvar escape (qenum "_ " 0))) + @ +\defvar{stringchar} <>= (eval-when (eval load) (defvar stringchar (qenum "\" " 0))) + @ +\defvar{pluscomment} <>= (eval-when (eval load) (defvar pluscomment (qenum "+ " 0))) + @ +\defvar{minuscomment} <>= (eval-when (eval load) (defvar minuscomment (qenum "- " 0))) + @ +\defvar{radixchar} <>= (eval-when (eval load) (defvar radixchar (qenum "r " 0))) + @ +\defvar{dot} <>= (eval-when (eval load) (defvar dot (qenum ". " 0))) + @ +\defvar{exponent1} <>= (eval-when (eval load) (defvar exponent1 (qenum "E " 0))) + @ +\defvar{exponent2} <>= (eval-when (eval load) (defvar exponent2 (qenum "e " 0))) + @ +\defvar{closeparen} <>= (eval-when (eval load) (defvar closeparen (qenum ") " 0))) + @ +\defvar{closeangle} <>= (eval-when (eval load) (defvar closeangle (qenum "> " 0))) + @ +\defvar{question} <>= (eval-when (eval load) (defvar question (qenum "? " 0))) + @ +\defvar{scanKeyWords} <>= (eval-when (eval load) (defvar |scanKeyWords| @@ -2554,6 +3013,7 @@ Note that incRgen recursively wraps this function in a delay list. @ +\defvar{infgeneric} <>= (eval-when (eval load) (prog () @@ -2622,13 +3082,26 @@ returning the token-dq and the rest of the line-stream ; a => ; $ln:=SUBSTRING($ln,8,nil) ; b:= dqUnit constoken($ln,$linepos,["command",$ln],0) -; cons([[b,s]],$r) +; cons([ [b,s] ],$r) ; ; while $n<$sz repeat toks:=dqAppend(toks,scanToken()) ; if null toks ; then cons([],$r) -; else cons([[toks,s]],$r) +; else cons([ [toks,s] ],$r) \end{verbatim} +\calls{lineoftoks}{nextline} +\calls{lineoftoks}{scanIgnoreLine} +\calls{lineoftoks}{incPrefix?} +\calls{lineoftoks}{substring} +\calls{lineoftoks}{dqUnit} +\calls{lineoftoks}{constoken} +\usesdollar{lineoftoks}{floatok} +\usesdollar{lineoftoks}{f} +\usesdollar{lineoftoks}{sz} +\usesdollar{lineoftoks}{linepos} +\usesdollar{lineoftoks}{r} +\usesdollar{lineoftoks}{n} +\usesdollar{lineoftoks}{ln} <>= (defun |lineoftoks| (s) (let (|$floatok| |$sz| |$n| |$linepos| |$ln| |$r| |$f| |b| |a| |toks|) @@ -2665,6 +3138,14 @@ returning the token-dq and the rest of the line-stream @ \defun{nextline}{nextline} +\calls{nextline}{npNull} +\calls{nextline}{strposl} +\usesdollar{nextline}{sz} +\usesdollar{nextline}{n} +\usesdollar{nextline}{linepos} +\usesdollar{nextline}{ln} +\usesdollar{nextline}{r} +\usesdollar{nextline}{f} <>= (defun |nextline| (s) (declare (special |$sz| |$n| |$linepos| |$ln| |$r| |$f|)) @@ -2682,6 +3163,8 @@ returning the token-dq and the rest of the line-stream @ \defun{scanIgnoreLine}{scanIgnoreLine} +\calls{scanIgnoreLine}{qenum} +\calls{scanIgnoreLine}{incPrefix?} <>= (defun |scanIgnoreLine| (ln n) (let (fst) @@ -2699,6 +3182,7 @@ returning the token-dq and the rest of the line-stream @ \defun{constoken}{constoken} +\calls{constoken}{ncPutQ} <>= (defun |constoken| (ln lp b n) (let (a) @@ -2709,6 +3193,28 @@ returning the token-dq and the rest of the line-stream @ \defun{scanToken}{scanToken} +\calls{scanToken}{qenum} +\calls{scanToken}{startsComment?} +\calls{scanToken}{scanComment} +\calls{scanToken}{startsNegComment?} +\calls{scanToken}{scanNegComment} +\calls{scanToken}{lfid} +\calls{scanToken}{punctuation?} +\calls{scanToken}{scanPunct} +\calls{scanToken}{startsId?} +\calls{scanToken}{scanWord} +\calls{scanToken}{scanSpace} +\calls{scanToken}{scanString} +\calls{scanToken}{digit?} +\calls{scanToken}{scanNumber} +\calls{scanToken}{scanEscape} +\calls{scanToken}{scanError} +\calls{scanToken}{dqUnit} +\calls{scanToken}{constoken} +\calls{scanToken}{lnExtraBlanks} +\usesdollar{scanToken}{linepos} +\usesdollar{scanToken}{n} +\usesdollar{scanToken}{ln} <>= (defun |scanToken| () (let (b ch n linepos c ln) @@ -2749,6 +3255,11 @@ To pair badge and badgee @ \defun{startsComment?}{startsComment?} +\calls{startsComment?}{qenum} +\usesdollar{startsComment?}{ln} +\usesdollar{startsComment?}{sz} +\usesdollar{startsComment?}{n} +\uses{startsComment?}{pluscomment} <>= (defun |startsComment?| () (let (www) @@ -2767,6 +3278,11 @@ To pair badge and badgee @ \defun{scanComment}{scanComment} +\calls{scanComment}{lfcomment} +\calls{scanComment}{substring} +\usesdollar{scanComment}{ln} +\usesdollar{scanComment}{sz} +\usesdollar{scanComment}{n} <>= (defun |scanComment| () (let (n) @@ -2785,6 +3301,10 @@ To pair badge and badgee @ \defun{startsNegComment?}{startsNegComment?} +\calls{startsNegComment?}{qenum} +\usesdollar{startsNegComment?}{ln} +\usesdollar{startsNegComment?}{sz} +\usesdollar{startsNegComment?}{n} <>= (defun |startsNegComment?| () (let (www) @@ -2803,6 +3323,11 @@ To pair badge and badgee @ \defun{scanNegComment}{scanNegComment} +\calls{scanNegComment}{lfnegcomment} +\calls{scanNegComment}{substring} +\usesdollar{scanNegComment}{ln} +\usesdollar{scanNegComment}{sz} +\usesdollar{scanNegComment}{n} <>= (defun |scanNegComment| () (let (n) @@ -2827,6 +3352,11 @@ To pair badge and badgee @ \defun{scanPunct}{scanPunct} +\calls{scanPunct}{subMatch} +\calls{scanPunct}{scanError} +\calls{scanPunct}{scanKeyTr} +\usesdollar{scanPunct}{n} +\usesdollar{scanPunct}{ln} <>= (defun |scanPunct| () (let (a sss) @@ -2840,6 +3370,7 @@ To pair badge and badgee @ \defun{subMatch}{subMatch} +\calls{subMatch}{substringMatch} <>= (defun |subMatch| (a b) (|substringMatch| a |scanDict| b)) @@ -2870,6 +3401,8 @@ To pair badge and badgee ; else false ; s1 \end{verbatim} +\calls{substringMatch}{qenum} +\calls{substringMatch}{size} <>= (defun |substringMatch| (l dict i) (let (equl ls s s1 done ll u h) @@ -2905,6 +3438,11 @@ To pair badge and badgee @ \defun{scanKeyTr}{scanKeyTr} +\calls{scanKeyTr}{keyword} +\calls{scanKeyTr}{scanPossFloat} +\calls{scanKeyTr}{lfkey} +\calls{scanKeyTr}{scanCloser?} +\usesdollar{scanKeyTr}{floatok} <>= (defun |scanKeyTr| (w) (declare (special |$floatok|)) @@ -2918,6 +3456,7 @@ To pair badge and badgee @ \defun{keyword}{keyword} +\calls{keyword}{hget} <>= (defun |keyword| (st) (hget |scanKeyTable| st)) @@ -2925,6 +3464,7 @@ To pair badge and badgee @ \defun{keyword?}{keyword?} +\calls{keyword?}{hget} <>= (defun |keyword?| (st) (null (null (hget |scanKeyTable| st)))) @@ -2932,6 +3472,13 @@ To pair badge and badgee @ \defun{scanPossFloat}{scanPossFloat} +\calls{scanPossFloat}{digit?} +\calls{scanPossFloat}{lfkey} +\calls{scanPossFloat}{spleI} +\calls{scanPossFloat}{scanExponent} +\usesdollar{scanPossFloat}{ln} +\usesdollar{scanPossFloat}{sz} +\usesdollar{scanPossFloat}{n} <>= (defun |scanPossFloat| (w) (declare (special |$ln| |$sz| |$n|)) @@ -2944,6 +3491,7 @@ To pair badge and badgee @ \defun{digit?}{digit?} +\calls{digit?}{digitp} <>= (defun |digit?| (x) (digitp x)) @@ -2951,6 +3499,7 @@ To pair badge and badgee @ \defun{lfkey}{lfkey} +\calls{lfkey}{keyword} <>= (defun |lfkey| (x) (list '|key| (|keyword| x))) @@ -2958,6 +3507,7 @@ To pair badge and badgee @ \defun{spleI}{spleI} +\calls{spleI}{spleI1} <>= (defun |spleI| (dig) (|spleI1| dig nil)) @@ -2965,6 +3515,14 @@ To pair badge and badgee @ \defun{spleI1}{spleI1} +\calls{spleI1}{qenum} +\calls{spleI1}{substring} +\calls{spleI1}{scanEsc} +\calls{spleI1}{spleI1} +\calls{spleI1}{concat} +\usesdollar{spleI1}{ln} +\usesdollar{spleI1}{sz} +\usesdollar{spleI1}{n} <>= (defun |spleI1| (dig zro) (let (bb a str l n) @@ -3028,6 +3586,16 @@ To pair badge and badgee ; false ; false \end{verbatim} +\calls{scanEsc}{nextline} +\calls{scanEsc}{scanEsc} +\calls{scanEsc}{strposl} +\calls{scanEsc}{qenum} +\calls{scanEsc}{startsNegComment?} +\calls{scanEsc}{startsComment?} +\usesdollar{scanEsc}{ln} +\usesdollar{scanEsc}{r} +\usesdollar{scanEsc}{sz} +\usesdollar{scanEsc}{n} <>= (defun |scanEsc| () (let (n1) @@ -3072,16 +3640,17 @@ To pair badge and badgee nil)) (t nil)))))))) - - @ +\defvar{scanCloser} <>= (eval-when (eval load) (setq |scanCloser| (list '|)| '} '] '|\|)| '|\|}| '|\|]|))) @ \defun{scanCloser?}{scanCloser?} +\calls{scanCloser?}{memq} +\calls{scanCloser?}{keyword} <>= (defun |scanCloser?| (w) (memq (|keyword| w) |scanCloser|)) @@ -3089,6 +3658,11 @@ To pair badge and badgee @ \defun{scanWord}{scanWord} +\calls{scanWord}{scanW} +\calls{scanWord}{lfid} +\calls{scanWord}{keyword?} +\calls{scanWord}{lfkey} +\usesdollar{scanWord}{floatok} <>= (defun |scanWord| (esp) (let (w aaa) @@ -3108,6 +3682,14 @@ To pair badge and badgee @ \defun{scanExponent}{scanExponent} +\calls{scanExponent}{lffloat} +\calls{scanExponent}{qenum} +\calls{scanExponent}{digit?} +\calls{scanExponent}{spleI} +\calls{scanExponent}{concat} +\usesdollar{scanExponent}{ln} +\usesdollar{scanExponent}{sz} +\usesdollar{scanExponent}{n} <>= (defun |scanExponent| (a w) (let (c1 e c n) @@ -3146,11 +3728,12 @@ To pair badge and badgee (t (setq |$n| n) (|lffloat| a w "0")))))))) - (t (|lffloat| a w "0")))))))) + (t (|lffloat| a w "0"))))))) @ \defun{lffloat}{lffloat} +\calls{lffloat}{concat} <>= (defun |lffloat| (a w e) (list '|float| (concat a "." w "e" e))) @@ -3165,6 +3748,16 @@ To pair badge and badgee @ \defun{scanW}{scanW} +\calls{scanW}{posend} +\calls{scanW}{qenum} +\calls{scanW}{substring} +\calls{scanW}{scanEsc} +\calls{scanW}{scanW} +\calls{scanW}{idChar?} +\calls{scanW}{concat} +\usesdollar{scanW}{ln} +\usesdollar{scanW}{sz} +\usesdollar{scanW}{n} <>= (defun |scanW| (b) (let (bb a str endid l n1) @@ -3211,6 +3804,11 @@ NOTE: do not replace ``lyne'' with ``line'' @ \defun{scanSpace}{scanSpace} +\calls{scanSpace}{strposl} +\calls{scanSpace}{lfspaces} +\usesdollar{scanSpace}{floatok} +\usesdollar{scanSpace}{ln} +\usesdollar{scanSpace}{n} <>= (defun |scanSpace| () (let (n) @@ -3231,6 +3829,10 @@ NOTE: do not replace ``lyne'' with ``line'' @ \defun{scanString}{scanString} +\calls{scanString}{lfstring} +\calls{scanString}{scanS} +\usesdollar{scanString}{floatok} +\usesdollar{scanString}{n} <>= (defun |scanString| () (declare (special |$floatok| |$n|)) @@ -3250,6 +3852,18 @@ NOTE: do not replace ``lyne'' with ``line'' @ \defun{scanS}{scanS} +\calls{scanS}{ncSoftError} +\calls{scanS}{lnExtraBlanks} +\calls{scanS}{strpos} +\calls{scanS}{substring} +\calls{scanS}{scanEsc} +\calls{scanS}{concat} +\calls{scanS}{scanTransform} +\calls{scanS}{scanS} +\usesdollar{scanS}{ln} +\usesdollar{scanS}{linepos} +\usesdollar{scanS}{sz} +\usesdollar{scanS}{n} <>= (defun |scanS| () (let (b a str mn escsym strsym n) @@ -3293,6 +3907,18 @@ NOTE: do not replace ``lyne'' with ``line'' @ \defun{scanNumber}{scanNumber} +\calls{scanNumber}{spleI} +\calls{scanNumber}{lfinteger} +\calls{scanNumber}{qenum} +\calls{scanNumber}{spleI1} +\calls{scanNumber}{scanExponent} +\calls{scanNumber}{scanCheckRadix} +\calls{scanNumber}{lfrinteger} +\calls{scanNumber}{concat} +\usesdollar{scanNumber}{floatok} +\usesdollar{scanNumber}{ln} +\usesdollar{scanNumber}{sz} +\usesdollar{scanNumber}{n} <>= (defun |scanNumber| () (let (v w n a) @@ -3337,6 +3963,7 @@ NOTE: do not replace ``lyne'' with ``line'' @ \defun{rdigit?}{rdigit?} +\calls{rdigit?}{strpos} <>= (defun |rdigit?| (x) (strpos x "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" 0 nil)) @@ -3351,6 +3978,7 @@ NOTE: do not replace ``lyne'' with ``line'' @ \defun{lfrinteger}{lfrinteger} +\calls{lfrinteger}{concat} <>= (defun |lfrinteger| (r x) (list '|integer| (concat r (concat "r" x)))) @@ -3368,6 +3996,8 @@ NOTE: do not replace ``lyne'' with ``line'' ; then ncSoftError(cons($linepos,lnExtraBlanks $linepos+$n-ns+i), ; "S2CN0002", [w.i]) \end{verbatim} +\usesdollar{scanCheckRadix}{n} +\usesdollar{scanCheckRadix}{linepos} <>= (defun |scanCheckRadix| (r w) (let (a ns) @@ -3390,6 +4020,9 @@ NOTE: do not replace ``lyne'' with ``line'' @ \defun{scanEscape}{scanEscape} +\calls{scanEscape}{scanEsc} +\calls{scanEscape}{scanWord} +\usesdollar{scanEscape}{n} <>= (defun |scanEscape| () (declare (special |$n|)) @@ -3399,6 +4032,12 @@ NOTE: do not replace ``lyne'' with ``line'' @ \defun{scanError}{scanError} +\calls{scanError}{ncSoftError} +\calls{scanError}{lnExtraBlanks} +\calls{scanError}{lferror} +\usesdollar{scanError}{ln} +\usesdollar{scanError}{linepos} +\usesdollar{scanError}{n} <>= (defun |scanError| () (let (n) @@ -3419,6 +4058,7 @@ NOTE: do not replace ``lyne'' with ``line'' @ +\defvar{scanKeyTable} <>= (eval-when (eval load) (defvar |scanKeyTable| (|scanKeyTableCons|))) @@ -3450,6 +4090,7 @@ This function is used to build the scanKeyTable @ +\defvar{scanDict} <>= (eval-when (eval load) (defvar |scanDict| (|scanDictCons|))) @@ -3468,6 +4109,7 @@ This function is used to build the scanKeyTable ; for s in l repeat scanInsert(s,d) ; d \end{verbatim} +\calls{scanDictCons}{hkeys} <>= (defun |scanDictCons| () (let (d b a l) @@ -3515,6 +4157,7 @@ This function is used to build the scanKeyTable ; VEC_-SETELT(d,h,v) ; s \end{verbatim} +\calls{scanInsert}{qenum} <>= (defun |scanInsert| (s d) (let (v k n u h l) @@ -3549,6 +4192,7 @@ This function is used to build the scanKeyTable @ +\defvar{scanPun} <>= (eval-when (eval load) (defvar |scanPun| (|scanPunCons|))) @@ -3566,6 +4210,7 @@ This function is used to build the scanKeyTable ; then BVEC_-SETELT(a,QENUM(k,0),1) ; a \end{verbatim} +\calls{scanPunCons}{hkeys} <>= (defun |scanPunCons| () (let (a listing) @@ -3596,7 +4241,7 @@ This function is used to build the scanKeyTable \chapter{Stream Utilities} The input stream is parsed into a large s-expression by repeated calls to Delay. Delay takes a function f and an argument x and returns a list -consisting of \verb}("nonnullstream" f x)|. Eventually multiple calls are made +consisting of \verb|("nonnullstream" f x)|. Eventually multiple calls are made and a large list structure is created that consists of \verb|("nonnullstream" f x ("nonnullstream" f1 x1 ("nonnullstream" f2 x2...| @@ -3610,12 +4255,14 @@ parser was a research project at IBM and Axiom was the testbed (which explains the strange parsing technique). \defun{npNull}{npNull} +\calls{npNull}{StreamNull} <>= (defun |npNull| (x) (|StreamNull| x)) @ \defun{StreamNull}{StreamNull} +\calls{StreamNull}{eqcar} <>= (defun |StreamNull| (x) (let (st) @@ -3647,6 +4294,11 @@ the root of the first tree is concatenated with its forest. column t is the number of spaces before the first non-space in line t \defun{insertpile}{insertpile} +\calls{insertpile}{npNull} +\calls{insertpile}{pilePlusComment} +\calls{insertpile}{pilePlusComments} +\calls{insertpile}{pileTree} +\calls{insertpile}{pileCforest} <>= (defun |insertpile| (s) (let (stream a t1 h1 t2 h tmp1) @@ -3673,6 +4325,10 @@ column t is the number of spaces before the first non-space in line t @ \defun{pilePlusComment}{pilePlusComment} +\calls{pilePlusComment}{tokType} +\calls{pilePlusComments}{npNull} +\calls{pilePlusComments}{pilePlusComment} +\calls{pilePlusComments}{pilePlusComments} <>= (defun |pilePlusComment| (arg) (eq (|tokType| (caar arg)) '|comment|)) @@ -3700,6 +4356,9 @@ column t is the number of spaces before the first non-space in line t @ \defun{pileTree}{pileTree} +\calls{pileTree}{npNull} +\calls{pileTree}{pileColumn} +\calls{pileTree}{pileForests} <>= (defun |pileTree| (n s) (let (hh t1 h tmp1) @@ -3717,6 +4376,7 @@ column t is the number of spaces before the first non-space in line t @ \defun{pileColumn}{pileColumn} +\calls{pileColumn}{tokPosn} <>= (defun |pileColumn| (arg) (cdr (|tokPosn| (caar arg)))) @@ -3724,6 +4384,10 @@ column t is the number of spaces before the first non-space in line t @ \defun{pileForests}{pileForests} +\calls{pileForests}{pileForest} +\calls{pileForests}{npNull} +\calls{pileForests}{pileForests} +\calls{pileForests}{pileCtree} <>= (defun |pileForests| (h n s) (let (t1 h1 tmp1) @@ -3737,6 +4401,8 @@ column t is the number of spaces before the first non-space in line t @ \defun{pileForest}{pileForest} +\calls{pileForest}{pileTree} +\calls{pileForest}{pileForest1} <>= (defun |pileForest| (n s) (let (t1 h1 t2 h hh b tmp) @@ -3757,6 +4423,8 @@ column t is the number of spaces before the first non-space in line t @ \defun{pileForest1}{pileForest1} +\calls{pileForest1}{eqpileTree} +\calls{pileForest1}{pileForest1} <>= (defun |pileForest1| (n s) (let (t1 h1 t2 h n1 b tmp) @@ -3776,6 +4444,9 @@ column t is the number of spaces before the first non-space in line t @ \defun{eqpileTree}{eqpileTree} +\calls{eqpileTree}{npNull} +\calls{eqpileTree}{pileColumn} +\calls{eqpileTree}{pileForests} <>= (defun |eqpileTree| (n s) (let (hh t1 h tmp) @@ -3793,6 +4464,8 @@ column t is the number of spaces before the first non-space in line t @ \defun{pileCtree}{pileCtree} +\calls{pileCtree}{dqAppend} +\calls{pileCtree}{pileCforest} <>= (defun |pileCtree| (x y) (|dqAppend| x (|pileCforest| y))) @@ -3801,6 +4474,9 @@ column t is the number of spaces before the first non-space in line t \defun{pileCforest}{pileCforest} Only enpiles forests with $>=2$ trees +\calls{pileCforest}{tokPart} +\calls{pileCforest}{enPile} +\calls{pileCforest}{separatePiles} <>= (defun |pileCforest| (x) (let (f) @@ -3815,6 +4491,11 @@ Only enpiles forests with $>=2$ trees @ \defun{enPile}{enPile} +\calls{enPile}{dqConcat} +\calls{enPile}{dqUnit} +\calls{enPile}{tokConstruct} +\calls{enPile}{firstTokPosn} +\calls{enPile}{lastTokPosn} <>= (defun |enPile| (x) (|dqConcat| @@ -3826,18 +4507,25 @@ Only enpiles forests with $>=2$ trees @ \defun{firstTokPosn}{firstTokPosn} +\calls{firstTokPosn}{tokPosn} <>= (defun |firstTokPosn| (arg) (|tokPosn| (caar arg))) @ \defun{lastTokPosn}{lastTokPosn} +\calls{lastTokPosn}{tokPosn} <>= (defun |lastTokPosn| (arg) (|tokPosn| (cadr arg))) @ \defun{separatePiles}{separatePiles} +\calls{separatePiles}{dqUnit} +\calls{separatePiles}{tokConstruct} +\calls{separatePiles}{lastTokPosn} +\calls{separatePiles}{dqConcat} +\calls{separatePiles}{separatePiles} <>= (defun |separatePiles| (x) (let (semicolon a) @@ -3865,6 +4553,8 @@ The dqUnit makes a unit dq i.e. a dq with one item, from the item \defun{dqConcat}{dqConcat} The dqConcat function concatenates a list of dq's, destroying all but the last +\calls{dqConcat}{dqAppend} +\calls{dqConcat}{dqConcat} <>= (defun |dqConcat| (ld) (cond @@ -3909,6 +4599,10 @@ msgObject tag -- catagory of msg prefix -- things like "Error: " text -- the actual text \end{verbatim} +\calls{msgCreate}{setMsgForcedAttrList} +\calls{msgCreate}{putDatabaseStuff} +\calls{msgCreate}{initImPr} +\calls{msgCreate}{initToWhere} <>= (defun |msgCreate| (tag posWTag key argL optPre &rest optAttr) (let (msg) @@ -3976,12 +4670,15 @@ msgObject tag -- catagory of msg \defun{getMsgTag}{getMsgTag} The valid message tags are: line, old, error, warn, bug, unimple, remark, stat, say, debug +\calls{getMsgTag}{ncTag} <>= (defun |getMsgTag| (msg) (|ncTag| msg)) @ \defun{getMsgTag?}{getMsgTag?} +\calls{getMsgTag?}{IFCAR} +\calls{getMsgTag?}{getMsgTag} <>= (defun |getMsgTag?| (|msg|) (ifcar (member (|getMsgTag| |msg|) @@ -3991,18 +4688,21 @@ line, old, error, warn, bug, unimple, remark, stat, say, debug @ \defun{line?}{line?} +\calls{line?}{getMsgTag} <>= (defun |line?| (msg) (eq (|getMsgTag| msg) '|line|)) @ \defun{leader?}{leader?} +\calls{leader?}{getMsgTag} <>= (defun |leader?| (msg) (eq (|getMsgTag| msg) '|leader|)) @ \defun{toScreen?}{toScreen?} +\calls{toScreen?}{getMsgToWhere} <>= (defun |toScreen?| (msg) (not (eq (|getMsgToWhere| msg) '|fileOnly|))) @@ -4012,6 +4712,11 @@ line, old, error, warn, bug, unimple, remark, stat, say, debug Messages for the USERS of the compiler. The program being compiled has a minor error. Give a message and continue processing. +\calls{ncSoftError}{desiredMsg} +\calls{ncSoftError}{processKeyedError} +\calls{ncSoftError}{msgCreate} +\usesdollar{ncSoftError}{compErrorPrefix} +\usesdollar{ncSoftError}{newcompErrorCount} <>= (defun |ncSoftError| (pos erMsgKey erArgL &rest optAttr) (declare (special |$compErrorPrefix| |$newcompErrorCount|)) @@ -4026,6 +4731,12 @@ Give a message and continue processing. \defun{ncHardError}{ncHardError} The program being compiled is seriously incorrect. Give message and throw to a recovery point. +\calls{ncHardError}{desiredMsg} +\calls{ncHardError}{processKeyedError} +\calls{ncHardError}{msgCreate} +\calls{ncHardError}{ncError} +\usesdollar{ncHardError}{compErrorPrefix} +\usesdollar{ncHardError}{newcompErrorCount} <>= (defun |ncHardError| (pos erMsgKey erArgL &rest optAttr) (let (erMsg) @@ -4040,6 +4751,7 @@ Give message and throw to a recovery point. @ \defun{desiredMsg}{desiredMsg} +\calls{desiredMsg}{isKeyQualityP} <>= (defun |desiredMsg| (erMsgKey &rest optCatFlag) (cond @@ -4062,6 +4774,7 @@ isKeyQualityP (key,qual) == if CDR qualPair = qual then found := true qualPair \end{verbatim} +\usesdollar{isKeyQualityP}{specificMsgTags} <>= (defun |isKeyQualityP| (key qual) (let (qualPair found) @@ -4076,6 +4789,14 @@ isKeyQualityP (key,qual) == @ \defun{processKeyedError}{processKeyedError} +\calls{processKeyedError}{getMsgTag?} +\calls{processKeyedError}{getMsgKey} +\calls{processKeyedError}{getMsgPrefix?} +\calls{processKeyedError}{sayBrightly} +\calls{processKeyedError}{CallerName} +\calls{processKeyedError}{msgImPr?} +\calls{processKeyedError}{msgOutputter} +\usesdollar{processKeyedError}{ncMsgList} <>= (defun |processKeyedError| (msg) (prog (pre erMsg) @@ -4093,6 +4814,16 @@ isKeyQualityP (key,qual) == @ \defun{msgOutputter}{msgOutputter} +\calls{msgOutputter}{getStFromMsg} +\calls{msgOutputter}{leader?} +\calls{msgOutputter}{line?} +\calls{msgOutputter}{toScreen?} +\calls{msgOutputter}{flowSegmentedMsg} +\calls{msgOutputter}{sayBrightly} +\calls{msgOutputter}{toFile?} +\calls{msgOutputter}{alreadyOpened?} +\usesdollar{msgOutputter}{loglength} +\usesdollar{msgOutputter}{linelength} <>= (defun |msgOutputter| (msg) (let (alreadyOpened shouldFlow st) @@ -4109,6 +4840,7 @@ isKeyQualityP (key,qual) == @ \defun{listOutputter}{listOutputter} +\calls{listOutputter}{msgOutputter} <>= (defun |listOutputter| (outputList) (dolist (msg outputList) @@ -4117,6 +4849,18 @@ isKeyQualityP (key,qual) == @ \defun{getStFromMsg}{getStFromMsg} +\calls{getStFromMsg}{setOptKeyBlanks} +\calls{getStFromMsg}{getPreStL} +\calls{getStFromMsg}{getMsgPrefix?} +\calls{getStFromMsg}{getMsgTag} +\calls{getStFromMsg}{getMsgText} +\calls{getStFromMsg}{getPosStL} +\calls{getStFromMsg}{getMsgKey?} +\calls{getStFromMsg}{pname} +\calls{getStFromMsg}{getMsgLitSym} +\calls{getStFromMsg}{tabbing} +\usesdollar{getStFromMsg}{showKeyNum} +\usesdollar{getStFromMsg}{optKeyBlanks} <>= (defun |getStFromMsg| (msg) (let (|$optKeyBlanks| st optKey msgKey posStL preStL) @@ -4148,6 +4892,8 @@ isKeyQualityP (key,qual) == @ \defun{setOptKeyBlanks}{setOptKeyBlanks} +\usesdollar{setOptKeyBlanks}{optKeyBlanks} +\usesdollar{setOptKeyBlanks}{showKeyNum} <>= (defun |setOptKeyBlanks| () (declare (special |$optKeyBlanks| |$showKeyNum|)) @@ -4156,6 +4902,9 @@ isKeyQualityP (key,qual) == @ \defun{getPreStL}{getPreStL} +\calls{getPreStL}{make-full-cvec} +\calls{getPreStL}{size} +\usesdollar{getPreStL}{preLength} <>= (defun |getPreStL| (optPre) (let (spses extraPlaces) @@ -4173,6 +4922,16 @@ isKeyQualityP (key,qual) == @ \defun{getPosStL}{getPosStL} +\calls{getPosStL}{showMsgPos?} +\calls{getPosStL}{getMsgPos} +\calls{getPosStL}{msgImPr?} +\calls{getPosStL}{decideHowMuch} +\calls{getPosStL}{listDecideHowMuch} +\calls{getPosStL}{ppos} +\calls{getPosStL}{remLine} +\calls{getPosStL}{remFile} +\usesdollar{getPosStL}{optKeyBlanks} +\usesdollar{getPosStL}{lastPos} <>= (defun |getPosStL| (msg) (let (printedOrigin printedLineNum printedFileName fullPrintedPos howMuch @@ -4213,12 +4972,17 @@ isKeyQualityP (key,qual) == @ \defun{remFile}{remFile} +\calls{remFile}{IFCDR} +\calls{remLine}{IFCAR} <>= (defun |remFile| (positionList) (ifcdr (ifcdr positionList))) @ \defun{showMsgPos?}{showMsgPos?} +\calls{showMsgPos?}{msgImPr?} +\calls{showMsgPos?}{leader?} +\usesdollar{showMsgPos?}{erMsgToss} <>= (defun |showMsgPos?| (msg) (declare (special |$erMsgToss|)) @@ -4227,6 +4991,7 @@ isKeyQualityP (key,qual) == @ \defun{msgImPr?}{msgImPr?} +\calls{msgImPr?}{getMsgCatAttr} <>= (defun |msgImPr?| (msg) (eq (|getMsgCatAttr| msg '|$imPrGuys|) '|imPr|)) @@ -4234,6 +4999,9 @@ isKeyQualityP (key,qual) == @ \defun{getMsgCatAttr}{getMsgCatAttr} +\calls{getMsgCatAttr}{ifcdr} +\calls{getMsgCatAttr}{qassq} +\calls{getMsgCatAttr}{ncAlist} <>= (defun |getMsgCatAttr| (msg cat) (ifcdr (qassq cat (|ncAlist| msg)))) @@ -4241,6 +5009,8 @@ isKeyQualityP (key,qual) == @ \defun{getMsgPos}{getMsgPos} +\calls{getMsgPos}{getMsgFTTag?} +\calls{getMsgPos}{getMsgPosTagOb} <>= (defun |getMsgPos| (msg) (if (|getMsgFTTag?| msg) @@ -4250,6 +5020,8 @@ isKeyQualityP (key,qual) == @ \defun{getMsgFTTag?}{getMsgFTTag?} +\calls{getMsgFTTag?}{ifcar} +\calls{getMsgFTTag?}{getMsgPosTagOb} <>= (defun |getMsgFTTag?| (msg) (ifcar (member (ifcar (|getMsgPosTagOb| msg)) (list 'from 'to 'fromto)))) @@ -4260,6 +5032,10 @@ isKeyQualityP (key,qual) == When printing a msg, we wish not to show pos information that was shown for a previous msg with identical pos info. org prints out the word noposition or console +\calls{decideHowMuch}{poNopos?} +\calls{decideHowMuch}{poPosImmediate?} +\calls{decideHowMuch}{poFileName} +\calls{decideHowMuch}{poLinePosn} <>= (defun |decideHowMuch| (pos oldPos) (cond @@ -4275,6 +5051,9 @@ org prints out the word noposition or console @ \defun{listDecideHowMuch}{listDecideHowMuch} +\calls{listDecideHowMuch}{poNopos?} +\calls{listDecideHowMuch}{poPosImmediate?} +\calls{listDecideHowMuch}{poGlobalLinePosn} <>= (defun |listDecideHowMuch| (pos oldPos) (cond @@ -4296,6 +5075,7 @@ org prints out the word noposition or console @ \defun{getMsgKey?}{getMsgKey?} +\calls{getMsgKey?}{identp} <>= (defun |getMsgKey?| (msg) (let ((val (|getMsgKey| msg))) @@ -4304,6 +5084,7 @@ org prints out the word noposition or console @ \defun{getMsgLitSym}{getMsgLitSym} +\calls{getMsgLitSym}{getMsgKey?} <>= (defun |getMsgLitSym| (msg) (if (|getMsgKey?| msg) " " "*")) @@ -4311,6 +5092,9 @@ org prints out the word noposition or console @ \defun{tabbing}{tabbing} +\calls{tabbing}{getMsgPrefix?} +\usesdollar{tabbing}{showKeyNum} +\usesdollar{tabbing}{preLength} <>= (defun |tabbing| (msg) (let (chPos) @@ -4323,12 +5107,15 @@ org prints out the word noposition or console @ \defun{getMsgToWhere}{getMsgToWhere} +\calls{getMsgToWhere}{getMsgCatAttr} <>= (defun |getMsgToWhere| (msg) (|getMsgCatAttr| msg '|$toWhereGuys|)) @ \defun{toFile?}{toFile?} +\calls{toFile?}{getMsgToWhere} +\usesdollar{toFile?}{fn} <>= (defun |toFile?| (msg) (declare (special |$fn|)) @@ -4337,12 +5124,15 @@ org prints out the word noposition or console @ \defun{alreadyOpened?}{alreadyOpened?} +\calls{alreadyOpened?}{msgImPr?} <>= (defun |alreadyOpened?| (msg) (null (|msgImPr?| msg))) @ \defun{setMsgForcedAttrList}{setMsgForcedAttrList} +\calls{setMsgForcedAttrList}{setMsgForcedAttr} +\calls{setMsgForcedAttrList}{whichCat} <>= (defun |setMsgForcedAttrList| (msg attrlist) (dolist (attr attrlist) @@ -4351,6 +5141,8 @@ org prints out the word noposition or console @ \defun{setMsgForcedAttr}{setMsgForcedAttr} +\calls{setMsgForcedAttr}{setMsgCatlessAttr} +\calls{setMsgForcedAttr}{ncPutQ} <>= (defun |setMsgForcedAttr| (msg cat attr) (if (eq cat '|catless|) @@ -4360,6 +5152,8 @@ org prints out the word noposition or console @ \defun{whichCat}{whichCat} +\calls{whichCat}{ListMember?} +\usesdollar{whichCat}{attrCats} <>= (defun |whichCat| (attr) (let ((found '|catless|) done) @@ -4374,6 +5168,10 @@ org prints out the word noposition or console @ \defun{setMsgCatlessAttr}{setMsgCatlessAttr} +\calls{setMsgCatlessAttr}{ncPutQ} +\calls{setMsgCatlessAttr}{ifcdr} +\calls{setMsgCatlessAttr}{qassq} +\calls{setMsgCatlessAttr}{ncAlist} <>= (defun |setMsgCatlessAttr| (msg attr) (|ncPutQ| msg |catless| ; probably should be '|catless|? -- TPDHERE @@ -4382,6 +5180,9 @@ org prints out the word noposition or console @ \defun{putDatabaseStuff}{putDatabaseStuff} +\calls{putDatabaseStuff}{getMsgInfoFromKey} +\calls{putDatabaseStuff}{setMsgUnforcedAttrList} +\calls{putDatabaseStuff}{setMsgText} <>= (defun |putDatabaseStuff| (msg) (let (attributes text tmp) @@ -4394,6 +5195,16 @@ org prints out the word noposition or console @ \defun{getMsgInfoFromKey}{getMsgInfoFromKey} +\calls{getMsgInfoFromKey}{getMsgKey?} +\calls{getMsgInfoFromKey}{getErFromDbL} +\calls{getMsgInfoFromKey}{getMsgKey} +\calls{getMsgInfoFromKey}{segmentKeyedMsg} +\calls{getMsgInfoFromKey}{removeAttributes} +\calls{getMsgInfoFromKey}{substituteSegmentedMsg} +\calls{getMsgInfoFromKey}{getMsgArgL} +\usesdollar{getMsgInfoFromKey}{msgDatabaseName} +\usesdollar{getMsgInfoFromKey}{erGlbMsgDatabaseName} +\usesdollar{getMsgInfoFromKey}{erLocMsgDatabaseName} <>= (defun |getMsgInfoFromKey| (msg) (let (|$msgDatabaseName| attributes tmp msgText dbl msgKey) @@ -4430,6 +5241,7 @@ org prints out the word noposition or console ; erMsg := fetchKeyedMsg(erMsgKey,not lastName) ; erMsg \end{verbatim} +\usesdollar{getErFromDbL}{msgDatabaseName} <>= (defun |getErFromDbL| (erMsgKey dbL) (let (fileFound lastName dbName erMsg) @@ -4452,6 +5264,8 @@ org prints out the word noposition or console @ \defun{setMsgUnforcedAttrList}{setMsgUnforcedAttrList} +\calls{setMsgUnforcedAttrList}{setMsgUnforcedAttr} +\calls{setMsgUnforcedAttrList}{whichCat} <>= (defun |setMsgUnforcedAttrList| (msg attrlist) (dolist (attr attrlist) @@ -4460,6 +5274,10 @@ org prints out the word noposition or console @ \defun{setMsgUnforcedAttr}{setMsgUnforcedAttr} +\calls{setMsgUnforcedAttr}{setMsgCatlessAttr} +\calls{setMsgUnforcedAttr}{qassq} +\calls{setMsgUnforcedAttr}{ncAlist} +\calls{setMsgUnforcedAttr}{ncPutQ} <>= (defun |setMsgUnforcedAttr| (msg cat attr) (cond @@ -4469,6 +5287,11 @@ org prints out the word noposition or console @ \defun{initImPr}{initImPr} +\calls{initImPr}{memq} +\calls{initImPr}{getMsgTag} +\calls{initImPr}{setMsgUnforcedAttr} +\usesdollar{initImPr}{imPrTagGuys} +\usesdollar{initImPr}{erMsgToss} <>= (defun |initImPr| (msg) (declare (special |$imPrTagGuys| |$erMsgToss|)) @@ -4478,6 +5301,8 @@ org prints out the word noposition or console @ \defun{initToWhere}{initToWhere} +\calls{initToWhere}{getMsgCatAttr} +\calls{initToWhere}{setMsgUnforcedAttr} <>= (defun |initToWhere| (msg) (if (member '|trace| (|getMsgCatAttr| msg '|catless|)) @@ -4487,6 +5312,13 @@ org prints out the word noposition or console \defun{ncBug}{ncBug} Bug in the compiler: something which shouldn't have happened did. +\calls{ncBug}{processKeyedError} +\calls{ncBug}{msgCreate} +\calls{ncBug}{enable-backtrace} +\calls{ncBug}{ncAbort} +\usesdollar{ncBug}{compBugPrefix} +\usesdollar{ncBug}{nopos} +\usesdollar{ncBug}{newcompErrorCount} <>= (defun |ncBug| (erMsgKey erArgL &rest optAttr) (let (erMsg) @@ -4502,6 +5334,14 @@ Bug in the compiler: something which shouldn't have happened did. @ \defun{processMsgList}{processMsgList} +\calls{processMsgList}{erMsgSort} +\calls{processMsgList}{makeMsgFromLine} +\calls{processMsgList}{poGlobalLinePosn} +\calls{processMsgList}{getMsgPos} +\calls{processMsgList}{queueUpErrors} +\calls{processMsgList}{listOutputter} +\usesdollar{processMsgList}{noRepList} +\usesdollar{processMsgList}{outputList} <>= (defun |processMsgList| (erMsgList lineList) (let (|$noRepList| |$outputList| st globalNumOfLine msgLine) @@ -4521,6 +5361,8 @@ Bug in the compiler: something which shouldn't have happened did. @ \defun{erMsgSort}{erMsgSort} +\calls{erMsgSort}{erMsgSep} +\calls{erMsgSort}{listSort} <>= (defun |erMsgSort| (erMsgList) (let (msgWOPos msgWPos tmp) @@ -4534,6 +5376,8 @@ Bug in the compiler: something which shouldn't have happened did. @ \defun{erMsgCompare}{erMsgCompare} +\calls{erMsgCompare}{compareposns} +\calls{erMsgCompare}{getMsgPos} <>= (defun |erMsgCompare| (ob1 ob2) (|compareposns| (|getMsgPos| ob2) (|getMsgPos| ob1))) @@ -4541,6 +5385,8 @@ Bug in the compiler: something which shouldn't have happened did. @ \defun{erMsgSep}{erMsgSep} +\calls{erMsgSep}{poNopos?} +\calls{erMsgSep}{getMsgPos} <>= (defun |erMsgSep| (erMsgList) (let (msgWOPos msgWPos) @@ -4553,6 +5399,16 @@ Bug in the compiler: something which shouldn't have happened did. @ \defun{makeMsgFromLine}{makeMsgFromLine} +\calls{makeMsgFromLine}{getLinePos} +\calls{makeMsgFromLine}{getLineText} +\calls{makeMsgFromLine}{poGlobalLinePosn} +\calls{makeMsgFromLine}{stringimage} +\calls{makeMsgFromLine}{poLinePosn} +\calls{makeMsgFromLine}{strconc} +\calls{makeMsgFromLine}{rep} +\calls{makeMsgFromLine}{char} +\calls{makeMsgFromLine}{size} +\usesdollar{makeMsgFromLine}{preLength} <>= (defun |makeMsgFromLine| (line) (let (localNumOfLine stNum i globalNumOfLine textOfLine posOfLine) @@ -4568,6 +5424,7 @@ Bug in the compiler: something which shouldn't have happened did. @ \defun{rep}{rep} +\calls{rep}{make-full-cvec} <>= (defun |rep| (c n) (if (< 0 n) @@ -4611,6 +5468,8 @@ Bug in the compiler: something which shouldn't have happened did. ; $outputList := NCONC(notThisPosMsgs,$outputList) ; msgList \end{verbatim} +\calls{queueUpErrors}{processChPosesForOneLine} +\usesdollar{queueUpErrors}{outputList} <>= (DEFUN |queueUpErrors| (|globalNumOfLine| |msgList|) (PROG (|notThisPosMsgs| |notThisLineMsgs| |thisPosMsgs|) @@ -4666,6 +5525,8 @@ Bug in the compiler: something which shouldn't have happened did. @ \defun{thisPosIsLess}{thisPosIsLess} +\calls{thisPosIsLess}{poNopos?} +\calls{thisPosIsLess}{poGlobalLinePosn} <>= (defun |thisPosIsLess| (pos num) (unless (|poNopos?| pos) (< (|poGlobalLinePosn| pos) num))) @@ -4673,6 +5534,8 @@ Bug in the compiler: something which shouldn't have happened did. @ \defun{thisPosIsEqual}{thisPosIsEqual} +\calls{thisPosIsEqual}{poNopos?} +\calls{thisPosIsEqual}{poGlobalLinePosn} <>= (defun |thisPosIsEqual| (pos num) (unless (|poNopos?| pos) (equal (|poGlobalLinePosn| pos) num))) @@ -4689,6 +5552,9 @@ redundant(msg,thisPosMsgs) == $noRepList := [msg,$noRepList] found or MEMBER(msg,thisPosMsgs) \end{verbatim} +\calls{redundant}{msgNoRep?} +\calls{redundant}{sameMsg?} +\usesdollar{redundant}{noRepList} <>= (defun |redundant| (msg thisPosMsgs) (prog (found) @@ -4713,12 +5579,15 @@ redundant(msg,thisPosMsgs) == @ \defun{msgNoRep?}{msgNoRep?} +\calls{msgNoRep?}{getMsgCatAttr} <>= (defun |msgNoRep?| (msg) (eq (|getMsgCatAttr| msg '|$repGuys|) '|noRep|)) @ \defun{sameMsg?}{sameMsg?} +\calls{sameMsg?}{getMsgKey} +\calls{sameMsg?}{getMsgArgL} <>= (defun |sameMsg?| (msg1 msg2) (and (equal (|getMsgKey| msg1) (|getMsgKey| msg2)) @@ -4727,6 +5596,18 @@ redundant(msg,thisPosMsgs) == @ \defun{processChPosesForOneLine}{processChPosesForOneLine} +\calls{processChPosesForOneLine}{posPointers} +\calls{processChPosesForOneLine}{getMsgFTTag?} +\calls{processChPosesForOneLine}{putFTText} +\calls{processChPosesForOneLine}{poCharPosn} +\calls{processChPosesForOneLine}{getMsgPos} +\calls{processChPosesForOneLine}{getMsgPrefix} +\calls{processChPosesForOneLine}{setMsgPrefix} +\calls{processChPosesForOneLine}{strconc} +\calls{processChPosesForOneLine}{make-full-cvec} +\calls{processChPosesForOneLine}{size} +\calls{processChPosesForOneLine}{makeLeaderMsg} +\usesdollar{processChPosesForOneLine}{preLength} <>= (defun |processChPosesForOneLine| (msgList) (let (leaderMsg oldPre posLetter chPosList) @@ -4753,8 +5634,11 @@ makeLeaderMsg chPosList == st := STRCONC(st, _ rep(char ".", (posNum - oldPos - 1)),posLetter) oldPos := posNum - ['leader,$nopos,'nokey,NIL,NIL,[st]] + ['leader,$nopos,'nokey,NIL,NIL,[st] ] \end{verbatim} +\calls{makeLeaderMsg}{make-full-cvec} +\usesdollar{makeLeaderMsg}{nopos} +\usesdollar{makeLeaderMsg}{preLength} <>= (defun |makeLeaderMsg| (chPosList) (let (posLetter posNum oldPos st) @@ -4783,6 +5667,11 @@ makeLeaderMsg chPosList == @ \defun{posPointers}{posPointers} +\calls{posPointers}{poCharPosn} +\calls{posPointers}{getMsgPos} +\calls{posPointers}{IFCAR} +\calls{posPointers}{getMsgPos2} +\calls{posPointers}{insertPos} <>= (defun |posPointers| (msgList) (let (posLetterList pos ftPosList posList increment pointers) @@ -4807,6 +5696,9 @@ makeLeaderMsg chPosList == @ \defun{getMsgPos2}{getMsgPos2} +\calls{getMsgPos2}{getMsgFTTag?} +\calls{getMsgPos2}{getMsgPosTagOb} +\calls{getMsgPos2}{ncBug} <>= (defun |getMsgPos2| (msg) (if (|getMsgFTTag?| msg) @@ -4818,6 +5710,7 @@ makeLeaderMsg chPosList == \defun{insertPos}{insertPos} This function inserts a position in the proper place of a position list. This is used for the 2nd pos of a fromto +\calls{insertPos}{done} <>= (defun |insertPos| (newPos posList) (let (pos top bot done) @@ -4838,6 +5731,12 @@ This is used for the 2nd pos of a fromto @ \defun{putFTText}{putFTText} +\calls{putFTText}{getMsgFTTag?} +\calls{putFTText}{poCharPosn} +\calls{putFTText}{getMsgPos} +\calls{putFTText}{setMsgText} +\calls{putFTText}{getMsgText} +\calls{putFTText}{getMsgPos2} <>= (defun |putFTText| (msg chPosList) (let (charMarker2 pos2 markingText charMarker pos tag) @@ -5337,7 +6236,7 @@ and the # operation to count its elements. This type of iteration is applicable to anything that uses ".". You can also use it with functions that use indices to extract elements. - m := matrix [[1,2],[4,3],[9,0]] + m := matrix [ [1,2],[4,3],[9,0] ] +- -+ | 1 2 | | 4 3 | @@ -6171,6 +7070,9 @@ THE PFORM DATA STRUCTURE \defun{tokConstruct}{tokConstruct} The tokConstruct function is a constructer and selectors for leaf tokens +\calls{tokConstruct}{ifcar} +\calls{tokConstruct}{pfNoPosition?} +\calls{tokConstruct}{ncPutQ} <>= (defun |tokConstruct| (hd tok &rest pos) (let (a) @@ -6188,6 +7090,7 @@ The tokConstruct function is a constructer and selectors for leaf tokens @ \defun{tokType}{tokType} +\calls{tokType}{ncTag} <>= (defun |tokType| (x) (|ncTag| x)) @@ -6200,6 +7103,9 @@ The tokConstruct function is a constructer and selectors for leaf tokens @ \defun{tokPosn}{tokPosn} +\calls{tokPosn}{qassq} +\calls{tokPosn}{ncAlist} +\calls{tokPosn}{pfNoPosition} <>= (defun |tokPosn| (x) (let (a) @@ -6211,13 +7117,13 @@ The tokConstruct function is a constructer and selectors for leaf tokens @ \defun{pfAbSynOp?}{pfAbSynOp?} +\calls{pfAbSynOp?}{eqcar} <>= (defun |pfAbSynOp?| (form op) (let (hd) (setq hd (car form)) (or (eq hd op) (eqcar hd op)))) - @ \chapter{Attributed Structures} @@ -6226,6 +7132,9 @@ For objects which are pairs where the CAR field is either just a tag \defun{ncTag}{ncTag} Pick off the tag +\calls{ncTag}{ncBug} +\calls{ncTag}{qcar} +\calls{ncTag}{identp} <>= (defun |ncTag| (x) (cond @@ -6241,6 +7150,10 @@ Pick off the tag \defun{ncAlist}{ncAlist} Pick off the property list +\calls{ncAlist}{ncBug} +\calls{ncAlist}{qcar} +\calls{ncAlist}{identp} +\calls{ncAlist}{qcdr} <>= (defun |ncAlist| (x) (cond @@ -6256,6 +7169,9 @@ Pick off the property list \defun{ncEltQ}{ncEltQ} Get the entry for key k on x's association list +\calls{ncEltQ}{qassq} +\calls{ncEltQ}{ncAlist} +\calls{ncEltQ}{ncBug} <>= (defun |ncEltQ| (x k) (let (r) @@ -6284,6 +7200,9 @@ Get the entry for key k on x's association list ; else ; RPLACD(r,v) ; v\end{verbatim} +\calls{ncPutQ}{qassq} +\calls{ncPutQ}{ncAlist} +\calls{ncPutQ}{ncTag} <>= (defun |ncPutQ| (x k v) (let (r) @@ -6359,6 +7278,7 @@ See:\\ \item The \fnref{synonym} command \item The \fnref{system} command \item The \fnref{trace} command +\item The \fnref{trademark} command \item The \fnref{undo} command \item The \fnref{what} command \item The \fnref{with} command @@ -6372,6 +7292,8 @@ See:\\ (defvar |$systemCommands| nil) @ + +\defdollar{systemCommands} <>= (eval-when (eval load) (setq |$systemCommands| @@ -6407,6 +7329,7 @@ See:\\ (|synonym| . |interpreter|) (|system| . |interpreter|) (|trace| . |interpreter|) + (|trademark| . |interpreter|) (|undo| . |interpreter|) (|what| . |interpreter|) (|with| . |interpreter|) @@ -6428,6 +7351,7 @@ This table is used to look up a symbol to see if it might be a command. (setq $syscommands (mapcar #'car |$systemCommands|))) @ + \defdollar{noParseCommands} This is a list of the commands which have their arguments passed verbatim. Certain functions, such as the lisp function need to be able to handle @@ -6436,13 +7360,15 @@ all kinds of input that will not be acceptable to the interpreter. (defvar |$noParseCommands| nil) @ + <>= (eval-when (eval load) (setq |$noParseCommands| - '(|boot| |copyright| |credits| |fin| |lisp| |pquit| |quit| |synonym| |system| - ))) + '(|boot| |copyright| |credits| |fin| |lisp| |pquit| |quit| + |synonym| |system| |trademark| ))) @ + \section{Functions} \defun{handleNoParseCommands}{handleNoParseCommands} The system commands given by the global variable @@ -6458,14 +7384,14 @@ There are four standard commands which receive arguments \item system \end{itemize} -There are five standard commands -which do not receive arguments -- +There are six standard commands which do not receive arguments -- \begin{itemize} \item quit \item fin \item pquit \item credits \item copyright +\item trademark \end{itemize} As these commands do not necessarily @@ -6475,6 +7401,15 @@ require an argument name themselves, those which do have their names prefixed by ``np''. This makes it possible to dynamically define new system commands provided you handle the argument parsing. +\calls{handleNoParseCommands}{stripSpaces} +\calls{handleNoParseCommands}{nplisp} +\calls{handleNoParseCommands}{stripLisp} +\calls{handleNoParseCommands}{sayKeyedMsg} +\calls{handleNoParseCommands}{npboot} +\calls{handleNoParseCommands}{npsystem} +\calls{handleNoParseCommands}{npsynonym} +\calls{handleNoParseCommands}{member} +\calls{handleNoParseCommands}{concat} <>= (defun |handleNoParseCommands| (unab string) (let (spaceindex funname) @@ -6499,7 +7434,7 @@ new system commands provided you handle the argument parsing. (|npsynonym| unab ""))) ((null spaceindex) (funcall unab)) - ((|member| unab '(|quit| |fin| |pquit| |credits| |copyright|)) + ((|member| unab '(|quit| |fin| |pquit| |credits| |copyright| |trademark|)) (|sayKeyedMsg| 's2iv0005 nil)) (t (setq funname (intern (concat "np" (string unab)))) @@ -6637,6 +7572,10 @@ Thus, when a system command is entered this function is called. The only exception is the \verb|)include| function which inserts the contents of a file inline in the input stream. This is useful for processing \verb|)read| of input files. +\calls{ncloopCommand}{ncloopPrefix?} +\calls{ncloopCommand}{ncloopInclude1} +\callsdollar{ncloopCommand}{systemCommandFunction} +\usesdollar{ncloopCommand}{systemCommandFunction} <>= (defun |ncloopCommand| (line n) (let (a) @@ -6660,6 +7599,9 @@ we return the remainder of the string without the leading prefix. @ \defun{selectOptionLC}{selectOptionLC} +\calls{selectOptionLC}{selectOption} +\calls{selectOptionLC}{downcase} +\calls{selectOptionLC}{object2Identifier} <>= (defun |selectOptionLC| (x l errorFunction) (|selectOption| (downcase (|object2Identifier| x)) l errorFunction)) @@ -6667,6 +7609,13 @@ we return the remainder of the string without the leading prefix. @ \defun{selectOption}{selectOption} +\calls{selectOption}{member} +\calls{selectOption}{identp} +\calls{selectOption}{stringPrefix?} +\calls{selectOption}{pname} +\calls{selectOption}{pairp} +\calls{selectOption}{qcdr} +\calls{selectOption}{qcar} <>= (defun |selectOption| (x l errorfunction) (let (u y) @@ -6768,12 +7717,30 @@ o )compile \section{Functions} \defun{abbreviations}{abbreviations} +\calls{abbreviations}{abbreviationsSpad2Cmd} <>= (defun |abbreviations| (l) (|abbreviationsSpad2Cmd| l)) @ \defun{abbreviationsSpad2Cmd}{abbreviationsSpad2Cmd} +\calls{abbreviationsSpad2Cmd}{listConstructorAbbreviations} +\calls{abbreviationsSpad2Cmd}{abbreviation?} +\calls{abbreviationsSpad2Cmd}{abbQuery} +\calls{abbreviationsSpad2Cmd}{deldatabase} +\calls{abbreviationsSpad2Cmd}{size} +\calls{abbreviationsSpad2Cmd}{sayKeyedMsg} +\calls{abbreviationsSpad2Cmd}{mkUserConstructorAbbreviation} +\calls{abbreviationsSpad2Cmd}{setdatabase} +\calls{abbreviationsSpad2Cmd}{seq} +\calls{abbreviationsSpad2Cmd}{exit} +\calls{abbreviationsSpad2Cmd}{opOf} +\calls{abbreviationsSpad2Cmd}{helpSpad2Cmd} +\calls{abbreviationsSpad2Cmd}{selectOptionLC} +\calls{abbreviationsSpad2Cmd}{pairp} +\calls{abbreviationsSpad2Cmd}{qcar} +\calls{abbreviationsSpad2Cmd}{qcdr} +\usesdollar{abbreviationsSpad2Cmd}{options} <>= (defun |abbreviationsSpad2Cmd| (arg) (let (abopts quiet opt key type constructor t2 a b al) @@ -6829,6 +7796,12 @@ o )compile @ \defun{listConstructorAbbreviations}{listConstructorAbbreviations} +\calls{listConstructorAbbreviations}{upcase} +\calls{listConstructorAbbreviations}{queryUserKeyedMsg} +\calls{listConstructorAbbreviations}{memq} +\calls{listConstructorAbbreviations}{string2id-n} +\calls{listConstructorAbbreviations}{whatSpad2Cmd} +\calls{listConstructorAbbreviations}{sayKeyedMsg} <>= (defun |listConstructorAbbreviations| () (let (x) @@ -7074,6 +8047,10 @@ The socket can be supplied on the command line but defaults to 8085. Axiom supplies the arguments as a list. \section{Variables Used} \section{Functions} +\calls{browse}{set} +\calls{browse}{loadLib} +\calls{browse}{AxiomServer} +\calls{browse}{AXSERV;axServer;IMV;2} <>= (defun |browse| (socket) (let (axserv browser) @@ -7251,6 +8228,7 @@ o )undo \section{Functions} \defun{clear}{clear} +\calls{clear}{clearSpad2Cmd} <>= (defun |clear| (l) (|clearSpad2Cmd| l)) @@ -7260,6 +8238,17 @@ o )undo \defun{clearSpad2Cmd}{clearSpad2Cmd} TPDHERE: Note that this function also seems to parse out )except )completely and )scaches which don't seem to be documented. +\calls{clearSpad2Cmd}{selectOptionLC} +\calls{clearSpad2Cmd}{sayKeyedMsg} +\calls{clearSpad2Cmd}{clearCmdAll} +\calls{clearSpad2Cmd}{clearCmdCompletely} +\calls{clearSpad2Cmd}{clearCmdSortedCaches} +\calls{clearSpad2Cmd}{clearCmdExcept} +\calls{clearSpad2Cmd}{clearCmdParts} +\calls{clearSpad2Cmd}{updateCurrentInterpreterFrame} +\usesdollar{clearSpad2Cmd}{clearExcept} +\usesdollar{clearSpad2Cmd}{options} +\usesdollar{clearSpad2Cmd}{clearOptions} <>= (defun |clearSpad2Cmd| (l) (let (|$clearExcept| opt optlist arg) @@ -7308,6 +8297,11 @@ TPDHERE: Note that this function also seems to parse out )except @ \defun{clearCmdSortedCaches}{clearCmdSortedCaches} +\calls{clearCmdSortedCaches}{compiledLookupCheck} +\calls{clearCmdSortedCaches}{spadcall} +\usesdollar{clearCmdSortedCaches}{lookupDefaults} +\usesdollar{clearCmdSortedCaches}{Void} +\usesdollar{clearCmdSortedCaches}{ConstructorCache} <>= (defun |clearCmdSortedCaches| () (let (|$lookupDefaults| domain pair) @@ -7326,6 +8320,21 @@ TPDHERE: Note that this function also seems to parse out )except @ \defun{clearCmdCompletely}{clearCmdCompletely} +\calls{clearCmdCompletely}{clearCmdAll} +\calls{clearCmdCompletely}{sayKeyedMsg} +\calls{clearCmdCompletely}{clearClams} +\calls{clearCmdCompletely}{clearConstructorCaches} +\calls{clearCmdCompletely}{reclaim} +\usesdollar{clearCmdCompletely}{localExposureData} +\usesdollar{clearCmdCompletely}{xdatabase} +\usesdollar{clearCmdCompletely}{CatOfCatDatabase} +\usesdollar{clearCmdCompletely}{DomOfCatDatabase} +\usesdollar{clearCmdCompletely}{JoinOfCatDatabase} +\usesdollar{clearCmdCompletely}{JoinOfDomDatabase} +\usesdollar{clearCmdCompletely}{attributeDb} +\usesdollar{clearCmdCompletely}{functionTable} +\usesdollar{clearCmdCompletely}{existingFiles} +\usesdollar{clearCmdCompletely}{localExposureDataDefault} <>= (defun |clearCmdCompletely| () (declare (special |$localExposureData| |$xdatabase| |$CatOfCatDatabase| @@ -7352,6 +8361,23 @@ TPDHERE: Note that this function also seems to parse out )except @ \defun{clearCmdAll}{clearCmdAll} +\calls{clearCmdAll}{clearCmdSortedCaches} +\calls{clearCmdAll}{untraceMapSubNames} +\calls{clearCmdAll}{resetInCoreHist} +\calls{clearCmdAll}{deleteFile} +\calls{clearCmdAll}{histFileName} +\calls{clearCmdAll}{updateCurrentInterpreterFrame} +\calls{clearCmdAll}{clearMacroTable} +\calls{clearCmdAll}{sayKeyedMsg} +\usesdollar{clearCmdAll}{frameRecord} +\usesdollar{clearCmdAll}{previousBindings} +\usesdollar{clearCmdAll}{variableNumberAlist} +\usesdollar{clearCmdAll}{InteractiveFrame} +\usesdollar{clearCmdAll}{useInternalHistoryTable} +\usesdollar{clearCmdAll}{internalHistoryTable} +\usesdollar{clearCmdAll}{frameMessages} +\usesdollar{clearCmdAll}{interpreterFrameName} +\usesdollar{clearCmdAll}{currentLine} <>= (defun |clearCmdAll| () (declare (special |$frameRecord| |$previousBindings| |$variableNumberAlist| @@ -7378,6 +8404,7 @@ TPDHERE: Note that this function also seems to parse out )except @ \defun{clearMacroTable}{clearMacroTable} +\usesdollar{clearMacroTable}{pfMacros} <>= (defun |clearMacroTable| () (declare (special |$pfMacros|)) @@ -7387,6 +8414,10 @@ TPDHERE: Note that this function also seems to parse out )except \defun{clearCmdExcept}{clearCmdExcept} Clear all the options except the argument. +\calls{clearCmdExcept}{stringPrefix?} +\calls{clearCmdExcept}{object2String} +\calls{clearCmdExcept}{clearCmdParts} +\usesdollar{clearCmdExcept}{clearOptions} <>= (defun |clearCmdExcept| (arg) (let ((opt (car arg)) (vl (cdr arg))) @@ -7398,6 +8429,35 @@ Clear all the options except the argument. @ \defun{clearCmdParts}{clearCmdParts} +\calls{clearCmdParts}{selectOptionLC} +\calls{clearCmdParts}{pname} +\calls{clearCmdParts}{types} +\calls{clearCmdParts}{modes} +\calls{clearCmdParts}{values} +\calls{clearCmdParts}{boot-equal} +\calls{clearCmdParts}{assocleft} +\calls{clearCmdParts}{remdup} +\calls{clearCmdParts}{assoc} +\calls{clearCmdParts}{isMap} +\calls{clearCmdParts}{get} +\calls{clearCmdParts}{pairp} +\calls{clearCmdParts}{exit} +\calls{clearCmdParts}{untraceMapSubNames} +\calls{clearCmdParts}{seq} +\calls{clearCmdParts}{recordOldValue} +\calls{clearCmdParts}{recordNewValue} +\calls{clearCmdParts}{deleteAssoc} +\calls{clearCmdParts}{sayKeyedMsg} +\calls{clearCmdParts}{getParserMacroNames} +\calls{clearCmdParts}{getInterpMacroNames} +\calls{clearCmdParts}{clearDependencies} +\calls{clearCmdParts}{member} +\calls{clearCmdParts}{clearParserMacro} +\calls{clearCmdParts}{sayMessage} +\calls{clearCmdParts}{fixObjectForPrinting} +\usesdollar{clearCmdParts}{e} +\usesdollar{clearCmdParts}{InteractiveFrame} +\usesdollar{clearCmdParts}{clearOptions} <>= (defun |clearCmdParts| (arg) (let (|$e| (opt (car arg)) option pmacs imacs (vl (cdr arg)) p1 lm prop p2) @@ -7510,6 +8570,10 @@ o )pquit \section{Functions} \defun{queryClients}{queryClients} Returns the number of active scratchpad clients +\calls{queryClients}{sockSendInt} +\calls{queryClients}{sockGetInt} +\usesdollar{queryClients}{SessionManager} +\usesdollar{queryClients}{QueryClients} <>= (defun |queryClients| () (declare (special |$SessionManager| |$QueryClients|)) @@ -7519,6 +8583,20 @@ Returns the number of active scratchpad clients @ \defun{close}{close} +\calls{close}{throwKeyedMsg} +\calls{close}{sockSendInt} +\calls{close}{closeInterpreterFrame} +\calls{close}{selectOptionLC} +\calls{close}{upcase} +\calls{close}{queryUserKeyedMsg} +\calls{close}{memq} +\calls{close}{string2id-n} +\calls{close}{queryClients} +\usesdollar{close}{SpadServer} +\usesdollar{close}{SessionManager} +\usesdollar{close}{CloseClient} +\usesdollar{close}{currentFrameNum} +\usesdollar{close}{options} <>= (defun |close| (args) (declare (ignore args)) @@ -7817,6 +8895,26 @@ o )library \section{Functions} \defun{compiler}{compiler} +\calls{compiler}{helpSpad2Cmd} +\calls{compiler}{selectOptionLC} +\calls{compiler}{new} +\calls{compiler}{translate} +\calls{compiler}{constructor} +\calls{compiler}{old} +\calls{compiler}{throwKeyedMsg} +\calls{compiler}{pathname} +\calls{compiler}{pathnameType} +\callsdollar{compiler}{findfile} +\calls{compiler}{compileAsharpCmd} +\calls{compiler}{compileSpad2Cmd} +\calls{compiler}{compileAsharpLispCmd} +\calls{compiler}{compileSpadLispCmd} +\calls{compiler}{compileAsharpArchiveCmd} +\calls{compiler}{mergePathnames} +\calls{compiler}{boot-equal} +\usesdollar{compiler}{newConlist} +\usesdollar{compiler}{options} +\uses{compiler}{/editfile} <>= (defun |compiler| (args) (let (|$newConlist| optlist optname optargs havenew haveold aft ef af af1) @@ -7916,6 +9014,11 @@ o )library \cmdhead{copyright} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% <>= +The term Axiom, in the field of computer algebra software, +along with AXIOM and associated images are common-law +trademarks. While the software license allows copies, the +trademarks may only be used when referring to this project. + Axiom is distributed under terms of the Modified BSD license. Axiom was released under this license as of September 3, 2002. Source code is freely available at: @@ -8168,9 +9271,21 @@ Portions Copyright (c) 2001-2009 Timothy Daly @ \section{Functions} \defun{copyright}{copyright} +\calls{copyright}{obey} +\calls{copyright}{concat} +\calls{copyright}{getenviron} <>= (defun |copyright| () - (obey (concat "cat " (getenviron "AXIOM") "/doc/spadhelp/spadhelp.help"))) + (obey (concat "cat " (getenviron "AXIOM") "/doc/spadhelp/copyright.help"))) + +@ +\defun{trademark}{trademark} +<>= +(defun |trademark| () + (format t "The term Axiom, in the field of computer algebra software, ~%") + (format t "along with AXIOM and associated images are common-law ~%") + (format t "trademarks. While the software license allows copies, the ~%") + (format t "trademarks may only be used when referring to this project ~%")) @ @@ -8186,6 +9301,7 @@ verbatim. This will eventually result in a call to the function \section{Variables Used} \section{Functions} \defun{credits}{credits} +\uses{credits}{credits} <>= (defun |credits| () (declare (special credits)) @@ -8213,11 +9329,11 @@ Command Syntax: - )display all - )display properties - )display properties all - - )display properties [obj1 [obj2 ...]] + - )display properties [obj1 [obj2 ...] ] - )display value all - - )display value [obj1 [obj2 ...]] + - )display value [obj1 [obj2 ...] ] - )display mode all - - )display mode [obj1 [obj2 ...]] + - )display mode [obj1 [obj2 ...] ] - )display names - )display operations opName @@ -8296,6 +9412,7 @@ The current value of \$displayOptions is This trivial function satisfies the standard pattern of making a user command match the name of the function which implements the command. That command immediatly invokes a ``Spad2Cmd'' version. +\calls{display}{displayspad2cmd} <>= (defun |display| (l) (displaySpad2Cmd l)) @@ -8315,6 +9432,19 @@ to be plural. If we fall all the way thru we use the \$displayOptions list to construct a list of strings for the sayMessage function and tell the user what options are available. +\calls{displaySpad2Cmd}{abbQuery} +\calls{displaySpad2Cmd}{opOf} +\calls{displaySpad2Cmd}{listConstructorAbbreviations} +\calls{displaySpad2Cmd}{displayOperations} +\calls{displaySpad2Cmd}{displayMacros} +\calls{displaySpad2Cmd}{displayWorkspaceNames} +\calls{displaySpad2Cmd}{displayProperties} +\calls{displaySpad2Cmd}{PAIRP} +\calls{displaySpad2Cmd}{selectOptionLC} +\calls{displaySpad2Cmd}{sayMessage} +\usesdollar{displaySpad2Cmd}{e} +\usesdollar{displaySpad2Cmd}{EmptyEnvironment} +\usesdollar{displaySpad2Cmd}{displayOptions} <>= (defun displaySpad2Cmd (l) (let ((|$e| |$EmptyEnvironment|) (opt (car l)) (vl (cdr l)) option) @@ -8350,6 +9480,8 @@ and tell the user what options are available. @ \defun{abbQuery}{abbQuery} +\calls{abbQuery}{getdatabase} +\calls{abbQuery}{sayKeyedMsg} <>= (defun |abbQuery| (x) (let (abb) @@ -8366,6 +9498,9 @@ and tell the user what options are available. This function takes a list of operation names. If the list is null we query the user to see if they want all operations printed. Otherwise we print the information for the requested symbols. +\calls{displayOperations}{reportOpSymbol} +\calls{displayOperations}{yesanswer} +\calls{displayOperations}{sayKeyedMsg} <>= (defun |displayOperations| (l) (if l @@ -8380,6 +9515,10 @@ This is a trivial function to simplify the logic of displaySpad2Cmd. If the user didn't supply an argument to the )display op command we ask if they wish to have all information about all Axiom operations displayed. If the answer is either Y or YES we return true else nil. +\calls{yesanswer}{memq} +\calls{yesanswer}{string2id-n} +\calls{yesanswer}{upcase} +\calls{yesanswer}{queryUserKeyedMsg} <>= (defun yesanswer () (memq (string2id-n (upcase (|queryUserKeyedMsg| 's2iz0058 nil)) 1) '(y yes))) @@ -8387,6 +9526,15 @@ displayed. If the answer is either Y or YES we return true else nil. @ \defun{displayMacros}{displayMacros} +\calls{displayMacros}{getInterpMacroNames} +\calls{displayMacros}{getParserMacroNames} +\calls{displayMacros}{remdup} +\calls{displayMacros}{sayBrightly} +\calls{displayMacros}{member} +\calls{displayMacros}{displayParserMacro} +\calls{displayMacros}{seq} +\calls{displayMacros}{exit} +\calls{displayMacros}{displayMacro} <>= (defun |displayMacros| (names) (let (imacs pmacs macros first) @@ -8479,6 +9627,8 @@ then it implies multiple example lines and we loop over them, splitting them up at the delimiter. If there is only one then we clean it up and print it. +\calls{sayexample}{cleanupline} +\calls{sayexample}{sayNewLine} <>= (defun sayExample (docstring) (let (line point) @@ -8597,12 +9747,21 @@ o )read \section{Functions} \defun{edit}{edit} +\calls{edit}{editSpad2Cmd} <>= (defun |edit| (l) (|editSpad2Cmd| l)) @ \defun{editSpad2Cmd}{editSpad2Cmd} +\calls{editSpad2Cmd}{pathname} +\calls{editSpad2Cmd}{pathnameDirectory} +\calls{editSpad2Cmd}{pathnameType} +\callsdollar{editSpad2Cmd}{FINDFILE} +\calls{editSpad2Cmd}{pathnameName} +\calls{editSpad2Cmd}{editFile} +\calls{editSpad2Cmd}{updateSourceFiles} +\uses{editSpad2Cmd}{/editfile} <>= (defun |editSpad2Cmd| (l) (let (olddir filetypes ll rc) @@ -8682,7 +9841,7 @@ Command Syntax: - )frame next - )frame last - )frame names - - )frame import frameName [objectName1 [objectName2 ...]] + - )frame import frameName [objectName1 [objectName2 ...] ] - )set message frame on | off - )set message prompt frame @@ -8907,6 +10066,10 @@ As a final step we update the world from this frame. This has the side-effect of resetting all the important global variables to their initial values. +\calls{initializeInterpreterFrameRing}{emptyInterpreterFrame} +\calls{initializeInterpreterFrameRing}{updateFromCurrentInterpreterFrame} +\usesdollar{initializeInterpreterFrameRing}{interpreterFrameName} +\usesdollar{initializeInterpreterFrameRing}{interpreterFrameRing} <>= (defun |initializeInterpreterFrameRing| () "Initializing the Interpreter Frame Ring" @@ -8921,6 +10084,7 @@ initial values. \defunsec{frameNames}{Creating a List of all of the Frame Names} This function simply walks across the frame in the frame ring and returns a list of the name of each frame. +\usesdollar{frameNames}{interpreterFrameRing} <>= (defun |frameNames| () "Creating a List of all of the Frame Names" @@ -8934,6 +10098,7 @@ If the frame is found we return the environment portion of the frame otherwise we construct an empty environment and return it. The initial values of an empty frame are created here. This function returns a single frame that will be placed in the frame ring. +\calls{frameEnvironment}{frameinteractive} <>= (defun |frameEnvironment| (fname) "Get Named Frame Environment (aka Interactive)" @@ -8944,6 +10109,12 @@ returns a single frame that will be placed in the frame ring. @ \defunsec{emptyInterpreterFrame}{Create a new, empty Interpreter Frame} +\usesdollar{emptyInterpreterFrame}{HiFiAccess} +\usesdollar{emptyInterpreterFrame}{HistList} +\usesdollar{emptyInterpreterFrame}{HistListLen} +\usesdollar{emptyInterpreterFrame}{HistListAct} +\usesdollar{emptyInterpreterFrame}{HistRecord} +\usesdollar{emptyInterpreterFrame}{localExposureDataDefault} <>= (defun |emptyInterpreterFrame| (name) "Create a new, empty Interpreter Frame" @@ -8968,6 +10139,16 @@ We can collect up all the current environment information into one frame element with this call. It creates a list of the current values of the global variables and returns this as a frame element. +\usesdollar{createCurrentInterpreterFrame}{interpreterFrameName} +\usesdollar{createCurrentInterpreterFrame}{InteractiveFrame} +\usesdollar{createCurrentInterpreterFrame}{IOindex} +\usesdollar{createCurrentInterpreterFrame}{HiFiAccess} +\usesdollar{createCurrentInterpreterFrame}{HistList} +\usesdollar{createCurrentInterpreterFrame}{HistListLen} +\usesdollar{createCurrentInterpreterFrame}{HistListAct} +\usesdollar{createCurrentInterpreterFrame}{HistRecord} +\usesdollar{createCurrentInterpreterFrame}{internalHistoryTable} +\usesdollar{createCurrentInterpreterFrame}{localExposureData} <>= (defun |createCurrentInterpreterFrame| () "Collecting up the Environment into a Frame" @@ -8992,6 +10173,19 @@ values of the global variables and returns this as a frame element. The frames are kept on a circular list. The first element on that list is known as ``the current frame''. This will initialize all of the interesting interpreter data structures from that frame. +\calls{updateFromCurrentInterpreterFrame}{sayMessage} +\usesdollar{updateFromCurrentInterpreterFrame}{interpreterFrameRing} +\usesdollar{updateFromCurrentInterpreterFrame}{interpreterFrameName} +\usesdollar{updateFromCurrentInterpreterFrame}{InteractiveFrame} +\usesdollar{updateFromCurrentInterpreterFrame}{IOindex} +\usesdollar{updateFromCurrentInterpreterFrame}{HiFiAccess} +\usesdollar{updateFromCurrentInterpreterFrame}{HistList} +\usesdollar{updateFromCurrentInterpreterFrame}{HistListLen} +\usesdollar{updateFromCurrentInterpreterFrame}{HistListAct} +\usesdollar{updateFromCurrentInterpreterFrame}{HistRecord} +\usesdollar{updateFromCurrentInterpreterFrame}{internalHistoryTable} +\usesdollar{updateFromCurrentInterpreterFrame}{localExposureData} +\usesdollar{updateFromCurrentInterpreterFrame}{frameMessages} <>= (defun |updateFromCurrentInterpreterFrame| () "Update from the Current Frame" @@ -9020,6 +10214,9 @@ of the interesting interpreter data structures from that frame. \defunsec{findFrameInRing}{Find a Frame in the Frame Ring by Name} Each frame contains its name as the 0th element. We simply walk all the frames and if we find one we return it. +\calls{findFrameInRing}{boot-equal} +\calls{findFrameInRing}{framename} +\usesdollar{findFrameInRing}{interpreterFrameRing} <>= (defun |findFrameInRing| (name) "Find a Frame in the Frame Ring by Name" @@ -9036,6 +10233,9 @@ the frames and if we find one we return it. This function collects the normal contents of the world into a frame object, places it first on the frame list, and then sets the current values of the world from the frame object. +\calls{updateCurrentInterpreterFrame}{createCurrentInterpreterFrame} +\calls{updateCurrentInterpreterFrame}{updateFromCurrentInterpreterFrame} +\usesdollar{updateCurrentInterpreterFrame}{interpreterFrameRing} <>= (defun |updateCurrentInterpreterFrame| () "Update the Current Interpreter Frame" @@ -9052,6 +10252,9 @@ to the end of the list, that is, assume the frame list reads (1 2 3) this function will destructively change it to (2 3 1). Note: the nconc2 function destructively inserts the second list at the end of the first. +\calls{nextInterpreterFrame}{nconc2} +\calls{nextInterpreterFrame}{updateFromCurrentInterpreterFrame} +\usesdollar{nextInterpreterFrame}{interpreterFrameRing} <>= (defun |nextInterpreterFrame| () "Move to the next Interpreter Frame in Ring" @@ -9064,6 +10267,11 @@ end of the first. @ \defunsec{changeToNamedInterpreterFrame}{Change to the Named Interpreter Frame} +\calls{changeToNamedInterpreterFrame}{updateCurrentInterpreterFrame} +\calls{changeToNamedInterpreterFrame}{findFrameInRing} +\calls{changeToNamedInterpreterFrame}{nremove} +\calls{changeToNamedInterpreterFrame}{updateFromCurrentInterpreterFrame} +\usesdollar{changeToNamedInterpreterFrame}{interpreterFrameRing} <>= (defun |changeToNamedInterpreterFrame| (name) "Change to the Named Interpreter Frame" @@ -9079,6 +10287,10 @@ end of the first. @ \defunsec{previousInterpreterFrame} {Move to the previous Interpreter Frame in Ring} +\calls{previousInterpreterFrame}{updateCurrentInterpreterFrame} +\calls{previousInterpreterFrame}{nconc2} +\calls{previousInterpreterFrame}{updateFromCurrentInterpreterFrame} +\usesdollar{previousInterpreterFrame}{interpreterFrameRing} <>= (defun |previousInterpreterFrame| () "Move to the previous Interpreter Frame in Ring" @@ -9094,6 +10306,16 @@ end of the first. @ \defunsec{addNewInterpreterFrame}{Add a New Interpreter Frame} +\calls{addNewInterpreterFrame}{boot-equal} +\calls{addNewInterpreterFrame}{framename} +\calls{addNewInterpreterFrame}{throwKeyedMsg} +\calls{addNewInterpreterFrame}{updateCurrentInterpreterFrame} +\calls{addNewInterpreterFrame}{initHistList} +\calls{addNewInterpreterFrame}{emptyInterpreterFrame} +\calls{addNewInterpreterFrame}{updateFromCurrentInterpreterFrame} +\callsdollar{addNewInterpreterFrame}{erase} +\calls{addNewInterpreterFrame}{histFileName} +\usesdollar{addNewInterpreterFrame}{interpreterFrameRing} <>= (defun |addNewInterpreterFrame| (name) "Add a New Interpreter Frame" @@ -9113,6 +10335,14 @@ end of the first. @ \defunsec{closeInterpreterFrame}{Close an Interpreter Frame} +\calls{closeInterpreterFrame}{nequal} +\calls{closeInterpreterFrame}{framename} +\calls{closeInterpreterFrame}{throwKeyedMsg} +\callsdollar{closeInterpreterFrame}{erase} +\calls{closeInterpreterFrame}{makeHistFileName} +\calls{closeInterpreterFrame}{updateFromCurrentInterpreterFrame} +\usesdollar{closeInterpreterFrame}{interpreterFrameRing} +\usesdollar{closeInterpreterFrame}{interpreterFrameName} <>= (defun |closeInterpreterFrame| (name) "Close an Interpreter Frame" @@ -9142,6 +10372,10 @@ end of the first. @ \defunsec{displayFrameNames}{Display the Frame Names} +\calls{displayFrameNames}{bright} +\calls{displayFrameNames}{framename} +\calls{displayFrameNames}{sayKeyedMsg} +\usesdollar{displayFrameNames}{interpreterFrameRing} <>= (defun |displayFrameNames| () "Display the Frame Names" @@ -9154,6 +10388,25 @@ end of the first. @ \defunsec{importFromFrame}{Import items from another frame} +\calls{importFromFrame}{member} +\calls{importFromFrame}{frameNames} +\calls{importFromFrame}{throwKeyedMsg} +\calls{importFromFrame}{boot-equal} +\calls{importFromFrame}{framename} +\calls{importFromFrame}{frameEnvironment} +\calls{importFromFrame}{upcase} +\calls{importFromFrame}{queryUserKeyedMsg} +\calls{importFromFrame}{memq} +\calls{importFromFrame}{string2id-n} +\calls{importFromFrame}{importFromFrame} +\calls{importFromFrame}{sayKeyedMsg} +\calls{importFromFrame}{clearCmdParts} +\calls{importFromFrame}{seq} +\calls{importFromFrame}{exit} +\calls{importFromFrame}{putHist} +\calls{importFromFrame}{get} +\calls{importFromFrame}{getalist} +\usesdollar{importFromFrame}{interpreterFrameRing} <>= (defun |importFromFrame| (args) "Import items from another frame" @@ -9238,6 +10491,7 @@ end of the first. @ \defunsec{frame}{The top level frame command} +\calls{frame}{frameSpad2Cmd} <>= (defun |frame| (l) "The top level frame command" @@ -9245,6 +10499,26 @@ end of the first. @ \defunsec{frameSpad2Cmd}{The top level frame command handler} +\calls{frameSpad2Cmd}{throwKeyedMsg} +\calls{frameSpad2Cmd}{helpSpad2Cmd} +\calls{frameSpad2Cmd}{selectOptionLC} +\calls{frameSpad2Cmd}{pairp} +\calls{frameSpad2Cmd}{qcdr} +\calls{frameSpad2Cmd}{qcar} +\calls{frameSpad2Cmd}{object2Identifier} +\calls{frameSpad2Cmd}{drop} +\calls{frameSpad2Cmd}{closeInterpreterFrame} +\calls{frameSpad2Cmd}{import} +\calls{frameSpad2Cmd}{importFromFrame} +\calls{frameSpad2Cmd}{last} +\calls{frameSpad2Cmd}{previousInterpreterFrame} +\calls{frameSpad2Cmd}{names} +\calls{frameSpad2Cmd}{displayFrameNames} +\calls{frameSpad2Cmd}{new} +\calls{frameSpad2Cmd}{addNewInterpreterFrame} +\calls{frameSpad2Cmd}{next} +\calls{frameSpad2Cmd}{nextInterpreterFrame} +\usesdollar{frameSpad2Cmd}{options} <>= (defun |frameSpad2Cmd| (args) "The top level frame command handler" @@ -9475,6 +10749,7 @@ Available algebra help topics are: \section{Functions} \defunsec{help}{The top level help command} +\calls{help}{helpSpad2Cmd} <>= (defun |help| (l) "The top level help command" @@ -9483,6 +10758,8 @@ Available algebra help topics are: @ \defunsec{helpSpad2Cmd}{The top level help command handler} +\calls{helpSpad2Cmd}{newHelpSpad2Cmd} +\calls{helpSpad2Cmd}{sayKeyedMsg} <>= (defun |helpSpad2Cmd| (|args|) "The top level help command handler" @@ -9492,6 +10769,18 @@ Available algebra help topics are: @ \defun{newHelpSpad2Cmd}{newHelpSpad2Cmd} +\calls{newHelpSpad2Cmd}{make-input-filename} +\calls{newHelpSpad2Cmd}{obey} +\calls{newHelpSpad2Cmd}{concat} +\calls{newHelpSpad2Cmd}{namestring} +\calls{newHelpSpad2Cmd}{make-instream} +\calls{newHelpSpad2Cmd}{say} +\calls{newHelpSpad2Cmd}{poundsign} +\calls{newHelpSpad2Cmd}{sayKeyedMsg} +\calls{newHelpSpad2Cmd}{pname} +\calls{newHelpSpad2Cmd}{selectOptionLC} +\usesdollar{newHelpSpad2Cmd}{syscommands} +\usesdollar{newHelpSpad2Cmd}{useFullScreenHelp} <>= (defun |newHelpSpad2Cmd| (args) (let (sarg arg narg helpfile filestream line) @@ -9723,12 +11012,15 @@ environment to \verb|$HistList| and \verb|$HistRecord|. \section{Data Structures} \section{Functions} \defun{makeHistFileName}{makeHistFileName} +\calls{makeHistFileName}{makePathname} <>= (defun |makeHistFileName| (fname) (|makePathname| fname |$historyFileType| |$historyDirectory|)) @ \defun{oldHistFileName}{oldHistFileName} +\calls{oldHistFileName}{makeHistFileName} +\usesdollar{oldHistFileName}{oldHistoryFileName} <>= (defun |oldHistFileName| () (declare (special |$oldHistoryFileName|)) @@ -9736,6 +11028,8 @@ environment to \verb|$HistList| and \verb|$HistRecord|. @ \defun{histFileName}{histFileName} +\calls{histFileName}{makeHistFileName} +\usesdollar{histFileName}{interpreterFrameName} <>= (defun |histFileName| () (declare (special |$interpreterFrameName|)) @@ -9743,6 +11037,9 @@ environment to \verb|$HistList| and \verb|$HistRecord|. @ \defun{histInputFileName}{histInputFileName} +\calls{histInputFileName}{makePathname} +\usesdollar{histInputFileName}{interpreterFrameName} +\usesdollar{histInputFileName}{historyDirectory} <>= (defun |histInputFileName| (fn) (declare (special |$interpreterFrameName| |$historyDirectory|)) @@ -9752,6 +11049,14 @@ environment to \verb|$HistList| and \verb|$HistRecord|. @ \defun{initHist}{initHist} +\calls{initHist}{initHistList} +\calls{initHist}{oldHistFileName} +\calls{initHist}{histFileName} +\calls{initHist}{histFileErase} +\calls{initHist}{make-input-filename} +\callsdollar{initHist}{replace} +\usesdollar{initHist}{useInternalHistoryTable} +\usesdollar{initHist}{HiFiAccess} <>= (defun |initHist| () (let (oldFile newFile) @@ -9768,6 +11073,10 @@ environment to \verb|$HistList| and \verb|$HistRecord|. @ \defun{initHistList}{initHistList} +\usesdollar{initHistList}{HistListLen} +\usesdollar{initHistList}{HistList} +\usesdollar{initHistList}{HistListAct} +\usesdollar{initHistList}{HistRecord} <>= (defun |initHistList| () (let (li) @@ -9784,6 +11093,9 @@ environment to \verb|$HistList| and \verb|$HistRecord|. @ \defunsec{history}{The top level history command} +\calls{history}{sayKeyedMsg} +\calls{history}{historySpad2Cmd} +\usesdollar{history}{options} <>= (defun |history| (l) "The top level history command" @@ -9794,6 +11106,30 @@ environment to \verb|$HistList| and \verb|$HistRecord|. @ \defunsec{historySpad2Cmd}{The top level history command handler} +\calls{historySpad2Cmd}{selectOptionLC} +\calls{historySpad2Cmd}{member} +\calls{historySpad2Cmd}{sayKeyedMsg} +\calls{historySpad2Cmd}{initHistList} +\calls{historySpad2Cmd}{upcase} +\calls{historySpad2Cmd}{queryUserKeyedMsg} +\calls{historySpad2Cmd}{memq} +\calls{historySpad2Cmd}{string2id-n} +\calls{historySpad2Cmd}{histFileErase} +\calls{historySpad2Cmd}{histFileName} +\calls{historySpad2Cmd}{clearSpad2Cmd} +\calls{historySpad2Cmd}{disableHist} +\calls{historySpad2Cmd}{setHistoryCore} +\calls{historySpad2Cmd}{resetInCoreHist} +\calls{historySpad2Cmd}{saveHistory} +\calls{historySpad2Cmd}{showHistory} +\calls{historySpad2Cmd}{changeHistListLen} +\calls{historySpad2Cmd}{restoreHistory} +\calls{historySpad2Cmd}{writeInputLines} +\calls{historySpad2Cmd}{seq} +\calls{historySpad2Cmd}{exit} +\usesdollar{historySpad2Cmd}{options} +\usesdollar{historySpad2Cmd}{HiFiAccess} +\usesdollar{historySpad2Cmd}{IOindex} <>= (defun |historySpad2Cmd| () "The top level history command handler" @@ -9896,6 +11232,22 @@ the history in memory and tell the user. \item Otherwise history must be on and in memory. We erase any old history file and then write the in-memory history to a new file \end{list} +\calls{setHistoryCore}{boot-equal} +\calls{setHistoryCore}{sayKeyedMsg} +\calls{setHistoryCore}{nequal} +\calls{setHistoryCore}{rkeyids} +\calls{setHistoryCore}{histFileName} +\calls{setHistoryCore}{readHiFi} +\calls{setHistoryCore}{disableHist} +\calls{setHistoryCore}{histFileErase} +\calls{setHistoryCore}{rdefiostream} +\calls{setHistoryCore}{spadrwrite} +\calls{setHistoryCore}{object2Identifier} +\calls{setHistoryCore}{rshut} +\usesdollar{setHistoryCore}{useInternalHistoryTable} +\usesdollar{setHistoryCore}{internalHistoryTable} +\usesdollar{setHistoryCore}{HiFiAccess} +\usesdollar{setHistoryCore}{IOindex} <>= (defun |setHistoryCore| (inCore) (let (l vec str n rec) @@ -9963,6 +11315,24 @@ Also used in the output routines. @ \defun{writeInputLines}{writeInputLines} +\calls{writeInputLines}{sayKeyedMsg} +\calls{writeInputLines}{throwKeyedMsg} +\calls{writeInputLines}{size} +\calls{writeInputLines}{spaddifference} +\calls{writeInputLines}{plus} +\calls{writeInputLines}{memq} +\calls{writeInputLines}{concat} +\calls{writeInputLines}{substring} +\calls{writeInputLines}{readHiFi} +\calls{writeInputLines}{histInputFileName} +\calls{writeInputLines}{histFileErase} +\calls{writeInputLines}{defiostream} +\calls{writeInputLines}{nequal} +\calls{writeInputLines}{namestring} +\calls{writeInputLines}{shut} +\uses{writeInputLines}{underbar} +\usesdollar{writeInputLines}{HiFiAccess} +\usesdollar{writeInputLines}{IOindex} <>= (defun |writeInputLines| (fn initial) (let (maxn breakChars vecl k svec done n lineList file inp) @@ -10012,6 +11382,9 @@ Also used in the output routines. @ \defun{resetInCoreHist}{resetInCoreHist} +\usesdollar{resetInCoreHist}{HistListAct} +\usesdollar{resetInCoreHist}{HistListLen} +\usesdollar{resetInCoreHist}{HistList} <>= (defun |resetInCoreHist| () (declare (special |$HistListAct| |$HistListLen| |$HistList|)) @@ -10023,6 +11396,11 @@ Also used in the output routines. @ \defun{changeHistListLen}{changeHistListLen} +\calls{changeHistListLen}{sayKeyedMsg} +\calls{changeHistListLen}{spaddifference} +\usesdollar{changeHistListLen}{HistListLen} +\usesdollar{changeHistListLen}{HistList} +\usesdollar{changeHistListLen}{HistListAct} <>= (defun |changeHistListLen| (n) (let (dif l) @@ -10051,6 +11429,17 @@ Also used in the output routines. @ \defun{updateHist}{updateHist} +\calls{updateHist}{startTimingProcess} +\calls{updateHist}{updateInCoreHist} +\calls{updateHist}{writeHiFi} +\calls{updateHist}{disableHist} +\calls{updateHist}{updateCurrentInterpreterFrame} +\calls{updateHist}{stopTimingProcess} +\usesdollar{updateHist}{IOindex} +\usesdollar{updateHist}{HiFiAccess} +\usesdollar{updateHist}{HistRecord} +\usesdollar{updateHist}{mkTestInputStack} +\usesdollar{updateHist}{currentLine} <>= (defun |updateHist| () (declare (special |$IOindex| |$HiFiAccess| |$HistRecord| |$mkTestInputStack| @@ -10069,6 +11458,10 @@ Also used in the output routines. @ \defun{updateInCoreHist}{updateInCoreHist} +\calls{updateInCoreHist}{plus} +\usesdollar{updateInCoreHist}{HistList} +\usesdollar{updateInCoreHist}{HistListLen} +\usesdollar{updateInCoreHist}{HistListAct} <>= (defun |updateInCoreHist| () (declare (special |$HistList| |$HistListLen| |$HistListAct|)) @@ -10079,6 +11472,11 @@ Also used in the output routines. @ \defun{putHist}{putHist} +\calls{putHist}{recordOldValue} +\calls{putHist}{get} +\calls{putHist}{recordNewValue} +\calls{putHist}{putIntSymTab} +\usesdollar{putHist}{HiFiAccess} <>= (defun |putHist| (x prop val e) (declare (special |$HiFiAccess|)) @@ -10088,6 +11486,9 @@ Also used in the output routines. @ \defun{recordNewValue}{recordNewValue} +\calls{recordNewValue}{startTimingProcess} +\calls{recordNewValue}{recordNewValue0} +\calls{recordNewValue}{stopTimingProcess} <>= (defun |recordNewValue| (x prop val) (|startTimingProcess| '|history|) @@ -10096,6 +11497,8 @@ Also used in the output routines. @ \defun{recordNewValue0}{recordNewValue0} +\calls{recordNewValue0}{assq} +\usesdollar{recordNewValue0}{HistRecord} <>= (defun |recordNewValue0| (x prop val) (let (p1 p2 p) @@ -10110,6 +11513,10 @@ Also used in the output routines. @ \defun{recordOldValue}{recordOldValue} +\calls{recordOldValue}{startTimingProcess} +\calls{recordOldValue}{recordOldValue0} +\calls{recordOldValue}{stopTimingProcess} +\calls{recordOldValue0}{assq} <>= (defun |recordOldValue| (x prop val) (|startTimingProcess| '|history|) @@ -10118,6 +11525,7 @@ Also used in the output routines. @ \defun{recordOldValue0}{recordOldValue0} +\usesdollar{recordOldValue0}{HistList} <>= (defun |recordOldValue0| (x prop val) (let (p1 p) @@ -10130,6 +11538,19 @@ Also used in the output routines. @ \defun{undoInCore}{undoInCore} +\calls{undoInCore}{undoChanges} +\calls{undoInCore}{spaddifference} +\calls{undoInCore}{readHiFi} +\calls{undoInCore}{disableHist} +\calls{undoInCore}{assq} +\calls{undoInCore}{sayKeyedMsg} +\calls{undoInCore}{putHist} +\calls{undoInCore}{updateHist} +\usesdollar{undoInCore}{HistList} +\usesdollar{undoInCore}{HistListLen} +\usesdollar{undoInCore}{IOindex} +\usesdollar{undoInCore}{HiFiAccess} +\usesdollar{undoInCore}{InteractiveFrame} <>= (defun |undoInCore| (n) (let (li vec p p1 val) @@ -10157,6 +11578,11 @@ Also used in the output routines. @ \defun{undoChanges}{undoChanges} +\calls{undoChanges}{boot-equal} +\calls{undoChanges}{undoChanges} +\calls{undoChanges}{putHist} +\usesdollar{undoChanges}{HistList} +\usesdollar{undoChanges}{InteractiveFrame} <>= (defun |undoChanges| (li) (let (x) @@ -10169,6 +11595,17 @@ Also used in the output routines. @ \defun{undoFromFile}{undoFromFile} +\calls{undoFromFile}{seq} +\calls{undoFromFile}{exit} +\calls{undoFromFile}{recordOldValue} +\calls{undoFromFile}{recordNewValue} +\calls{undoFromFile}{readHiFi} +\calls{undoFromFile}{disableHist} +\calls{undoFromFile}{putHist} +\calls{undoFromFile}{assq} +\calls{undoFromFile}{updateHist} +\usesdollar{undoFromFile}{InteractiveFrame} +\usesdollar{undoFromFile}{HiFiAccess} <>= (defun |undoFromFile| (n) (let (varl prop vec x p p1 val) @@ -10220,6 +11657,23 @@ Also used in the output routines. @ \defun{saveHistory}{saveHistory} +\calls{saveHistory}{sayKeyedMsg} +\calls{saveHistory}{make-input-filename} +\calls{saveHistory}{histFileName} +\calls{saveHistory}{throwKeyedMsg} +\calls{saveHistory}{makeHistFileName} +\calls{saveHistory}{histInputFileName} +\calls{saveHistory}{writeInputLines} +\calls{saveHistory}{histFileErase} +\calls{saveHistory}{rdefiostream} +\calls{saveHistory}{spadrwrite0} +\calls{saveHistory}{object2Identifier} +\calls{saveHistory}{rshut} +\calls{saveHistory}{namestring} +\usesdollar{saveHistory}{seen} +\usesdollar{saveHistory}{HiFiAccess} +\usesdollar{saveHistory}{useInternalHistoryTable} +\usesdollar{saveHistory}{internalHistoryTable} <>= (defun |saveHistory| (fn) (let (|$seen| savefile inputfile saveStr n rec val) @@ -10266,6 +11720,35 @@ Also used in the output routines. @ \defun{restoreHistory}{restoreHistory} +\calls{restoreHistory}{pairp} +\calls{restoreHistory}{qcdr} +\calls{restoreHistory}{qcar} +\calls{restoreHistory}{identp} +\calls{restoreHistory}{throwKeyedMsg} +\calls{restoreHistory}{makeHistFileName} +\calls{restoreHistory}{putHist} +\calls{restoreHistory}{make-input-filename} +\calls{restoreHistory}{sayKeyedMsg} +\calls{restoreHistory}{namestring} +\calls{restoreHistory}{clearSpad2Cmd} +\calls{restoreHistory}{histFileName} +\calls{restoreHistory}{histFileErase} +\callsdollar{restoreHistory}{fcopy} +\calls{restoreHistory}{rkeyids} +\calls{restoreHistory}{readHiFi} +\calls{restoreHistory}{disableHist} +\calls{restoreHistory}{updateInCoreHist} +\calls{restoreHistory}{get} +\calls{restoreHistory}{rempropI} +\calls{restoreHistory}{plus} +\calls{restoreHistory}{clearCmdSortedCaches} +\usesdollar{restoreHistory}{options} +\usesdollar{restoreHistory}{internalHistoryTable} +\usesdollar{restoreHistory}{HiFiAccess} +\usesdollar{restoreHistory}{e} +\usesdollar{restoreHistory}{useInternalHistoryTable} +\usesdollar{restoreHistory}{InteractiveFrame} +\usesdollar{restoreHistory}{oldHistoryFileName} <>= (defun |restoreHistory| (fn) (let (|$options| fnq restfile curfile l oldInternal vec line x a) @@ -10337,6 +11820,7 @@ Also used in the output routines. @ \defun{setIOindex}{setIOindex} +\usesdollar{setIOindex}{IOindex} <>= (defun |setIOindex| (n) (declare (special |$IOindex|)) @@ -10344,6 +11828,10 @@ Also used in the output routines. @ \defun{showInput}{showInput} +\calls{showInput}{tab} +\calls{showInput}{readHiFi} +\calls{showInput}{disableHist} +\calls{showInput}{sayMSG} <>= (defun |showInput| (mini maxi) (let (vec l) @@ -10365,6 +11853,13 @@ Also used in the output routines. @ \defun{showInOut}{showInOut} +\calls{showInOut}{assq} +\calls{showInOut}{spadPrint} +\calls{showInOut}{objValUnwrap} +\calls{showInOut}{objMode} +\calls{showInOut}{readHiFi} +\calls{showInOut}{disableHist} +\calls{showInOut}{sayMSG} <>= (defun |showInOut| (mini maxi) (let (vec Alist triple) @@ -10380,6 +11875,14 @@ Also used in the output routines. @ \defun{fetchOutput}{fetchOutput} +\calls{fetchOutput}{boot-equal} +\calls{fetchOutput}{spaddifference} +\calls{fetchOutput}{getI} +\calls{fetchOutput}{plus} +\calls{fetchOutput}{throwKeyedMsg} +\calls{fetchOutput}{readHiFi} +\calls{fetchOutput}{disableHist} +\calls{fetchOutput}{assq} <>= (defun |fetchOutput| (n) (let (vec Alist val) @@ -10410,6 +11913,16 @@ Also used in the output routines. @ \defunsec{readHiFi}{Read the history file using index n} +\calls{readHiFi}{assoc} +\calls{readHiFi}{keyedSystemError} +\calls{readHiFi}{qcdr} +\calls{readHiFi}{rdefiostream} +\calls{readHiFi}{histFileName} +\calls{readHiFi}{spadrread} +\calls{readHiFi}{object2Identifier} +\calls{readHiFi}{rshut} +\usesdollar{readHiFi}{useInternalHistoryTable} +\usesdollar{readHiFi}{internalHistoryTable} <>= (defun |readHiFi| (n) "Read the history file using index n" @@ -10433,7 +11946,17 @@ Also used in the output routines. vec)) @ -\defunsec{writeHiFi}{Writes information of the current step to history file} +\defunsec{writeHiFi}{Write information of the current step to history file} +\calls{writeHiFi}{rdefiostream} +\calls{writeHiFi}{histFileName} +\calls{writeHiFi}{spadrwrite} +\calls{writeHiFi}{object2Identifier} +\calls{writeHiFi}{rshut} +\usesdollar{writeHiFi}{useInternalHistoryTable} +\usesdollar{writeHiFi}{internalHistoryTable} +\usesdollar{writeHiFi}{IOindex} +\usesdollar{writeHiFi}{HistRecord} +\usesdollar{writeHiFi}{currentLine} <>= (defun |writeHiFi| () "Writes information of the current step to history file" @@ -10458,6 +11981,9 @@ Also used in the output routines. @ \defunsec{disableHist}{Disable history if an error occurred} +\calls{disableHist}{histFileErase} +\calls{disableHist}{histFileName} +\usesdollar{disableHist}{HiFiAccess} <>= (defun |disableHist| () "Disable history if an error occurred" @@ -10469,6 +11995,9 @@ Also used in the output routines. @ \defun{writeHistModesAndValues}{writeHistModesAndValues} +\calls{writeHistModesAndValues}{get} +\calls{writeHistModesAndValues}{putHist} +\usesdollar{writeHistModesAndValues}{InteractiveFrame} <>= (defun |writeHistModesAndValues| () (let (a x) @@ -10497,6 +12026,8 @@ Lisplib output transformations Some types of objects cannot be saved by LISP/VM in lisplibs. These functions transform an object to a writable form and back. \defun{spadrwrite0}{spadrwrite0} +\calls{spadrwrite0}{safeWritify} +\calls{spadrwrite0}{rwrite} <>= (defun spadrwrite0 (vec item stream) (let (val) @@ -10509,6 +12040,8 @@ These functions transform an object to a writable form and back. @ \defun{spadrwrite}{spadrwrite} +\calls{spadrwrite}{spadrwrite0} +\calls{spadrwrite}{throwKeyedMsg} <>= (defun spadrwrite (vec item stream) (let (val) @@ -10519,12 +12052,18 @@ These functions transform an object to a writable form and back. @ \defun{spadrread}{spadrread} +\calls{SPADRREAD}{dewritify} +\calls{SPADRREAD}{rread} <>= (defun spadrread (vec stream) (|dewritify| (|rread| vec stream nil))) @ \defun{unwritable?}{unwritable?} +\calls{unwritable?}{pairp} +\calls{unwritable?}{vecp} +\calls{unwritable?}{hashtablep} +\calls{unwritable?}{placep} <>= (defun |unwritable?| (ob) (cond @@ -10540,6 +12079,8 @@ Create a full isomorphic object which can be saved in a lisplib. Note that {\tt dewritify(writify(x))} preserves UEQUALity of hashtables. HASHTABLEs go both ways. READTABLEs cannot presently be transformed back. +\calls{writifyComplain}{sayKeyedMsg} +\usesdollar{writifyComplain}{writifyComplained} <>= (defun |writifyComplain| (s) (declare (special |$writifyComplained|)) @@ -10549,12 +12090,41 @@ back. @ \defun{safeWritify}{safeWritify} +\calls{safeWritify}{writify} <>= (defun |safeWritify| (ob) (catch '|writifyTag| (|writify| ob))) @ \defun{writify,writifyInner}{writify,writifyInner} +\calls{writify,writifyInner}{seq} +\calls{writify,writifyInner}{exit} +\calls{writify,writifyInner}{hget} +\calls{writify,writifyInner}{pairp} +\calls{writify,writifyInner}{qcar} +\calls{writify,writifyInner}{qcdr} +\calls{writify,writifyInner}{spadClosure?} +\calls{writify,writifyInner}{writify,writifyInner} +\calls{writify,writifyInner}{hput} +\calls{writify,writifyInner}{qrplaca} +\calls{writify,writifyInner}{qrplacd} +\calls{writify,writifyInner}{vecp} +\calls{writify,writifyInner}{isDomainOrPackage} +\calls{writify,writifyInner}{mkEvalable} +\calls{writify,writifyInner}{devaluate} +\calls{writify,writifyInner}{qvmaxindex} +\calls{writify,writifyInner}{plus} +\calls{writify,writifyInner}{qsetvelt} +\calls{writify,writifyInner}{qvelt} +\calls{writify,writifyInner}{constructor?} +\calls{writify,writifyInner}{hashtablep} +\calls{writify,writifyInner}{hkeys} +\calls{writify,writifyInner}{hashtable-class} +\calls{writify,writifyInner}{placep} +\calls{writify,writifyInner}{boot-equal} +\usesdollar{writify,writifyInner}{seen} +\usesdollar{writify,writifyInner}{NonNullStream} +\usesdollar{writify,writifyInner}{NullStream} <>= (defun |writify,writifyInner| (ob) (prog (e name tmp1 tmp2 tmp3 x qcar qcdr d n keys nob) @@ -10689,6 +12259,11 @@ back. @ \defun{writify}{writify} +\calls{writify}{ScanOrPairVec} +\calls{writify}{function} +\calls{writify}{writify,writifyInner} +\usesdollar{writify}{seen} +\usesdollar{writify}{writifyComplained} <>= (defun |writify| (ob) (let (|$seen| |$writifyComplained|) @@ -10702,6 +12277,10 @@ back. @ \defun{spadClosure?}{spadClosure?} +\calls{spadClosure?}{qcar} +\calls{spadClosure?}{bpiname} +\calls{spadClosure?}{qcdr} +\calls{spadClosure?}{vecp} <>= (defun |spadClosure?| (ob) (let (fun name vec) @@ -10723,6 +12302,34 @@ back. @ \defun{dewritify,dewritifyInner}{dewritify,dewritifyInner} +\calls{dewritify,dewritifyInner}{seq} +\calls{dewritify,dewritifyInner}{exit} +\calls{dewritify,dewritifyInner}{hget} +\calls{dewritify,dewritifyInner}{pairp} +\calls{dewritify,dewritifyInner}{intp} +\calls{dewritify,dewritifyInner}{gensymmer} +\calls{dewritify,dewritifyInner}{error} +\calls{dewritify,dewritifyInner}{poundsign} +\calls{dewritify,dewritifyInner}{nequal} +\calls{dewritify,dewritifyInner}{hasheq} +\calls{dewritify,dewritifyInner}{hput} +\calls{dewritify,dewritifyInner}{dewritify,dewritifyInner} +\calls{dewritify,dewritifyInner}{concat} +\calls{dewritify,dewritifyInner}{vmread} +\calls{dewritify,dewritifyInner}{make-instream} +\calls{dewritify,dewritifyInner}{spaddifference} +\calls{dewritify,dewritifyInner}{qcar} +\calls{dewritify,dewritifyInner}{qcdr} +\calls{dewritify,dewritifyInner}{qrplaca} +\calls{dewritify,dewritifyInner}{qrplacd} +\calls{dewritify,dewritifyInner}{vecp} +\calls{dewritify,dewritifyInner}{qvmaxindex} +\calls{dewritify,dewritifyInner}{plus} +\calls{dewritify,dewritifyInner}{qsetvelt} +\calls{dewritify,dewritifyInner}{qvelt} +\usesdollar{dewritify,dewritifyInner}{seen} +\usesdollar{dewritify,dewritifyInner}{NullStream} +\usesdollar{dewritify,dewritifyInner}{NonNullStream} <>= (defun |dewritify,dewritifyInner| (ob) (prog (e type oname f vec name tmp1 signif expon sign fval qcar qcdr n nob) @@ -10855,6 +12462,10 @@ back. @ \defun{dewritify}{dewritify} +\calls{dewritify}{ScanOrPairVec} +\calls{dewritify}{function} +\calls{dewritify}{dewritify,dewritifyInner} +\usesdollar{dewritify}{seen} <>= (defun |dewritify| (ob) (let (|$seen|) @@ -10868,6 +12479,14 @@ back. @ \defun{ScanOrPairVec,ScanOrInner}{ScanOrPairVec,ScanOrInner} +\calls{ScanOrPairVec,ScanOrInner}{hget} +\calls{ScanOrPairVec,ScanOrInner}{pairp} +\calls{ScanOrPairVec,ScanOrInner}{hput} +\calls{ScanOrPairVec,ScanOrInner}{ScanOrPairVec,ScanOrInner} +\calls{ScanOrPairVec,ScanOrInner}{qcar} +\calls{ScanOrPairVec,ScanOrInner}{qcdr} +\calls{ScanOrPairVec,ScanOrInner}{vecp} +\usesdollar{ScanOrPairVec,ScanOrInner}{seen} <>= (defun |ScanOrPairVec,ScanOrInner| (f ob) (declare (special |$seen|)) @@ -10887,6 +12506,8 @@ back. @ \defun{ScanOrPairVec}{ScanOrPairVec} +\calls{ScanOrPairVec}{ScanOrPairVec,ScanOrInner} +\usesdollar{ScanOrPairVec}{seen} <>= (defun |ScanOrPairVec| (f ob) (let (|$seen|) @@ -10896,6 +12517,12 @@ back. @ \defun{gensymInt}{gensymInt} +\calls{gensymInt}{gensymp} +\calls{gensymInt}{error} +\calls{gensymInt}{pname} +\calls{gensymInt}{plus} +\calls{gensymInt}{times} +\calls{gensymInt}{charDigitVal} <>= (defun |gensymInt| (g) (let (p n) @@ -10911,6 +12538,8 @@ back. @ \defun{charDigitVal}{charDigitVal} +\calls{charDigitVal}{spaddifference} +\calls{charDigitVal}{error} <>= (defun |charDigitVal| (c) (let (digits n) @@ -11038,6 +12667,8 @@ absolute or relative pathname. @ \section{Functions} \defun{ncloopInclude1}{ncloopInclude1} +\calls{ncloopInclude1}{ncloopIncFileName} +\calls{ncloopInclude1}{ncloopInclude} <>= (defun |ncloopInclude1| (name n) (let (a) @@ -11048,6 +12679,8 @@ absolute or relative pathname. @ \defunsec{ncloopIncFileName} {Returns the first non-blank substring of the given string} +\calls{ncloopIncFileName}{incFileName} +\calls{ncloopIncFileName}{concat} <>= (defun |ncloopIncFileName| (string) "Returns the first non-blank substring of the given string" @@ -11061,6 +12694,7 @@ absolute or relative pathname. \defunsec{ncloopInclude}{Open the include file and read it in} The ncloopInclude0 function is part of the parser and lives in int-top.boot. +\calls{ncloopInclude}{ncloopInclude0} <>= (defun |ncloopInclude| (name n) "Open the include file and read it in" @@ -11071,6 +12705,7 @@ of the parser and lives in int-top.boot. \defunsec{incFileName}{Return the include filename} Given a string we return the first token from the string which is the first non-blank substring. +\calls{incFileName}{incBiteOff} <>= (defun |incFileName| (x) "Return the include filename" @@ -11311,6 +12946,7 @@ o )system \section{Functions} \defunsec{pquit}{The top level pquit command} +\calls{pquit}{pquitSpad2Cmd} <>= (defun |pquit| () "The top level pquit command" @@ -11319,6 +12955,8 @@ o )system @ \defunsec{pquitSpad2Cmd}{The top level pquit command handler} +\calls{pquitSpad2Cmd}{quitSpad2Cmd} +\usesdollar{pquitSpad2Cmd}{quitCommandType} <>= (defun |pquitSpad2Cmd| () "The top level pquit command handler" @@ -11388,6 +13026,7 @@ o )system \section{Functions} \defunsec{quit}{The top level quit command} +\calls{quit}{quitSpad2Cmd} <>= (defun |quit| () "The top level quit command" @@ -11395,6 +13034,14 @@ o )system @ \defunsec{quitSpad2Cmd}{The top level quit command handler} +\calls{quitSpad2Cmd}{upcase} +\calls{quitSpad2Cmd}{queryUserKeyedMsg} +\calls{quitSpad2Cmd}{memq} +\calls{quitSpad2Cmd}{string2id-n} +\calls{quitSpad2Cmd}{leaveScratchpad} +\calls{quitSpad2Cmd}{sayKeyedMsg} +\calls{quitSpad2Cmd}{tersyscommand} +\usesdollar{quitSpad2Cmd}{quitCommandType} <>= (defun |quitSpad2Cmd| () "The top level quit command handler" @@ -11603,25 +13250,58 @@ The fifth element is usually a variable to set. The sixth element is a subtree to recurse for the TREE switch. The seventh element is usually the default value. For more detailed explanations see the list structure section \ref{Theliststructure}. +\calls{initializeSetVariables}{sayMSG} +\calls{initializeSetVariables}{literals} +\calls{initializeSetVariables}{translateYesNo2TrueFalse} +\calls{initializeSetVariables}{tree} +\calls{initializeSetVariables}{initializeSetVariables} <>= (defun |initializeSetVariables| (settree) "Initialize the set variables" (dolist (setdata settree) (case (fourth setdata) - (FUNCTION + (function (if (functionp (fifth setdata)) (funcall (fifth setdata) '|%initialize%|) (|sayMSG| (concatenate 'string " Function not implemented. " (package-name *package*) ":" (string (fifth setdata)))))) - (INTEGER (set (fifth setdata) (seventh setdata))) - (STRING (set (fifth setdata) (seventh setdata))) - (LITERALS + (integer (set (fifth setdata) (seventh setdata))) + (string (set (fifth setdata) (seventh setdata))) + (literals (set (fifth setdata) (|translateYesNo2TrueFalse| (seventh setdata)))) - (TREE (|initializeSetVariables| (sixth setdata)))))) + (tree (|initializeSetVariables| (sixth setdata)))))) @ \defunsec{resetWorkspaceVariables}{Reset the workspace variables} +\calls{resetWorkspaceVariables}{copy} +\calls{resetWorkspaceVariables}{initializeSetVariables} +\uses{resetWorkspaceVariables}{/countlist} +\uses{resetWorkspaceVariables}{/editfile} +\uses{resetWorkspaceVariables}{/sourcefiles} +\uses{resetWorkspaceVariables}{/pretty} +\uses{resetWorkspaceVariables}{/spacelist} +\uses{resetWorkspaceVariables}{/timerlist} +\usesdollar{resetWorkspaceVariables}{sourceFiles} +\usesdollar{resetWorkspaceVariables}{existingFiles} +\usesdollar{resetWorkspaceVariables}{functionTable} +\usesdollar{resetWorkspaceVariables}{boot} +\usesdollar{resetWorkspaceVariables}{compileMapFlag} +\usesdollar{resetWorkspaceVariables}{echoLineStack} +\usesdollar{resetWorkspaceVariables}{operationNameList} +\usesdollar{resetWorkspaceVariables}{slamFlag} +\usesdollar{resetWorkspaceVariables}{CommandSynonymAlist} +\usesdollar{resetWorkspaceVariables}{InitialCommandSynonymAlist} +\usesdollar{resetWorkspaceVariables}{UserAbbreviationsAlist} +\usesdollar{resetWorkspaceVariables}{msgAlist} +\usesdollar{resetWorkspaceVariables}{msgDatabase} +\usesdollar{resetWorkspaceVariables}{msgDatabaseName} +\usesdollar{resetWorkspaceVariables}{dependeeClosureAlist} +\usesdollar{resetWorkspaceVariables}{IOindex} +\usesdollar{resetWorkspaceVariables}{coerceIntByMapCounter} +\usesdollar{resetWorkspaceVariables}{e} +\usesdollar{resetWorkspaceVariables}{env} +\usesdollar{resetWorkspaceVariables}{setOptions} <>= (defun |resetWorkspaceVariables| () "Reset the workspace variables" @@ -11661,6 +13341,20 @@ explanations see the list structure section \ref{Theliststructure}. @ \defunsec{displaySetOptionInformation}{Display the set option information} +\calls{displaySetOptionInformation}{displaySetVariableSettings} +\calls{displaySetOptionInformation}{centerAndHighlight} +\calls{displaySetOptionInformation}{concat} +\calls{displaySetOptionInformation}{object2String} +\calls{displaySetOptionInformation}{specialChar} +\calls{displaySetOptionInformation}{sayBrightly} +\calls{displaySetOptionInformation}{bright} +\calls{displaySetOptionInformation}{sayMSG} +\calls{displaySetOptionInformation}{boot-equal} +\calls{displaySetOptionInformation}{sayMessage} +\calls{displaySetOptionInformation}{eval} +\calls{displaySetOptionInformation}{literals} +\calls{displaySetOptionInformation}{translateTrueFalse2YesNo} +\usesdollar{displaySetOptionInformation}{linelength} <>= (defun |displaySetOptionInformation| (arg setdata) "Display the set option information" @@ -11676,25 +13370,25 @@ explanations see the list structure section \ref{Theliststructure}. (|sayBrightly| `(|%l| ,@(|bright| "Description:") ,(second setdata))) (case (fourth setdata) - (FUNCTION + (function (terpri) (if (functionp (fifth setdata)) (funcall (fifth setdata) '|%describe%|) (|sayMSG| " Function not implemented."))) - (INTEGER + (integer (|sayMessage| `(" The" ,@(|bright| arg) "option" " may be followed by an integer in the range" ,@(|bright| (elt (sixth setdata) 0)) "to" |%l| ,@(|bright| (elt (sixth setdata) 1)) "inclusive." " The current setting is" ,@(|bright| (|eval| (fifth setdata)))))) - (STRING + (string (|sayMessage| `(" The" ,@(|bright| arg) "option" " is followed by a string enclosed in double quote marks." '|%l| " The current setting is" ,@(|bright| (list '|"| (|eval| (fifth setdata)) '|"|))))) - (LITERALS + (literals (|sayMessage| `(" The" ,@(|bright| arg) "option" " may be followed by any one of the following:")) @@ -11709,6 +13403,24 @@ explanations see the list structure section \ref{Theliststructure}. @ \defunsec{displaySetVariableSettings}{Display the set variable settings} +\calls{displaySetVariableSettings}{concat} +\calls{displaySetVariableSettings}{object2String} +\calls{displaySetVariableSettings}{centerAndHighlight} +\calls{displaySetVariableSettings}{sayBrightly} +\calls{displaySetVariableSettings}{say} +\calls{displaySetVariableSettings}{fillerSpaces} +\calls{displaySetVariableSettings}{specialChar} +\calls{displaySetVariableSettings}{pairp} +\calls{displaySetVariableSettings}{concat} +\calls{displaySetVariableSettings}{satisfiesUserLevel} +\calls{displaySetVariableSettings}{spaddifference} +\calls{displaySetVariableSettings}{poundsign} +\calls{displaySetVariableSettings}{eval} +\calls{displaySetVariableSettings}{bright} +\calls{displaySetVariableSettings}{literals} +\calls{displaySetVariableSettings}{translateTrueFalse2YesNo} +\calls{displaySetVariableSettings}{tree} +\usesdollar{displaySetVariableSettings}{linelength} <>= (defun |displaySetVariableSettings| (settree label) "Display the set variable settings" @@ -11736,7 +13448,7 @@ explanations see the list structure section \ref{Theliststructure}. (concat setoption (|fillerSpaces| (spaddifference 55 (|#| setoption)) " "))) (case (fourth setdata) - (FUNCTION + (function (setq opt (if (functionp (fifth setdata)) (funcall (fifth setdata) '|%display%|) @@ -11748,13 +13460,13 @@ explanations see the list structure section \ref{Theliststructure}. ((or (atom t2) (progn (setq |o| (car t2)) nil)) t1) (setq t1 (append t1 (cons |o| (cons " " nil)))))))) (|sayBrightly| (|concat| setoption '|%b| opt '|%d|))) - (STRING + (string (setq opt (|object2String| (|eval| (fifth setdata)))) (|sayBrightly| `(,setoption ,@(|bright| opt)))) - (INTEGER + (integer (setq opt (|object2String| (|eval| (fifth setdata)))) (|sayBrightly| `(,setoption ,@(|bright| opt)))) - (LITERALS + (literals (setq opt (|object2String| (|translateTrueFalse2YesNo| (|eval| (fifth setdata))))) (|sayBrightly| `(,setoption ,@(|bright| opt)))) @@ -11775,6 +13487,7 @@ explanations see the list structure section \ref{Theliststructure}. @ \defunsec{translateYesNo2TrueFalse}{Translate options values to t or nil} +\calls{translateYesNo2TrueFalse}{member} <>= (defun |translateYesNo2TrueFalse| (x) "Translate options values to t or nil" @@ -12000,6 +13713,11 @@ args arguments for compiling AXIOM code \section{Variables Used} \section{Functions} \defunsec{setOutputLibrary}{The set output command handler} +\calls{setOutputLibrary}{poundsign} +\calls{setOutputLibrary}{describeOutputLibraryArgs} +\calls{setOutputLibrary}{filep} +\calls{setOutputLibrary}{openOutputLibrary} +\usesdollar{setOutputLibrary}{outputLibraryName} <>= (defun |setOutputLibrary| (arg) "The set output command handler" @@ -12018,6 +13736,7 @@ args arguments for compiling AXIOM code @ \defunsec{describeOutputLibraryArgs}{Describe the set output library arguments} +\calls{describeOutputLibraryArgs}{sayBrightly} <>= (defun |describeOutputLibraryArgs| () "Describe the set output library arguments" @@ -12033,6 +13752,9 @@ args arguments for compiling AXIOM code \defunsec{openOutputLibrary}{Open the output library} The input-libraries and output-library are now truename based. +\calls{openOutputLibrary}{dropInputLibrary} +\uses{openOutputLibrary}{output-library} +\uses{openOutputLibrary}{input-libraries} <>= (defun |openOutputLibrary| (lib) "Open the output library" @@ -12069,6 +13791,15 @@ The input-libraries and output-library are now truename based. \section{Functions} \defunsec{setInputLibrary}{The set input library command handler} The input-libraries is now maintained as a list of truenames. +\calls{setInputLibrary}{describeInputLibraryArgs} +\calls{setInputLibrary}{pairp} +\calls{setInputLibrary}{qcar} +\calls{setInputLibrary}{qcdr} +\calls{setInputLibrary}{selectOptionLC} +\calls{setInputLibrary}{addInputLibrary} +\calls{setInputLibrary}{dropInputLibrary} +\calls{setInputLibrary}{setInputLibrary} +\uses{setInputLibrary}{input-libraries} <>= (defun |setInputLibrary| (arg) "The set input library command handler" @@ -12097,6 +13828,7 @@ The input-libraries is now maintained as a list of truenames. @ \defunsec{describeInputLibraryArgs}{Describe the set input library arguments} +\calls{describeInputLibraryArgs}{sayBrightly} <>= (defun |describeInputLibraryArgs| () "Describe the set input library arguments" @@ -12117,6 +13849,8 @@ The input-libraries is now maintained as a list of truenames. \defunsec{addInputLibrary}{Add the input library to the list} The input-libraries variable is now maintained as a list of truenames. +\calls{addInputLibrary}{dropInputLibrary} +\usesdollar{addInputLibrary}{input-libraries} <>= (defun |addInputLibrary| (lib) "Add the input library to the list" @@ -12127,6 +13861,7 @@ The input-libraries variable is now maintained as a list of truenames. @ \defunsec{dropInputLibrary}{Drop an input library from the list} +\usesdollar{dropInputLibrary}{input-libraries} <>= (defun |dropInputLibrary| (lib) "Drop an input library from the list" @@ -12155,6 +13890,7 @@ The input-libraries variable is now maintained as a list of truenames. (defvar |$asharpCmdlineFlags| "-O -Fasy -Fao -Flsp -laxiom -Mno-AXL__W__WillObsolete -DAxiom -Y $AXIOM/algebra" "arguments for compiling AXIOM code") + @ <>= (|args| @@ -12173,6 +13909,8 @@ The input-libraries variable is now maintained as a list of truenames. \section{Variables Used} \section{Functions} \defunsec{setAsharpArgs}{Handle the set compiler command arguments} +\calls{setAsharpArgs}{describeAsharpArgs} +\usesdollar{setAsharpArgs}{asharpCmdlineFlags} <>= (defun |setAsharpArgs| (arg) "Handle the set compiler command arguments" @@ -12189,6 +13927,8 @@ The input-libraries variable is now maintained as a list of truenames. @ \defunsec{describeAsharpArgs}{Describe the set compiler command arguments} +\calls{describeAsharpArgs}{sayBrightly} +\usesdollar{describeAsharpArgs}{asharpCmdlineFlags} <>= (defun |describeAsharpArgs| () "Describe the set compiler command arguments" @@ -12249,6 +13989,21 @@ The input-libraries variable is now maintained as a list of truenames. \section{Variables Used} \section{Functions} \defunsec{setExpose}{The top level set expose command handler} +\calls{setExpose}{loadExposureGroupData} +\calls{setExpose}{displayExposedGroups} +\calls{setExpose}{sayMSG} +\calls{setExpose}{displayExposedConstructors} +\calls{setExpose}{displayHiddenConstructors} +\calls{setExpose}{sayKeyedMsg} +\calls{setExpose}{namestring} +\calls{setExpose}{pathname} +\calls{setExpose}{pairp} +\calls{setExpose}{qcar} +\calls{setExpose}{qcdr} +\calls{setExpose}{selectOptionLC} +\calls{setExpose}{setExposeAdd} +\calls{setExpose}{setExposeDrop} +\calls{setExpose}{setExpose} <>= (defun |setExpose| (arg) "The top level set expose command handler" @@ -12278,6 +14033,20 @@ The input-libraries variable is now maintained as a list of truenames. @ \defunsec{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}{pairp} +\calls{setExposeAdd}{qcar} +\calls{setExposeAdd}{qcdr} +\calls{setExposeAdd}{selectOptionLC} +\calls{setExposeAdd}{setExposeAddGroup} +\calls{setExposeAdd}{setExposeAddConstr} +\calls{setExposeAdd}{setExposeAdd} +\usesdollar{setExposeAdd}{linelength} <>= (defun |setExposeAdd| (arg) "The top level set expose add command handler" @@ -12306,6 +14075,28 @@ The input-libraries variable is now maintained as a list of truenames. \defunsec{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}{pairp} +\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} <>= (defun |setExposeAddGroup| (arg) "Expose a group" @@ -12350,6 +14141,22 @@ It consists of [exposed groups,exposed constructors,hidden constructors] @ \defunsec{setExposeAddConstr}{The top level set expose add constructor handler} +\calls{setExposeAddConstr}{unabbrev} +\calls{setExposeAddConstr}{pairp} +\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} <>= (defun |setExposeAddConstr| (arg) "The top level set expose add constructor handler" @@ -12379,6 +14186,19 @@ It consists of [exposed groups,exposed constructors,hidden constructors] @ \defunsec{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}{pairp} +\calls{setExposeDrop}{qcar} +\calls{setExposeDrop}{qcdr} +\calls{setExposeDrop}{selectOptionLC} +\calls{setExposeDrop}{setExposeDropGroup} +\calls{setExposeDrop}{setExposeDropConstr} +\calls{setExposeDrop}{setExposeDrop} +\usesdollar{setExposeDrop}{linelength} <>= (defun |setExposeDrop| (arg) "The top level set expose drop handler" @@ -12403,6 +14223,24 @@ It consists of [exposed groups,exposed constructors,hidden constructors] @ \defunsec{setExposeDropGroup}{The top level set expose drop group handler} +\calls{setExposeDropGroup}{pairp} +\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} <>= (defun |setExposeDropGroup| (arg) "The top level set expose drop group handler" @@ -12440,6 +14278,24 @@ It consists of [exposed groups,exposed constructors,hidden constructors] @ \defunsec{setExposeDropConstr} {The top level set expose drop constructor handler} +\calls{setExposeDropConstr}{unabbrev} +\calls{setExposeDropConstr}{pairp} +\calls{setExposeDropConstr}{qcar} +\calls{setExposeDropConstr}{getdatabase} +\calls{setExposeDropConstr}{sayKeyedMsg} +\calls{setExposeDropConstr}{member} +\calls{setExposeDropConstr}{setelt} +\calls{setExposeDropConstr}{delete} +\calls{setExposeDropConstr}{msort} +\calls{setExposeDropConstr}{clearClams} +\calls{setExposeDropConstr}{centerAndHighlight} +\calls{setExposeDropConstr}{specialChar} +\calls{setExposeDropConstr}{sayMSG} +\calls{setExposeDropConstr}{displayExposedConstructors} +\calls{setExposeDropConstr}{displayHiddenConstructors} +\usesdollar{setExposeDropConstr}{linelength} +\usesdollar{setExposeDropConstr}{localExposureData} +\usesdollar{setExposeDropConstr}{interpreterFrameName} <>= (defun |setExposeDropConstr| (arg) "The top level set expose drop constructor handler" @@ -12473,6 +14329,10 @@ It consists of [exposed groups,exposed constructors,hidden constructors] @ \defunsec{displayExposedGroups}{Display exposed groups} +\calls{displayExposedGroups}{sayKeyedMsg} +\calls{displayExposedGroups}{centerAndHighlight} +\usesdollar{displayExposedGroups}{interpreterFrameName} +\usesdollar{displayExposedGroups}{localExposureData} <>= (defun |displayExposedGroups| () "Display exposed groups" @@ -12486,6 +14346,9 @@ It consists of [exposed groups,exposed constructors,hidden constructors] @ \defunsec{displayExposedConstructors}{Display exposed constructors} +\calls{displayExposedConstructors}{sayKeyedMsg} +\calls{displayExposedConstructors}{centerAndHighlight} +\usesdollar{displayExposedConstructors}{localExposureData} <>= (defun |displayExposedConstructors| () "Display exposed constructors" @@ -12499,6 +14362,9 @@ It consists of [exposed groups,exposed constructors,hidden constructors] @ \defunsec{displayHiddenConstructors}{Display hidden constructors} +\calls{displayHiddenConstructors}{sayKeyedMsg} +\calls{displayHiddenConstructors}{centerAndHighlight} +\usesdollar{displayHiddenConstructors}{localExposureData} <>= (defun |displayHiddenConstructors| () "Display hidden constructors" @@ -12568,6 +14434,18 @@ recurrence specially compile recurrence relations on \section{Functions} \defunsec{setFunctionsCache}{The top level set functions cache handler} \begin{verbatim} +\calls{setFunctionsCache}{object2String} +\calls{setFunctionsCache}{describeSetFunctionsCache} +\calls{setFunctionsCache}{sayAllCacheCounts} +\calls{setFunctionsCache}{nequal} +\calls{setFunctionsCache}{fixp} +\calls{setFunctionsCache}{sayMessage} +\calls{setFunctionsCache}{bright} +\calls{setFunctionsCache}{terminateSystemCommand} +\calls{setFunctionsCache}{countCache} +\usesdollar{setFunctionsCache}{options} +\usesdollar{setFunctionsCache}{cacheCount} +\usesdollar{setFunctionsCache}{cacheAlist} <>= (defun |setFunctionsCache| (arg) "The top level set functions cache handler" @@ -12600,6 +14478,18 @@ recurrence specially compile recurrence relations on @ \defunsec{countCache}{Display a particular cache count} +\calls{countCache}{pairp} +\calls{countCache}{qcdr} +\calls{countCache}{qcar} +\calls{countCache}{identp} +\calls{countCache}{sayKeyedMsg} +\calls{countCache}{insertAlist} +\calls{countCache}{internl} +\calls{countCache}{sayCacheCount} +\calls{countCache}{optionError} +\usesdollar{countCache}{options} +\usesdollar{countCache}{cacheAlist} +\usesdollar{countCache}{cacheCount} <>= (defun |countCache| (n) "Display a particular cache count" @@ -12611,7 +14501,7 @@ recurrence specially compile recurrence relations on ((and (pairp |$options|) (eq (qcdr |$options|) nil) (progn - (spadlet tmp1 (qcar |$options|)) + (setq tmp1 (qcar |$options|)) (and (pairp tmp1) (eq (qcar tmp1) '|vars|) (progn (setq l (qcdr tmp1)) t)))) @@ -12630,6 +14520,7 @@ recurrence specially compile recurrence relations on @ \defunsec{describeSetFunctionsCache}{Describe the set functions cache} +\calls{describeSetFunctionsCache}{sayBrightly} <>= (defun |describeSetFunctionsCache| () "Describe the set functions cache" @@ -12656,6 +14547,10 @@ recurrence specially compile recurrence relations on @ \defunsec{sayAllCacheCounts}{Display all cache counts} +\calls{sayAllCacheCounts}{sayCacheCount} +\calls{sayAllCacheCounts}{nequal} +\usesdollar{sayAllCacheCounts}{cacheCount} +\usesdollar{sayAllCacheCounts}{cacheAlist} <>= (defun |sayAllCacheCounts| () "Display all cache counts" @@ -12675,6 +14570,9 @@ recurrence specially compile recurrence relations on @ \defunsec{sayCacheCount}{Describe the cache counts} +\calls{sayCacheCount}{bright} +\calls{sayCacheCount}{linearFormatName} +\calls{sayCacheCount}{sayBrightly} <>= (defun |sayCacheCount| (fn n) "Describe the cache counts" @@ -13165,6 +15063,12 @@ linker linker arguments (e.g. libraries to search) -lxlf @ \defunsec{setFortTmpDir}{The top level set fortran calling tempfile handler} +\calls{setFortTmpDir}{pname} +\calls{setFortTmpDir}{describeSetFortTmpDir} +\calls{setFortTmpDir}{validateOutputDirectory} +\calls{setFortTmpDir}{sayBrightly} +\calls{setFortTmpDir}{bright} +\usesdollar{setFortTmpDir}{fortranTmpDir} <>= (defun |setFortTmpDir| (arg) "The top level set fortran calling tempfile handler" @@ -13198,6 +15102,8 @@ linker linker arguments (e.g. libraries to search) -lxlf @ \defunsec{describeSetFortTmpDir}{Describe the set fortran calling tempfile} +\calls{describeSetFortTmpDir}{sayBrightly} +\usesdollar{describeSetFortTmpDir}{fortranTmpDir} <>= (defun |describeSetFortTmpDir| () "Describe the set fortran calling tempfile" @@ -13255,6 +15161,12 @@ linker linker arguments (e.g. libraries to search) -lxlf @ \defun{setFortDir}{setFortDir} +\calls{setFortDir}{pname} +\calls{setFortDir}{describeSetFortDir} +\calls{setFortDir}{validateOutputDirectory} +\calls{setFortDir}{sayBrightly} +\calls{setFortDir}{bright} +\usesdollar{setFortDir}{fortranDirectory} <>= (defun |setFortDir| (arg) (declare (special |$fortranDirectory|)) @@ -13276,6 +15188,8 @@ linker linker arguments (e.g. libraries to search) -lxlf @ \defun{describeSetFortDir}{describeSetFortDir} +\calls{describeSetFortDir}{sayBrightly} +\usesdollar{describeSetFortDir}{fortranDirectory} <>= (defun |describeSetFortDir| () (declare (special |$fortranDirectory|)) @@ -13333,6 +15247,9 @@ linker linker arguments (e.g. libraries to search) -lxlf @ \defun{setLinkerArgs}{setLinkerArgs} +\calls{setLinkerArgs}{object2String} +\calls{setLinkerArgs}{describeSetLinkerArgs} +\usesdollar{setLinkerArgs}{fortranLibraries} <>= (defun |setLinkerArgs| (arg) (declare (special |$fortranLibraries|)) @@ -13348,6 +15265,8 @@ linker linker arguments (e.g. libraries to search) -lxlf @ \defun{describeSetLinkerArgs}{describeSetLinkerArgs} +\calls{describeSetLinkerArgs}{sayBrightly} +\usesdollar{describeSetLinkerArgs}{fortranLibraries} <>= (defun |describeSetLinkerArgs| () (declare (special |$fortranLibraries|)) @@ -13418,6 +15337,9 @@ command: |htSetKernelWarn|) @ \defun{protectedSymbolsWarning}{protectedSymbolsWarning} +\calls{protectedSymbolsWarning}{protected-symbol-warn} +\calls{protectedSymbolsWarning}{describeProtectedSymbolsWarning} +\calls{protectedSymbolsWarning}{translateYesNo2TrueFalse} <>= (defun |protectedSymbolsWarning| (arg) (let (v) @@ -13434,6 +15356,7 @@ command: @ \defun{describeProtectedSymbolsWarning}{describeProtectedSymbolsWarning} +\calls{describeProtectedSymbolsWarning}{sayBrightly} <>= (defun |describeProtectedSymbolsWarning| () (|sayBrightly| (list @@ -13474,6 +15397,9 @@ command: @ \defun{protectSymbols}{protectSymbols} +\calls{protectSymbols}{protect-symbols} +\calls{protectSymbols}{describeProtectSymbols} +\calls{protectSymbols}{translateYesNo2TrueFalse} <>= (defun |protectSymbols| (arg) (let (v) @@ -13489,6 +15415,7 @@ command: @ \defun{describeProtectSymbols}{describeProtectSymbols} +\calls{describeProtectSymbols}{sayBrightly} <>= (defun |describeProtectSymbols| () (|sayBrightly| (list @@ -14435,6 +16362,9 @@ double enforce DOUBLE PRECISION ASPs on @ \defun{setNagHost}{setNagHost} +\calls{setNagHost}{object2String} +\calls{setNagHost}{describeSetNagHost} +\usesdollar{setNagHost}{nagHost} <>= (defun |setNagHost| (|arg|) (declare (special |$nagHost|)) @@ -14448,6 +16378,8 @@ double enforce DOUBLE PRECISION ASPs on @ \defun{describeSetNagHost}{describeSetNagHost} +\calls{describeSetNagHost}{sayBrightly} +\usesdollar{describeSetNagHost}{nagHost} <>= (defun |describeSetNagHost| () (declare (special |$nagHost|)) @@ -14496,6 +16428,12 @@ double enforce DOUBLE PRECISION ASPs on @ \defun{setFortPers}{setFortPers} +\calls{setFortPers}{describeFortPersistence} +\calls{setFortPers}{fixp} +\calls{setFortPers}{sayMessage} +\calls{setFortPers}{bright} +\calls{setFortPers}{terminateSystemCommand} +\usesdollar{setFortPers}{fortPersistence} <>= (defun |setFortPers| (arg) (let (n) @@ -14518,6 +16456,8 @@ double enforce DOUBLE PRECISION ASPs on @ \defun{describeFortPersistence}{describeFortPersistence} +\calls{describeFortPersistence}{sayBrightly} +\usesdollar{describeFortPersistence}{fortPersistence} <>= (defun |describeFortPersistence| () (declare (special |$fortPersistence|)) @@ -14727,10 +16667,30 @@ The current setting is: On:CONSOLE @ \defun{setOutputAlgebra}{setOutputAlgebra} +\calls{setOutputAlgebra}{defiostream} +\calls{setOutputAlgebra}{concat} +\calls{setOutputAlgebra}{describeSetOutputAlgebra} +\calls{setOutputAlgebra}{pairp} +\calls{setOutputAlgebra}{qcdr} +\calls{setOutputAlgebra}{qcar} +\calls{setOutputAlgebra}{member} +\calls{setOutputAlgebra}{upcase} +\calls{setOutputAlgebra}{sayKeyedMsg} +\calls{setOutputAlgebra}{shut} +\calls{setOutputAlgebra}{pathnameType} +\calls{setOutputAlgebra}{pathnameDirectory} +\calls{setOutputAlgebra}{pathnameName} +\callsdollar{setOutputAlgebra}{filep} +\calls{setOutputAlgebra}{make-outstream} +\calls{setOutputAlgebra}{object2String} +\usesdollar{setOutputAlgebra}{algebraOutputStream} +\usesdollar{setOutputAlgebra}{algebraOutputFile} +\usesdollar{setOutputAlgebra}{filep} +\usesdollar{setOutputAlgebra}{algebraFormat} <>= (defun |setOutputAlgebra| (arg) (let (label tmp1 tmp2 ptype fn ft fm filename teststream) - (declare (special |$algebraOutputStream| |$algebraOutputFile| + (declare (special |$algebraOutputStream| |$algebraOutputFile| $filep |$algebraFormat|)) (cond ((eq arg '|%initialize%|) @@ -14804,9 +16764,12 @@ The current setting is: On:CONSOLE (t (|sayKeyedMsg| 's2iv0005 nil) (|describeSetOutputAlgebra|))))))) + @ \defun{describeSetOutputAlgebra}{describeSetOutputAlgebra} +\calls{describeSetOutputAlgebra}{sayBrightly} +\calls{describeSetOutputAlgebra}{setOutputAlgebra} <>= (defun |describeSetOutputAlgebra| () (|sayBrightly| (list @@ -14882,6 +16845,22 @@ The current setting is: On:CONSOLE @ \defun{setOutputCharacters}{setOutputCharacters} +\calls{setOutputCharacters}{sayMessage} +\calls{setOutputCharacters}{bright} +\calls{setOutputCharacters}{sayBrightly} +\calls{setOutputCharacters}{concat} +\calls{setOutputCharacters}{pname} +\calls{setOutputCharacters}{specialChar} +\calls{setOutputCharacters}{sayAsManyPerLineAsPossible} +\calls{setOutputCharacters}{pairp} +\calls{setOutputCharacters}{qcdr} +\calls{setOutputCharacters}{qcar} +\calls{setOutputCharacters}{downcase} +\calls{setOutputCharacters}{setOutputCharacters} +\usesdollar{setOutputCharacters}{specialCharacters} +\usesdollar{setOutputCharacters}{plainRTspecialCharacters} +\usesdollar{setOutputCharacters}{RTspecialCharacters} +\usesdollar{setOutputCharacters}{specialCharacterAlist} <>= (defun |setOutputCharacters| (arg) (let (current char s l fn) @@ -14923,7 +16902,7 @@ The current setting is: On:CONSOLE (|sayAsManyPerLineAsPossible| (reverse l))) ((and (pairp arg) (eq (qcdr arg) NIL) - (progn (spadlet fn (qcar arg)) t) + (progn (setq fn (qcar arg)) t) (setq fn (downcase fn))) (cond ((eq fn '|default|) @@ -15001,10 +16980,30 @@ The current setting is: Off:CONSOLE @ \defun{setOutputFortran}{setOutputFortran} +\calls{setOutputFortran}{defiostream} +\calls{setOutputFortran}{concat} +\calls{setOutputFortran}{describeSetOutputFortran} +\calls{setOutputFortran}{upcase} +\calls{setOutputFortran}{pairp} +\calls{setOutputFortran}{qcdr} +\calls{setOutputFortran}{qcar} +\calls{setOutputFortran}{member} +\calls{setOutputFortran}{sayKeyedMsg} +\calls{setOutputFortran}{shut} +\calls{setOutputFortran}{pathnameType} +\calls{setOutputFortran}{pathnameDirectory} +\calls{setOutputFortran}{pathnameName} +\callsdollar{setOutputFortran}{filep} +\calls{setOutputFortran}{makeStream} +\calls{setOutputFortran}{object2String} +\usesdollar{setOutputFortran}{fortranOutputStream} +\usesdollar{setOutputFortran}{fortranOutputFile} +\usesdollar{setOutputFortran}{filep} +\usesdollar{setOutputFortran}{fortranFormat} <>= (defun |setOutputFortran| (arg) (let (label APPEND quiet tmp1 tmp2 ptype fn ft fm filename teststream) - (declare (special |$fortranOutputStream| |$fortranOutputFile| + (declare (special |$fortranOutputStream| |$fortranOutputFile| $filep |$fortranFormat|)) (cond ((eq arg '|%initialize%|) @@ -15092,6 +17091,8 @@ The current setting is: Off:CONSOLE @ \defun{describeSetOutputFortran}{describeSetOutputFortran} +\calls{describeSetOutputFortran}{sayBrightly} +\calls{describeSetOutputFortran}{setOutputFortran} <>= (defun |describeSetOutputFortran| () (|sayBrightly| (list @@ -15247,10 +17248,31 @@ The current setting is: Off:CONSOLE @ \defun{setOutputMathml}{setOutputMathml} +\calls{setOutputMathml}{defiostream} +\calls{setOutputMathml}{concat} +\calls{setOutputMathml}{describeSetOutputMathml} +\calls{setOutputMathml}{pairp} +\calls{setOutputMathml}{qcdr} +\calls{setOutputMathml}{qcar} +\calls{setOutputMathml}{member} +\calls{setOutputMathml}{upcase} +\calls{setOutputMathml}{sayKeyedMsg} +\calls{setOutputMathml}{shut} +\calls{setOutputMathml}{pathnameType} +\calls{setOutputMathml}{pathnameDirectory} +\calls{setOutputMathml}{pathnameName} +\callsdollar{setOutputMathml}{filep} +\calls{setOutputMathml}{make-outstream} +\calls{setOutputMathml}{object2String} +\usesdollar{setOutputMathml}{mathmlOutputStream} +\usesdollar{setOutputMathml}{mathmlOutputFile} +\usesdollar{setOutputMathml}{mathmlFormat} +\usesdollar{setOutputMathml}{filep} <>= (defun |setOutputMathml| (arg) (let (label tmp1 tmp2 ptype fn ft fm filename teststream) - (declare (special |$mathmlOutputStream| |$mathmlOutputFile| |$mathmlFormat|)) + (declare (special |$mathmlOutputStream| |$mathmlOutputFile| |$mathmlFormat| + $filep)) (cond ((eq arg '|%initialize%|) (setq |$mathmlOutputStream| @@ -15328,6 +17350,8 @@ The current setting is: Off:CONSOLE @ \defun{describeSetOutputMathml}{describeSetOutputMathml} +\calls{describeSetOutputMathml}{sayBrightly} +\calls{describeSetOutputMathml}{setOutputMathml} <>= (defun |describeSetOutputMathml| () (|sayBrightly| (LIST @@ -15427,10 +17451,30 @@ The current setting is: Off:CONSOLE @ \defun{setOutputOpenMath}{setOutputOpenMath} +\calls{setOutputOpenMath}{defiostream} +\calls{setOutputOpenMath}{concat} +\calls{setOutputOpenMath}{describeSetOutputOpenMath} +\calls{setOutputOpenMath}{pairp} +\calls{setOutputOpenMath}{qcdr} +\calls{setOutputOpenMath}{qcar} +\calls{setOutputOpenMath}{member} +\calls{setOutputOpenMath}{upcase} +\calls{setOutputOpenMath}{sayKeyedMsg} +\calls{setOutputOpenMath}{shut} +\calls{setOutputOpenMath}{pathnameType} +\calls{setOutputOpenMath}{pathnameDirectory} +\calls{setOutputOpenMath}{pathnameName} +\callsdollar{setOutputOpenMath}{filep} +\calls{setOutputOpenMath}{make-outstream} +\calls{setOutputOpenMath}{object2String} +\usesdollar{setOutputOpenMath}{openMathOutputStream} +\usesdollar{setOutputOpenMath}{openMathFormat} +\usesdollar{setOutputOpenMath}{filep} +\usesdollar{setOutputOpenMath}{openMathOutputFile} <>= (defun |setOutputOpenMath| (arg) (let (label tmp1 tmp2 ptype fn ft fm filename teststream) - (declare (special |$openMathOutputStream| |$openMathFormat| + (declare (special |$openMathOutputStream| |$openMathFormat| $filep |$openMathOutputFile|)) (cond ((eq arg '|%initialize%|) @@ -15507,6 +17551,8 @@ The current setting is: Off:CONSOLE @ \defun{describeSetOutputOpenMath}{describeSetOutputOpenMath} +\calls{describeSetOutputOpenMath}{sayBrightly} +\calls{describeSetOutputOpenMath}{setOutputOpenMath} <>= (defun |describeSetOutputOpenMath| () (|sayBrightly| (list @@ -15609,10 +17655,30 @@ The current setting is: Off:CONSOLE @ \defun{setOutputFormula}{setOutputFormula} +\calls{setOutputFormula}{defiostream} +\calls{setOutputFormula}{concat} +\calls{setOutputFormula}{describeSetOutputFormula} +\calls{setOutputFormula}{pairp} +\calls{setOutputFormula}{qcdr} +\calls{setOutputFormula}{qcar} +\calls{setOutputFormula}{member} +\calls{setOutputFormula}{upcase} +\calls{setOutputFormula}{sayKeyedMsg} +\calls{setOutputFormula}{shut} +\calls{setOutputFormula}{pathnameType} +\calls{setOutputFormula}{pathnameDirectory} +\calls{setOutputFormula}{pathnameName} +\callsdollar{setOutputFormula}{filep} +\calls{setOutputFormula}{make-outstream} +\calls{setOutputFormula}{object2String} +\usesdollar{setOutputFormula}{formulaOutputStream} +\usesdollar{setOutputFormula}{formulaOutputFile} +\usesdollar{setOutputFormula}{filep} +\usesdollar{setOutputFormula}{formulaFormat} <>= (defun |setOutputFormula| (arg) (let (label tmp1 tmp2 ptype fn ft fm filename teststream) - (declare (special |$formulaOutputStream| |$formulaOutputFile| + (declare (special |$formulaOutputStream| |$formulaOutputFile| $filep |$formulaFormat|)) (cond ((eq arg '|%initialize%|) @@ -15688,6 +17754,8 @@ The current setting is: Off:CONSOLE @ \defun{describeSetOutputFormula}{describeSetOutputFormula} +\calls{describeSetOutputFormula}{sayBrightly} +\calls{describeSetOutputFormula}{setOutputFormula} <>= (defun |describeSetOutputFormula| () (|sayBrightly| (list @@ -15847,10 +17915,30 @@ The current setting is: Off:CONSOLE @ \defun{setOutputTex}{setOutputTex} +\calls{setOutputTex}{defiostream} +\calls{setOutputTex}{concat} +\calls{setOutputTex}{describeSetOutputTex} +\calls{setOutputTex}{pairp} +\calls{setOutputTex}{qcdr} +\calls{setOutputTex}{qcar} +\calls{setOutputTex}{member} +\calls{setOutputTex}{upcase} +\calls{setOutputTex}{sayKeyedMsg} +\calls{setOutputTex}{shut} +\calls{setOutputTex}{pathnameType} +\calls{setOutputTex}{pathnameDirectory} +\calls{setOutputTex}{pathnameName} +\callsdollar{setOutputTex}{filep} +\calls{setOutputTex}{make-outstream} +\calls{setOutputTex}{object2String} +\usesdollar{setOutputTex}{texOutputStream} +\usesdollar{setOutputTex}{texOutputFile} +\usesdollar{setOutputTex}{texFormat} +\usesdollar{setOutputTex}{filep} <>= (defun |setOutputTex| (arg) (let (label tmp1 tmp2 ptype fn ft fm filename teststream) - (declare (special |$texOutputStream| |$texOutputFile| |$texFormat|)) + (declare (special |$texOutputStream| |$texOutputFile| |$texFormat| $filep)) (cond ((eq arg '|%initialize%|) (setq |$texOutputStream| @@ -15923,6 +18011,8 @@ The current setting is: Off:CONSOLE @ \defun{describeSetOutputTex}{describeSetOutputTex} +\calls{describeSetOutputTex}{sayBrightly} +\calls{describeSetOutputTex}{setOutputTex} <>= (defun |describeSetOutputTex| () (|sayBrightly| (list @@ -16040,6 +18130,14 @@ showall display all stream elements computed off @ \defun{setStreamsCalculate}{setStreamsCalculate} +\calls{setStreamsCalculate}{object2String} +\calls{setStreamsCalculate}{describeSetStreamsCalculate} +\calls{setStreamsCalculate}{nequal} +\calls{setStreamsCalculate}{fixp} +\calls{setStreamsCalculate}{sayMessage} +\calls{setStreamsCalculate}{bright} +\calls{setStreamsCalculate}{terminateSystemCommand} +\usesdollar{setStreamsCalculate}{streamCount} <>= (defun |setStreamsCalculate| (arg) (let (n) @@ -16062,6 +18160,8 @@ showall display all stream elements computed off @ \defun{describeSetStreamsCalculate}{describeSetStreamsCalculate} +\calls{describeSetStreamsCalculate}{sayKeyedMsg} +\usesdollar{describeSetStreamsCalculate}{streamCount} <>= (defun |describeSetStreamsCalculate| () (declare (special |$streamCount|)) @@ -16259,6 +18359,8 @@ prettyprint prettyprint BOOT func's as they compile off )) @ + +\defdollar{setOptionNames} <>= (defvar |$setOptionNames| (mapcar #'car |$setOptions|)) @@ -16273,6 +18375,8 @@ prettyprint prettyprint BOOT func's as they compile off \section{Set code} \defun{set}{set} +\calls{set}{set1} +\usesdollar{set}{setOptions} <>= (defun |set| (l) (declare (special |$setOptions|)) @@ -16303,6 +18407,30 @@ which, because ``message'' is a TREE, generates the recursive call: \end{verbatim} The ``autoload'' subtree is a FUNCTION (printLoadMessages), which gets called with \verb|%describe%| +\calls{set1}{displaySetVariableSettings} +\calls{set1}{seq} +\calls{set1}{exit} +\calls{set1}{selectOption} +\calls{set1}{downcase} +\calls{set1}{lassoc} +\calls{set1}{satisfiesUserLevel} +\calls{set1}{sayKeyedMsg} +\calls{set1}{poundsign} +\calls{set1}{displaySetOptionInformation} +\calls{set1}{kdr} +\calls{set1}{sayMSG} +\calls{set1}{fixp} +\calls{set1}{sayMessage} +\calls{set1}{bright} +\calls{set1}{object2String} +\calls{set1}{translateYesNo2TrueFalse} +\calls{set1}{use-fast-links} +\calls{set1}{literals} +\calls{set1}{tree} +\calls{set1}{set1} +\usesdollar{set1}{setOptionNames} +\usesdollar{set1}{UserLevel} +\usesdollar{set1}{displaySetValue} <>= (defun |set1| (l settree) (let (|$setOptionNames| arg setdata st setfunarg num upperlimit arg2) @@ -16326,7 +18454,7 @@ which gets called with \verb|%describe%| (t (setq st (fourth setdata)) (case (fourth setdata) - (FUNCTION + (function (setq setfunarg (if (eq (elt l 1) 'default) '|%initialize%| @@ -16338,7 +18466,7 @@ which gets called with \verb|%describe%| (when |$displaySetValue| (|displaySetOptionInformation| arg setdata)) NIL) - (STRING + (string (setq arg2 (elt l 1)) (cond ((eq arg2 'default) (set (fifth setdata) (seventh setdata))) @@ -16347,7 +18475,7 @@ which gets called with \verb|%describe%| (when (or |$displaySetValue| (null arg2)) (|displaySetOptionInformation| arg setdata)) NIL) - (INTEGER + (integer (setq arg2 (progn (setq num (elt l 1)) @@ -16374,7 +18502,7 @@ which gets called with \verb|%describe%| `(" Your value" ,@(|bright| (|object2String| (elt l 1))) "is not among the valid choices."))) (t nil))) - (LITERALS + (literals (cond ((setq arg2 (|selectOption| (elt l 1) @@ -16399,7 +18527,7 @@ which gets called with \verb|%describe%| (append (|bright| (|object2String| (elt l 1))) (cons "is not among the valid choices." nil))))) (t nil))) - (TREE (|set1| (kdr l) (sixth setdata)) nil) + (tree (|set1| (kdr l) (sixth setdata)) nil) (t (|sayMessage| `("Cannot handle set tree node type" ,@(|bright| st) |yet|)) @@ -16536,6 +18664,9 @@ o )cd @ \defun{summary}{summary} +\calls{summary}{obey} +\calls{summary}{concat} +\calls{summary}{getenviron} <>= (defun |summary| (l) (declare (ignore l)) @@ -16851,7 +18982,7 @@ The following are the general options for the )trace command. The following are the options for tracing constructors, domains and packages. - )local [op1 [... opN]] + )local [op1 [... opN] ] causes local functions of the constructor to be traced. Note that to untrace an individual local function, you must use the fully qualified internal name, using the escape character _ before the semicolon. @@ -16882,27 +19013,32 @@ o )ltrace \subsection{The trace global variables} This decides when to give trace and untrace messages. +\defdollar{traceNoisely} <>= (defvar |$traceNoisely| nil) @ +\defdollar{reportSpadTrace} This reports the traced functions <>= (defvar |$reportSpadTrace| nil) @ +\defdollar{optionAlist} <>= (defvar |$optionAlist| nil) @ +\defdollar{tracedMapSignatures} <>= (defvar |$tracedMapSignatures| nil) @ +\defdollar{traceOptionList} <>= (defvar |$traceOptionList| '(|after| |before| |break| |cond| |count| |depth| |local| |mathprint| @@ -16912,6 +19048,7 @@ This reports the traced functions @ \defun{trace}{trace} +\calls{trace}{traceSpad2Cmd} <>= (defun |trace| (l) (|traceSpad2Cmd| l)) @@ -16919,6 +19056,14 @@ This reports the traced functions @ \defun{traceSpad2Cmd}{traceSpad2Cmd} +\calls{traceSpad2Cmd}{pairp} +\calls{traceSpad2Cmd}{qcar} +\calls{traceSpad2Cmd}{qcdr} +\calls{traceSpad2Cmd}{getMapSubNames} +\calls{traceSpad2Cmd}{trace1} +\calls{traceSpad2Cmd}{augmentTraceNames} +\calls{traceSpad2Cmd}{traceReply} +\usesdollar{traceSpad2Cmd}{mapSubNameAlist} <>= (defun |traceSpad2Cmd| (l) (let (tmp1 l1) @@ -16941,6 +19086,44 @@ This reports the traced functions @ \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}{pairp} +\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} <>= (defun |trace1| (arg) (prog (|$traceNoisely| constructor ops lops temp1 opt a @@ -17090,6 +19273,13 @@ This reports the traced functions @ \defun{getTraceOptions}{getTraceOptions} +\calls{getTraceOptions}{throwKeyedMsg} +\calls{getTraceOptions}{throwListOfKeyedMsgs} +\calls{getTraceOptions}{poundsign} +\calls{getTraceOptions}{seq} +\calls{getTraceOptions}{exit} +\calls{getTraceOptions}{getTraceOption} +\usesdollar{getTraceOptions}{traceErrorStack} <>= (defun |getTraceOptions| (|options|) (prog (|$traceErrorStack| optionlist temp1 key |parms|) @@ -17124,6 +19314,11 @@ This reports the traced functions @ \defun{saveMapSig}{saveMapSig} +\calls{saveMapSig}{rassoc} +\calls{saveMapSig}{addassoc} +\calls{saveMapSig}{getMapSig} +\usesdollar{saveMapSig}{tracedMapSignatures} +\usesdollar{saveMapSig}{mapSubNameAlist} <>= (defun |saveMapSig| (funnames) (let (map) @@ -17136,6 +19331,9 @@ This reports the traced functions @ \defun{getMapSig}{getMapSig} +\calls{getMapSig}{get} +\calls{getMapSig}{boot-equal} +\usesdollar{getMapSig}{InteractiveFrame} <>= (defun |getMapSig| (mapname subname) (let (lmms sig) @@ -17149,6 +19347,11 @@ This reports the traced functions @ \defun{getTraceOption}{getTraceOption} +\calls{getTraceOption,hn}{seq} +\calls{getTraceOption,hn}{exit} +\calls{getTraceOption,hn}{isDomainOrPackage} +\calls{getTraceOption,hn}{stackTraceOptionError} +\calls{getTraceOption,hn}{domainToGenvar} <>= (defun |getTraceOption,hn| (x) (prog (g) @@ -17167,6 +19370,24 @@ This reports the traced functions @ +\calls{getTraceOption}{memq} +\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}{pairp} +\calls{getTraceOption}{qcdr} +\calls{getTraceOption}{qcar} +\calls{getTraceOption}{fixp} +\calls{getTraceOption}{getTraceOption,hn} +\calls{getTraceOption}{isListOfIdentifiersOrStrings} +\calls{getTraceOption}{isListOfIdentifiers} +\calls{getTraceOption}{throwKeyedMsg} +\usesdollar{getTraceOption}{traceOptionList} <>= (defun |getTraceOption| (arg) (prog (l |opts| key a |n|) @@ -17310,6 +19531,8 @@ This reports the traced functions @ \defun{traceOptionError}{traceOptionError} +\calls{traceOptionError}{stackTraceOptionError} +\calls{traceOptionError}{commandAmbiguityError} <>= (defun |traceOptionError| (opt keys) (if (null keys) @@ -17319,6 +19542,8 @@ This reports the traced functions @ \defun{resetTimers}{resetTimers} +\calls{resetTimers}{concat} +\uses{resetTimers}{/timerlist} <>= (defun |resetTimers| () (declare (special /timerlist)) @@ -17328,6 +19553,8 @@ This reports the traced functions @ \defun{resetSpacers}{resetSpacers} +\calls{resetSpacers}{concat} +\uses{resetSpacers}{/spacelist} <>= (defun |resetSpacers| () (declare (special /spacelist)) @@ -17336,6 +19563,8 @@ This reports the traced functions @ \defun{resetCounters}{resetCounters} +\calls{resetCounters}{concat} +\uses{resetCounters}{/countlist} <>= (defun |resetCounters| () (declare (special /countlist)) @@ -17345,6 +19574,12 @@ This reports the traced functions @ \defun{ptimers}{ptimers} +\calls{ptimers}{sayBrightly} +\calls{ptimers}{bright} +\calls{ptimers}{quotient} +\calls{ptimers}{concat} +\calls{ptimers}{float} +\uses{ptimers}{/timerlist} <>= (defun |ptimers| () (declare (special /timerlist |$timerTicksPerSecond|)) @@ -17359,6 +19594,10 @@ This reports the traced functions @ \defun{pspacers}{pspacers} +\calls{pspacers}{sayBrightly} +\calls{pspacers}{bright} +\calls{pspacers}{concat} +\uses{pspacers}{/spacelist} <>= (defun |pspacers| () (declare (special /spacelist)) @@ -17372,6 +19611,10 @@ This reports the traced functions @ \defun{pcounters}{pcounters} +\calls{pcounters}{sayBrightly} +\calls{pcounters}{bright} +\calls{pcounters}{concat} +\uses{pcounters}{/countlist} <>= (defun |pcounters| () (declare (special /countlist)) @@ -17385,6 +19628,14 @@ This reports the traced functions @ \defun{transOnlyOption}{transOnlyOption} +\calls{transOnlyOption}{fixp} +\calls{transOnlyOption}{transOnlyOption} +\calls{transOnlyOption}{memq} +\calls{transOnlyOption}{upcase} +\calls{transOnlyOption}{stackTraceOptionError} +\calls{transOnlyOption}{pairp} +\calls{transOnlyOption}{qcar} +\calls{transOnlyOption}{qcdr} <>= (defun |transOnlyOption| (arg) (let (y n) @@ -17399,6 +19650,7 @@ This reports the traced functions @ \defun{stackTraceOptionError}{stackTraceOptionError} +\usesdollar{stackTraceOptionError}{traceErrorStack} <>= (defun |stackTraceOptionError| (x) (declare (special |$traceErrorStack|)) @@ -17408,6 +19660,7 @@ This reports the traced functions @ \defun{removeOption}{removeOption} +\calls{removeOption}{nequal} <>= (defun |removeOption| (op options) (let (opt t0) @@ -17421,6 +19674,12 @@ This reports the traced functions @ \defun{domainToGenvar}{domainToGenvar} +\calls{domainToGenvar}{unabbrevAndLoad} +\calls{domainToGenvar}{getdatabase} +\calls{domainToGenvar}{opOf} +\calls{domainToGenvar}{genDomainTraceName} +\calls{domainToGenvar}{evalDomain} +\usesdollar{domainToGenvar}{doNotAddEmptyModeIfTrue} <>= (defun |domainToGenvar| (arg) (let (|$doNotAddEmptyModeIfTrue| y g) @@ -17436,6 +19695,9 @@ This reports the traced functions @ \defun{genDomainTraceName}{genDomainTraceName} +\calls{genDomainTraceName}{lassoc} +\calls{genDomainTraceName}{genvar} +\usesdollar{genDomainTraceName}{domainTraceNameAssoc} <>= (defun |genDomainTraceName| (y) (let (u g) @@ -17450,6 +19712,14 @@ This reports the traced functions @ \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} <>= (defun |untrace| (arg) (let (untracelist) @@ -17472,6 +19742,19 @@ This reports the traced functions @ \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}{pairp} +\calls{transTraceItem}{vecp} +\calls{transTraceItem}{transTraceItem} +\calls{transTraceItem}{devaluate} +\calls{transTraceItem}{throwKeyedMsg} +\usesdollar{transTraceItem}{doNotAddEmptyModeIfTrue} <>= (defun |transTraceItem| (x) (prog (|$doNotAddEmptyModeIfTrue| |value| y) @@ -17504,6 +19787,7 @@ This reports the traced functions @ \defun{removeTracedMapSigs}{removeTracedMapSigs} +\usesdollar{removeTracedMapSigs}{tracedMapSignatures} <>= (defun |removeTracedMapSigs| (untraceList) (declare (special |$tracedMapSignatures|)) @@ -17513,6 +19797,16 @@ This reports the traced functions @ \defun{coerceTraceArgs2E}{coerceTraceArgs2E} +\calls{coerceTraceArgs2E}{memq} +\calls{coerceTraceArgs2E}{spadsysnamep} +\calls{coerceTraceArgs2E}{pname} +\calls{coerceTraceArgs2E}{coerceSpadArgs2E} +\calls{coerceTraceArgs2E}{objValUnwrap} +\calls{coerceTraceArgs2E}{coerceInteractive} +\calls{coerceTraceArgs2E}{objNewWrap} +\usesdollar{coerceTraceArgs2E}{OutputForm} +\usesdollar{coerceTraceArgs2E}{mathTraceList} +\usesdollar{coerceTraceArgs2E}{tracedMapSignatures} <>= (defun |coerceTraceArgs2E| (tracename subname args) (declare (ignore tracename)) @@ -17550,6 +19844,14 @@ This reports the traced functions @ \defun{coerceSpadArgs2E}{coerceSpadArgs2E} +\calls{coerceSpadArgs2E}{seq} +\calls{coerceSpadArgs2E}{exit} +\calls{coerceSpadArgs2E}{objValUnwrap} +\calls{coerceSpadArgs2E}{coerceInteractive} +\calls{coerceSpadArgs2E}{objNewWrap} +\usesdollar{coerceSpadArgs2E}{streamCount} +\usesdollar{coerceSpadArgs2E}{OutputForm} +\usesdollar{coerceSpadArgs2E}{tracedSpadModemap} <>= (defun |coerceSpadArgs2E| (args) (let ((|$streamCount| 0)) @@ -17585,6 +19887,10 @@ This reports the traced functions @ \defun{subTypes}{subTypes} +\calls{subTypes}{lassoc} +\calls{subTypes}{seq} +\calls{subTypes}{exit} +\calls{subTypes}{subTypes} <>= (defun |subTypes| (|mm| |sublist|) (prog (s) @@ -17606,6 +19912,17 @@ This reports the traced functions @ \defun{coerceTraceFunValue2E}{coerceTraceFunValue2E} +\calls{coerceTraceFunValue2E}{spadsysnamep} +\calls{coerceTraceFunValue2E}{pname} +\calls{coerceTraceFunValue2E}{coerceSpadFunValue2E} +\calls{coerceTraceFunValue2E}{lassoc} +\calls{coerceTraceFunValue2E}{objValUnwrap} +\calls{coerceTraceFunValue2E}{coerceInteractive} +\calls{coerceTraceFunValue2E}{objNewWrap} +\calls{coerceTraceFunValue2E}{memq} +\usesdollar{coerceTraceFunValue2E}{tracedMapSignatures} +\usesdollar{coerceTraceFunValue2E}{OutputForm} +\usesdollar{coerceTraceFunValue2E}{mathTraceList} <>= (defun |coerceTraceFunValue2E| (tracename subname |value|) (let (name u) @@ -17622,6 +19939,12 @@ This reports the traced functions @ \defun{coerceSpadFunValue2E}{coerceSpadFunValue2E} +\calls{coerceSpadFunValue2E}{objValUnwrap} +\calls{coerceSpadFunValue2E}{coerceInteractive} +\calls{coerceSpadFunValue2E}{objNewWrap} +\usesdollar{coerceSpadFunValue2E}{streamCount} +\usesdollar{coerceSpadFunValue2E}{tracedSpadModemap} +\usesdollar{coerceSpadFunValue2E}{OutputForm} <>= (defun |coerceSpadFunValue2E| (|value|) (let (|$streamCount|) @@ -17635,6 +19958,9 @@ This reports the traced functions @ \defun{isListOfIdentifiers}{isListOfIdentifiers} +\calls{isListOfIdentifiers}{seq} +\calls{isListOfIdentifiers}{exit} +\calls{isListOfIdentifiers}{identp} <>= (defun |isListOfIdentifiers| (arg) (prog () @@ -17652,6 +19978,9 @@ This reports the traced functions @ \defun{isListOfIdentifiersOrStrings}{isListOfIdentifiersOrStrings} +\calls{isListOfIdentifiersOrStrings}{seq} +\calls{isListOfIdentifiersOrStrings}{exit} +\calls{isListOfIdentifiersOrStrings}{identp} <>= (defun |isListOfIdentifiersOrStrings| (arg) (prog () @@ -17669,6 +19998,13 @@ This reports the traced functions @ \defun{getMapSubNames}{getMapSubNames} +\calls{getMapSubNames}{get} +\calls{getMapSubNames}{union} +\calls{getMapSubNames}{getPreviousMapSubNames} +\calls{getMapSubNames}{unionq} +\usesdollar{getMapSubNames}{lastUntraced} +\usesdollar{getMapSubNames}{InteractiveFrame} +\uses{getMapSubNames}{/tracenames} <>= (defun |getMapSubNames| (arg) (let (lmm subs) @@ -17689,6 +20025,10 @@ This reports the traced functions @ \defun{getPreviousMapSubNames}{getPreviousMapSubNames} +\calls{getPreviousMapSubNames}{get} +\calls{getPreviousMapSubNames}{memq} +\calls{getPreviousMapSubNames}{exit} +\calls{getPreviousMapSubNames}{seq} <>= (defun |getPreviousMapSubNames| (|traceNames|) (prog (lmm subs) @@ -17720,6 +20060,7 @@ This reports the traced functions @ \defun{lassocSub}{lassocSub} +\calls{lassocSub}{lassq} <>= (defun |lassocSub| (x subs) (let (y) @@ -17730,6 +20071,7 @@ This reports the traced functions @ \defun{rassocSub}{rassocSub} +\calls{rassocSub}{rassoc} <>= (defun |rassocSub| (x subs) (let (y) @@ -17740,6 +20082,8 @@ This reports the traced functions @ \defun{isUncompiledMap}{isUncompiledMap} +\calls{isUncompiledMap}{get} +\usesdollar{isUncompiledMap}{InteractiveFrame} <>= (defun |isUncompiledMap| (x) (let (y) @@ -17752,6 +20096,8 @@ This reports the traced functions @ \defun{isInterpOnlyMap}{isInterpOnlyMap} +\calls{isInterpOnlyMap}{get} +\usesdollar{isInterpOnlyMap}{InteractiveFrame} <>= (defun |isInterpOnlyMap| (map) (let (x) @@ -17762,6 +20108,8 @@ This reports the traced functions @ \defun{augmentTraceNames}{augmentTraceNames} +\calls{augmentTraceNames}{get} +\usesdollar{augmentTraceNames}{InteractiveFrame} <>= (defun |augmentTraceNames| (arg) (let (mml res) @@ -17785,6 +20133,11 @@ This reports the traced functions @ \defun{isSubForRedundantMapName}{isSubForRedundantMapName} +\calls{isSubForRedundantMapName}{rassocSub} +\calls{isSubForRedundantMapName}{member} +\calls{isSubForRedundantMapName}{memq} +\calls{isSubForRedundantMapName}{assocleft} +\usesdollar{isSubForRedundantMapName}{mapSubNameAlist} <>= (defun |isSubForRedundantMapName| (subname) (let (mapname tail) @@ -17796,6 +20149,13 @@ This reports the traced functions @ \defun{untraceMapSubNames}{untraceMapSubNames} +\calls{untraceMapSubNames}{assocright} +\calls{untraceMapSubNames}{memq} +\calls{untraceMapSubNames}{/untrace,2} +\calls{untraceMapSubNames}{setdifference} +\calls{untraceMapSubNames}{getPreviousMapSubNames} +\usesdollar{untraceMapSubNames}{mapSubNameAlist} +\usesdollar{untraceMapSubNames}{lastUntraced} <>= (defun |untraceMapSubNames| (|traceNames|) (let (|$mapSubNameAlist| subs) @@ -17811,6 +20171,11 @@ This reports the traced functions @ \defun{funfind,LAM}{funfind,LAM} +\calls{funfind,LAM}{pairp} +\calls{funfind,LAM}{qcar} +\calls{funfind,LAM}{SEQ} +\calls{funfind,LAM}{isFunctor} +\calls{funfind,LAM}{exit} <>= (defun |funfind,LAM| (functor opname) (prog (ops tmp1) @@ -17844,6 +20209,10 @@ This reports the traced functions @ \defun{isDomainOrPackage}{isDomainOrPackage} +\calls{isDomainOrPackage}{refvecp} +\calls{isDomainOrPackage}{poundsign} +\calls{isDomainOrPackage}{isFunctor} +\calls{isDomainOrPackage}{opOf} <>= (defun |isDomainOrPackage| (dom) (and @@ -17854,6 +20223,7 @@ This reports the traced functions @ \defun{isTraceGensym}{isTraceGensym} +\calls{isTraceGensym}{gensymp} <>= (defun |isTraceGensym| (x) (gensymp x)) @@ -17868,6 +20238,11 @@ This reports the traced functions @ \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} <>= (defun |spadTrace,isTraceable| (x |domain|) (prog (n |functionSlot|) @@ -17891,6 +20266,41 @@ This reports the traced functions @ \defun{spadTrace}{spadTrace} +\calls{spadTrace}{pairp} +\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}{memq} +\calls{spadTrace}{fixp} +\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} <>= (defun |spadTrace| (domain options) (let (|$tracedModemap| listofoperations listofvariables @@ -18037,6 +20447,7 @@ This reports the traced functions @ \defun{traceDomainLocalOps}{traceDomainLocalOps} +\calls{traceDomainLocalOps}{sayMSG} <>= (defun |traceDomainLocalOps| () (|sayMSG| '(" The )local option has been withdrawn")) @@ -18045,6 +20456,7 @@ This reports the traced functions @ \defun{untraceDomainLocalOps}{untraceDomainLocalOps} +\calls{untraceDomainLocalOps}{sayMSG} <>= (defun |untraceDomainLocalOps| () (|sayMSG| '(" The )local option has been withdrawn")) @@ -18053,6 +20465,16 @@ This reports the traced functions @ \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} <>= (defun |traceDomainConstructor| (|domainConstructor| options) (prog (|listOfLocalOps| |argl| |domain| |innerDomainConstructor|) @@ -18110,6 +20532,15 @@ This reports the traced functions @ \defun{untraceDomainConstructor}{untraceDomainConstructor} +\calls{untraceDomainConstructor,keepTraced?}{seq} +\calls{untraceDomainConstructor,keepTraced?}{pairp} +\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} <>= (defun |untraceDomainConstructor,keepTraced?| (df |domainConstructor|) (prog (dc) @@ -18125,6 +20556,14 @@ This reports the traced functions @ +\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} <>= (defun |untraceDomainConstructor| (|domainConstructor|) (prog (|innerDomainConstructor|) @@ -18153,6 +20592,8 @@ This reports the traced functions @ \defun{flattenOperationAlist}{flattenOperationAlist} +\calls{flattenOperationAlist}{seq} +\calls{flattenOperationAlist}{exit} <>= (defun |flattenOperationAlist| (|opAlist|) (prog (op |mmList| |res|) @@ -18185,6 +20626,9 @@ This reports the traced functions @ \defun{mapLetPrint}{mapLetPrint} +\calls{mapLetPrint}{getAliasIfTracedMapParameter} +\calls{mapLetPrint}{getBpiNameIfTracedMap} +\calls{mapLetPrint}{letPrint} <>= (defun |mapLetPrint| (x val currentFunction) (setq x (|getAliasIfTracedMapParameter| x currentFunction)) @@ -18194,6 +20638,18 @@ This reports the traced functions @ \defun{letPrint}{letPrint} +\calls{letPrint}{lassoc} +\calls{letPrint}{memq} +\calls{letPrint}{isgenvar} +\calls{letPrint}{isSharpVarWithNum} +\calls{letPrint}{gensymp} +\calls{letPrint}{sayBrightlyNT} +\calls{letPrint}{bright} +\calls{letPrint}{shortenForPrinting} +\calls{letPrint}{hasPair} +\calls{letPrint}{pname} +\calls{letPrint}{break} +\usesdollar{letPrint}{letAssoc} <>= (defun |letPrint| (x |val| |currentFunction|) (prog (y) @@ -18208,7 +20664,7 @@ This reports the traced functions ((and (or (eq y '|all|) (memq x y)) (null - (or (is_genvar x) (|isSharpVarWithNum| x) (gensymp x)))) + (or (isgenvar x) (|isSharpVarWithNum| x) (gensymp x)))) (|sayBrightlyNT| (append (|bright| x) (cons '|: | nil))) (prin1 (|shortenForPrinting| |val|)) (terpri))) @@ -18230,11 +20686,37 @@ This reports the traced functions @ +\defun{isgenvar}{isgenvar} +\calls{isgenvar}{size} +\calls{isgenvar}{digitp} +\calls{isgenvar}{identp} +<>= +(defun isgenvar (x) + (and (identp x) + (let ((y (symbol-name x))) + (and (char= #\$ (elt y 0)) (> (size y) 1) (digitp (elt y 1)))))) + +@ + + \defun{letPrint2}{letPrint2} +\calls{letPrint2}{lassoc} +\calls{letPrint2}{memq} +\calls{letPrint2}{isgenvar} +\calls{letPrint2}{isSharpVarWithNum} +\calls{letPrint2}{gensymp} +\calls{letPrint2}{mathprint} +\calls{letPrint2}{print} +\calls{letPrint2}{hasPair} +\calls{letPrint2}{pname} +\calls{letPrint2}{break} +\calls{letPrint2}{bright} +\usesdollar{letPrint2}{BreakMode} +\usesdollar{letPrint2}{letAssoc} <>= (defun |letPrint2| (x |printform| |currentFunction|) (prog (|$BreakMode| |flag| y) - (declare (special |$BreakMode| |$letAssoc| )) + (declare (special |$BreakMode| |$letAssoc|)) (return (progn (setq |$BreakMode| nil) @@ -18245,7 +20727,7 @@ This reports the traced functions (cond ((and (or (eq y '|all|) (memq x y)) - (null (or (is_genvar x) (|isSharpVarWithNum| x) (gensymp x)))) + (null (or (isgenvar x) (|isSharpVarWithNum| x) (gensymp x)))) (setq |$BreakMode| '|letPrint2|) (setq |flag| nil) (catch '|letPrint2| @@ -18274,10 +20756,24 @@ This reports the traced functions \defun{letPrint3}{letPrint3} This is the version for use when we have our hands on a function to convert the data into type "Expression" +\calls{letPrint3}{lassoc} +\calls{letPrint3}{memq} +\calls{letPrint3}{isgenvar} +\calls{letPrint3}{isSharpVarWithNum} +\calls{letPrint3}{gensymp} +\calls{letPrint3}{mathprint} +\calls{letPrint3}{spadcall} +\calls{letPrint3}{print} +\calls{letPrint3}{hasPair} +\calls{letPrint3}{pname} +\calls{letPrint3}{break} +\calls{letPrint3}{bright} +\usesdollar{letPrint3}{BreakMode} +\usesdollar{letPrint3}{letAssoc} <>= (defun |letPrint3| (x |xval| |printfn| |currentFunction|) (prog (|$BreakMode| |flag| y) - (declare (special |$BreakMode| |$letAssoc| )) + (declare (special |$BreakMode| |$letAssoc|)) (return (progn (setq |$BreakMode| nil) @@ -18288,7 +20784,7 @@ to convert the data into type "Expression" (cond ((and (or (eq y '|all|) (memq x y)) - (null (or (is_genvar x) (|isSharpVarWithNum| x) (gensymp x)))) + (null (or (isgenvar x) (|isSharpVarWithNum| x) (gensymp x)))) (setq |$BreakMode| '|letPrint2|) (setq |flag| nil) (catch '|letPrint2| @@ -18317,6 +20813,15 @@ to convert the data into type "Expression" @ \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} <>= (defun |getAliasIfTracedMapParameter| (x |currentFunction|) (prog (|aliasList|) @@ -18337,22 +20842,32 @@ to convert the data into type "Expression" @ \defun{getBpiNameIfTracedMap}{getBpiNameIfTracedMap} +\calls{getBpiNameIfTracedMap}{get} +\calls{getBpiNameIfTracedMap}{memq} +\calls{getBpiNameIfTracedMap}{exit} +\calls{getBpiNameIfTracedMap}{seq} +\usesdollar{getBpiNameIfTracedMap}{InteractiveFrame} +\uses{getBpiNameIfTracedMap}{/tracenames} <>= (defun |getBpiNameIfTracedMap| (name) - (prog (lmm |bpiName|) + (prog (lmm bpiName) (declare (special |$InteractiveFrame| /tracenames)) (return (seq (cond ((setq lmm (|get| name '|localModemap| |$InteractiveFrame|)) (cond - ((memq (setq |bpiName| (cadar lmm)) /tracenames) - (exit |bpiName|)))) + ((memq (setq bpiName (cadar lmm)) /tracenames) + (exit bpiName)))) (t name)))))) @ \defun{hasPair}{hasPair} +\calls{hasPair}{pairp} +\calls{hasPair}{qcar} +\calls{hasPair}{qcdr} +\calls{hasPair}{hasPair} <>= (defun |hasPair| (key arg) (prog (tmp1 a) @@ -18371,6 +20886,8 @@ to convert the data into type "Expression" @ \defun{shortenForPrinting}{shortenForPrinting} +\calls{shortenForPrinting}{isDomainOrPackage} +\calls{shortenForPrinting}{devaluate} <>= (defun |shortenForPrinting| (|val|) (if (|isDomainOrPackage| |val|) @@ -18380,6 +20897,7 @@ to convert the data into type "Expression" @ \defun{spadTraceAlias}{spadTraceAlias} +\calls{spadTraceAlias}{internl} <>= (defun |spadTraceAlias| (domainid op n) (internl domainid (intern "." "boot") op '|,| (princ-to-string n))) @@ -18387,6 +20905,7 @@ to convert the data into type "Expression" @ \defun{getOption}{getOption} +\calls{getOption}{assoc} <>= (defun |getOption| (opt l) (let (y) @@ -18395,6 +20914,10 @@ to convert the data into type "Expression" @ \defun{reportSpadTrace}{reportSpadTrace} +\calls{reportSpadTrace}{pairp} +\calls{reportSpadTrace}{qcar} +\calls{reportSpadTrace}{sayBrightly} +\usesdollar{reportSpadTrace}{traceNoisely} <>= (defun |reportSpadTrace| (|header| t0) (prog (op sig n |t| |msg| |namePart| y |tracePart|) @@ -18433,6 +20956,10 @@ to convert the data into type "Expression" @ \defun{orderBySlotNumber}{orderBySlotNumber} +\calls{orderBySlotNumber}{seq} +\calls{orderBySlotNumber}{assocright} +\calls{orderBySlotNumber}{orderList} +\calls{orderBySlotNumber}{exit} <>= (defun |orderBySlotNumber| (arg) (prog (n) @@ -18455,6 +20982,13 @@ to convert the data into type "Expression" @ \defun{/tracereply}{/tracereply} +\calls{/tracereply}{pairp} +\calls{/tracereply}{qcar} +\calls{/tracereply}{isDomainOrPackage} +\calls{/tracereply}{devaluate} +\calls{/tracereply}{seq} +\calls{/tracereply}{exit} +\uses{/tracereply}{/tracenames} <>= (defun /tracereply () (prog (|d| domainlist |functionList|) @@ -18480,7 +21014,13 @@ to convert the data into type "Expression" @ -\defun{spadReply}{spadReply} +\defun{spadReply,printName}{spadReply,printName} +\calls{spadReply,printName}{seq} +\calls{spadReply,printName}{pairp} +\calls{spadReply,printName}{qcar} +\calls{spadReply,printName}{isDomainOrPackage} +\calls{spadReply,printName}{exit} +\calls{spadReply,printName}{devaluate} <>= (defun |spadReply,printName| (x) (prog (|d|) @@ -18493,6 +21033,11 @@ to convert the data into type "Expression" @ +\defun{spadReply}{spadReply} +\calls{spadReply}{seq} +\calls{spadReply}{exit} +\calls{spadReply}{spadReply,printName} +\uses{spadReply}{/tracenames} <>= (defun |spadReply| () (prog () @@ -18511,6 +21056,26 @@ to convert the data into type "Expression" @ \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}{memq} +\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} <>= (defun |spadUntrace| (|domain| options) (prog (anyiftrue listofoperations domainid |pair| sigslotnumberalist @@ -18584,6 +21149,13 @@ to convert the data into type "Expression" @ \defun{prTraceNames,fn}{prTraceNames,fn} +\calls{prTraceNames,fn}{seq} +\calls{prTraceNames,fn}{pairp} +\calls{prTraceNames,fn}{qcar} +\calls{prTraceNames,fn}{qcdr} +\calls{prTraceNames,fn}{isDomainOrPackage} +\calls{prTraceNames,fn}{exit} +\calls{prTraceNames,fn}{devaluate} <>= (defun |prTraceNames,fn| (x) (prog (|d| |t|) @@ -18598,6 +21170,10 @@ to convert the data into type "Expression" @ \defun{prTraceNames}{prTraceNames} +\calls{prTraceNames}{seq} +\calls{prTraceNames}{exit} +\calls{prTraceNames}{prTraceNames,fn} +\uses{prTraceNames}{/tracenames} <>= (defun |prTraceNames| () (declare (special /tracenames)) @@ -18612,6 +21188,32 @@ to convert the data into type "Expression" @ \defun{traceReply}{traceReply} +\calls{traceReply}{sayMessage} +\calls{traceReply}{sayBrightly} +\calls{traceReply}{pairp} +\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}{plus} +\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} <>= (defun |traceReply| () (prog (|$domains| |$packages| |$constructors| |d| |functionList| @@ -18639,7 +21241,7 @@ to convert the data into type "Expression" ((atom x) (cond ((|isFunctor| x) (|addTraceItem| x)) - ((is_genvar x) (|addTraceItem| (EVAL x))) + ((isgenvar x) (|addTraceItem| (EVAL x))) (t (setq |functionList| (cons x |functionList|))))) (t (|userError| "bad argument to trace")))))) (setq |functionList| @@ -18727,6 +21329,13 @@ to convert the data into type "Expression" @ \defun{addTraceItem}{addTraceItem} +\calls{addTraceItem}{constructor?} +\calls{addTraceItem}{isDomain} +\calls{addTraceItem}{devaluate} +\calls{addTraceItem}{isDomainOrPackage} +\usesdollar{addTraceItem}{constructors} +\usesdollar{addTraceItem}{domains} +\usesdollar{addTraceItem}{packages} <>= (defun |addTraceItem| (|d|) (declare (special |$constructors| |$domains| |$packages|)) @@ -18741,6 +21350,23 @@ to convert the data into type "Expression" @ \defun{?t}{?t} +\calls{?t}{isgenvar} +\calls{?t}{get} +\calls{?t}{sayMSG} +\calls{?t}{bright} +\calls{?t}{rassocSub} +\calls{?t}{pairp} +\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} <>= (defun |?t| () (let (llm d suffix l) @@ -18750,7 +21376,7 @@ to convert the data into type "Expression" (progn (dolist (x /tracenames) (cond - ((and (atom x) (null (is_genvar x))) + ((and (atom x) (null (isgenvar x))) (progn (cond ((setq llm (|get| x '|localModemap| |$InteractiveFrame|)) @@ -18773,11 +21399,25 @@ to convert the data into type "Expression" @ \defun{tracelet}{tracelet} +\calls{tracelet}{gensymp} +\calls{tracelet}{stupidIsSpadFunction} +\calls{tracelet}{bpiname} +\calls{tracelet}{lassoc} +\calls{tracelet}{union} +\calls{tracelet}{setletprintflag} +\calls{tracelet}{memq} +\calls{tracelet}{isgenvar} +\calls{tracelet}{compileBoot} +\calls{tracelet}{delete} +\usesdollar{tracelet}{traceletflag} +\usesdollar{tracelet}{QuickLet} +\usesdollar{tracelet}{letAssoc} +\usesdollar{tracelet}{traceletFunctions} <>= (defun |tracelet| (fn |vars|) (prog ($traceletflag |$QuickLet| l) (declare (special $traceletflag |$QuickLet| |$letAssoc| - |$traceletFunctions|)) + |$traceletFunctions|)) (return (progn (cond @@ -18800,7 +21440,7 @@ to convert the data into type "Expression" (setq |$QuickLet| nil) (cond ((and (null (memq fn |$traceletFunctions|)) - (null (is_genvar fn)) + (null (isgenvar fn)) (compiled-function-p (symbol-function fn)) (null (|stupidIsSpadFunction| fn)) (null (gensymp fn))) @@ -18812,6 +21452,19 @@ to convert the data into type "Expression" @ \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}{memq} +\calls{breaklet}{compileBoot} +\calls{breaklet}{delete} +\usesdollar{breaklet}{QuickLet} +\usesdollar{breaklet}{letAssoc} +\usesdollar{breaklet}{traceletFunctions} <>= (defun |breaklet| (fn |vars|) (prog (|$QuickLet| |fnEntry| |pair|) @@ -18852,6 +21505,8 @@ to convert the data into type "Expression" @ \defun{stupidIsSpadFunction}{stupidIsSpadFunction} +\calls{stupidIsSpadFunction}{strpos} +\calls{stupidIsSpadFunction}{pname} <>= (defun |stupidIsSpadFunction| (fn) (strpos ";" (pname fn) 0 nil)) @@ -18859,6 +21514,11 @@ to convert the data into type "Expression" @ \defun{break}{break} +\calls{break}{MONITOR,EVALTRAN} +\calls{break}{enable-backtrace} +\calls{break}{sayBrightly} +\calls{break}{interrupt} +\uses{break}{/breakcondition} <>= (defun |break| (msg) (prog (condition) @@ -18873,6 +21533,7 @@ to convert the data into type "Expression" @ \defun{compileBoot}{compileBoot} +\calls{compileBoot}{/D,1} <>= (defun |compileBoot| (fn) (|/D,1| (list fn) '(/comp) nil nil)) @@ -18975,13 +21636,45 @@ $undoFlag := true --Default setting for undo is "on" $frameRecord := nil --Initial setting for frame record $previousBindings := nil \end{verbatim} + +\defdollar{undoFlag} <>= (defvar |$undoFlag| t "t means we record undo information") + +@ + +\defdollar{frameRecord} +<>= (defvar |$frameRecord| nil "a list of value changes") + +@ + +\defdollar{previousBindings} +<>= (defvar |$previousBindings| nil "a copy of Interactive Frame info for undo") + +@ + +\defdollar{reportUndo} +<>= (defvar |$reportUndo| nil "t means we report the steps undo takes") + @ \defun{undo}{undo} +\calls{undo}{stringPrefix?} +\calls{undo}{pname} +\calls{undo}{read} +\calls{undo}{userError} +\calls{undo}{pairp} +\calls{undo}{qcdr} +\calls{undo}{qcar} +\calls{undo}{spaddifference} +\calls{undo}{identp} +\calls{undo}{fixp} +\calls{undo}{undoSteps} +\calls{undo}{undoCount} +\usesdollar{undo}{options} +\usesdollar{undo}{InteractiveFrame} <>= (defun |undo| (l) (let (tmp1 key s undoWhen n) @@ -19015,6 +21708,14 @@ $previousBindings := nil @ \defun{recordFrame}{recordFrame} +\calls{recordFrame}{kar} +\calls{recordFrame}{diffAlist} +\calls{recordFrame}{seq} +\calls{recordFrame}{exit} +\usesdollar{recordFrame}{undoFlag} +\usesdollar{recordFrame}{frameRecord} +\usesdollar{recordFrame}{InteractiveFrame} +\usesdollar{recordFrame}{previousBindings} <>= (defun |recordFrame| (systemNormal) (prog (currentAlist delta) @@ -19078,15 +21779,15 @@ diffAlist(new,old) == oldPair := ASSQ(name,old) => null (oldProplist := CDR oldPair) => --record old values of new properties as NIL - acc := [[name,:[[prop] for [prop,:.] in proplist]],:acc] + acc := [ [name,:[ [prop] for [prop,:.] in proplist] ],:acc] deltas := nil for (propval := [prop,:val]) in proplist repeat null (oldPropval := ASSOC(prop,oldProplist)) => --missing property - deltas := [[prop],:deltas] + deltas := [ [prop],:deltas] EQ(CDR oldPropval,val) => 'skip deltas := [oldPropval,:deltas] - deltas => acc := [[name,:NREVERSE deltas],:acc] - acc := [[name,:[[prop] for [prop,:.] in proplist]],:acc] + deltas => acc := [ [name,:NREVERSE deltas],:acc] + acc := [ [name,:[ [prop] for [prop,:.] in proplist] ],:acc] --record properties absent on new list (say, from a )cl all) for (oldPair := [name,:r]) in old repeat r and null LASSQ(name,new) => @@ -19101,6 +21802,13 @@ diffAlist(new,old) == if BOUNDP '$reportUndo and $reportUndo then reportUndo res res \end{verbatim} +\calls{diffAlist}{assq} +\calls{diffAlist}{tmp1} +\calls{diffAlist}{seq} +\calls{diffAlist}{exit} +\calls{diffAlist}{assoc} +\calls{diffAlist}{lassq} +\calls{diffAlist}{reportUndo} <>= (defun |diffAlist| (new old) (prog (proplist oldPair oldProplist val oldPropval deltas prop name r acc res) @@ -19225,6 +21933,15 @@ Properties of r :: \end{verbatim} +\calls{reportUndo}{seq} +\calls{reportUndo}{exit} +\calls{reportUndo}{sayBrightly} +\calls{reportUndo}{concat} +\calls{reportUndo}{pname} +\calls{reportUndo}{lassoc} +\calls{reportUndo}{sayBrightlyNT} +\calls{reportUndo}{pp} +\usesdollar{reportUndo}{InteractiveFrame} <>= (defun |reportUndo| (acc) (prog (name proplist curproplist prop value) @@ -19269,6 +21986,9 @@ Properties of r :: @ \defun{clearFrame}{clearFrame} +\calls{clearFrame}{clearCmdAll} +\usesdollar{clearFrame}{frameRecord} +\usesdollar{clearFrame}{previousBindings} <>= (defun |clearFrame| () (declare (special |$frameRecord| |$previousBindings|)) @@ -19278,6 +21998,10 @@ Properties of r :: @ \defunsec{undoCount}{Undo previous n commands} +\calls{undoCount}{spaddifference} +\calls{undoCount}{userError} +\calls{undoCount}{concat} +\usesdollar{undoCount}{IOindex} <>= (defun |undoCount| (n) "Undo previous n commands" @@ -19314,6 +22038,17 @@ Properties of r :: -- An "undo 3 )before" will additionally restore . -- Thus, the later requires one extra undo at the end. \end{verbatim} +\calls{undoSteps}{writeInputLines} +\calls{undoSteps}{spaddifference} +\calls{undoSteps}{recordFrame} +\calls{undoSteps}{copy} +\calls{undoSteps}{undoSingleStep} +\calls{undoSteps}{pairp} +\calls{undoSteps}{qcdr} +\calls{undoSteps}{qcar} +\usesdollar{undoSteps}{IOindex} +\usesdollar{undoSteps}{InteractiveFrame} +\usesdollar{undoSteps}{frameRecord} <>= (defun |undoSteps| (m beforeOrAfter) (let (tmp1 tmp2 systemDelta lastTailSeen env) @@ -19357,6 +22092,11 @@ undoSingleStep(changes,env) == -- pp '"----Undoing 1 step--------" -- pp changes \end{verbatim} +\calls{undoSingleStep}{assq} +\calls{undoSingleStep}{seq} +\calls{undoSingleStep}{exit} +\calls{undoSingleStep}{lassoc} +\calls{undoSingleStep}{undoLocalModemapHack} <>= (defun |undoSingleStep| (changes env) (prog (name changeList pairlist proplist prop value node) @@ -19408,6 +22148,8 @@ undoSingleStep(changes,env) == @ \defun{undoLocalModemapHack}{undoLocalModemapHack} +\calls{undoLocalModemapHack}{seq} +\calls{undoLocalModemapHack}{exit} <>= (defun |undoLocalModemapHack| (changeList) (prog (name value) @@ -19441,6 +22183,20 @@ undoSingleStep(changes,env) == @ \defunsec{removeUndoLines}{Remove undo lines from history write} Removing undo lines from \verb|)hist )write linelist| +\calls{removeUndoLines}{stringPrefix?} +\calls{removeUndoLines}{seq} +\calls{removeUndoLines}{exit} +\calls{removeUndoLines}{trimString} +\calls{removeUndoLines}{substring} +\calls{removeUndoLines}{nequal} +\calls{removeUndoLines}{charPosition} +\calls{removeUndoLines}{maxindex} +\calls{removeUndoLines}{plus} +\calls{removeUndoLines}{undoCount} +\calls{removeUndoLines}{spaddifference} +\calls{removeUndoLines}{concat} +\usesdollar{removeUndoLines}{currentLine} +\usesdollar{removeUndoLines}{IOindex} <>= (defun |removeUndoLines| (u) "Remove undo lines from history write" @@ -19639,6 +22395,7 @@ o )show @ \defun{what}{what} +\calls{what}{whatSpad2Cmd} <>= (defun |what| (l) (|whatSpad2Cmd| l)) @@ -19646,18 +22403,33 @@ o )show @ \defun{whatSpad2Cmd,fixpat}{whatSpad2Cmd,fixpat} +\calls{whatSpad2Cmd,fixpat}{pairp} +\calls{whatSpad2Cmd,fixpat}{qcar} +\calls{whatSpad2Cmd,fixpat}{downcase} <>= (defun |whatSpad2Cmd,fixpat| (x) - (prog (|x'|) - (return - (seq - (if (and (pairp x) (progn (setq |x'| (qcar x)) t)) - (exit (downcase |x'|))) - (exit (downcase x)))))) + (let (xp) + (if (and (pairp x) (progn (setq xp (qcar x)) t)) + (downcase xp) + (downcase x)))) @ \defun{whatSpad2Cmd}{whatSpad2Cmd} +\calls{whatSpad2Cmd}{reportWhatOptions} +\calls{whatSpad2Cmd}{selectOptionLC} +\calls{whatSpad2Cmd}{sayKeyedMsg} +\calls{whatSpad2Cmd}{seq} +\calls{whatSpad2Cmd}{exit} +\calls{whatSpad2Cmd}{whatSpad2Cmd,fixpat} +\calls{whatSpad2Cmd}{memq} +\calls{whatSpad2Cmd}{whatSpad2Cmd} +\calls{whatSpad2Cmd}{filterAndFormatConstructors} +\calls{whatSpad2Cmd}{whatCommands} +\calls{whatSpad2Cmd}{apropos} +\calls{whatSpad2Cmd}{printSynonyms} +\usesdollar{whatSpad2Cmd}{e} +\usesdollar{whatSpad2Cmd}{whatOptions} <>= (defun |whatSpad2Cmd| (arg) (prog (|$e| |key0| key args) @@ -19712,10 +22484,19 @@ o )show @ \defun{filterAndFormatConstructors}{filterAndFormatConstructors} +\calls{filterAndFormatConstructors}{sayMessage} +\calls{filterAndFormatConstructors}{blankList} +\calls{filterAndFormatConstructors}{pp2Cols} +\calls{filterAndFormatConstructors}{centerAndHighlight} +\calls{filterAndFormatConstructors}{specialChar} +\calls{filterAndFormatConstructors}{filterListOfStringsWithFn} +\calls{filterAndFormatConstructors}{whatConstructors} +\calls{filterAndFormatConstructors}{function} +\usesdollar{filterAndFormatConstructors}{linelength} <>= (defun |filterAndFormatConstructors| (|constrType| label |patterns|) (prog (l) - (declare (special $linelength )) + (declare (special $linelength)) (return (progn (|centerAndHighlight| label $linelength (|specialChar| '|hbar|)) (setq l @@ -19748,6 +22529,11 @@ o )show @ \defun{whatConstructors}{whatConstructors} +\calls{whatConstructors}{boot-equal} +\calls{whatConstructors}{getdatabase} +\calls{whatConstructors}{seq} +\calls{whatConstructors}{msort} +\calls{whatConstructors}{exit} <>= (defun |whatConstructors| (|constrType|) (prog nil @@ -19776,6 +22562,15 @@ o )show \defunsec{apropos}{Display all operation names containing the fragment} Argument l is a list of operation name fragments. This displays all operation names containing these fragments +\calls{apropos}{allOperations} +\calls{apropos}{filterListOfStrings} +\calls{apropos}{seq} +\calls{apropos}{exit} +\calls{apropos}{downcase} +\calls{apropos}{sayMessage} +\calls{apropos}{sayAsManyPerLineAsPossible} +\calls{apropos}{msort} +\calls{apropos}{sayKeyedMsg} <>= (defun |apropos| (arg) "Display all operation names containing the fragment" @@ -19823,6 +22618,7 @@ o )library \footnote{\fnref{library}} \defun{with}{with} +\calls{with}{library} <>= (defun |with| (args) (|library| args)) @@ -19833,6 +22629,7 @@ o )library \cmdhead{workfiles} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \defun{workfiles}{workfiles} +\calls{workfiles}{workfilesSpad2Cmd} <>= (defun |workfiles| (l) (|workfilesSpad2Cmd| l)) @@ -19840,6 +22637,22 @@ o )library @ \defun{workfilesSpad2Cmd}{workfilesSpad2Cmd} +\calls{workfilesSpad2Cmd}{throwKeyedMsg} +\calls{workfilesSpad2Cmd}{selectOptionLC} +\calls{workfilesSpad2Cmd}{pathname} +\calls{workfilesSpad2Cmd}{delete} +\calls{workfilesSpad2Cmd}{make-input-filename} +\calls{workfilesSpad2Cmd}{sayKeyedMsg} +\calls{workfilesSpad2Cmd}{namestring} +\calls{workfilesSpad2Cmd}{updateSourceFiles} +\calls{workfilesSpad2Cmd}{say} +\calls{workfilesSpad2Cmd}{centerAndHighlight} +\calls{workfilesSpad2Cmd}{specialChar} +\calls{workfilesSpad2Cmd}{sortby} +\calls{workfilesSpad2Cmd}{sayBrightly} +\usesdollar{workfilesSpad2Cmd}{options} +\usesdollar{workfilesSpad2Cmd}{sourceFiles} +\usesdollar{workfilesSpad2Cmd}{linelength} <>= (defun |workfilesSpad2Cmd| (args) (let (deleteflag type flist type1 fl) @@ -19897,6 +22710,7 @@ o )library \cmdhead{zsystemdevelopment} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \defun{zsystemdevelopment}{zsystemdevelopment} +\calls{zsystemdevelopment}{zsystemDevelopmentSpad2Cmd} <>= (defun |zsystemdevelopment| (arg) (|zsystemDevelopmentSpad2Cmd| arg)) @@ -19904,6 +22718,8 @@ o )library @ \defun{zsystemDevelopmentSpad2Cmd}{zsystemDevelopmentSpad2Cmd} +\calls{zsystemDevelopmentSpad2Cmd}{zsystemdevelopment1} +\usesdollar{zsystemDevelopmentSpad2Cmd}{InteractiveMode} <>= (defun |zsystemDevelopmentSpad2Cmd| (arg) (declare (special |$InteractiveMode|)) @@ -19912,6 +22728,23 @@ o )library @ \defun{zsystemdevelopment1}{zsystemdevelopment1} +\calls{zsystemdevelopment1}{selectOptionLC} +\calls{zsystemdevelopment1}{/D,1} +\calls{zsystemdevelopment1}{/comp} +\calls{zsystemdevelopment1}{version} +\calls{zsystemdevelopment1}{defiostream} +\calls{zsystemdevelopment1}{next} +\calls{zsystemdevelopment1}{shut} +\calls{zsystemdevelopment1}{kar} +\calls{zsystemdevelopment1}{kadr} +\calls{zsystemdevelopment1}{kaddr} +\calls{zsystemdevelopment1}{sayMessage} +\calls{zsystemdevelopment1}{sayBrightly} +\calls{zsystemdevelopment1}{bright} +\usesdollar{zsystemdevelopment1}{InteractiveMode} +\usesdollar{zsystemdevelopment1}{options} +\uses{zsystemdevelopment1}{/wsname} +\uses{zsystemdevelopment1}{/version} <>= (defun |zsystemdevelopment1| (arg im) (let (|$InteractiveMode| fromopt opt optargs newopt opt1 constream upf fun) @@ -19986,6 +22819,488 @@ o )library @ +\chapter{Command Handling} + +\defun{satisfiesUserLevel}{satisfiesUserLevel} +\usesdollar{satisfiesUserLevel}{UserLevel} +<>= +(defun |satisfiesUserLevel| (x) + (declare (special |$UserLevel|)) + (cond + ((eq x '|interpreter|) t) + ((eq |$UserLevel| '|interpreter|) nil) + ((eq x '|compiler|) t) + ((eq |$UserLevel| '|compiler|) nil) + (t t))) + +@ + +\defun{hasOption}{hasOption} +\calls{hasOption}{stringPrefix?} +\calls{hasOption}{pname} +<>= +(defun |hasOption| (al opt) + (let ((optPname (pname opt)) found) + (loop for pair in al do + (when (|stringPrefix?| (pname (car pair)) optPname) (setq found pair)) + until found) + found)) + +@ + +\defun{terminateSystemCommand}{terminateSystemCommand} +\calls{terminateSystemCommand}{tersyscommand} +<>= +(defun |terminateSystemCommand| nil (tersyscommand)) + +@ + +\defun{commandAmbiguityError}{commandAmbiguityError} +\calls{commandAmbiguityError}{sayKeyedMsg} +\calls{commandAmbiguityError}{sayMSG} +\calls{commandAmbiguityError}{bright} +\calls{commandAmbiguityError}{terminateSystemCommand} +<>= +(defun |commandAmbiguityError| (kind x u) + (|sayKeyedMsg| 's2iz0009 (list kind x)) + (dolist (a u) (|sayMSG| (cons " " (|bright| a)))) + (|terminateSystemCommand|)) + +@ + +\defun{getParserMacroNames}{getParserMacroNames} +The \verb|$pfMacros| is a list of all of the user-defined macros. +<>= +(defun |getParserMacroNames| () + (remove-duplicates (mapcar #'car |$pfMacros|))) + +@ + +\defun{clearParserMacro}{clearParserMacro} +Note that if a macro is defined twice this will clear the last instance. +Thus: +\begin{verbatim} + a ==> 3 + a ==> 4 + )d macros + a ==> 4 + )clear prop a + )d macros + a ==> 3 + )clear prop a + )d macros + nil +\end{verbatim} +\calls{clearParserMacro}{ifcdr} +\calls{clearParserMacro}{assoc} +\calls{clearParserMacro}{remalist} +\usesdollar{clearParserMacro}{pfMacros} +<>= +(defun |clearParserMacro| (macro) + (declare (special |$pfMacros|)) + (when (ifcdr (|assoc| macro |$pfMacros|)) + (setq |$pfMacros| (remalist |$pfMacros| macro)))) + +@ + +\defun{displayMacro}{displayMacro} +\calls{displayMacro}{isInterpMacro} +\calls{displayMacro}{sayBrightly} +\calls{displayMacro}{bright} +\calls{displayMacro}{strconc} +\calls{displayMacro}{object2String} +\calls{displayMacro}{mathprint} +\usesdollar{displayMacro}{op} +<>= +(defun |displayMacro| (name) + (let (|$op| m body args) + (declare (special |$op|)) + (setq m (|isInterpMacro| name)) + (cond + ((null m) + (|sayBrightly| + (cons " " (append (|bright| name) + (cons "is not an interpreter macro." nil))))) + (t + (setq |$op| (strconc "macro " (|object2String| name))) + (setq args (car m)) + (setq body (cdr m)) + (setq args + (cond + ((null args) nil) + ((null (cdr args)) (car args)) + (t (cons '|Tuple| args)))) + (|mathprint| (cons 'map (cons (cons args body) nil))))))) + +@ + +\defun{displayWorkspaceNames}{displayWorkspaceNames} +\calls{displayWorkspaceNames}{getInterpMacroNames} +\calls{displayWorkspaceNames}{getParserMacroNames} +\calls{displayWorkspaceNames}{sayMessage} +\calls{displayWorkspaceNames}{msort} +\calls{displayWorkspaceNames}{getWorkspaceNames} +\calls{displayWorkspaceNames}{sayAsManyPerLineAsPossible} +\calls{displayWorkspaceNames}{sayBrightly} +\calls{displayWorkspaceNames}{setdifference} +<>= +(defun |displayWorkspaceNames| () + (let (pmacs names imacs) + (setq imacs (|getInterpMacroNames|)) + (setq pmacs (|getParserMacroNames|)) + (|sayMessage| "Names of User-Defined Objects in the Workspace:") + (setq names (msort (append (|getWorkspaceNames|) pmacs))) + (if names + (|sayAsManyPerLineAsPossible| (mapcar #'|object2String| names)) + (|sayBrightly| " * None *")) + (setq imacs (setdifference imacs pmacs)) + (when imacs + (|sayMessage| "Names of System-Defined Objects in the Workspace:") + (|sayAsManyPerLineAsPossible| (mapcar #'|object2String| imacs))))) + +@ + +\defun{getWorkspaceNames}{getWorkspaceNames} +\begin{verbatim} +;getWorkspaceNames() == +; NMSORT [n for [n,:.] in CAAR $InteractiveFrame | +; (n ^= "--macros--" and n^= "--flags--")] +\end{verbatim} +\calls{getWorkspaceNames}{nequal} +\calls{getWorkspaceNames}{seq} +\calls{getWorkspaceNames}{nmsort} +\calls{getWorkspaceNames}{exit} +\usesdollar{getWorkspaceNames}{InteractiveFrame} +<>= +(defun |getWorkspaceNames| () + (PROG (|n|) + (declare (special |$InteractiveFrame|)) + (RETURN + (SEQ (NMSORT (PROG (G166322) + (setq G166322 NIL) + (RETURN + (DO ((G166329 (CAAR |$InteractiveFrame|) + (CDR G166329)) + (G166313 NIL)) + ((OR (ATOM G166329) + (PROGN + (SETQ G166313 (CAR G166329)) + NIL) + (PROGN + (PROGN + (setq |n| (CAR G166313)) + G166313) + NIL)) + (NREVERSE0 G166322)) + (SEQ (EXIT (COND + ((AND (NEQUAL |n| '|--macros--|) + (NEQUAL |n| '|--flags--|)) + (SETQ G166322 + (CONS |n| G166322)))))))))))))) + +@ + +\defun{fixObjectForPrinting}{fixObjectForPrinting} +The \verb|$msgdbPrims| variable is set to: +\begin{verbatim} +(|%b| |%d| |%l| |%i| |%u| %U |%n| |%x| |%ce| |%rj| + "%U" "%b" "%d" "%l" "%i" "%u" "%U" "%n" "%x" "%ce" "%rj") +\end{verbatim} +\calls{fixObjectForPrinting}{object2Identifier} +\calls{fixObjectForPrinting}{member} +\calls{fixObjectForPrinting}{strconc} +\calls{fixObjectForPrinting}{pname} +\usesdollar{fixObjectForPrinting}{msgdbPrims} +<>= +(defun |fixObjectForPrinting| (v) + (let (vp) + (declare (special |$msgdbPrims|)) + (setq vp (|object2Identifier| v)) + (cond + ((eq vp '%) "\\%") + ((|member| vp |$msgdbPrims|) (strconc "\\" (pname vp))) + (t v)))) + +@ + +\defun{displayProperties,sayFunctionDeps}{displayProperties,sayFunctionDeps} +\begin{verbatim} +;displayProperties(option,l) == +; $dependentAlist : local := nil +; $dependeeAlist : local := nil +; [opt,:vl]:= (l or ['properties]) +; imacs := getInterpMacroNames() +; pmacs := getParserMacroNames() +; macros := REMDUP append(imacs, pmacs) +; if vl is ['all] or null vl then +; vl := MSORT append(getWorkspaceNames(),macros) +; if $frameMessages then sayKeyedMsg("S2IZ0065",[$interpreterFrameName]) +; null vl => +; null $frameMessages => sayKeyedMsg("S2IZ0066",NIL) +; sayKeyedMsg("S2IZ0067",[$interpreterFrameName]) +; interpFunctionDepAlists() +; for v in vl repeat +; isInternalMapName(v) => 'iterate +; pl := getIProplist(v) +; option = 'flags => getAndSay(v,"flags") +; option = 'value => displayValue(v,getI(v,'value),nil) +; option = 'condition => displayCondition(v,getI(v,"condition"),nil) +; option = 'mode => displayMode(v,getI(v,'mode),nil) +; option = 'type => displayType(v,getI(v,'value),nil) +; option = 'properties => +; v = "--flags--" => nil +; pl is [ ['cacheInfo,:.],:.] => nil +; v1 := fixObjectForPrinting(v) +; sayMSG ['"Properties of",:bright prefix2String v1,'":"] +; null pl => +; v in pmacs => +; sayMSG '" This is a user-defined macro." +; displayParserMacro v +; isInterpMacro v => +; sayMSG '" This is a system-defined macro." +; displayMacro v +; sayMSG '" none" +; propsSeen:= nil +; for [prop,:val] in pl | ^MEMQ(prop,propsSeen) and val repeat +; prop in '(alias generatedCode IS_-GENSYM mapBody localVars) => +; nil +; prop = 'condition => +; displayCondition(prop,val,true) +; prop = 'recursive => +; sayMSG '" This is recursive." +; prop = 'isInterpreterFunction => +; sayMSG '" This is an interpreter function." +; sayFunctionDeps v where +; sayFunctionDeps x == +; if dependents := GETALIST($dependentAlist,x) then +; null rest dependents => +; sayMSG ['" The following function or rule ", +; '"depends on this:",:bright first dependents] +; sayMSG +; '" The following functions or rules depend on this:" +; msg := ["%b",'" "] +; for y in dependents repeat msg := ['" ",y,:msg] +; sayMSG [:nreverse msg,"%d"] +; if dependees := GETALIST($dependeeAlist,x) then +; null rest dependees => +; sayMSG ['" This depends on the following function ", +; '"or rule:",:bright first dependees] +; sayMSG +; '" This depends on the following functions or rules:" +; msg := ["%b",'" "] +; for y in dependees repeat msg := ['" ",y,:msg] +; sayMSG [:nreverse msg,"%d"] +; prop = 'isInterpreterRule => +; sayMSG '" This is an interpreter rule." +; sayFunctionDeps v +; prop = 'localModemap => +; displayModemap(v,val,true) +; prop = 'mode => +; displayMode(prop,val,true) +; prop = 'value => +; val => displayValue(v,val,true) +; sayMSG ['" ",prop,'": ",val] +; propsSeen:= [prop,:propsSeen] +; sayKeyedMsg("S2IZ0068",[option]) +; terminateSystemCommand() +\end{verbatim} +\calls{displayProperties,sayFunctionDeps}{seq} +\calls{displayProperties,sayFunctionDeps}{getalist} +\calls{displayProperties,sayFunctionDeps}{exit} +\calls{displayProperties,sayFunctionDeps}{sayMSG} +\calls{displayProperties,sayFunctionDeps}{bright} +\usesdollar{displayProperties,sayFunctionDeps}{dependeeAlist} +\usesdollar{displayProperties,sayFunctionDeps}{dependentAlist} +<>= +(defun |displayProperties,sayFunctionDeps| (x) + (prog (dependents dependees msg) + (declare (special |$dependeeAlist| |$dependentAlist|)) + (return + (seq + (if (setq dependents (getalist |$dependentAlist| x)) + (seq + (if (null (cdr dependents)) + (exit + (|sayMSG| (cons " The following function or rule " + (cons "depends on this:" (|bright| (car dependents))))))) + (|sayMSG| " The following functions or rules depend on this:") + (setq msg (cons '|%b| (cons " " nil))) + (do ((G166397 dependents (cdr G166397)) (y nil)) + ((or (atom G166397) (progn (setq y (car G166397)) nil)) nil) + (seq (exit (setq msg (cons " " (cons y msg)))))) + (exit (|sayMSG| (append (nreverse msg) (cons '|%d| nil))))) + nil) + (exit + (if (setq dependees (getalist |$dependeeAlist| x)) + (seq + (if (null (cdr dependees)) + (exit + (|sayMSG| (cons " This depends on the following function " + (cons "or rule:" (|bright| (car dependees))))))) + (|sayMSG| " This depends on the following functions or rules:") + (setq msg (cons '|%b| (cons " " nil))) + (do ((G166406 dependees (cdr G166406)) (y nil)) + ((or (atom G166406) (progn (setq y (car G166406)) nil)) nil) + (seq (exit (setq msg (cons " " (cons y msg)))))) + (exit (|sayMSG| (append (nreverse msg) (cons '|%d| nil))))) + nil)))))) + +@ + +\defun{displayProperties}{displayProperties} +\calls{displayProperties}{getInterpMacroNames} +\calls{displayProperties}{getParserMacroNames} +\calls{displayProperties}{remdup} +\calls{displayProperties}{pairp} +\calls{displayProperties}{qcdr} +\calls{displayProperties}{qcar} +\calls{displayProperties}{msort} +\calls{displayProperties}{getWorkspaceNames} +\calls{displayProperties}{sayKeyedMsg} +\calls{displayProperties}{interpFunctionDepAlists} +\calls{displayProperties}{isInternalMapName} +\calls{displayProperties}{getIProplist} +\calls{displayProperties}{getAndSay} +\calls{displayProperties}{displayValue} +\calls{displayProperties}{getI} +\calls{displayProperties}{displayCondition} +\calls{displayProperties}{displayMode} +\calls{displayProperties}{displayType} +\calls{displayProperties}{fixObjectForPrinting} +\calls{displayProperties}{sayMSG} +\calls{displayProperties}{bright} +\calls{displayProperties}{prefix2String} +\calls{displayProperties}{member} +\calls{displayProperties}{displayParserMacro} +\calls{displayProperties}{isInterpMacro} +\calls{displayProperties}{displayMacro} +\calls{displayProperties}{memq} +\calls{displayProperties}{displayProperties,sayFunctionDeps} +\calls{displayProperties}{displayModemap} +\calls{displayProperties}{exit} +\calls{displayProperties}{seq} +\calls{displayProperties}{terminateSystemCommand} +\usesdollar{displayProperties}{dependentAlist} +\usesdollar{displayProperties}{dependeeAlist} +\usesdollar{displayProperties}{frameMessages} +\usesdollar{displayProperties}{interpreterFrameName} +<>= +(defun |displayProperties| (option al) + (let (|$dependentAlist| |$dependeeAlist| tmp1 opt imacs pmacs macros vl pl + tmp2 vone prop val propsSeen) + (declare (special |$dependentAlist| |$dependeeAlist| |$frameMessages| + |$interpreterFrameName|)) + (setq |$dependentAlist| nil) + (setq |$dependeeAlist| nil) + (setq tmp1 (or al (cons '|properties| nil))) + (setq opt (car tmp1)) + (setq vl (cdr tmp1)) + (setq imacs (|getInterpMacroNames|)) + (setq pmacs (|getParserMacroNames|)) + (setq macros (remdup (append imacs pmacs))) + (when (or + (and (pairp vl) (eq (qcdr vl) nil) (eq (qcar vl) '|all|)) + (null vl)) + (setq vl (msort (append (|getWorkspaceNames|) macros)))) + (when |$frameMessages| + (|sayKeyedMsg| 'S2IZ0065 (cons |$interpreterFrameName| nil))) + (cond + ((null vl) + (if (null |$frameMessages|) + (|sayKeyedMsg| 'S2IZ0066 nil)) + (|sayKeyedMsg| 'S2IZ0067 (cons |$interpreterFrameName| nil))) + (t + (|interpFunctionDepAlists|) + (do ((G166440 vl (cdr G166440)) (v nil)) + ((or (atom G166440) (progn (setq v (car G166440)) nil)) nil) + (seq (exit + (cond + ((|isInternalMapName| v) '|iterate|) + (t + (setq pl (|getIProplist| v)) + (cond + ((eq option '|flags|) + (|getAndSay| v '|flags|)) + ((eq option '|value|) + (|displayValue| v (|getI| v '|value|) nil)) + ((eq option '|condition|) + (|displayCondition| v (|getI| v '|condition|) nil)) + ((eq option '|mode|) + (|displayMode| v (|getI| v '|mode|) nil)) + ((eq option '|type|) + (|displayType| v (|getI| v '|value|) nil)) + ((eq option '|properties|) + (cond + ((eq v '|--flags--|) + nil) + ((and (pairp pl) + (progn + (setq tmp2 (qcar pl)) + (and (pairp tmp2) (eq (qcar tmp2) '|cacheInfo|)))) + nil) + (t + (setq vone (|fixObjectForPrinting| v)) + (|sayMSG| + (cons "Properties of" + (append (|bright| (|prefix2String| vone)) (cons ":" nil)))) + (cond + ((null pl) + (cond + ((|member| v pmacs) + (|sayMSG| " This is a user-defined macro.") + (|displayParserMacro| v)) + ((|isInterpMacro| v) + (|sayMSG| " This is a system-defined macro.") + (|displayMacro| v)) + (t + (|sayMSG| " none")))) + (t + (setq propsSeen nil) + (do ((G166451 pl (cdr G166451)) (G166425 nil)) + ((or (atom G166451) + (progn (setq G166425 (car G166451)) nil) + (progn + (progn + (setq prop (car G166425)) + (setq val (cdr G166425)) + G166425) + nil)) + nil) + (seq (exit + (cond + ((and (null (memq prop propsSeen)) val) + (cond + ((|member| prop + '(|alias| |generatedCode| IS-GENSYM + |mapBody| |localVars|)) + nil) + ((eq prop '|condition|) + (|displayCondition| prop val t)) + ((eq prop '|recursive|) + (|sayMSG| " This is recursive.")) + ((eq prop '|isInterpreterFunction|) + (|sayMSG| " This is an interpreter function.") + (|displayProperties,sayFunctionDeps| v)) + ((eq prop '|isInterpreterRule|) + (|sayMSG| " This is an interpreter rule.") + (|displayProperties,sayFunctionDeps| v)) + ((eq prop '|localModemap|) + (|displayModemap| v val t)) + ((eq prop '|mode|) + (|displayMode| prop val t)) + (t + (when (eq prop '|value|) + (exit + (when val + (exit (|displayValue| v val t))))) + (|sayMSG| (list " " prop ": " val)) + (setq propsSeen (cons prop propsSeen)))))))))))))) + (t + (|sayKeyedMsg| 'S2IZ0068 (cons option nil))))))))) + (|terminateSystemCommand|))))) + +@ + \chapter{Handling output} \section{Special Character Tables} @@ -20182,6 +23497,7 @@ o )library \chapter{Stream Handling} \defun{make-instream}{make-instream} +\calls{make-instream}{make-input-filename} <>= (defun make-instream (filespec &optional (recnum 0)) (declare (ignore recnum)) @@ -20193,6 +23509,7 @@ o )library @ \defun{make-outstream}{make-outstream} +\calls{make-outstream}{make-filename} <>= (defun make-outstream (filespec &optional (width nil) (recnum 0)) (declare (ignore width) (ignore recnum)) @@ -20203,6 +23520,7 @@ o )library @ \defun{make-appendstream}{make-appendstream} +\calls{make-appendstream}{make-filename} <>= (defun make-appendstream (filespec &optional (width nil) (recnum 0)) "fortran support" @@ -20235,6 +23553,7 @@ o )library @ \defun{shut}{shut} +\calls{shut}{is-console} <>= (defun shut (st) (if (is-console st) @@ -20250,6 +23569,8 @@ o )library @ \defun{makeStream}{makeStream} +\calls{makeStream}{make-appendstream} +\calls{makeStream}{make-outstream} <>= (defun |makeStream| (append filename i j) (if append @@ -20258,14 +23579,19 @@ o )library @ \chapter{The Spad Server Mechanism} +\defdollar{openServerIfTrue} <>= (defvar $openServerIfTrue nil "t means try starting an open server") @ + +\defdollar{SpadServerName} <>= (defconstant $SpadServerName "/tmp/.d" "the name of the spad server socket") @ + +\defdollar{SpadServer} <>= (defvar |$SpadServer| nil "t means Scratchpad acts as a remote server") @@ -20273,6 +23599,7 @@ o )library \pagehead{openserver}{openserver} This is a cover function for the C code used for communication interface. +%\calls{openserver}{open_server} <>= (defun openserver (name) (open_server name)) @@ -20330,6 +23657,9 @@ file and it will show up here. DEBUGSYS=${OBJ}/${SYS}/bin/debugsys \end{verbatim} \end{list} +\calls{spad-save}{save-system} +\usesdollar{spad-save}{SpadServer} +\usesdollar{spad-save}{openServerIfTrue} <>= (defun user::spad-save (save-file) (declare (special |$SpadServer| $openServerIfTrue)) @@ -20367,6 +23697,8 @@ page~\pageref{TheFrameMechanism}. \pagehead{loadExposureGroupData}{loadExposureGroupData} This function is called from \fnref{restart} at system startup time to load the file \verb|exposed.lsp| to set up the exposure group information. +\calls{loadExposureGroupData}{concat} +\calls{loadExposureGroupData}{getenviron} <>= (defun |loadExposureGroupData| () (cond @@ -20381,6 +23713,7 @@ load the file \verb|exposed.lsp| to set up the exposure group information. \chapter{System Statistics} \pagehead{statisticsInitialization}{statisticsInitialization} +\calls{statisticsInitialization}{gbc-time} <>= (defun |statisticsInitialization| () "initialize the garbage collection timer" @@ -20391,6 +23724,9 @@ load the file \verb|exposed.lsp| to set up the exposure group information. \chapter{Special Lisp Functions} \defun{wrap}{wrap} +\calls{wrap}{pairp} +\calls{wrap}{lotsof} +\calls{wrap}{wrap} <>= (defun wrap (list-of-items wrapper) (prog nil @@ -20449,6 +23785,7 @@ load the file \verb|exposed.lsp| to set up the exposure group information. @ \defun{digitp}{digitp} +\calls{digitp}{digitp} <>= (defun digitp (x) (or (and (symbolp x) (digitp (symbol-name x))) @@ -20512,6 +23849,7 @@ Note that this assumes ``table'' is a string. @ \defun{concat}{concat} +\calls{concat}{string-concatenate} <>= (defun concat (a b &rest l) (if (bit-vector-p a) @@ -20525,6 +23863,7 @@ Note that this assumes ``table'' is a string. @ \defun{functionp}{functionp} +\calls{functionp}{identp} <>= (defun |functionp| (fn) (if (identp fn) @@ -20535,6 +23874,7 @@ Note that this assumes ``table'' is a string. ;; --------------------> NEW DEFINITION (override in msgdb.boot.pamphlet) \defun{brightprint}{brightprint} +\calls{brightprint}{messageprint} <>= (defun brightprint (x) (messageprint x)) @@ -20543,6 +23883,7 @@ Note that this assumes ``table'' is a string. ;; --------------------> NEW DEFINITION (override in msgdb.boot.pamphlet) \defun{brightprint-0}{brightprint-0} +\calls{brightprint-0}{messageprint-1} <>= (defun brightprint-0 (x) (messageprint-1 x)) @@ -20568,6 +23909,9 @@ Note that this assumes ``table'' is a string. @ \defun{messageprint-1}{messageprint-1} +\calls{messageprint-1}{identp} +\calls{messageprint-1}{messageprint-1} +\calls{messageprint-1}{messageprint-2} <>= (defun messageprint-1 (x) (cond @@ -20583,6 +23927,8 @@ Note that this assumes ``table'' is a string. @ \defun{messageprint-2}{messageprint-2} +\calls{messageprint-2}{messageprint-1} +\calls{messageprint-2}{messageprint-2} <>= (defun messageprint-2 (x) (if (atom x) @@ -20592,6 +23938,8 @@ Note that this assumes ``table'' is a string. @ \defun{sayBrightly1}{sayBrightly1} +\calls{saybrightly1}{brightprint-0} +\calls{saybrightly1}{brightprint} <>= (defun sayBrightly1 (x *standard-output*) (if (atom x) @@ -20607,6 +23955,8 @@ Note that this assumes ``table'' is a string. @ \defun{sayMSG}{sayMSG} +\calls{saymsg}{saybrightly1} +\usesdollar{sayMSG}{algebraOutputStream} <>= (defun |sayMSG| (x) (declare (special |$algebraOutputStream|)) @@ -20973,6 +24323,7 @@ maxindex <> <> <> +<> <> <> <> @@ -20980,6 +24331,7 @@ maxindex <> <> <> +<> <> <> <> @@ -21023,11 +24375,15 @@ maxindex <> <> <> +<> <> <> +<> +<> <> <> <> +<> <> <> <> @@ -21052,6 +24408,7 @@ maxindex <> <> <> +<> <> <> <> @@ -21100,6 +24457,7 @@ maxindex <> <> <> +<> <> <> <> @@ -21107,8 +24465,10 @@ maxindex <> <> <> +<> <> +<> <> <> <> @@ -21188,6 +24548,7 @@ maxindex <> <> <> +<> <> <> <> @@ -21353,6 +24714,7 @@ maxindex <> <> +<> <> <> <> @@ -21469,6 +24831,7 @@ maxindex <> <> +<> <> <> <> @@ -21488,6 +24851,7 @@ maxindex <> <> <> +<> <> <> <> diff --git a/changelog b/changelog index d4509ba..83bec40 100644 --- a/changelog +++ b/changelog @@ -1,3 +1,8 @@ +20091115 tpd src/axiom-website/patches.html 20091115.01.tpd.patch +20091115 tpd src/interp/patches.lisp code ports to bookvol5 +20091115 tpd src/interp/nci.lisp code ports to bookvol5 +20091115 tpd src/interp/i-syscmd.lisp code ports to bookvol5 +20091115 tpd books/bookvol5 \calls, \uses, and code ports 20091114 tpd src/axiom-website/patches.html 20091114.02.tpd.patch 20091114 tpd src/input/unit-macro.input add macro test cases 20091114 tpd src/input/Makefile add unit-macro diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html index 84b8935..272cc18 100644 --- a/src/axiom-website/patches.html +++ b/src/axiom-website/patches.html @@ -2259,5 +2259,7 @@ src/interp/nci.lisp merge and remove osyscmd.lisp
books/bookvol10.3 clean up bootstrap lisp code format
20091114.02.tpd.patch src/input/unit-macro unit test macro commands
+20091115.01.tpd.patch +books/bookvol5 \calls, \uses, and code ports
diff --git a/src/interp/i-syscmd.lisp.pamphlet b/src/interp/i-syscmd.lisp.pamphlet index 1b14556..c73282b 100644 --- a/src/interp/i-syscmd.lisp.pamphlet +++ b/src/interp/i-syscmd.lisp.pamphlet @@ -160,22 +160,6 @@ ('T (SPADLET |nl| (CONS |syn| |nl|)))))))) |nl|)))))) -;satisfiesUserLevel x == -; x = 'interpreter => true -; $UserLevel = 'interpreter => false -; x = 'compiler => true -; $UserLevel = 'compiler => false -; true - -(DEFUN |satisfiesUserLevel| (|x|) - (declare (special |$UserLevel|)) - (COND - ((BOOT-EQUAL |x| '|interpreter|) 'T) - ((BOOT-EQUAL |$UserLevel| '|interpreter|) NIL) - ((BOOT-EQUAL |x| '|compiler|) 'T) - ((BOOT-EQUAL |$UserLevel| '|compiler|) NIL) - ('T 'T))) - ;unAbbreviateKeyword x == ; x' :=selectOptionLC(x,$SYSCOMMANDS,'commandErrorIfAmbiguous) ; if not x' then @@ -203,34 +187,6 @@ (|selectOption| |x'| (|commandsForUserLevel| |$systemCommands|) '|commandUserLevelError|))))) -;hasOption(al,opt) == -; optPname:= PNAME opt -; found := NIL -; for pair in al while not found repeat -; stringPrefix?(PNAME CAR pair,optPname) => found := pair -; found - -(DEFUN |hasOption| (|al| |opt|) - (PROG (|optPname| |found|) - (RETURN - (SEQ (PROGN - (SPADLET |optPname| (PNAME |opt|)) - (SPADLET |found| NIL) - (SEQ (DO ((G166160 |al| (CDR G166160)) (|pair| NIL)) - ((OR (ATOM G166160) - (PROGN (SETQ |pair| (CAR G166160)) NIL) - (NULL (NULL |found|))) - NIL) - (SEQ (EXIT (COND - ((|stringPrefix?| (PNAME (CAR |pair|)) - |optPname|) - (EXIT (SPADLET |found| |pair|))))))) - (EXIT |found|))))))) - -;terminateSystemCommand() == TERSYSCOMMAND() - -(DEFUN |terminateSystemCommand| NIL (TERSYSCOMMAND)) - ;commandUserLevelError(x,u) == userLevelErrorMessage("command",x,u) (DEFUN |commandUserLevelError| (|x| |u|) @@ -299,17 +255,6 @@ ; for a in u repeat sayMSG ['" ",:bright a] ; terminateSystemCommand() -(DEFUN |commandAmbiguityError| (|kind| |x| |u|) - (SEQ (PROGN - (|sayKeyedMsg| 'S2IZ0009 (CONS |kind| (CONS |x| NIL))) - (DO ((G166206 |u| (CDR G166206)) (|a| NIL)) - ((OR (ATOM G166206) - (PROGN (SETQ |a| (CAR G166206)) NIL)) - NIL) - (SEQ (EXIT (|sayMSG| - (CONS (MAKESTRING " ") (|bright| |a|)))))) - (|terminateSystemCommand|)))) - ;--% Utility for access to original command line ;getSystemCommandLine() == ; p := STRPOS('")",$currentLine,0,NIL) @@ -345,174 +290,6 @@ (SUBSTRING |line| (PLUS |index| 2) NIL)))) |line|))))) -;------------ start of commands ------------------------------------------ -;--% )display -;getParserMacroNames() == -; REMDUP [CAR mac for mac in getParserMacros()] - -(DEFUN |getParserMacroNames| () - (PROG () - (RETURN - (SEQ (REMDUP (PROG (G166237) - (SPADLET G166237 NIL) - (RETURN - (DO ((G166242 (|getParserMacros|) - (CDR G166242)) - (|mac| NIL)) - ((OR (ATOM G166242) - (PROGN - (SETQ |mac| (CAR G166242)) - NIL)) - (NREVERSE0 G166237)) - (SEQ (EXIT (SETQ G166237 - (CONS (CAR |mac|) G166237)))))))))))) - -;--------------------> NEW DEFINITION (override in patches.lisp.pamphlet) -;clearParserMacro(macro) == -; -- first see if it is one -; not IFCDR ASSOC(macro, ($pfMacros)) => NIL -; $pfMacros := REMALIST($pfMacros, macro) - -(DEFUN |clearParserMacro| (|macro|) - (declare (special |$pfMacros|)) - (COND - ((NULL (IFCDR (|assoc| |macro| |$pfMacros|))) NIL) - ('T (SPADLET |$pfMacros| (REMALIST |$pfMacros| |macro|))))) - -;displayMacro name == -; m := isInterpMacro name -; null m => -; sayBrightly ['" ",:bright name,'"is not an interpreter macro."] -; -- $op is needed in the output routines. -; $op : local := STRCONC('"macro ",object2String name) -; [args,:body] := m -; args := -; null args => nil -; null rest args => first args -; ['Tuple,:args] -; mathprint ['MAP,[args,:body]] - -(DEFUN |displayMacro| (|name|) - (PROG (|$op| |m| |body| |args|) - (DECLARE (SPECIAL |$op|)) - (RETURN - (PROGN - (SPADLET |m| (|isInterpMacro| |name|)) - (COND - ((NULL |m|) - (|sayBrightly| - (CONS (MAKESTRING " ") - (APPEND (|bright| |name|) - (CONS (MAKESTRING - "is not an interpreter macro.") - NIL))))) - ('T - (SPADLET |$op| - (STRCONC (MAKESTRING "macro ") - (|object2String| |name|))) - (SPADLET |args| (CAR |m|)) (SPADLET |body| (CDR |m|)) - (SPADLET |args| - (COND - ((NULL |args|) NIL) - ((NULL (CDR |args|)) (CAR |args|)) - ('T (CONS '|Tuple| |args|)))) - (|mathprint| (CONS 'MAP (CONS (CONS |args| |body|) NIL))))))))) - -;displayWorkspaceNames() == -; imacs := getInterpMacroNames() -; pmacs := getParserMacroNames() -; sayMessage '"Names of User-Defined Objects in the Workspace:" -; names := MSORT append(getWorkspaceNames(),pmacs) -; if null names -; then sayBrightly " * None *" -; else sayAsManyPerLineAsPossible [object2String x for x in names] -; imacs := SETDIFFERENCE(imacs,pmacs) -; if imacs then -; sayMessage '"Names of System-Defined Objects in the Workspace:" -; sayAsManyPerLineAsPossible [object2String x for x in imacs] - -(DEFUN |displayWorkspaceNames| () - (PROG (|pmacs| |names| |imacs|) - (RETURN - (SEQ (PROGN - (SPADLET |imacs| (|getInterpMacroNames|)) - (SPADLET |pmacs| (|getParserMacroNames|)) - (|sayMessage| - (MAKESTRING - "Names of User-Defined Objects in the Workspace:")) - (SPADLET |names| - (MSORT (APPEND (|getWorkspaceNames|) |pmacs|))) - (COND - ((NULL |names|) - (|sayBrightly| (MAKESTRING " * None *"))) - ('T - (|sayAsManyPerLineAsPossible| - (PROG (G166278) - (SPADLET G166278 NIL) - (RETURN - (DO ((G166283 |names| (CDR G166283)) - (|x| NIL)) - ((OR (ATOM G166283) - (PROGN - (SETQ |x| (CAR G166283)) - NIL)) - (NREVERSE0 G166278)) - (SEQ (EXIT (SETQ G166278 - (CONS (|object2String| |x|) - G166278)))))))))) - (SPADLET |imacs| (SETDIFFERENCE |imacs| |pmacs|)) - (COND - (|imacs| (|sayMessage| - (MAKESTRING - "Names of System-Defined Objects in the Workspace:")) - (|sayAsManyPerLineAsPossible| - (PROG (G166293) - (SPADLET G166293 NIL) - (RETURN - (DO ((G166298 |imacs| - (CDR G166298)) - (|x| NIL)) - ((OR (ATOM G166298) - (PROGN - (SETQ |x| (CAR G166298)) - NIL)) - (NREVERSE0 G166293)) - (SEQ (EXIT - (SETQ G166293 - (CONS (|object2String| |x|) - G166293))))))))) - ('T NIL))))))) - -;getWorkspaceNames() == -; NMSORT [n for [n,:.] in CAAR $InteractiveFrame | -; (n ^= "--macros--" and n^= "--flags--")] - -(DEFUN |getWorkspaceNames| () - (PROG (|n|) - (declare (special |$InteractiveFrame|)) - (RETURN - (SEQ (NMSORT (PROG (G166322) - (SPADLET G166322 NIL) - (RETURN - (DO ((G166329 (CAAR |$InteractiveFrame|) - (CDR G166329)) - (G166313 NIL)) - ((OR (ATOM G166329) - (PROGN - (SETQ G166313 (CAR G166329)) - NIL) - (PROGN - (PROGN - (SPADLET |n| (CAR G166313)) - G166313) - NIL)) - (NREVERSE0 G166322)) - (SEQ (EXIT (COND - ((AND (NEQUAL |n| '|--macros--|) - (NEQUAL |n| '|--flags--|)) - (SETQ G166322 - (CONS |n| G166322)))))))))))))) - ;interpFunctionDepAlists() == ; $e : local := $InteractiveFrame ; deps := getFlag "$dependencies" @@ -558,357 +335,6 @@ (GETALIST |$dependeeAlist| |dependent|))))))))))))) -;fixObjectForPrinting(v) == -; v' := object2Identifier v -; EQ(v',"%") => '"\%" -; v' in $msgdbPrims => STRCONC('"\",PNAME v') -; v - -(DEFUN |fixObjectForPrinting| (|v|) - (PROG (|v'|) - (declare (special |$msgdbPrims|)) - (RETURN - (PROGN - (SPADLET |v'| (|object2Identifier| |v|)) - (COND - ((EQ |v'| '%) (MAKESTRING "\\%")) - ((|member| |v'| |$msgdbPrims|) - (STRCONC (MAKESTRING "\\") (PNAME |v'|))) - ('T |v|)))))) - -;displayProperties(option,l) == -; $dependentAlist : local := nil -; $dependeeAlist : local := nil -; [opt,:vl]:= (l or ['properties]) -; imacs := getInterpMacroNames() -; pmacs := getParserMacroNames() -; macros := REMDUP append(imacs, pmacs) -; if vl is ['all] or null vl then -; vl := MSORT append(getWorkspaceNames(),macros) -; if $frameMessages then sayKeyedMsg("S2IZ0065",[$interpreterFrameName]) -; null vl => -; null $frameMessages => sayKeyedMsg("S2IZ0066",NIL) -; sayKeyedMsg("S2IZ0067",[$interpreterFrameName]) -; interpFunctionDepAlists() -; for v in vl repeat -; isInternalMapName(v) => 'iterate -; pl := getIProplist(v) -; option = 'flags => getAndSay(v,"flags") -; option = 'value => displayValue(v,getI(v,'value),nil) -; option = 'condition => displayCondition(v,getI(v,"condition"),nil) -; option = 'mode => displayMode(v,getI(v,'mode),nil) -; option = 'type => displayType(v,getI(v,'value),nil) -; option = 'properties => -; v = "--flags--" => nil -; pl is [['cacheInfo,:.],:.] => nil -; v1 := fixObjectForPrinting(v) -; sayMSG ['"Properties of",:bright prefix2String v1,'":"] -; null pl => -; v in pmacs => -; sayMSG '" This is a user-defined macro." -; displayParserMacro v -; isInterpMacro v => -; sayMSG '" This is a system-defined macro." -; displayMacro v -; sayMSG '" none" -; propsSeen:= nil -; for [prop,:val] in pl | ^MEMQ(prop,propsSeen) and val repeat -; prop in '(alias generatedCode IS_-GENSYM mapBody localVars) => -; nil -; prop = 'condition => -; displayCondition(prop,val,true) -; prop = 'recursive => -; sayMSG '" This is recursive." -; prop = 'isInterpreterFunction => -; sayMSG '" This is an interpreter function." -; sayFunctionDeps v where -; sayFunctionDeps x == -; if dependents := GETALIST($dependentAlist,x) then -; null rest dependents => -; sayMSG ['" The following function or rule ", -; '"depends on this:",:bright first dependents] -; sayMSG -; '" The following functions or rules depend on this:" -; msg := ["%b",'" "] -; for y in dependents repeat msg := ['" ",y,:msg] -; sayMSG [:nreverse msg,"%d"] -; if dependees := GETALIST($dependeeAlist,x) then -; null rest dependees => -; sayMSG ['" This depends on the following function ", -; '"or rule:",:bright first dependees] -; sayMSG -; '" This depends on the following functions or rules:" -; msg := ["%b",'" "] -; for y in dependees repeat msg := ['" ",y,:msg] -; sayMSG [:nreverse msg,"%d"] -; prop = 'isInterpreterRule => -; sayMSG '" This is an interpreter rule." -; sayFunctionDeps v -; prop = 'localModemap => -; displayModemap(v,val,true) -; prop = 'mode => -; displayMode(prop,val,true) -; prop = 'value => -; val => displayValue(v,val,true) -; sayMSG ['" ",prop,'": ",val] -; propsSeen:= [prop,:propsSeen] -; sayKeyedMsg("S2IZ0068",[option]) -; terminateSystemCommand() - -(DEFUN |displayProperties,sayFunctionDeps| (|x|) - (PROG (|dependents| |dependees| |msg|) - (declare (special |$dependeeAlist| |$dependentAlist|)) - (RETURN - (SEQ (IF (SPADLET |dependents| (GETALIST |$dependentAlist| |x|)) - (SEQ (IF (NULL (CDR |dependents|)) - (EXIT (|sayMSG| - (CONS (MAKESTRING - " The following function or rule ") - (CONS - (MAKESTRING - "depends on this:") - (|bright| (CAR |dependents|))))))) - (|sayMSG| - (MAKESTRING - " The following functions or rules depend on this:")) - (SPADLET |msg| - (CONS '|%b| - (CONS (MAKESTRING " ") NIL))) - (DO ((G166397 |dependents| (CDR G166397)) - (|y| NIL)) - ((OR (ATOM G166397) - (PROGN (SETQ |y| (CAR G166397)) NIL)) - NIL) - (SEQ (EXIT (SPADLET |msg| - (CONS (MAKESTRING " ") - (CONS |y| |msg|)))))) - (EXIT (|sayMSG| - (APPEND (NREVERSE |msg|) - (CONS '|%d| NIL))))) - NIL) - (EXIT (IF (SPADLET |dependees| - (GETALIST |$dependeeAlist| |x|)) - (SEQ (IF (NULL (CDR |dependees|)) - (EXIT (|sayMSG| - (CONS - (MAKESTRING - " This depends on the following function ") - (CONS (MAKESTRING "or rule:") - (|bright| (CAR |dependees|))))))) - (|sayMSG| - (MAKESTRING - " This depends on the following functions or rules:")) - (SPADLET |msg| - (CONS '|%b| - (CONS (MAKESTRING " ") NIL))) - (DO ((G166406 |dependees| (CDR G166406)) - (|y| NIL)) - ((OR (ATOM G166406) - (PROGN - (SETQ |y| (CAR G166406)) - NIL)) - NIL) - (SEQ (EXIT (SPADLET |msg| - (CONS (MAKESTRING " ") - (CONS |y| |msg|)))))) - (EXIT (|sayMSG| - (APPEND (NREVERSE |msg|) - (CONS '|%d| NIL))))) - NIL)))))) - - -(DEFUN |displayProperties| (|option| |l|) - (PROG (|$dependentAlist| |$dependeeAlist| |LETTMP#1| |opt| |imacs| - |pmacs| |macros| |vl| |pl| |ISTMP#1| |v1| |prop| |val| - |propsSeen|) - (DECLARE (SPECIAL |$dependentAlist| |$dependeeAlist| |$frameMessages| - |$interpreterFrameName|)) - (RETURN - (SEQ (PROGN - (SPADLET |$dependentAlist| NIL) - (SPADLET |$dependeeAlist| NIL) - (SPADLET |LETTMP#1| (OR |l| (CONS '|properties| NIL))) - (SPADLET |opt| (CAR |LETTMP#1|)) - (SPADLET |vl| (CDR |LETTMP#1|)) - (SPADLET |imacs| (|getInterpMacroNames|)) - (SPADLET |pmacs| (|getParserMacroNames|)) - (SPADLET |macros| (REMDUP (APPEND |imacs| |pmacs|))) - (COND - ((OR (AND (PAIRP |vl|) (EQ (QCDR |vl|) NIL) - (EQ (QCAR |vl|) '|all|)) - (NULL |vl|)) - (SPADLET |vl| - (MSORT (APPEND (|getWorkspaceNames|) |macros|))))) - (COND - (|$frameMessages| - (|sayKeyedMsg| 'S2IZ0065 - (CONS |$interpreterFrameName| NIL)))) - (COND - ((NULL |vl|) - (COND - ((NULL |$frameMessages|) - (|sayKeyedMsg| 'S2IZ0066 NIL)) - ('T - (|sayKeyedMsg| 'S2IZ0067 - (CONS |$interpreterFrameName| NIL))))) - ('T (|interpFunctionDepAlists|) - (DO ((G166440 |vl| (CDR G166440)) (|v| NIL)) - ((OR (ATOM G166440) - (PROGN (SETQ |v| (CAR G166440)) NIL)) - NIL) - (SEQ (EXIT (COND - ((|isInternalMapName| |v|) '|iterate|) - ('T (SPADLET |pl| (|getIProplist| |v|)) - (COND - ((BOOT-EQUAL |option| '|flags|) - (|getAndSay| |v| '|flags|)) - ((BOOT-EQUAL |option| '|value|) - (|displayValue| |v| - (|getI| |v| '|value|) NIL)) - ((BOOT-EQUAL |option| '|condition|) - (|displayCondition| |v| - (|getI| |v| '|condition|) NIL)) - ((BOOT-EQUAL |option| '|mode|) - (|displayMode| |v| - (|getI| |v| '|mode|) NIL)) - ((BOOT-EQUAL |option| '|type|) - (|displayType| |v| - (|getI| |v| '|value|) NIL)) - ((BOOT-EQUAL |option| '|properties|) - (COND - ((BOOT-EQUAL |v| '|--flags--|) - NIL) - ((AND (PAIRP |pl|) - (PROGN - (SPADLET |ISTMP#1| - (QCAR |pl|)) - (AND (PAIRP |ISTMP#1|) - (EQ (QCAR |ISTMP#1|) - '|cacheInfo|)))) - NIL) - ('T - (SPADLET |v1| - (|fixObjectForPrinting| |v|)) - (|sayMSG| - (CONS - (MAKESTRING "Properties of") - (APPEND - (|bright| - (|prefix2String| |v1|)) - (CONS (MAKESTRING ":") NIL)))) - (COND - ((NULL |pl|) - (COND - ((|member| |v| |pmacs|) - (|sayMSG| - (MAKESTRING - " This is a user-defined macro.")) - (|displayParserMacro| |v|)) - ((|isInterpMacro| |v|) - (|sayMSG| - (MAKESTRING - " This is a system-defined macro.")) - (|displayMacro| |v|)) - ('T - (|sayMSG| - (MAKESTRING " none"))))) - ('T (SPADLET |propsSeen| NIL) - (DO - ((G166451 |pl| - (CDR G166451)) - (G166425 NIL)) - ((OR (ATOM G166451) - (PROGN - (SETQ G166425 - (CAR G166451)) - NIL) - (PROGN - (PROGN - (SPADLET |prop| - (CAR G166425)) - (SPADLET |val| - (CDR G166425)) - G166425) - NIL)) - NIL) - (SEQ - (EXIT - (COND - ((AND - (NULL - (MEMQ |prop| - |propsSeen|)) - |val|) - (COND - ((|member| |prop| - '(|alias| - |generatedCode| - IS-GENSYM - |mapBody| - |localVars|)) - NIL) - ((BOOT-EQUAL |prop| - '|condition|) - (|displayCondition| - |prop| |val| 'T)) - ((BOOT-EQUAL |prop| - '|recursive|) - (|sayMSG| - (MAKESTRING - " This is recursive."))) - ((BOOT-EQUAL |prop| - '|isInterpreterFunction|) - (|sayMSG| - (MAKESTRING - " This is an interpreter function.")) - (|displayProperties,sayFunctionDeps| - |v|)) - ((BOOT-EQUAL |prop| - '|isInterpreterRule|) - (|sayMSG| - (MAKESTRING - " This is an interpreter rule.")) - (|displayProperties,sayFunctionDeps| - |v|)) - ((BOOT-EQUAL |prop| - '|localModemap|) - (|displayModemap| - |v| |val| 'T)) - ((BOOT-EQUAL |prop| - '|mode|) - (|displayMode| - |prop| |val| 'T)) - ('T - (SEQ - (COND - ((BOOT-EQUAL - |prop| - '|value|) - (EXIT - (COND - (|val| - (EXIT - (|displayValue| - |v| |val| - 'T))))))) - (|sayMSG| - (CONS - (MAKESTRING - " ") - (CONS |prop| - (CONS - (MAKESTRING - ": ") - (CONS |val| - NIL))))) - (SPADLET - |propsSeen| - (CONS |prop| - |propsSeen|))))))))))))))) - ('T - (|sayKeyedMsg| 'S2IZ0068 - (CONS |option| NIL))))))))) - (|terminateSystemCommand|)))))))) ;displayModemap(v,val,giveVariableIfNil) == ; for mm in val repeat g(v,mm,giveVariableIfNil) where diff --git a/src/interp/nci.lisp.pamphlet b/src/interp/nci.lisp.pamphlet index 97542f9..4522854 100644 --- a/src/interp/nci.lisp.pamphlet +++ b/src/interp/nci.lisp.pamphlet @@ -48,10 +48,6 @@ (declare (special *package*)) (apply fun args))) -(defun |getParserMacros| () - (declare (special |$pfMacros|)) - |$pfMacros|) - (defun |displayParserMacro| (m) (let ((m (assq m |$pfMacros|))) (declare (special |$pfMacros|)) diff --git a/src/interp/patches.lisp.pamphlet b/src/interp/patches.lisp.pamphlet index c7b4e13..9302a9d 100644 --- a/src/interp/patches.lisp.pamphlet +++ b/src/interp/patches.lisp.pamphlet @@ -456,17 +456,6 @@ It used to read: ;; (|xdrRead| xfoo (make-array 10 :element-type 'long-float )) ;; (setq *print-array* NIL) -;; clearParserMacro has problems as boot code (package notation) -;; defined here in Lisp -;;--------------------> NEW DEFINITION (see i-syscmd.boot.pamphlet) -(DEFUN |clearParserMacro| (|macro|) - (PROG () - (RETURN (COND - ((NULL (IFCDR (|assoc| |macro| |$pfMacros|))) NIL) - ((QUOTE T) (SPADLET |$pfMacros| - (REMALIST |$pfMacros| |macro|))))))) -; - (setq /MAJOR-VERSION 2) (setq echo-meta nil) (defun /versioncheck (n) (unless (= n /MAJOR-VERSION) (throw 'versioncheck -1)))