github.com/PDP-10.its
1
0
Fork 0
mirror of https://github.com/PDP-10/its.git synced 2026-01-11 23:53:12 +00:00
Code Issues Releases Wiki Activity
PDP-10.its/doc/_info_/lisp.stepmm
Eric Swenson 88aae69a9e Added documentation for lisp and lisp libraries.
2016-11-30 17:58:42 +01:00

697 lines
32 KiB
Plaintext
Executable File
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

--- THE LISP STEPPER ---
(FOR MORE INFORMATION THAN PROVIDED HERE CONTACT THE AUTHOR:
MATTHEW MORGENSTERN M.I.T. NE43-317 253-3546
OR :MAIL TO MM; @ML:)
TO LOAD: FROM LISP EXECUTE (FASLOAD STEPMM FASL COM).
NOTE: THE STEPPER HAS BEEN MODIFIED TO WORK IN BOTH OLDIO AND
NEWIO LISP ENVIRONMENTS. AN ENDPAGEFN IS PROVIDED
WITHIN THE STEPPER FOR NEWIO AND IT MAY BE CHANGED BY
GIVING A DIFFERENT VALUE TO THE ATOM MMSTEP-ENDPAGEFN .
THIS IS ALSO THE NAME OF THE INITIAL ENDPAGEFN, AND IT
CAN BE USED OUTSIDE THE STEPPER TOO BY DOING
(ENDPAGEFN T 'MMSTEP-ENDPAGEFN).
TO CURRENT USERS:
A NEW INTERESTING DISPLAY MODE IS NOW AVAILABLE, SEE THE
S COMMAND. OTHER NEW COMMANDS INCLUDE (U -), PATTERN MATCHING
FOR AN S-EXPRESSION IN A (COND ...), E(VAL), WTALL (WAIT-ALL),
WTIF (WAIT-IF), AND VARIABLE LENGTH PAUSING WHILE IN A AND C
MODES.
I CAPABILITIES
THE LISP STEPPER PACKAGE PROVIDES DEBUGGING CAPABILITIES
FOR INTERPRETED LISP PROGRAMS THAT ARE COMPARABLE TO THE CAPABILITIES
PROVIDED BY DDT FOR ASSEMBLER CODE. THESE CAPABILITIES INCLUDE:
1) SINGLE STEPPING THROUGH THE EVALUATION OF A FUNCTION AND
OVER OR INTO OTHER INTERPRETED FUNCTIONS, WHEN CALLED, ON A
SELECTIVE BASIS AS DETERMINED BY THE USER. EACH SUCH FORM
AND ITS RESULTING VALUE MAY BE DISPLAYED.
2) DYNAMIC BREAKPOINTING ON ONE OR MORE OF THE FOLLOWING
CONDITIONS: THE S-EXPRESSION OR ATOM ABOUT TO BE EVALUATED
MATCHES A PATTERN YOU PROVIDE; A SPECIFIC FUNCTION IS EXPLICITLY
EVAL'D; A GIVEN ATOM EVALUATES TO A GIVEN VALUE; A GIVEN ATOM
IS TO BE BOUND IN A PROG, EITHER TYPE OF DO, OR AN EVAL'D
LAMBDA; OR UPON AN ARBITRARY USER-SPECIFIED CONDITION.
3) RETURNING A DIFFERENT VALUE FOR A GIVEN S-EXPRESSION --
THIS ALLOWS FOR CHANGING THE ACTION THAT WOULD BE INITIATED BY
CONDITIONALS IN THE PROGRAM AND/OR BY GO'S IN A PROG OR DO.
YOU CAN ALSO "GO" TO ANY <TAG> INSIDE THE CURRENT PROG.
4) THESE CAPABILITIES MAY BE REQUESTED WHEN THE INITIAL
FUNCTION IS STARTED, OR THEY MAY BE INITIATED AT ANY
OTHER POINT IN THE COURSE OF EXECUTION -- EITHER FROM THE
CONSOLE WHILE IN A BREAKPOINT, OR DIRECTLY FROM THE PROGRAM.
II HOW TO USE
THE STEPPER MAY BE INVOKED INITIALLY BY USING THE
FUNCTION MEV AS ONE WOULD USE EVAL OF ONE ARGUMENT; EG.
(MEV '(FCN ARG1 ARG2)). FROM A BREAKPOINT OR IN A PROGRAM,
THE STEPPER MAY BE TURNED ON BY INVOKING (HKSTART) WITH NO
ARGUMENTS. IT MAY BE TURNED OFF BY THE Q COMMAND DESCRIBED
BELOW, OR OF COURSE BY CONTROL-G. AFTER MEV EVALUATES ITS
ARGUMENT, IT RETURNS THE VALUE AND TURNS OFF THE STEPPER.
NOTE THAT IN THE ABOVE EXAMPLE THE FORM TO MEV WAS QUOTED.
IF, SAY, THE VALUE OF F WAS THE S-EXPRESSION (FCN ARG1 ARG2),
THEN ONE COULD USE (MEV F) INSTEAD.
AT ANY POINT DURING THE STEPPING, ONE MAY INSPECT THE
VALUES OF OTHER VARIABLES, AND EVEN REAPPLY MEV TO ANY FORM.
THIS MAY BE DONE IN EITHER OF THREE WAYS. EACH COMMAND WILL BE
PROMPTED FOR BY // , USUALLY FOLLOWING THE LAST FORM PRINTED
OUT. ANY S-EXPRESSION THAT YOU TYPE WHICH IS NOT RECOGNIZED AS
A COMMAND WILL BE EVAL'D (WITHIN AN ERRSET TO CATCH ERRORS).
ALTERNATIVELY, YOU CAN USE THE E COMMAND TO EVAL ANY EXPRESSION,
OR THE H COMMAND TO GET A NICE TYPE OF CONTROL-H BREAK.
EACH COMMAND MUST BE FOLLOWED BY A SPACE (UNLESS THE
COMMAND IS A LIST). EACH FORM AND RESULT WHICH IS
PRINTED OUT WILL BE FOLLOWED BY #<NUMBER> INDICATING THE
RELATIVE LEVEL OF EVALUATION (IE. STACK DEPTH SINCE INVOCATION).
THE PRIMARY COMMANDS ARE:
D (MNEMONIC FOR DOWN) GO DOWN TO THE NEXT DEEPER LEVEL OF
EVALUATION AND DISPLAY THE FIRST FORM THERE BEFORE EVALUATING
IT. EG. IF THE FORM IS A FUNCTION CALL, WILL DISPLAY THE FIRST
ARGUMENT OF THE FUNCTION IF IT HAS ARGUMENTS IN THE CALL;
ELSE WILL DISPLAY THE FIRST S-EXP OF THE FUNCTION.
THEN PROMPTS FOR THE NEXT COMMAND.
E (EVAL) CAN BE USED TO EVAL AN ARBITRARY EXPRESSION. IT
STARTS A NEW LINE, WAITS FOR YOU TO TYPE THE EXPRESSION,
THEN EVAL'S IT WITHIN AN ERRSET, AND PRINTS THE RESULT.
COMPARABLE TO JUST TYPING THE EXPRESSION OR ATOM AFTER
THE //, BUT CANNOT BE CONFUSED WITH A COMMAND, AND THE
FORMAT IS NICER.
H (CONTROL-H) EXECUTES A CONTROL-H BREAK, AND WHEN $P'ED
DISPLAYS THE CURRENT FORM. WITHIN THE BREAK, ONE CAN
INSPECT THE VALUES OF VARIABLES, ETC., AND EVEN REAPPLY MEV
TO ANY FORM.
N (NEXT) DISPLAY THE NEXT FORM (IE. S-EXP) AT THIS LEVEL,
WITHOUT SHOWING OR INSPECTING THE EVALUATION OF THE LOWER
LEVELS OF THE CURRENT FORM. THE VALUE OF THE CURRENT FORM
IS DISPLAYED FIRST. IF YOU WISH A CONDITION TO BE TESTED FOR
AT LOWER LEVELS, USE NN INSTEAD.
NN LIKE N BUT SLOWER SINCE IT INSPECTS THE LOWER LEVELS.
USE INSTEAD OF N WHEN TESTING FOR A CONDITION.
U (UP) GO UP TO THE NEXT HIGHER LEVEL OF EVALUATION AND SHOW
THE NEXT FORM AT THAT LEVEL. THE FORM(S) AT THE CURRENT AND
LOWER LEVELS ARE EVALUATED WITHOUT DISPLAY. AS AN EXAMPLE
OF ITS USE, AFTER YOU HAVE SEEN THE EVALUATION OF THE
ARGUMENTS TO A FUNCTION, THE NEXT FORM TO BE EVALUATED, IF
THE FUNCTION IS BEING INTERPRETED, WILL BE THE FIRST
S-EXPRESSION OF THE FUNCTION; TO AVOID SEEING HOW THE
FUNCTION IS EVALUATED INTERNALLY, YOU CAN TYPE U .
NOTE THAT THE LOWER LEVELS ARE NOT INSPECTED -- THUS
IF A CONDITION IS TO BE TESTED FOR AT THESE LEVELS, USE UU.
(U <NUM>) IF <NUM> IS POSITIVE (INCL. 0), FORMS ARE NOT
INSPECTED NOR DISPLAYED UNTIL THAT LEVEL NUMBER IS RETURNED
TO. IF NEGATIVE, GOES UP THIS NUMBER (ABSOLUTE VALUE) OF
LEVELS RELATIVE TO THE CURRENT LEVEL. THUS (U -1) IS
EQUIVALENT TO U .
UU LIKE U BUT SLOWER. USE IF TESTING FOR A CONDITION.
(UU <NUM>) LIKE (U <NUM>) BUT SLOWER. USE IF TESTING FOR A
CONDITION.
Q (QUIT) EXIT FROM THE STEPPER.
S (SHOW OR DISPLAY MODE) FOR DATAPOINTS AND OTHER DISPLAY
CONSOLES, THIS GIVES A NICE EASY READING OUTPUT
OF SELECTED LEVELS THAT CONSTITUTE THE CONTEXT OF THE
CURRENT EVALUATION. SPECIFICALLY, IT SELECTS THE CURRENT
LEVEL FOR SPRINTING AS A "HEADER", AND AS YOU GO DEEPER, THE
LOCAL CONTEXT IS ABBREVIATE-PRINTED UNDER THIS HEADER, AND
THE CURRENT OUTPUT WILL BE SPRINTED. S MAY BE USED AS OFTEN
AS YOU LIKE. HEADERS WILL AUTOMATICALLY BE POPPED WHEN YOU
RETURN . THE COMMAND (S <NUM>) SELECTS A PARTICULAR LEVEL
AS A HEADER. IT AND THE COMMAND SN AND SEVERAL USER
SETTABLE PARAMETERS ARE DESCRIBED IN THE MORE DETAILED
SECTION BELOW.
(= <S-EXP>) THE S-EXPRESSION IS SUBSTITUTED FOR THE CURRENT
FORM AND ANOTHER COMMAND IS PROMPTED FOR (IE. YOU CAN STEP
INTO OR OVER THE NEW FORM IF YOU WANT TO). WHEN THE
RESULTING VALUE IS RETURNED IT WILL BE AS IF THE
ORIGINAL FORM HAD YIELDED THAT VALUE. FOR
EXAMPLE YOU CAN CHANGE THE APPARENT TRUTH OR FALSITY OF
PREDICATES OR BYPASS A (GO <LABEL>), AS WELL AS JUST RETURN-
ING DIFFERENT VALUES FOR AN S-EXPRESSION.
(COND ...) TESTS FOR CONDITIONS PRIOR TO EVALUATION OF EACH
FUTURE FORM, AND WHEN SATISFIED WILL PRINT A MESSAGE,
DISPLAY THE FORM, AND WAIT FOR ANOTHER COMMAND (WHICH
MAY OF COURSE BE H FOR A BREAK). THE ARGUMENT TO THIS
"COND" IS AN ARBITRARY S-EXPRESSION OR ATOM WHICH IS
EVALUATED LIKE A PREDICATE (SIMILAR TO THAT IN THE
TRACE PACKAGE).
IN SPECIFYING THE PREDICATE, THE FORM ABOUT TO BE
EVALUATED MAY BE OBTAINED AS THE VALUE OF %%FORM. THE
FUNCTION (HOOKLEVEL) RETURNS THE RELATIVE LEVEL OF EVALUATION.
MORE THAN ONE ARGUMENT MAY BE GIVEN, IN WHICH CASE
THEY ARE OR'ED TOGETHER, EXCEPT WHEN TWO ARGUMENTS FORM A
SPECIAL TEST AS DESCRIBED IN THE MORE DETAILED SECTION BELOW.
THE CONDITION WILL REMAIN ACTIVE AT ALL LEVELS THAT ARE
INSPECTED BY THE STEPPER UNTIL EXPLICITLY TURNED OFF BY
(COND NIL).
(MATCHF ...) IS A FUNCTION WHICH WILL PATTERN MATCH AGAINST
THE CURRENT FORM, AND MAY BE USED IN THE PREDICATE OF THE
COND. (ALSO SEE ITS RELATED USE AS A COMMAND.) THE ARGUMENT
TO MATCHF IS COMPARED TO %%FORM ELEMENT BY ELEMENT FROM LEFT
TO RIGHT, AND SUCCEEDS WHEN EACH ELEMENT OF THE PATTERN
SUCCEEDS. OF IMPORTANCE, THE PATTERN NEED NOT INCLUDE THE
ENTIRE S-EXPRESSION OF %%FORM. * MATCHES ANYTHING. THE
PROCEDURE IS APPLIED RECURSIVELY TO SUBLISTS, UNLESS THE
SUBLIST IS OF THE FORM (# ...) IN WHICH CASE # IS BOUND TO
THE CURRENT ELEMENT OF %%FORM AND THE CDR (NOT CADR) OF THE
#-LIST IS EVAL'D AS THE TEST ON THAT ELEMENT. EXCEPT IN THIS
CASE, ATOMS AND LISTS SHOULD BE GIVEN AS IN THE ORIGINAL CODE
AS THEY ARE NOT EVALUATED. SOME SIMPLE EXAMPLES ARE:
(MATCHF XYZ) SUCCEEDS IF THE ATOM XYZ IS ABOUT TO BE EVAL'D
(MATCHF (SETQ ALPHA)) SUCCEEDS IF THE ATOM ALPHA IS ABOUT TO
BE SETQ'D.
(MATCHF (PUTPROP NAME * 'SOURCE)) SUCCEEDS IF THE PROPERTY
SOURCE IS ABOUT TO BE PUTPROP'D ON THE ATOM POINTED TO
BY (IE. THE VALUE OF) NAME.
(MATCHF (SETQ (# MEMBER # '(ALPHA BETA S3)))) SUCCEEDS IF
EITHER ALPHA, BETA, OR S3 ARE ABOUT TO BE SETQ'D.
(MATHCF (RPLACD * '(* 9))) FOR EXAMPLE MATCHES
(RPLACD (LAST URLIST) '(2 9 4))
(MATHCF ((# MEMBER # '(FOO BAR)))) SUCCEEDS IF A FUNCTION
CALL TO EITHER FOO OR BAR IS ABOUT TO BE EVAL'D (MORE
PRECISELY IF THE CAR OF THE LIST ABOUT TO BE EVAL'D
IS EITHER FOO OR BAR).
NIL (COND NIL) TURNS THE CONDITION OFF AND SAVES THE
CURRENT NON-NIL CONDITION.
(COND) WHEN NO ARGUMENT IS GIVEN, THE LAST NON-NIL CONDITION
(WHICH IS THE 'OLD PROPERTY OF '%%COND) IS ESTABLISHED
AS THE CURRENT CONDITION (WHICH IS THE VALUE OF
%%COND). (IF THE PREVIOUS CONDITION WAS NOT NIL THEN
IT IS SAVED AS THE 'OLD PROPERTY, THUS ALLOWING FOR
ALTERNATION OF TWO CONDITIONS.)
(MATCHF ...) IS EQUIVALENT TO (COND (MATCHF ...)), SEE ABOVE.
RELATED FUNCTIONS:
(HKSTART) WILL INITIATE STEPPING WHEN ENCOUNTERED IN A PROGRAM
OR TYPED FROM A BREAKPOINT. (HKSTOP) WILL ACT LIKE THE Q
COMMAND TO TURN OFF STEPPING. (ALSO SEE BELOW FOR MORE INFO.)
(MBAK) IS A FUNCTION TO BE USED LIKE THE LISP SYSTEM'S
(BAKLIST). (MBAK) STRIPS OUT FROM THE RESULT OF (BAKLIST)
THOSE FUNCTIONS THAT HAVE TO DO WITH THE STEPPER.
-------------------------
III COMPLETE LIST OF COMMANDS:
COMMANDS WHICH ARE NOT LISTS MUST BE FOLLOWED BY A SPACE.
YOU CAN USE RUBOUT BEFORE COMPLETING THE COMMAND (AND ITS SPACE
IF NECESSARY). ALTERNATIVELY YOU MAY ABORT THE COMMAND
BEFORE COMPLETING IT BY DOING CONTROL-X.
ANY S-EXPRESSION THAT YOU TYPE WHICH IS NOT RECOGNIZED AS A
COMMAND WILL BE EVAL'D (WITHIN AN ERRSET TO CATCH ERRORS). THUS
YOU CAN EVALUATE ANY ATOM OR DO ANY FUNCTION CALL SIMPLY BY
TYPING IT FOLLOWING THE PROMPTING // SO LONG AS IT IS NOT
INTERPRETABLE AS ONE OF THE COMMANDS BELOW (OR NIL). NOTE THAT
YOU CAN ACTUALLY "GO" TO A <TAG> WITHIN YOUR PROGRAM SIMPLY BY
TYPING (GO <TAG>) AFTER THE //. TO EVALUATE A FORM WHICH LOOKS
LIKE A COMMAND, TYPE (OR <S-EXP>) TO EVALUATE IT, EG. (OR A)
EVALUATES THE ATOM A. (IF YOU WISH YOU CAN EVEN WRITE FUNCTIONS
WITH REGARD TO THE STEPPER AND TREAT THEM AS COMMANDS.)
A (ALL) AUTOMATICALLY DISPLAYS ALL FORMS AND VALUES SEEN BY
THE STEPPER AT ALL LEVELS. TYPING A SPACE AT ANY TIME
THEREAFTER WILL CAUSE THE STEPPER TO LEAVE THIS MODE AND
PROMPT FOR A NEW COMMAND. IF YOU WANT THE STEPPER TO WAIT
FOR A COMMAND AFTER EACH FORM, YOU CAN USE THE D COMMAND.
COMMANDS A AD (A -) C AND CC PAUSE AFTER EACH NEW FORM
IS DISPLAYED IF %%AC-SLEEP IS NON-NIL, ITS VALUE IS USED AS
THE SLEEP TIME IN SECONDS.
AD (ALL DOWN) AUTOMATICALLY DISPLAYS ALL FORMS AND VALUES
ENCOUNTERED BY THE STEPPER IN EVALUATING THE CURRENT FORM
(IE. AT DEEPER LEVELS). TYPING A SPACE PRIOR TO COMPLETION
WILL CAUSE THE STEPPER TO LEAVE THIS MODE AND PROMPT FOR A
NEW COMMAND. (ALSO SEE D.) SLEEPS AFTER EACH FORM, AS
DESRIBED UNDER THE A COMMAND.
(A <LEV>) AUTOMATICALLY DISPLAYS ALL FORMS AND VALUES AT THE
INDICATED LEVEL AND LOWER (DEEPER) LEVELS, TURNING ITSELF
OFF WHEN EVALUATION POPS TO A LEVEL WITH A SMALLER LEVEL
NUMBER. TYPING A SPACE PRIOR TO COMPLETION WILL CAUSE
THE STEPPER TO LEAVE THIS MODE AND PROMPT FOR A NEW
COMMAND. (ALSO SEE D.) SLEEPS AFTER EACH FORM, AS
DESRIBED UNDER THE A COMMAND.
B SETS A BREAKPOINT TO OCCUR AFTER EVALUATION OF THE CURRENT
FORM. AT THE BREAK, THE VALUE TO BE RETURNED IS THE VALUE
OF %%VALUE, AND MAY BE CHANGED BY SETQING THIS VARIABLE.
THE FORM THAT YIELDED THIS VALUE IS THE VALUE OF %%FORM.
DO $P TO PROCEED FROM THE BREAKPOINT. IF YOU PREFER THE
SYSTEM TO WAIT RATHER THAN BREAK SEE THE WTIF COMMAND.
(B OPERATES BY ADDING THE CURRENT HOOKLEVEL TO
%%BREAKLIST.) YOU CAN GET AUTOMATIC BREAKING AT ALL LEVELS
BY USING (RETCOND T) OR CONDITIONAL BREAKING AS DESCRIBED
BELOW FOR THE (RETCOND ...) COMMAND.
C (CURRENT) AUTOMATICALLY DISPLAYS ALL FORMS AND VALUES AT
JUST THE CURRENT LEVEL. TYPING A SPACE AT ANY TIME DURING
THE DISPLAY WILL CAUSE THE STEPPER TO LEAVE THIS MODE AND
PROMPT FOR A NEW COMMAND. THE STEPPER DOES NOT INSPECT
THE FORMS OF LOWER LEVELS -- THUS IF A CONDITION IS TO
BE TESTED FOR AT THESE LEVELS, USE CC. SLEEPS AFTER EACH
FORM, AS DESRIBED UNDER THE A COMMAND.
CC LIKE C, BUT INSPECTS THE LOWER LEVELS.
CTOG FLIPS THE %%CONDNOTALLOW TOGGLE WHICH IS INITIALLY T,
MEANING DO NOT ALLOW C, M, N, OR U COMMANDS IF A CONDITION
IS BEING TESTED FOR. NIL MEANS ALLOW THESE ANYWAY.
(COND ...) TESTS FOR CONDITIONS PRIOR TO EVALUATION OF EACH
FUTURE FORM. FOR PATTERN MATCHING AGAINST THE FORM USING
THE MATCHF FUNCTION AND FOR OTHER INFOR. ALSO SEE THE
DESCRIPTION OF (COND ...) IN SECTION II ABOVE.
SPECIAL TESTS FOR (COND ...) :
TO AID THE SPECIFICATION OF COMMON TESTS, THE FOLLOWING
"FLAGS" ARE PROVIDED -- THE SAME EFFECTS COULD BE OBTAINED
BY INSPECTING %%FORM IN YOUR OWN PREDICATE GIVEN TO "COND".
IF THE FIRST ARGUMENT TO THE COND IS FROM THE SET:
(FORM FORMQ BIND BINDQ ATOMVAL ATOMVALQ
FCN FCNQ AND ANDQ)
THEN THE SECOND ARGUMENT IS USED TO DERIVE A TEST.
THIS PROCESS IS REPEATED WITH THE REMAINING ARGUMENTS,
IF ANY. THE RESULTING TESTS, TOGETHER WITH ANY
REMAINING ARGUMENTS NOT SATISFYING THIS PROCESS, ARE
EFFECTIVELY OR'ED TOGETHER TO DERIVE THE OVERALL
CONDITION (EXCEPT FOR THE "AND ANDQ FLAG" SPECIAL TESTS
WHICH ARE AND'ED). THE ARGUMENTS ARE NOT EVALUATED WHEN
TYPED BUT ARE EVAL'D EACH TIME THE CONDITION IS TESTED.
THESE FLAGS EACH MAY BE USED MORE THAN ONCE.
THE MEANING OF THESE FLAGS ARE:
ANDQ THE NEXT ARGUMENT IS AND'ED WITH THE REMAINING
TESTS, AND MUST YIELD A NON-NIL VALUE FOR THE
REMAINDER OF THE CONDITION TO SUCCEED. (SEE THE
COMMENTS FOR COND IN THE "COMPLETE LIST OF
COMMANDS" BELOW REGARDING THE USE OF SIDE EFFECTS)
ATOMVALQ THE NEXT ARGUMENT SHOULD BE A LIST OF TWO
ELEMENTS, THE FIRST AN (UNQUOTED) NAME OF AN ATOM,
AND THE SECOND THE VALUE OF THIS ATOM FOR THE TEST
TO SUCCEED.
BINDQ WATCH FOR THE FOLLOWING (UNQUOTED) ATOM
TO BE BOUND IN A PROG, OR IN EITHER TYPE OF DO, OR
AN EXPLICITLY "EVAL'D" LAMBDA (AS DISTINCT FROM AN
"APPLY'D" LAMBDA OR FUNCTION CALL).
FCNQ WATCH FOR THE FOLLOWING (UNQUOTED) FUNCTION NAME
TO BE SEEN BY "EVAL" AS THE "CAR" OF THE FORM
ABOUT TO BE EVALUATED (CANNOT CHECK FOR "APPLY'D"
OR "MAP'D" FUNCTION CALLS).
FORMQ THE FOLLOWING (UNQUOTED) S-EXP IS TO BE WATCHED
FOR. EG.USE TO CHECK WHEN AN ATOM IS ABOUT TO BE
EVALUATED.
AND : THESE EVALUATE THEIR ARGUMENT EACH TIME THE
BIND : CONDITION IS TESTED IN ORDER TO GET THE DESIRED
FCN : S-EXP OR ATOM NAME, AND THEN PERFORM LIKE THEIR
FORM : "Q" COUNTERPARTS. PARTICULARLY USEFUL IF THE
: FLAG'S ARGUMENT IS THE VALUE OF AN ATOM.
: (BE SURE NOT TO CHANGE THE ATOM'S VALUE ACCIDENT-
: ALLY WHILE THE CONDITION REMAINS IN EFFECT.)
ATOMVAL SIMILARLY, EVALUATES THE CAR OF ITS ARGUMENT TO GET
THE ATOM NAME, AND THEN ACTS LIKE ATOMVALQ.
AS A SIMPLE EXAMPLE, (COND FCNQ RPLACD) WILL CHECK AND
STOP WHEN THE FUNCTION RPLACD IS ABOUT TO BE EVALUATED
(IE. WHEN IT IS THE THE "CAR" OF THE FORM TO BE EVAL'D).
THE COMMANDS C, M, N, AND U DO NOT INSPECT ALL
LEVELS, AND THUS THE CONDITION CANNOT BE TESTED FOR AT
THESE LEVELS. YOU CAN USE CC, NN, MM, OR UU INSTEAD, OR
USE THE CTOG COMMAND. NATURALLY, CONDITION TESTING SLOWS
THE SPEED OF EXECUTION AT LEVELS THAT ARE INSPECTED BY
THE STEPPER BUT WHICH YOU DO NOT HAVE DISPLAYED.
IF YOU CHOOSE TO, YOU CAN HAVE YOUR PREDICATES
PRODUCE SIDE-EFFECTS SUCH AS RECORDING INFORMATION OF VALUE
TO YOU OR SETTING STATES FOR USE BY THE CONDITION LATTER.
YOU CAN USE THE AND ANDQ FLAGS (MORE THAN ONCE IF
YOU LIKE) TO HAVE THE EXPRESSIONS EXECUTED EVEN UPON
SUCCESS, SO LONG AS THESE FLAGS APPEAR FIRST IN THE
CONDITION. OTHER CONDITIONS ARE EVALUATED IN THE ORDER
OF APPEARANCE UNTIL THE FIRST SUCCESS IS FOUND.
D (DOWN) DISPLAYS THE NEXT LEVEL DOWN (AS DESCRIBED ABOVE ALSO).
NOTE THAT IF THE FORM IS AN ATOM, THE EFFECT IS THE SAME
AS THE N COMMAND. HENCE IF YOU WANT THE STEPPER TO DISPLAY
EVERY FORM AND VALUE, BUT TO WAIT FOR A COMMAND AFTER EACH
FORM, JUST KEEP USING THE D COMMAND.
E (EVAL) CAN USE TO EVAL AN ARBITRARY EXPRESSION. IT STARTS
A NEW LINE, WAITS FOR YOU TO TYPE IT, THEN EVAL'S IT WITHIN
AN ERRSET, AND PRINTS THE RESULT. COMPARABLE TO JUST
TYPING THE EXPRESSION OR ATOM AFTER THE //, BUT CANNOT BE
CONFUSED WITH A COMMAND, AND THE FORMAT IS NICER.
(= <S-EXP>) REPLACES THE CURRENT FORM WITH THE GIVEN
S-EXPRESSION, AND THEN PROMPTS FOR ANOTHER COMMAND,
AS DESCRIBED ABOVE. IF TWO ARGUMENTS ARE GIVEN, THEN
THIS EXPRESSION WILL NOT BE TREATED AS A STEPPER COMMAND,
RATHER IT WILL BE EVALUATED (SEE COMMENTS AT TOP OF THIS
SECTION).
H CONTROL-H BREAK IS EXECUTED. CURRENT FORM IS REDISPLAYED
WHEN $P IS DONE. THE FORM ABOUT TO BE EVALUATED IS THE
VALUE OF %%FORM. WITHIN THE BREAK, ONE CAN INSPECT
THE VALUES OF VARIABLES, ETC., AND EVEN REAPPLY MEV TO
ANY FORM.
K (KILL) DOES NOT EVALUATE THE CURRENT FORM NOR DISPLAY
ANY VALUE. EG. GOOD FOR AVOIDING SIDE EFFECTS IF
RESTEPPING THROUGH A PROGRAM AGAIN. EQUIVALENT TO (= NIL)
FOLLOWED BY M COMMAND.
LR (LAST RESULT) A COMPLETE RATHER THAN ABBREVIATED PRINTOUT
OF THE LAST RESULT IS GIVEN. (SEE (P - -) FOR FURTHER INFO)
M NEXT, LIKE N BUT THE RESULT OF THE CURRENT FORM IS NOT
DISPLAYED. IF A CONDITION IS TO BE TESTED FOR AT LOWER
LEVELS, USE MM.
(MATCHF ...) IS EQUIVALENT TO (COND (MATCHF ...)), SEE THE
THE DESCRIPTION OF (COND ...) IN SECTION II ABOVE.
MM NEXT, LIKE NN BUT THE RESULT OF THE CURRENT FORM IS NOT
DISPLAYED
N (NEXT) DISPLAYS THE VALUE OF THE CURRENT FORM AND DISPLAYS
THE NEXT FORM, THEN AWAITS THE NEXT COMMAND. DOES NOT
INSPECT THE LOWER LEVELS. IF A CONDITION IS TO BE TESTED
FOR AT LOWER LEVELS, USE NN INSTEAD.
NN LIKE N BUT INSPECTS THE LOWER LEVELS.
O (OLD) DOES (MEV '<LAST FORM>). USEFUL FOR SEEING HOW A
FORM PRODUCED AN UNEXPECTED VALUE WHEN YOU WENT OVER IT
WITH N OR NN. IF REEVALUATING THE FORM CAN PRODUCE SIDE
EFFECTS BE CAREFUL. CAN BE EXITED FROM BY THE XX COMMAND.
(THE OLD FORM IS THE VALUE OF %%OLDFORM.)
OL (OLD, AT CURRENT LEVEL) DOES (MEV '<LAST FORM AT THIS
LEVEL>). BEHAVES LIKE O. USEFUL TO SEE THE FORM (AT
THIS LEVEL) WHICH PRODUCED THE CURRENT VALUE -- RATHER
THAN THE LAST FORM PRINTED OUT, AS O WOULD YIELD.
(THE OLD FORM USED HERE CAN BE OBTAINED BY
(GET %%HOOKLEVEL 'OLDFORM).)
P (PRINT) REDISPLAYS THE CURRENT FORM. EG. USEFUL IF YOU
WISH TO CLEAR SCREEN FIRST WITH CONTROL-L. GIVES TYPICAL
ABBREVIATED DISPLAY (SEE (P - -)), EXCEPT HAS SOMEWHAT
DIFFERENT EFFECT IF IN DISPLAY MODE (SEE S COMMAND).
(FOR HACKERS OF SPECIAL DATA STRUCTURES, EG "OWL",
PRINTING WILL BE DONE WITH THE FUNCTION WHICH IS THE
VALUE OF THE ATOM PRIN1 IF NON-NIL -- AS ALSO APPLIES
TO TOP-LEVEL IN LISP. THIS VALUE OF PRIN1 IS CHECKED
ONLY IN MEV FUNCTION. MOREOVER, UNLESS YOU REQUEST
LISP NOT TO "SNAP LINKS" IN COMPILED CODE, YOU MAY HAVE
TO RELOAD THE STEPPER AFTER CHANGING PRIN1. TO AVOID
THE RELOADING MESSAGES HAVE FASLOAD = NIL.)
PP (FULL PRINT) GIVES A COMPLETE PRINTOUT OF THE CURRENT FORM.
3
PPP (P , IE. EVEN BETTER PRINTOUT) PRETTY-PRINTS THE CURRENT
FORM USING THE SPRINT FUNCTION. USES A LOT OF SCREEN IN
GENERAL, AND SO WILL PAGEPAUSE FOR YOU.
(P - -) RESETS THE PARAMETERS FOR THE ABBREVIATED PRINTOUT USED
FOR RESULTS, FORMS AND THE P COMMAND. FIRST PARAMETER IS
THE PRINLEVEL, THE SECOND IS PRINLENGTH (AS IN THE LISP
MANUAL); BOTH MUST BE GIVEN. IF NIL IS GIVEN INSTEAD OF A
NUMBER NO ABBREVIATING IS DONE WITH RESPECT TO THAT
PARAMETER; THUS (P NIL NIL) TURNS OFF ABBREVIATING. (THE
CURRENT SETTINGS ARE THE VALUE OF %%HOOKPRIN.)
Q (QUIT) EXITS FROM THE STEPPER. PREVIOUSLY REQUESTED BREAKS
AND CONDITIONS ARE DISABLED, AND ANY NON-NIL CONDITIONS
ARE SAVED ON THE 'OLD PROPERTY OF THE CONDITON NAME.
(CONTROL-G ALSO EXITS AS USUAL.)
S (SHOW OR DISPLAY MODE) FOR DATAPOINTS AND OTHER DISPLAY
CONSOLES, THIS GIVES A NICE EASY READING OUTPUT
OF SELECTED LEVELS THAT CONSTITUTE THE CONTEXT OF THE
CURRENT EVALUATION. SPECIFICALLY, IT SELECTS THE CURRENT
LEVEL FOR SPRINTING AS A "HEADER", AND AS YOU GO DEEPER,
THE LOCAL CONTEXT IS ABBREVIATE-PRINTED UNDER THIS HEADER,
AND THE CURRENT OUTPUT WILL BE SPRINTED. S MAY BE USED AS
OFTEN AS YOU LIKE. HEADERS WILL AUTOMATICALLY BE POPPED
WHEN YOU RETURN. ALL SPRINTING IS DONE WITH PAGEPAUSE ON.
IF CONTROL-X IS TYPED DURING SPRINTING, THAT EXPRESSION
WILL BE REDISPLAYED USING ABBREVIATED-PRINTING INSTEAD.
WHEN IN THIS DISPLAY MODE, THE P COMMAND WILL CLEAR THE
SCREEN FROM THE LAST FORM DOWN, UNLESS PRECEEDED BY
CONTROL-L (OR IF WRAP-AROUND OCCURRED), IN WHICH CASE THE
SCREEN IS FULLY REDISPLAYED. ALSO SEE (S <ARG>) FOR MORE
INFORMATION AND OPTIONS.
(S <ARG>) IF <ARG> IS POSITIVE, SELECTS THE FORM AT THAT LEVEL
AS THE "HEADER" FOR S(HOW) MODE. IF NEGATIVE, USES THE
FORM AT <ARG> LEVELS ABOVE THE CURRENT ONE. IF <ARG> IS
NIL, DISPLAY MODE IS TURNED OFF (HEADERS ARE REMEMBERED
THO). (S T) JUST TURNS DISPLAY MODE ON IF CURRENTLY OFF
USING THE PREVIOUSLY REMEMBERED HEADERS IF STILL APPLICABLE
; BUT IF ALREADY ON, THIS POPS THE STACK OF HEADERS BY ONE
(NORMALLY HEADERS ARE AUTOMATICALLY POPPED WHEN THE LEVEL
RETURNED FROM). ALL SPRINTING IS DONE WITH PAGEPAUSE ON.
IF CONTROL-X IS TYPED DURING SPRINTING, THAT EXPRESSION
WILL BE REDISPLAYED USING ABBREVIATED-PRINTING INSTEAD.
ALSO SEE SN COMMAND.
SEVERAL PARAMETERS ARE USER SETTABLE FROM THEIR
DEFAULTS. %%LOWERDISPLAY AND %%LOWERDISPLAY-MIN CONTROL
THE MAX AND MIN NUMBER OF LEVELS TO DISPLAY BELOW THE
HEADER (DEFAULTS OF 5 AND 2). THIS IS DONE IN IN
ABBREVIATE-PRINTED FORM USING %%SHORTPRIN WHICH IS A
LIST OF THE PRINLEVEL AND PRINLENGTH (DEFAULT 3 3).
SPRINTING OF FORMS AND RESULTS WILL BE ABBREVIATE-SPRINTED
BY THE MSPRINT FUNCTION IF THE FLATSIZE OF THE EXPRESSION
EXCEEDS %%FLATSIZE-MAX (DEFAULT ABOUT 450). THE PRINLEVEL
AND PRINLENGTH FOR THE LATTER ARE THE LIST %%SPRINTABBR
(DEFAULT IS 7 8). IF %%FLATSIZE IS NIL, FULL SPRINTING
WILL ALWAYS BE USED; (IF NEGATIVE, ABBREVIATE SPRINTING
WILL ALWAYS BE USED SO THAT INFINITE PRINTING
CIRCULAR STRUCTURES WILL SPRINT AND ABBREVIATE-PRINT
FINITELY -- REQUESTED BY SUN; FOR "OWL" WORKERS).
TO TURN OFF SPRINTING OF RESULTS SETQ
%%RESULT-SPRINT TO NIL (DEFAULT T). IF %%MDISTITLE IS
NEITHER NIL OR A NUMBER, IT WILL BE EVAL'D JUST AFTER THE
SCREEN IS CLEARED, ALLOWING PRINTING OF A TITLE. IF IT IS
A NUMBER, THAT NUMBER OF BLANK LINES WILL BE LEFT AT THE
TOP OF THE SCREEN (ALSO SEE SVIEWMSG FUNCTION BELOW).
IF THE PARTIAL CLEARING OF THE SCREEN BOTHERS YOUR EYES,
SETQ'ING %%EYESTRAIN1 TO A NUMBER OF SECONDS (EG 0.5
TO 2.0) WILL SLOW DOWN THE NEW DISPLAY DEPENDING ON THE
NUMBER OF LINES CLEARED.
SN JUST FOR S(HOW) DISPLAY MODE. IT PREVENTS CLEARING OF THE
SCREEN AFTER PROMPTING FOR ANOTHER COMMAND, BUT ONLY UNTIL
THE NEXT PROMPTING // AFTER THAT. USEFUL IF YOU WANT A
RESULT TO REMAIN DISPLAYED A LITTLE LONGER. IF YOU WANT TO
PREVENT CLEARING OF THE SCREEN FOR MORE THAN A COUPLE OF
TIMES, USE (S NIL), THEN DO (S T) WHEN YOU WANT TO RESUME
DISPLAY MODE.
(RETCOND ...) TESTS FOR CONDITIONS JUST AFTER EACH FORM IS
EVALUATED, AND BREAKS WHEN SUCH CONDITION IS SATISFIED.
AT THE BREAK, THE VALUE TO BE RETURNED IS THE VALUE
OF %%VALUE, AND MAY BE CHANGED BY SETQING THIS VARIABLE.
THE FORM THAT YIELDED THIS VALUE IS THE VALUE OF %%FORM.
DO $P TO PROCEED FROM THE BREAKPOINT. THE CONDITIONS ARE
SPECIFIED AS FOR (COND ...) NOTE THAT (RETCOND T) WILL
GIVE YOU A BREAK AS EACH LEVEL IS POPPED (RETURNED FROM),
INCLUDING LEVELS ABOVE THE ONE WHERE THE REQUEST WAS
MADE. (RETCOND NIL) DISABLES THE RETCOND. IF YOU PREFER
WAITING RATHER THAN BREAKING SEE THE WTIF COMMAND.
ALSO, TWO ADDITIONAL FLAGS ARE AVAILBLE:
VALUEQ THE TEST (EQUAL %%VALUE <NEXT-ARGUMENT>) IS
PERFORMED AS IF IT WERE ANDED WITH THE REMAINING
PREDICATES IN THE CONDITION.
VALUE LIKE VALUEQ BUT THE TEST IS
(EQUAL %%VALUE (EVAL <NEXT-ARGUMENT>)) .
THE OVERALL CONDITION IS MAINTAINED ON THE ATOM %%RETCOND,
AND THE PREVIOUS NON-NIL CONDITION IS ON THE 'OLD PROPERTY
OF THIS ATOM. IF YOU WANT BOTH COND AND RETCOND CONDITIONS
TO BE THE SAME YOU CAN (SETQ %%RETCOND %%COND). THE VALUE
AND VALUEQ PREDICATES WILL BE IGNORED IN A (COND ...).
U (UP) GO UP TO NEXT HIGHER LEVEL. CURRENT AND LOWER LEVELS
ARE EXECUTED WITHOUT DISPLAY. THE LOWER LEVELS ARE NOT
INSPECTED -- THUS IF A CONDITION IS TO BE TESTED FOR AT
THESE LEVELS, USE UU. CAN BE USED TO SKIP THE DISPLAY
OF A FUNCTION'S INTERNAL EVALUATION AFTER HAVING
SEEN THE ARGUMENTS, AS DESCRIBED IN THE PREVIOUS SECTION.
(U <NUM>) IF <NUM> IS POSITIVE (INCL. 0), FORMS ARE NOT
INSPECTED NOR DISPLAYED UNTIL THAT LEVEL NUMBER IS REACHED.
IF NEGATIVE, GOES UP THIS NUMBER (ABSOLUTE VALUE) OF LEVELS
RELATIVE TO THE CURRENT LEVEL. THUS (U -1) IS EQUIVALENT
TO U .
UU LIKE U, BUT ALSO INSPECTS LOWER LEVELS. USE IF YOU
HAVE A CONDITION TO BE TESTED.
(UU <NUM>) LIKE (U <NUM>) BUT SLOWER. USE IF TESTING FOR A
CONDITION. NOTE THAT (UU -999) EFFECTIVELY MEANS THAT
YOU WON'T SEE ANY LEVELS UNLESS THE CONDITION IN A COND
OR RETCOND IS SATISFIED.
WTAL (WAIT-ALL) FLIPS A TOGGLE WHICH WHEN ON CAUSES A PAUSE
AFTER THE EVALUATION OF EVERY FORM, BUT BEFORE THAT VALUE
IS RETURNED. THE SYSTEM WAITS FOR AN INPUT CHARACTER.
TYPING Y(ES), B(REAK), OR H (FOR CONTROL-H) FOLLOWED BY
SPACE WILL CAUSE A BREAK AS WOULD THE B COMMAND. TYPING
JUST A SPACE, OR ANY OTHER CHARACTER FOLLOWED BY A SPACE,
WILL PROCEED FROM THE PAUSE. DEFAULT IS OFF.
WTIF (WAIT-IF) FLIPS A TOGGLE WHICH WHEN ON CAUSES REQUESTS BY
THE B AND (RETCOND ...) COMMANDS TO RESULT IN A PAUSE
RATHER THAN A BREAK. THE PAUSE IS LIKE THAT OF THE WTAL
COMMAND, AND MAY BE PROCEEDED BY A SPACE; OR A BREAK
INITIATED BY TYPING Y, B, OR H FOLLOWED BY A SPACE.
DEFAULT IS OFF.
XX DOES A CONTROL-X TYPE OF LISP QUIT.
(A CONTROL-X TYPED AFTER THE // PROMPTER WILL BE CAUGHT
BY AN ERRSET. THE XX COMMAND IS EXECUTED OUTSIDE OF THAT
ERRSET.)
OTHER FACILITIES:
(GETHKLEVEL <NO.>) THIS FUNCTION RETURNS THE S-EXPRESSION
THAT IS ON THE EXECUTION STACK OF THE STEPPER AT THE GIVEN
LEVEL NUMBER (SEE HKSHOW). CAN BE USED TO GET AN
UNSPRINTED UNABBREVIATED DISPLAY OF THE FORM OR TO RECORD
OR PROCESS THE FORM AS YOU DESIRE, INCLUDING REAPPLICATION
OF MEV TO IT IN THE CURRENT CONTEXT.
(HKSHOW <NO.>) THIS FUNCTION WILL DISPLAY PREVIOUS FORMS WHICH
ARE ON THE EXECUTION STACK, AS SEEN BY THE STEPPER WHILE
IT HAS BEEN ACTIVATED. THE PREVIOUS <NO.> OF LEVELS ARE
SHOWN, WITH THE CURRENT FORM LAST. IF NO ARGUMENT IS
GIVEN, THEN ALL LEVELS ARE SHOWN. THE DISPLAY IS DONE UNDER
THE CONTROL OF PRINLEVEL AND PRINLENGTH WHICH ARE SETTABLE
BY THE (P - -) COMMAND. OF COURSE THIS FUNCTION CAN ALSO
BE USED AS IF IT WERE A COMMAND BY TYPING IT AFTER THE
PROMPTING // .
(HKSPRINT <NO.>) THIS FUNCTION WILL SPRINT THE FORM ON THE
LEVEL WHOSE NUMBER IS GIVEN AS THE ARGUMENT. CAN ALSO
BE USED AS A COMMAND.
(HKSTART) USE THIS FUNCTION TO INVOKE OR REINVOKE THE STEPPER
FROM A BREAKPOINT OR FROM A PROGRAM AS DESCRIBED ABOVE.
IF USED WITHIN A BREAK, TYPE (HKSTART) BY ITSELF
RATHER THAN WITHIN ANOTHER S-EXPRESSION OR FUNCTION,
AS IT HAS TO CLIMB THE STACK FROM THE POINT OF INVOCATION.
IF AN ARGUMENT IS GIVEN TO THIS FEXPR, IT WILL BE EVAL'D
JUST PRIOR TO ESTABLISHING STEPPING, WITH ^W BOUND TO NIL,
-- EG. YOU CAN PRINT OUT INFOR. IF CALLED FROM A PROGRAM.
(IT IS POSSIBLE FOR THE INVOCATION OF THE
STEPPER BY THIS METHOD TO HAVE LIMITED SCOPE UNDER
SOME CIRCUMSTANCES. SUCH A BOUNDARY WOULD BE
A SECOND BREAKPOINT HIGHER ON THE STACK OR A PREVIOUSLY
TERMINATED INVOCATION OF THE STEPPER THAT IS STILL ON THE
STACK. ALSO IF THE PROGRAM WAS INITIALLY STARTED WITHOUT
MEV, AND STEPPING IS RETAINED THOUGHOUT THE REST OF THE
EXECUTION, STEPPING MAY ALSO REMAIN FOR FORMS TYPED AT TOP
LEVEL -- TO STOP THIS JUST DO CONTROL-G (OR USE THE Q
COMMAND) .)
(HKSTOP) THIS FUNCTION TURNS OFF THE STEPPER WHENEVER EXECUTED
-- IN THE SAME MANNER AS THE Q COMMAND WOULD.
HOOKLIST IS AN ATOM WHOSE VALUE IS INSPECTED BEFORE
EACH ATTEMPT TO READ A COMMAND FROM THE CONSOLE.
IF HOOKLIST IS NON-NIL, IT IS ASSUMMED TO BE A
LIST OF COMMANDS TO THE STEPPER -- EACH IS PRINTED OUT WHEN
USED AND TREATED AS IF IT CAME FROM YOUR TYPEIN. HOOKLIST
IS ALSO EXAMINED AT EACH LEVEL THAT IS INSPECTED BY THE
STEPPER EVEN IF NO COMMAND READING IS DONE (EG. NN OR UU
MODES).
(MBAK) THIS FUNCTION GIVES (BAKLIST) BUT WITHOUT THE STEPPER
FUNCTIONS, AS DESCRIBED ABOVE.
(MEV <TOP-FORM>) THIS FUNCTION INITIATES STEPPING AND OTHERWISE
ACTS LIKE EVAL OF ONE ARGUMENT, AS DESCRIBED ABOVE.
(MSPRINT <FORM>) GIVES "ABBREVIATED" SPRINTING OF THE <FORM>.
A SECOND AND THIRD NUMERIC ARGUMENT SPECIFY THE EFFECTIVE
PRINLEVEL AND PRINLENGTH HERE, ELSE A LIST OF TWO NUMBERS
FOUND AS THE VALUE OF MSPRINT ARE USED. THE CURRENT
IMPLEMENTATION IS SOMEWHAT SLOW AS THE REGULAR SPRINT DOES
NOT RESPOND TO STANDARD ABBREVIATING.
(SVIEWMSG <LINENO.> <TOEVAL>) USEFUL IN CONJUNCTION WITH S(HOW)
MODE. PUTS THE CURSOR AT THE <LINENO.> AND EVAL'S THE
SECOND ARGUMENT, THEN RETURNS THE CURSOR TO ITS ORIGINAL
POSITION BEFORE THE CALL. <LINENO.> = 0 MEANS TOP; IF
NEGATIVE COUNTS FROM BOTTOM, WITH -1 THE BOTTOM LINE.
TYPICALLY HAVE %%MDISTITLE (SEE (S -) COMMAND) BE A NUMBER
TO SKIP LINES ON TOP, AND USE SVIEWMSG TO DISPLAY
YOUR DEBUG INFOR. UP THERE.
IF YOU REALLY WANT SPECIALIZED PROCESSING IN PARTICULAR
SITUATIONS, YOU CAN INSPECT AND/OR CHANGE %%FORM IN A (COND ...)
PREDICATE, AND %%VALUE IN A (RETCOND ...). IF %%NOHOOKFLAG
IS T, FORM AND VALUE PRINTOUT AND COMMAND READING (EXCEPT FROM
A NON-NIL HOOKLIST) IS INHIBITED UNTIL IT IS RESET TO NIL.
NORMAL COMMAND PROCESSING IS INVOKED BY (%%MHOOKCOM) WITH
%%NOHOOKFLAG BOUND TO NIL. ALSO DESCRIBED ABOVE ARE
%%BREAKLIST, %%COND, %%RETCOND, AND %%HOOKPRIN.
DECEMBER 2, 1974 UPDATED MARCH 1976.
(c) Copyright 1974, 1975, and 1976 by Matthew Morgenstern,
Massachusetts Institute of Technology.
Reference in New Issue View Git Blame Copy Permalink