ASMB,R,L,C
      HED   *** RTE/2100 DEBUG ***
* 
*     NAME:   DEBUG 
*     SOURCE: 92068-18016 
*     RELOC:  PART OF 92067-16268 AND 92067-16035 
*     PGMR:   R.A.G.
* 
*  ***************************************************************
*  * (C) COPYRIGHT HEWLETT-PACKARD COMPANY 1980.  ALL RIGHTS     *
*  * RESERVED.  NO PART OF THIS PROGRAM MAY BE PHOTOCOPIED,      *
*  * REPRODUCED OR TRANSLATED TO ANOTHER PROGRAM LANGUAGE WITHOUT*
*  * THE PRIOR WRITTEN CONSENT OF HEWLETT-PACKARD COMPANY.       *
*  ***************************************************************
* 
* 
      NAM DEBUG,7 92068-1X016 REV.2013 771123   
      ENT DEBUG 
      ENT $DBP1 
* 
      EXT DBGLU,$DBP3 
      EXT $LIBR,$LIBX 
      EXT EXEC,REIO 
      EXT IFBRK 
* 
XTEMP EQU 1721B 
FENCE EQU 1775B 
BGLWA EQU 1777B 
* 
      SUP 
* 
* 
* RTE 'DEBUG' IS A UTILITY-TYPE PROGRAM 
* PROVIDED WITH MEMORY BASED AND DISC BASED 
* OPERATING SYSTEMS.
* 
*  THE FUNCTION OF THIS PROGRAM IS TO PROVIDE 
* CHECKOUT FACILITIES FOR USER PROGRAMS LOADED
* ON-LINE BY THE RELOCATING LOADER. 
* DEBUG IS COMBINED WITH A USER PROGRAM DURING
* THE LOADING PROCESS.  THE PRIMARY ENTRY 
* POINT OF THE ABSOLUTE PROGRAM UNIT IS SET 
* TO "INIT" IN DEBUG. THE TRANSFER POINT OF 
* THE USER PROGRAM IS STORED AT THE ENTRY POINT 
* "DEBUG" BY THE RELOCATING LOADER. THIS ALLOWS 
* DEBUG TO BE IN CONTROL WHEN THE USER PROGRAM
* IS SCHEDULED AND INITIATED BY THE OPERATOR. 
* 
* THE USER PROGRAM (INCLUDING 'DEBUG') IS 
* SCHEDULED BY THE "RU" OR "ON" STATEMENT 
* 
* AN EXTERNAL ROUTINE, "DBGLU," 
* INITIALLY SETS THE LOGICAL UNIT # OF A
* CONSOLE TO BE USED FOR OPERATOR/
* DEBUG COMMUNICATION IN "$DBP3". 
* "DBGLU" IS NOT APPENDED TO EACH SEGMENT 
* (ONLY TO THE MAIN) AND IS CALLED ONLY 
* ONCE (FROM THE MAIN).  IF THE USER
* DOES NOT ASSEMBLE HIS OWN "DBGLU,"
* THE LIBRARY VERSION USES THE
* FIRST "RU" PARAMETER. 
* THE "$DBP3" ENTRY POINT IS ALSO USED TO 
* STORE THE LIST DEVICE LU AFTER INITIAL ENTRY. 
* 
* WHEN DEBUG IS ENTERED, THE MESSAGE
* "BEGIN 'DEBUG' OPERATION" IS TYPED AND AN 
* INPUT REQUEST IS MADE FOR THE FIRST STATEMENT 
* FROM THE OPERATOR.
* 
      SKP 
* 
*   THE FOLLOWING STATEMENTS ARE VALID DEBUG COMMANDS.
* 
*   VALUES INDICATED BY THE SYMBOLS D1, D2, ..., DN 
*   ARE OCTAL DATA VALUES.
*   VALUES INDICATED BY THE SYMBOLS A1 AND A2 ARE INTERPRETED 
*   AS ADDRESSES.  THE PROGRAM RELOCATION BASE (SEE 
*   'M' COMMAND) IS ADDED TO EACH TO FORM THE ACTUAL ADDRESS. 
*   THE SIGN BIT OF THE RESULT MUST NOT BE SET. 
* 
* 
* 
*   0)  A                ABORT PROGRAM
* 
*   1)  B,A1             SET AN INSTRUCTION BREAKPOINT AT ADDRESS A1. 
* 
* 
*   2)  D,A,A1[,A2][,H]  ASCII DUMP OF CORE ADDRESS A1, 
*                        OR FROM A1 THRU A2.  DISPLAY CONTROL 
*                        CHARACTERS IF 'H' ENTERED (HONESTY MODE).
*       D,B,A1[,A2]      BINARY DUMP OF CORE ADDRESS A1,
*                        OR FROM A1 THRU A2.
* 
*   3)  M,D1             SET ABSOLUTE BASE OF RELOCATABLE PROGRAM 
*                        TO D1.  (ADDED TO ADDRESS INPUTS 
*                        AND SUBTRACTED FROM DISPLAYED ADDRESSES.)
* 
*   4)  R,A1             EXECUTE USER PROGRAM STARTING AT A1. 
*       R                EXECUTE STARTING AT CURRENT P-REGISTER.
*                        (USED AFTER A BREAKPOINT TO CONTINUE PROGRAM 
*                        OR TO INITIATE PROGRAM EXECUTION.) 
* 
*   5)  S,A1,D1          SET "D1" IN LOCATION "A1". 
*       S,A1,D1,,DN      SET "D1" TO "DN" IN SUCCESSIVE 
*                        MEMORY LOCATIONS BEGINNING AT
*                        LOCATION "A1". 
*                        (AN OMITTED VALUE CAUSES A MEMORY
*                        LOCATION TO REMAIN UNCHANGED.) 
* 
*   6)  W,A,D1           SET A REGISTER TO DATA D1
*       W,B,D1           SET B REGISTER TO DATA D1
*       W,E,D1           SET E REGISTER  (0=OFF, ELSE ON) 
*       W,O,D1           SET OVERFLOW    (0=OFF, ELSE ON) 
* 
*   7)  X,A1             CLEAR BREAKPOINT AT ADDRESS A1.
* 
* 
*  AN ILLEGAL REQUEST OR OPERAND CAUSES THE MESSAGE 
*   "ENTRY ERROR" TO BE TYPED AND THE INPUT REQUEST 
*  REPEATED.
      SKP 
      ORB           BASE PAGE LINKS 
DBA   DEF DEBUG 
DBA.I DEF DEBUG,I 
      ORR 
INIT  JSB SAVR      SAVE REGISTERS
*                   (LOADER PUTS PRIMARY ENTRY POINT IN 'DEBUG'.) 
      LDA DEBUG 
      STA PREG
      LDA INITS 
      LDB DBGLU     IF THE CONSOLE LU IS KNOWN, 
      SZB 
      JMP INIT1         DO NOT CALL DBGLU 
      JSB RSTR      RESTORE REGISTERS 
      JSB DBGLU     FETCH CONSOLE LU
      LDA $DBP3 
      SZA,RSS         OR ZERO, USE "1"
      CLA,INA           FOR SYSTEM CONSOLE. 
      STA $DBP3     SET FOR OUTPUT CALL.
      IOR =B400      SET K BIT FOR KEYBOARD 
      STA DBGLU      INPUT CALL.
      LDA INITA 
* 
* 
INIT1 LDB =D-14 
MPERP STB NOSIM     NO INSTRUCTION TO SIMULATE
ERP   JSB OUT 
* 
START LDA QUESA     REQUEST DATA ENTRY. 
      LDB =D-2
      JSB OUT       PROMPT
* 
      JSB REIO      REQUEST INPUT 
      DEF *+5 
      DEF B1
      DEF DBGLU 
IDATX DEF IDATA 
      DEF M72 
* 
      SZB,RSS 
      JMP START     NO INPUT, ASK AGAIN 
      STB INCNT 
      CLA 
      STA INC       INITIALIZE POINTERS 
      JSB GETAS     GET ASCII INPUT 
      CPA =B101     "A" 
      JMP TERM       TERMINATE DEBUG OPERATION. 
      CPA =B102     'B' 
      JMP BA        SET BREAKPOINT
      CPA D 
      JMP DA        DUMP MEMORY 
      CPA M 
      JMP MA        SET MODULE MEMORY BASE
      CPA R 
      JMP RA        RUN PROGRAM 
      CPA S 
      JMP SA        SET VALUES IN MEMORY
      CPA W 
      JMP WA        SET REGISTERS 
      CPA X 
      JMP XA        CLEAR BREAKPOINT
* 
INER  LDA INERX 
      LDB =D-12 
      JMP ERP 
* 
* 
TERM  JSB EXEC      "COMPLETION"
      DEF *+2        REQUEST
      DEF B6       TO SYSTEM. 
* 
* 
INITA DEF *+1 
      ASC 7, BEGIN 'DEBUG'
INITS DEF *+1 
      ASC 7, BEGIN SEGMENT
QUESA DEF *+1 
      ASC 1,?_! 
* 
* 
INIT2 CLA 
      JSB $FORM     "P=NNNNN  JSB DEBUG"
      DEF INITJ 
      DEF PREG
      JSB $PRNT 
      CCB 
      STB NOSIM 
      JMP START 
* 
* 
INITJ ASC 8, P=@  JSB DEBUG!
      SKP 
* 
************ - LIST - ****  LIST DATA 
* 
* 
*     THIS ROUTINE LISTS INFO ON DEVICE GIVEN BY $DBP3
* 
* 
*     ON ENTRY, A=DATA ADDRESS, B=CHARACTER COUNT 
* 
* 
* 
LIST  NOP 
      STA LSTB      SAVE ADDRESS
      STB OUT 
* 
      JSB REIO      OUTPUT IT 
      DEF *+5 
      DEF B2      WRITE REQUEST CODE
      DEF $DBP3     LIST DEVICE 
LSTB  NOP           BUFFER ADDRESS
      DEF OUT       COUNT 
* 
      JMP LIST,I
* 
* 
******** - OUT - ****  OUTPUT DATA
* 
* 
*  THIS ROUTINE OUTPUTS A BLOCK OF DATA ON THE CONSOLE
* 
* 
* * *  INPUT: 
*              A= DATA ADDRESS
*              B= CHARACTER COUNT (- #) 
* 
* 
* 
OUT   NOP 
      STA OUTB      SAVE ADDRESS
      STB LIST      SAVE CHARACTER COUNT. 
* 
      JSB REIO     WRITE
      DEF *+5       CALL
      DEF B2
      DEF DBGLU 
OUTB  NOP           -BUFFER ADDRESS.
      DEF LIST
* 
      JMP OUT,I    EXIT.
      SKP 
* 
***  ***  -BA-  **  ** -BREAKPOINT- 
* 
*  THIS ROUTINE IS ENTERED WHEN A BREAKPOINT STATEMENT
*  IS RECOGNIZED. THE STATEMENT FORMAT IS:
* 
*       B,A     INSTRUCTION BREAKPOINT AT (A).
* 
*  A  TOTAL OF 15 BREAKPOINT SELECTIONS CAN BE
*  IN EFFECT AT ONE TIME. THE SELECTIONS ARE
*  STORED IN THE BKPTB (BREAKPOINT TABLE) ALONG 
*  WITH THE INSTRUCTION AT (A). THERE ARE 2 WORDS 
*  PER ENTRY. THE LENGTH OF THE TABLE MAY BE
*  MODIFIED BY CHANGING THE TERMINATOR (BKPLG) AND
*  THE VALUE OF THE REP STATEMENT AND RE-ASSEMBLING.
* 
* 
BA    JSB CONVA    GET THE BREAKPOINT ADDRESS.
      JMP INER      ADDRESS REQUIRED
      SZA 
      CPA B1
      JMP INER      CAN'T PUT BREAK IN A- OR B-REGISTER 
      STA TEMP       SAVE ABSOLUTE ADDRESS. 
      JSB MPCHK     CHECK FOR MEMORY PROTECT
* 
      JSB SERCH     SEARCH BREAKPOINT TABLE 
      CLA,RSS       SET TO SEARCH FOR EMPTY SLOT
      JMP INER      THIS BREAKPOINT IS ALREADY SET
      JSB SERCH 
      JMP INER      NO EMPTY SLOTS IN BREAKPOINT TABLE
* 
      LDA TEMP     SET INSTR. ADDRESS 
      STA B,I       IN WORD 1 OF ENTRY. 
      LDA A,I      SET INSTRUCTION
      INB           IN WORD 2 
      STA B,I       OF ENTRY. 
      LDA JSBDB    SET 'JSB DEBUG'
      STA TEMP,I    TO REPLACE FIRST WORD OF CODE 
      JMP START    -GET NEXT ENTRY. 
* 
* 
      SKP 
* 
***  ***  -DA-  *** *** -DUMP-
* 
*  THIS ROUTINE IS ENTERED WHEN A DUMP STATEMENT
*  HAS BEEN ENTERED BY THE USER. THE ACCEPTABLE 
*  ENTRIES ARE AS FOLLOWS:
* 
* * * * *      D,A,A1[,A2][,H]   A= ASCII OUTPUT
*              D,B,A1[,A2]       B= BINARY OUTPUT 
***************************** 
* 
DA    JSB GETAS     GET A CH, (A) OR (B). 
      LDB $!
      CPA =B101     'A' 
      LDB "!        ASCII DUMP
      STB BLANK+1 
* 
      JSB CONVA     GET 1ST DUMP ADDRESS. 
      LDA MEMOR     DEFAULT TO MEMORY BASE
      STA DSA       SAVE ACTUAL DUMP STARTING ADDRESS.
      JSB CONVA     NO, GET NEXT ADDRESS
      LDA DSA       DEFAULT TO FIRST ADDRESS
      STA SAVR      SAVE LAST DUMP ADDRESS. 
      LDA DSA 
      CMA,INA 
      ADA SAVR
      SSA 
      JMP INER      FIRST > LAST
      JSB GETC      INPUT HONESTY MODE CHAR 
      JMP *+2       NO INPUT
      STA HMODE 
* 
      CLA 
      JSB $FORM     DUMP HEADING
      DEF DMHD
      DEF MEMOR     MEMORY BASE 
      JSB $PRNT     PRINT LINE
* 
NEXTA LDA =D-8
      STA CONVA 
      CLA 
      JSB $FORM     PRINT ADDRESS 
      DEF DMADD 
      DEF DSA 
* 
NEXTV CCA 
      JSB $FORM     PRINT DATA VALUE
      DEF BLANK 
DSA   DEF * 
* 
      LDA DSA 
      ISZ DSA       BUMP TO NEXT VALUE
      CPA SAVR
      JMP DONE      LAST VALUE
      ISZ CONVA 
      JMP NEXTV 
      JSB IFBRK     ABORT LISTING IF 'BR' COMMAND ENTERED 
      DEF *+1 
      SZA 
      JMP DONE
      JSB $PRNT     PRINT LINE
      JMP NEXTA     START NEW LINE
* 
BLANK ASC 2,  XX
DMHD  ASC 7, DUMP--BASE = 
$!    ASC 1,$!
"!    ASC 1,"!
DMADD ASC 2, @ !
* 
* 
DONE  JSB $PRNT     PRINT LAST LINE 
      JMP START 
* 
***  ***  -MA- *** *** -MEMORY ORIGIN-
* 
*  THIS ROUTINE IS ENTERED WHEN A MEMORY ORIGIN STATEMENT 
*  HAS BEEN ENTERED BY THE USER.  THIS ESTABLISHES THE
*  BASE TO BE ADDED TO ALL SUBSEQUENT ADDRESS ENTRIES 
*  MADE BY THE USER IN ALL STATEMENTS.  THE ACCEPTABLE
*  ENTRY IS:
* 
* * * *       M,A     A = THE OCTAL BASE ADDRESS. 
* 
*       EXIT:  MEMOR  CONTAINS THE MEMORY ORIGIN (BASE) ADDRESS.
* 
* 
MA    JSB CONV      GET THE ADDRESS 
      CLA 
      SSA 
      JMP INER      CANNOT HAVE INDIRECT BIT SET
      STA MEMOR     SET USER BASE ADDRESS.
      JMP START     INPUT NEXT STATEMENT. 
      SKP 
*** ***  -RA- *** ***  -RUN-
* 
*  THIS ROUTINE IS ENTERED WHEN A RUN STATEMENT HAS 
*  BEEN ENTERED BY THE USER. THIS STATEMENT RESULTS 
*  IN THE PROGRAM RUNNING AT THE SPECIFIED ADDRESS. 
*  IF NO ADDRESS IS SPECIFIED THE PROGRAM WILL RUN
*  AT THE ADDRESS OF THE NEXT PROGRAM INSTRUCTION.
*  ENTRIES ARE AS FOLLOWS:
* 
* * * *     R       RUN AT NEXT PROGRAM ADDRESS.
*                   (THE FIRST TIME, THE B-REGISTER 
*                   WILL BE SET UP TO RETRIEVE THE
*                   'RU' PARAMETERS.) 
*           R,A1    RUN AT ADDRESS A1.
*                   (BREAK INSTRUCTION IS NOT SIMULATED.) 
* 
* 
RA    JSB CONVA     FETCH RUN ADDRESS 
      JMP RA1 
      SZA 
      CPA B1
      JMP INER      CANNOT EXECUTE A- OR B-REGISTER 
      JSB MPCHK     CHECK FOR MEMORY PROTECT
      STA PREG     SET NEW RUN ADDRESS AS 'PREG'
RA0   JSB RSTR      DO NOT SIMULATE BREAK INSTRUCTION 
      JMP PREG,I   GO FOR FULL EXECUTION
* 
RA1   LDB NOSIM 
      SSB 
      JMP RA0       SKIP INSTRUCTION SIMULATION 
      LDA PREG
      INA 
      STA JSBAD,I   STORE RETURN ADDRESS FOR JSB
*                   (IF NOT A JSB INSTRUCTION, STORES ADDRESS IN A-REGISTER.) 
      JSB RSTR      -RESTORE PROGRAM REGISTERS. 
INSTR NOP           SIMULATE BREAK INSTRUCTION * * *
      RSS           (OVERLAID BY 2-WORD INSTRUCTIONS) 
      ISZ PREG      INCREMENT P IF A SKIP RESULTED. 
      ISZ PREG      NORMAL P-REGISTER INCREMENT 
      JMP PREG,I    GO TO PROGRAM.
* 
* 
* 
RSTR  NOP           RESTORE DATA REGISTERS
      LDB IDTMP     FROM SAVE AREA
      LDA XTEMP     TO ID SEGMENT 
      JSB MOVE5 
      LDA EOVRG 
      CLO 
      SLA,ELA 
      STO 
DLD   DLD AREG
      JMP RSTR,I
* 
* 
* 
SAVR  NOP           SAVE DATA REGISTERS 
DST   DST AREG
      ERA,ALS 
      SOC 
      INA 
      STA EOVRG 
      LDB XTEMP     FROM ID SEGMENT 
      LDA IDTMP     TO SAVE AREA
      JSB MOVE5 
      JMP SAVR,I
* 
* 
MPCHK NOP           CHECK FOR MEMORY PROTECT
      JSB CHK 
      JMP INER      OUTPUT ERROR MESSAGE
      JMP MPCHK,I 
* 
* 
CHK   NOP           CHECK FOR MEMORY PROTECT
      SZA 
      CPA B1
      JMP OK        A- & B-REG LEGAL
      STA IDRST 
      LDA FENCE 
      CMA,INA 
      ADA IDRST     CHECK FOR ADDRESS UNDER FENCE 
      SSA 
      JMP CHK,I     BELOW FENCE 
      LDA IDRST 
      CMA,INA 
      ADA BGLWA 
      SSA 
      JMP CHK,I     BEYOND LAST WORD OF MEMORY
      LDA IDRST 
OK    ISZ CHK       GOOD RETURN 
      JMP CHK,I 
* 
* 
ACHK  NOP           MEMORY PROTECT ON CURRENT INSTR 
      JSB CHK 
      RSS           BAD ADDRESS 
      JMP ACHK,I    OK
MPERR LDA MPDF
      LDB =D-12 
      JMP MPERP 
* 
* 
* 
MPDF  DEF *+1 
      ASC 6, MEM PROTECT
      SKP 
*** *** *** -SA- ***  -SET MEMORY-
* 
*  THIS ROUTINE IS ENTERED WHEN A SET MEMORY STATEMENT
*  HAS BEEN ENTERED BY THE USER.  THIS STATEMENT ALLOWS 
*  THE USER TO SET ONE OR SEVERAL CONSECUTIVE MEMORY
*  ADDRESS'S TO SPECIFIED VALUES.  THE ACCEPTABLE 
*  ENTRIES ARE AS FOLLOWS:
* 
* * * *   S,A1,D1       STORE D1 IN A1
*         S,A1,D1,D2    STORE D1 IN A1, D2 IN A1+1
*         S,A1,D1,,D2   STORE D1 IN A1, D2 IN A1+2
*                       (OMITTED VALUES SKIP ONE ADDRESS.)
* 
*              THE NUMBER OF DATA ENTRIES IS LIMITED
*              BY LINE LENGTH (72 CH'S).
* 
* 
SA    JSB CONVA     FETCH THE MEMORY ADDRESS. 
      JMP INER
      STA TEMP
* 
SA1   JSB CONV      INPUT DATA WORD 
      JMP SA2       IF DEFAULT, DO NOT STORE
      STA CONV
      LDA TEMP
      JSB CHK       CHECK FOR MEMORY PROTECT
      JMP MPER
      SZA,RSS 
      JMP WA10      SET A-REGISTER
      CPA B1
      JMP WA20      SET B-REGISTER
      JSB SERCH     CHECK FOR BREAK INSTRUCTION 
      JMP STUFF     NO
      INB 
      LDA CONV
      STA B,I       CHANGE BREAK TABLE
SA2   LDA INC       NUMBER OF CHARACTERS PROCESSED
      ISZ TEMP
      CPA INCNT     DONE IF ALL CHARACTERS READ 
      JMP SA3 
      JMP SA1 
* 
STUFF LDA CONV
      STA TEMP,I
      JMP SA2 
* 
WA10  STA AREG
      JMP SA2 
* 
WA20  STA BREG
      JMP SA2 
* 
* 
MPER  CLA 
      JSB $FORM     'ADDR XXXXX ILLEGAL'
      DEF ILGL
      DEF TEMP
      JSB $PRNT 
* 
SA3   LDA NOSIM 
      SSA 
      JMP START     NO INSTRUCTION TO SIMULATE
      LDA PREG      SIMULATED INSTRUCTION MAY HAVE CHANGED
      JMP ANLYZ     RE-EVALUATE IT
* 
* 
ILGL  ASC 8, ADDR @ ILLEGAL!
* 
      SKP 
*** ***  -WA-  ***  -SET REGISTER-
* 
*  THIS ROUTINE IS ENTERED WHEN A SET REGISTER
*  STATEMENT HAS BEEN ENTERED BY THE USER. THIS 
*  STATEMENT ALLOWS THE USER THE ABILITY TO 
*  MODIFY REGISTERS AS DEFINED IN THE FOLLOWING 
*  ACCEPTABLE ENTRIES:
* 
* * * *      W,A,D1    SET AREG = D1
*            W,B,D1        BREG = D1
*            W,E,D1        EREG = D1
*            W,O,D1        OREG = D1   (OVERFLOW) 
* 
* 
WA    JSB GETAS     FETCH THE REGISTER ID 
      STA TEMP
      JSB CONV      GET REGISTER DATA WORD. 
      CLA 
      LDB TEMP
      CPB =B101        SET A REGISTER?
      JMP WA1       YES 
      CPB =B102        SET B REGISTER?
      JMP WA2       YES 
      CLE,SZA 
      CCE 
      CPB E         SET E REGISTER? 
      JMP WA3       YES 
      CPB O         SET OVERFLOW? 
      JMP WA5       YES 
      JMP INER      NO, REGISTER ID ERROR.
* 
WA1   STA AREG      SET A REGISTER
      JMP SA3 
* 
WA2   STA BREG      SET B REGISTER
      JMP SA3 
* 
WA3   LDB EOVRG     SAVED REGISTERS 
      RBL,ERB 
WA4   STB EOVRG 
      JMP START 
* 
WA5   LDB EOVRG 
      RBR,ELB       E TO LEAST BIT
      JMP WA4 
* 
      SKP 
* 
***  ***  -XA-  **  ** - CLEAR BREAKPOINT - 
* 
*  THIS ROUTINE IS ENTERED WHEN A CLEAR BREAKPOINT
*  STATEMENT IS RECOGNIZED. THE STATEMENT FORMAT IS:
* 
*     X,A1    CLEAR BRKPT AT ADDRESS "A1".
* 
*  A SCAN OF THE BREAKPOINT TABLE IS MADE TO
*  FIND A MATCHING BP ADDRESS TO "A1". IF NO MATCH
*  IS FOUND, "ENTRY ERROR" IS TYPED.
* 
*  IF A MATCH IS FOUND,  THE USER INSTRUCTION IS
*  RESTORED IN (A1), THE BREAKPOINT TABLE ENTRY IS
*  CLEARED AND CONTROL TRANSFERRED TO "START".
* 
* 
XA    JSB CONVA    GET BREAKPOINT ADDRESS 
      JMP INER      ADDRESS REQUIRED
      STA TEMP      AND SAVE IT.
      JSB SERCH     SEARCH BREAKPOINT TABLE 
      JMP INER      NOT FOUND 
* 
      CLA          SET WORD 1 OF
      STA B,I       ENTRY = 0.
      INB          GET USER INSTR.
      LDA B,I       FROM WORD 2.
      STA TEMP,I   RESTORE IN USER PROGRAM. 
      JMP START    -GET NEXT ENTRY. 
* 
      SKP 
* 
* 
*  INSTRUCTION BREAKPOINT PROCESSOR 
* 
* 
* THE BREAK COMMAND SETS 'JSB DEBUG' INSTRUCTIONS 
* IN PLACE OF EXISTING CODE AND SAVES THE REPLACED
* INSTRUCTION IN THE BREAK TABLE. 
* 
* WHEN 'DEBUG' IS ENTERED BY A 'JSB'
* THE ADDRESS OF THE BREAKPOINT IS DETERMINED 
* BY SCANNING THE BREAKPOINT TABLE TO 
* FIND A MATCH. 
* 'DEBUG' CAN ALSO BE ENTERED BY A JUMP TO 'ANLYZ'. 
* THIS ENTRY POINT RE-EVALUATES THE CURRENT INSTRUCTION 
* IN CASE IT HAS BEEN CHANGED BY THE 'S' COMMAND. 
* 
* THE INSTRUCTION TO BE SIMULATED IS DECODED, AND 
* THE REGISTERS AND MEMORY VALUES ARE DISPLAYED.
* THE INSTRUCTION AT THE BREAKPOINT ADDRESS IS
* SET IN 'INSTR'.  THE FINAL ADDRESS OF 
* A MEMORY REFERENCE INSTRUCTION IS SET 
* IN 'DEBUG'.  CONTROL IS THEN TRANSFERRED
* TO 'START'. 
* 
* 
$DBP1 EQU * 
DEBUG NOP 
      JSB SAVR      SAVE DATA REGISTERS 
      CLA 
      STA SW1 
      STA IOCHK     PRINT REGISTERS ONLY ONCE 
      CCA 
      ADA DEBUG 
      STA PREG     SAVE BREAK ADDRESS AS P-REGISTER.
* 
ANLYZ JSB SERCH     SEARCH BREAKPOINT TABLE 
      JMP INIT2     NOT FOUND, DIRECT JSB TO DEBUG
      INB          SET TO WORD 2 OF ENTRY.
      LDA B,I      GET INSTRUCTION
* 
      STA INSTR 
      LDA RSS 
      STA INSTR+1 
      CLA 
      STA NOSIM     ALLOW INSTRUCTION SIMULATION
      STA JSBAD     DEFAULT TO 'NOT A JSB'
      JSB DECOD     DECODE INSTRUCTION
      STA SFLAG 
      STB OP
* 
      SZA,RSS 
      JMP PSTD      NOT MEMORY REFERENCE
      LDB =D-24 
      STB DEBUG 
* 
      INA,SZA 
      JMP WORD1     1-WORD INSTRUCTION
      LDB PREG
      INB 
      LDB B,I       GET UNRESOLVED ADDRESS
      JSB INDIR     CLEAR INDIRECTS 
      LDA DEF.I 
      STA INSTR+1 
      JMP DBP4
* 
WORD1 LDA IDRST 
      ALF,RAL 
      ELA           Z OR C BIT IN E 
      LDA IDRST 
      AND =B101777  PAGE OFFSET AND INDIRECT BIT
      STA B 
      CLA,SEZ 
      LDA PREG      ADDRESS OF INSTRUCTION
      AND =B76000   PAGE PREFIX 
      ADB A         B CONTAINS ADDRESS
      JSB INDIR     CLEAR INDIRECTS 
* 
      LDA IDRST 
      AND =B74000 
      CPA JSB       JSB COMMAND?
      RSS 
      JMP DBP3      NO
      STB JSBAD     LOCATION OF RETURN ADDRESS
      LDA JMP.I     SIMULATE JMP INSTRUCTION
      INB,RSS       ADDRESS OF JUMP 
DBP3  IOR DEF.I     MAKE IT REFERENCE 'DEBUG' 
      STA INSTR 
DBP4  CPB DEFA
      CLB           USE REAL A-REGISTER 
      CPB DEFB
      CLB,INB       USE REAL B-REGISTER 
      STB DEBUG     SAVE MEMORY ADDRESS 
* 
      SKP 
* 
* 
*     THIS ROUTINE PRINTS THE CONTENTS OF 
*     THE SAVED P-REGISTER, INSTRUCTION REGISTER, 
*     A-, B-, E-, AND O-REGISTERS.  IF THE
*     INSTRUCTION IS A MEMORY REFERENCE INSTRUCTION,
*     THE MEMORY ADDRESS AND CONTENTS ARE ALSO
*     DISPLAYED.  THE A- AND B-REGISTERS AND THE
*     MEMORY CONTENTS ARE DISPLAYED.
* 
PSTD  LDB BLK0      SET E AND O TO ZERO IN MESSAGE
      STB E1
      STB O1
      LDB BLK1
      LDA EOVRG 
      SSA 
      STB E1        SET E TO 1
      SLA 
      STB O1        SET O TO 1
* 
      CLA 
      JSB $FORM     OUTPUT REGISTERS
      DEF REGMS 
      DEF PREG
PREG  NOP 
DEFA  DEF AREG
DEFB  DEF BREG
* 
      LDA SFLAG 
      SZA,RSS 
      JMP IOCHK     NOT MEMORY REFERENCE
      LDB DEBUG 
      SSB 
      JMP IND       INDIRECT LOOP 
      JSB $FORM 
      DEF MAMS      PRINT MEMORY ADDRESS
      DEF DEBUG 
DEF.I DEF DBA.I,I     AND CONTENTS
SW1   NOP 
      JSB $PRNT     PRINT SECOND LINE 
      LDA RSS 
      STA SW1       PRINT ONLY ONCE 
* 
      LDA JSBAD 
      JSB ACHK      CHECK FOR MEMORY PROTECT
      LDA DEBUG 
      LDB SFLAG 
      CPB =B70000   IF 'STA' OR 'STB' 
      JSB ACHK      CHECK FOR MEMORY PROTECT
      LDB INSTR 
      CPB DST       OR DOUBLE STORE 
      JMP BCHK      NO DOUBLE STORE TO B-REGISTER 
      CPB ISZ.I     OR ISZ
      JSB ACHK
      CPB JMP.I     OR 'JMP' OR 'JSB' 
      RSS 
      JMP START     DONE
      SZA           NO JUMP TO A- OR B-REGISTER 
BCHK  CPA B1
      JMP MPERR 
      JSB ACHK
      JMP START 
* 
* 
IOCHK NOP 
      JSB $PRNT 
      LDA RSS 
      STA IOCHK     PRINT ONLY ONCE 
      LDA OP
      SSA 
      JMP UNDEF     UNRECOGNIZED INSTRUCTION
      SZA 
      JMP START 
      LDA INSTR     I/O INSTRUCTION 
      AND =B77
      CPA B1
RSS   RSS 
      JMP MPERR     SELECT CODE NOT 1 
      LDA INSTR 
      AND =B700 
      SZA,RSS 
      JMP MPERR     HALT
      JMP START 
* 
REGMS ASC 10, P=@ I=$  A=$ B=$ E= 
E1    ASC 2,XXO=
O1    ASC 2,XX !
MAMS  ASC 5,MA=@ MC=$!
* 
* 
UNDEF LDA INST? 
      LDB =D-10 
      JMP MPERP     UNRECOGNIZED INSTRUCTION
* 
INST? DEF *+1 
      ASC 5, ? INSTR ?
* 
IDRST NOP 
* 
* 
* 
* 
      SKP 
* 
* 
INDIR NOP           RESOLVE INDIRECT ADDRESS
      RBL,CLE,ERB 
      SZB,RSS 
      LDB DEFA      A-REGISTER REFERENCE
      CPB B1
      LDB DEFB      B-REGISTER REFERENCE
      SEZ,RSS 
      JMP INDIR,I   DONE
      LDB B,I 
      ISZ DEBUG 
      JMP INDIR+1 
* 
*     TOO MANY LEVELS OF INDIRECT ADDRESSES!! 
* 
* 
      STB NOSIM     DO NOT SIMULATE INSTRUCTION 
      JMP DBP4      SAVE ADDRESS
* 
* 
* 
* 
IND   JSB $FORM     'INDIRECT LOOP' 
      DEF TIN 
      JMP DONE
* 
      SKP 
* 
* 
*     THIS ROUTINE DECODES AN HP 2100 INSTRUCTION.
*     THE A-REG IS SET TO ZERO FOR REGISTER REFERENCE 
*     INSTRUCTIONS, TO -1 FOR 2-WORD MEMORY REFERENCE 
*     INSTRUCTIONS, AND GREATER THAN ZERO FOR 1-WORD MEMORY 
*     REFERENCE INSTRUCTIONS.  IN ADDITION, THE 
*     B-REGISTER IS SET TO A VALUE INDICATING MORE
*     EXACTLY THE TYPE OF INSTRUCTION, AS FOLLOWS:
*                   00-I/O GROUP
*                   01-EAU GROUP
*                   02-MPY
*                   03-DIV
*                   04-DLD
*                   05-DST
*                   06-SHIFT-ROTATE GROUP (A) 
*                   07-SHIFT-ROTATE GROUP (B) 
*                   08-ALTER-SKIP GROUP (A) 
*                   09-ALTER-SKIP GROUP (B) 
*                   10-AND
*                   11-JSB
*                   12-XOR
*                   13-JMP
*                   14-IOR
*                   15-ISZ
*                   16-ADA
*                   17-ADB
*                   18-CPA
*                   19-CPB
*                   20-LDA
*                   21-LDB
*                   22-STA
*                   23-STB
*                   24-FIX
*                   25-FLT
*                   26-FAD
*                   27-FSB
*                   28-FMP
*                   29-FDV
* 
*                   -1-XXX (UNRECOGNIZED) 
* 
* 
*     ON ENTRY, B= ADDRESS OF INSTRUCTION 
* 
DECOD NOP           DECODE INSTRUCTION
      LDA B,I 
      STA IDRST 
      AND =B70000 
      STA INDIR 
      SZA 
      JMP MRFIN     ONE-WORD MEMORY REFERENCE 
      LDA IDRST 
      CLB,INB 
      CPA DST       OP=5
      INB,RSS 
      CPA DLD       OP=4
      INB,RSS 
      CPA DIV       OP=3
WD2   INB,RSS 
      CPA MPY       OP=2
      INB,RSS 
      JMP DCD2      ONE WORD REGISTER REFERENCE OR I/O
      CCA 
      JMP DECOD,I 
* 
DCD2  AND =B177760  MASK OFF SHIFT COUNT
      CPA ASR 
      JMP DCDEX 
      CPA ASL 
      JMP DCDEX 
      CPA LSR 
      JMP DCDEX 
      CPA LSL 
      JMP DCDEX 
      CPA RRR 
      JMP DCDEX 
      CPA RRL 
      JMP DCDEX 
      RAL,SLA,ALF 
      JMP DCD3
      LDB B6
      SSA           SHIFT-ROTATE? 
      ADB B2        NO, ALTER-SKIP
      SLA           A-REGISTER? 
      INB           NO, B-REGISTER
      JMP DCDEX 
* 
DCD3  CLB           I-O GROUP?
      SSA 
      JMP DCDEX     YES 
      LDB =D24      CHECK FOR FLOATING POINT
      LDA IDRST 
      CPA FLT 
      INB,RSS 
      CPA FIX 
      JMP DCDEX     NO ADDRESS REQUIRED 
* 
      CPA FDV 
      INB,RSS 
      CPA FMP 
      INB,RSS 
      CPA FSB 
      INB,RSS 
      CPA FAD 
      JMP WD2       2-WORD MEMORY REFERENCE 
* 
      CCB 
      JMP DCDEX     UNRECOGNIZED
* 
MRFIN LDA IDRST 
      AND =B74000   ISOLATE OP CODE 
      ALF,RAL 
      ADA =B10
      STA B 
DCDEX LDA INDIR 
      JMP DECOD,I 
* 
ASR   ASR 16
ASL   ASL 16
LSR   LSR 16
LSL   LSL 16
RRR   RRR 16
RRL   RRL 16
MPY   OCT 100200
DIV   OCT 100400
FIX   OCT 105100
FLT   OCT 105120
FAD   OCT 105000
FSB   OCT 105020
FMP   OCT 105040
FDV   OCT 105060
* 
      SKP 
* 
*CALLING SEQUENCE:
*     CLA           IF START OF MESSAGE 
*            OR 
*     CCA(NON-ZERO) IF CONTINUATION OF PREVIOUS MESSAGE 
*     JSB $FORM 
*     DEF MSG       ADDRESS OF MESSAGE
*     DEF V1        FIRST VALUE 
*     DEF V2        SECOND VALUE
*     (ANY NUMBER OF VALUES TO LIMIT OF BUFFER SPACE) 
* 
*     JSB $PRNT     SEND TO LIST DEVICE 
* 
*THE MESSAGE IS SCANNED AND MOVED TO THE OUTPUT BUFFER A CHARACTER
*AT A TIME.  THE FOLLOWING CHARACTERS CAUSE SPECIAL ACTION TO OCCUR:
* 
*        " CAUSES TWO ASCII CHARACTERS TO BE OUTPUT.
* 
*        $ CAUSES AN OCTAL VALUE TO BE CONVERTED TO ASCII 
*       AND MOVED TO THE OUTPUT BUFFER (6 DIGITS OUTPUT). 
* 
*        @ CAUSES AN OCTAL VALUE TO BE INTERPRETED AS A 
*       'DEBUG' ADDRESS WITH OFFSET 'MEMOR' IN MEMORY.
*       ONLY 5 DIGITS ARE OUTPUT. 
* 
* 
*        ! TERMINATES THE LINE OF OUTPUT. 
* 
* 
*FOR EXAMPLE: 
*     CLA 
*     JSB $FORM 
*     DEF SAMP
*     DEF OCT 
*     DEF ASC 
*     JSB $PRNT 
*      .
*      .
*      .
*OCT  OCT 100001
*ASC  ASC 1,$.
* 
*SAMP ASC 2,$ "!
* 
*WILL PRINT THE FOLLOWING:
*100001$. 
* 
* 
* 
$FORM NOP           OUTPUT FORMATTER
      SZA,RSS 
      STA CNTT
      LDA $FORM 
      ISZ $FORM 
      LDA A,I 
      RAL,CLE,SLA,ERA 
      JMP *-2 
      STA DEFF
      CLA 
      STA CNTF
NEXT  JSB FECH      GET A CHARACTER FROM MESSAGE
      CPA $ 
      JMP CVT       DOLLAR, CONVERT SPECIAL VALUE 
      CPA " 
      JMP CVT 
      CPA @ 
      JMP CVT 
      CPA ! 
      JMP $FORM,I 
      JSB PUTC      MOVE CHARACTER TO OUTPUT BUFFER 
      JMP NEXT
* 
CVT   LDB $FORM 
      ISZ $FORM 
      LDB B,I 
      RBL,CLE,SLB,ERB 
      JMP *-2 
      CPA @ 
      JMP ADDRS     @, 5 DIGIT ADDRESS
      CLE,SZB,RSS 
      LDB DEFA      USE DEBUG A-REGISTER
      CPB B1
      LDB DEFB      USE DEBUG B-REGISTER
      STA FECH
      LDA B 
      JSB SERCH     IF VALUE IN BREAK TABLE 
      JMP *+2 
      INB,RSS         USE TABLE ADDRESS TO FETCH VALUE
      LDB A 
      LDA FECH
      CPA " 
      JMP ASCII     TWO ASCII CHARACTERS
* 
      LDB B,I       OCTAL CONVERSION
      CLA 
      RRR 2 
      JSB DIGIT     OUTPUT BIT FIFTEEN
OUT5  REP 5         AND REMAINING CHARACTERS
      JSB DIGIT 
      JMP NEXT
* 
* 
* 
$PRNT NOP           OUTPUT LINE TO LIST DEVICE
      LDB CNTT
      CMB,INB       NEGATE CHARACTER COUNT
      LDA MSAD      BUFFER ADDRESS
      JSB LIST      OUTPUT TO LIST DEVICE 
      JMP $PRNT,I 
* 
* 
ADDRS LDA B,I 
      STA $PRNT 
      LDB MEMOR 
      CMB,INB       CHECK FOR BELOW MEMORY BASE 
      ADB A 
      SSB,RSS       ABSOLUTE ADDRESS IF B NEGATIVE, OR BASE=0 
      CPB A 
      JMP ABS 
      STB $PRNT     PRINT OFFSET, NOT ABSOLUTE ADDRESS
      LDA M 
      JSB PUTC      'M' 
      LDA =B53      '+' 
      JMP OUT2
* 
ABS   LDA =B40
      JSB PUTC
      LDA =B40
OUT2  JSB PUTC
      CLA 
      LDB $PRNT 
      RBL           DO NOT PRINT SIGN DIGIT 
      JMP OUT5
* 
* 
ASCII LDA HMODE 
      CPA H         HONESTY MODE? 
      JMP HA1       YES 
      LDA B,I 
      ALF,ALF 
      AND =B177 
      CPA =B177     'DELETE' CHARACTER? 
      JMP RP1       YES, REPLACE IT 
      AND =B140 
      SZA           NON-PRINTING CHAR?
      JMP HA1       NO
RP1   LDA =B40      YES, REPLACE WITH SPACE 
      JMP PUT1
HA1   LDA B,I 
      ALF,ALF 
      AND =B377 
PUT1  JSB PUTC      OUTPUT FIRST CHAR 
* 
      LDA HMODE 
      CPA H         HONESTY MODE? 
      JMP HA2       YES 
      LDA B,I 
      AND =B177 
      CPA =B177     'DELETE' CHARACTER? 
      JMP RP2       YES, REPLACE IT 
      AND =B140 
      SZA           NON-PRINTING CHAR?
      JMP HA2       NO
RP2   LDA =B40      YES, REPLACE WITH SPACE 
      JMP PUT2
HA2   LDA B,I 
      AND =B377 
PUT2  JSB PUTC      SECOND CHAR 
      JMP NEXT
* 
* 
* 
* 
FECH  NOP 
      LDA CNTF
      ISZ CNTF
      CLE,ERA 
      ADA DEFF
      LDA A,I 
      SEZ,RSS 
      ALF,ALF 
      AND =B377 
      JMP FECH,I
* 
$     OCT 44
"     OCT 42
@     OCT 100 
!     OCT 41
* 
* 
* 
DIGIT NOP 
      RRL 3         SHIFT THREE BITS INTO A 
      IOR =B60      ADD ASCII PREFIX
      JSB PUTC
      CLA           SET FOR NEXT CHARACTER
      JMP DIGIT,I 
* 
* 
* 
* 
* 
* 
PUTC  NOP 
      STB FECH
      LDB CNTT
      CPB MAX 
      JMP PUTEX     TOO MANY CHARCTERS FOR BUFFER - IGNORE IT 
      ISZ CNTT
      CLE,ERB 
      ADB MSAD
      SEZ 
      IOR B,I       ADD PREVIOUS CHAR 
      SEZ,CLE,RSS 
      ALF,ALF       ROTATE TO UPPER CHAR
      STA B,I 
PUTEX LDB FECH
      JMP PUTC,I
* 
* 
* 
CNTF  NOP           NUMBER OF CHARS ALREADY READ
CNTT  NOP           NUMBER OF CHARACTERS OUTPUT 
MAX   DEC 80        MAX NUMBER OF CHARACTERS OUTPUT 
MSAD  DEF $MSBF     ADDRESS OF CHARACTER COUNT
$MSBF BSS 40        80 CHAR BUFFER
DEFF  NOP           ADDRESS OF MESSAGE
* 
* 
* 
******* MOVE5 *********** 
* 
* 
*     THIS ROUTINE MOVES THE ID SEGMENT TEMPORARY VALUES
*     TO THE SAVE AREA WHEN A BREAK IS ENCOUNTERED, AND 
*     RESTORES THEM BEFORE RETURNING TO THE PROGRAM.
* 
* 
*     CALLING SEQUENCE: 
* 
*     LDB FROM
*     LDA TO
*     JSB MOVE5 
* 
* 
* 
MOVE5 NOP 
      JSB $LIBR     TURN OFF INTERRUPTS 
      DEC 0         TO PREVENT MEMORY PROTECT VIOLATION 
      STA GETC      SAVE DESTINATION ADDRESS
      LDA =D-5
      STA GETAS 
* 
RMPLP LDA B,I 
      STA GETC,I
      INB 
      ISZ GETC
      ISZ GETAS 
      JMP RMPLP 
      JSB $LIBX     RESTORE INTERRUPTS
      DEF MOVE5 
* 
IDTMP DEF *+1 
      BSS 5         IDSEG PARAMETERS
* 
      SKP 
****** ** GETC ** 
* 
*  THIS ROUTINE EXTRACTS A CHARACTER FROM THE 
*  INPUT OPTION STATEMENT AND RETURNS TO THE
*  CALLER WITH THE CHARACTER RIGHT JUSTIFIED IN "A".
* 
GETC  NOP 
      LDA INC 
      CPA INCNT 
      JMP GETC,I    NO MORE CHARACTERS
      ISZ INC 
      CLE,ERA 
      ADA IDATX 
      LDA A,I 
      SEZ,RSS 
      ALF,ALF       SHIFT TO RIGHT BYTE 
      AND =B377 
      CPA =B40
      JMP GETC+1    IGNORE ALL SPACES 
      CPA COMA
      JMP GETC,I
      ISZ GETC      GOOD RETURN 
      JMP GETC,I
* 
* 
INC   NOP 
INCNT NOP 
      SKP 
* 
*     THIS ROUTINE RETURNS A SINGLE ASCII CHARACTER 
*     FROM THE INPUT BUFFER.
* 
GETAS NOP           GET ONE ASCII CHARACTER 
      CLB 
      JSB GETC      THIS IS IT
      JMP ASCEX     NO INPUT, DEFAULT TO ZERO 
      STA B 
      JSB GETC      THROW AWAY COMMA
      RSS 
      JMP *-2       NOT A COMMA 
ASCEX LDA B 
      JMP GETAS,I 
* 
* 
      SKP 
* 
* 
********* -CONV- ************ 
* 
*     THIS ROUTINE CONVERTS THE NEXT INPUT VALUE
*     TO BINARY.  THE VALUE IS RETURNED IN THE
*     A- AND B-REGISTERS. 
*     ALL SPACES ARE SKIPPED. 
*       VALUES MUST BE IN THE RANGE 0 TO 177777.
*       EACH DIGIT MUST BE IN THE RANGE 0 TO 7. 
* 
* 
*     CALLING SEQUENCE: 
*     JSB CONV
*     ***           NO INPUT
*     ***           INPUT VALUE IN A- AND B-REGISTER
* 
* 
CONV  NOP 
      JSB GETC      GET FIRST CHARACTER 
      JMP CONV,I    NONE,EXIT 
      ISZ CONV
      CLB 
CONLP AND =B7 
      BLF,CLE,RBR 
      ADB A 
      JSB GETC      GET NEXT CHARACTER
      RSS           DONE
      JMP CONLP 
      LDA B 
      JMP CONV,I
******* -CONVA- ********* 
*     THIS ROUTINE CHANGES AN INPUT VALUE TO
*     A MEMORY ADDRESS BY ADDING THE ABSOLUTE 
*     MEMORY BASE TO IT (SEE 'M' COMMAND).
*     IF THE INDIRECT BIT IS SET ON THE ORIGINAL
*     VALUE, OR ON THE CONVERTED VALUE, AN ERROR
*     MESSAGE IS OUTPUT.
* 
*     CALLING SEQUENCE: 
*     JSB CONVA 
*     ***           NO INPUT
*     ***           ADDRESS IN A
* 
* 
CONVA NOP           GET AN ADDRESS
      JSB CONV      INPUT VALUE 
      JMP CONVA,I   NO INPUT
      SSA 
      JMP INER      NEGATIVE VALUE
      ADA MEMOR 
      SSA 
      JMP INER      INDIRECT BIT SET
      ISZ CONVA 
      JMP CONVA,I 
* 
* 
* 
* 
* 
********* -SERCH- *********** 
*     THIS ROUTINE SEARCHES THE BREAKPOINT TABLE FOR
*     THE MEMORY ADDRESS IN THE A-REGISTER. 
*     THE ADDRESS OF THE BREAKPOINT TABLE ENTRY IS
*     RETURNED IN B.
* 
*     CALLING SEQUENCE: 
*     LDA ADDRESS 
*     JSB SERCH 
*     ***           NOT FOUND 
*     ***           TABLE ENTRY IN B
* 
SERCH NOP 
      LDB BKPTA     START OF BREAKPOINT TABLE 
SERLP CPA B,I 
      JMP SEREX     FOUND 
      ADB B2
      CPB BKPLG 
      JMP SERCH,I   END OF BREAKPOINT TABLE 
      JMP SERLP 
* 
SEREX ISZ SERCH 
      JMP SERCH,I 
* 
      SKP 
A     EQU 0 
B     EQU 1 
* 
AREG  OCT 0         SIMULATED A REGISTER
BREG  OCT 0         SIMULATED B REGISTER
B1    OCT 1 
B2    OCT 2 
B6    OCT 6 
BLK0  ASC 1,0       0,BLK 
BLK1  ASC 1,1       1,BLK 
* 
COMA  OCT 54        COMMA (,) 
* 
D     OCT 104 
E     OCT 105 
EOVRG OCT 0         E REG = BIT 15; OV = BIT 0
* 
H     OCT 110 
HMODE NOP           HONESTY MODE FOR ASCII OUTPUT 
IDATA BSS 37        INPUT DATA BUFFER 
INERR ASC 6,ENTRY ERROR 
INERX DEF INERR     ORIGIN OF ENTRY ERROR MESSAGE.
ISZ.I ISZ DBA.I,I 
* 
JMP.I JMP DBA.I,I 
JSB   JSB 0 
JSBAD NOP           RETURN ADDRESS STORAGE LOCATION 
JSBDB JSB DBA,I 
* 
M     OCT 115 
M72   DEC -72 
MEMOR OCT 0         MEMORY ORIGIN OR BASE ADDRESS 
* 
NOSIM NOP 
* 
O     OCT 117 
OP    NOP 
R     OCT 122 
S     OCT 123 
SFLAG OCT 0         INSTRUCTION OP-CODE STORAGE.
* 
TEMP  NOP 
TIN   ASC 7,INDIRECT LOOP!
W     OCT 127 
X     OCT 130 
BKPTA DEF BKPT      BREAKPOINT TABLE
* 
BKPT  REP 30
      NOP 
BKPLG DEF * 
* 
* 
      END INIT
                                                                                                                                                                                                                                                