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