---  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.