Directory of image this file is from
This file as a plain text file
/ O D T / 8 TASK FOR RTS/8 14-SEP-83 16:20 / / / / / / / / / / OOOOOO DDDDDDD TTTTTTTT / 8888 / OO OO DD DD TT / 88 88 / OO OO DD DD TT / 8888 / OO OO DD DD TT / 88 88 / OO OO DD DD TT / 88 88 / OOOOOO DDDDDDD TT / 888888 / / / ON-LINE DEBUGGING TECHNIQUE TASK FOR RTS/8 / / / / / / / TASK SOURCE FILE / / / / / / / / VERSION: 4A / / DATE: 01-SEP-83 / / / / / / / / LEE H. NICHOLS III / / RESEARCH ASSOCIATE / / E. I. DUPONT DE NEMOURS AND COMPANY, INC. / ENGINEERING PHYSICS LABORATORY / EXPERIMENTAL STATION / WILMINGTON, DELAWARE 19898 / /
/ / VERS= 4 / / IFNZRO ASMVER <.SBTTL EDIT HSITORY > / / / EDIT HISTORY: / / /21-DEC-77: (LHN) / 1) CREATED THIS DATE / /17-JUN-81: (LHN) [N1] / 1) FIXED MASK BUG IN "OPEN PAGE RELATIVE". / /29-JUN-81: (LHN) / 1) ADDED CONDITIONAL CODE SO THAT ODT WILL / ASSEMBLE FOR RTS8 VERSION 2 OR 3. / 2) CHANGED "CDI" TO "CDF CIF" FOR MACREL. / 3) FORMATED THIS FILE FOR MACREL LISTING. / /20-JUL-81: (LHN) / 1) COMPLETED BREAKPOINT PROCESSING CODE. / / /01-SEP-83: (LHN) [N2] VERSION 4A / 1) DEBUGGED CODE FOR USE WITH KT8A. / /09-SEP-83: (LHN) / 1) CHANGED PACKED ASCII OUTPUT INTO SUBROUTINE. / 2) EXTENDED OUTPUT BUFFER BY 1. / /14-SEP-83: (LHN) [N3] / 1) FIXED SIMULATION OF CIF INSTRUCTION DURING / SINGLE STEP OPERATIONS. /
/ IFNZRO ASMVER < .SBTTL REFERENCE TABLE OF DEFINED COMMAND CHARACTERS > / / / REFERENCE TABLE OF DEFINED COMMAND CHARACTERS / / / RUBOUT CANCEL CURRENT INPUT / / / OPEN OCTAL WORD / " OPEN PACKED ASCII WORD / ' OPEN UNPACKED ASCII WORD / / (CR) CLOSE, NO SUCCESSIVE OPEN / (LF) CLOSE, OPEN NEXT LOCATION / : CLOSE, FILL SEQUENTIAL LOCATIONS / ^ CLOSE, OPEN PREVIOUS LOCATION / @ CLOSE, OPEN INDIRECT / _ CLOSE, OPEN PAGE RELATIVE / < CLOSE, OPEN OLD SEQUENCE / / $ INTERNAL REGISTER REFERENCE / = PRINT EXPRESSION IN OCTAL / C CONSTANT REGISTER CONTENTS / Q QUANTITY REGISTER CONTENTS / . LAST OPENED LOCATION'S ADDRESS / / ; MULTIPLE ARGUMENT DELIMITER / - ARGUMENT SUBTRACTION OPERATOR / + ARGUMENT ADDITION OPERATOR / , RELOCATION REGISTER OPERATOR / ( CONVERT TASK NAME OPERATOR / / B SET / RESET BREAKPOINTS / G SET BREAKPOINTS AND GO / H HOOK A TASK INTO DEBUG WAIT / P PROCEED WITH USER PROGRAM / R SET / RESET RELOCATION REGISTERS / S SINGLE STEP / T DISPLAY TASK STATE REGISTERS / U UNHOOK A TASK FROM DEBUG WAIT / X EXIT ODT TO RTS/8 / / A LIST REGISTER ASSIGNMENTS / D LIST THE TASKS IN DEBUG WAIT / E EFFECTIVE ADDRESS SEARCH / F FILL MEMORY / K KOMPUTE & PRINT RELOCATION DATA / L LIST MEMORY / N NOT THIS WORD SEARCH / W THIS WORD SEARCH
/ / / REFERENCE TABLE OF DEFINED INTERNAL REGISTERS / / / A SEARCH ARGUMENT REGISTER / M SEARCH MASK REGISTER / L LOW MEMORY LIMIT REGISTER / H HIGH MEMORY LIMIT REGISTER / C CONSTANT REGISTER / Q QUANTITY REGISTER / F ADDRESS FORMAT REGISTER / T ACTIVE TASK REGISTER / E BREAKPOINT SERVICE ROUTINE EXIT / / / B BREAKPOINT ADDRESS REGISTERS / R RELOCATION REGISTERS / G BREAKPOINT PROCEED COUNT REGISTERS / I BREAKPOINT INSTRUCTION REGISTERS / U USER TASK BREAKPOINT ASSIGNMENT REGISTERS / / / D DEVICE CONTROL REGISTERS / / / TABLE OF DEFINED ARGUMENTS FOR THE "T" COMMAND / / / E PRINT ALL THE STATE REGISTERS / F OPEN TASK FLAG WORD / Q OPEN TASK MESSAGE QUEUE HEADER / S OPEN TASK STATUS REGISTER / P OPEN TASK PROGRAM COUNTER / A OPEN TASK ACCUMULATOR / M OPEN TASK M/Q/ REGISTER / C OPEN TASK EAE STEP COUNTER /
/ IFZERO RTS8VER-2 < /[N2] FOR RTS/8 V1&2. TASK= ODT CUR= ODTFLD > IFNZRO RTS8VER-2 < /[N2] FOR RTS/8 V3. .RSECT RTODT8 .TASK ODT,,,,,GETCHR .EXTERNAL ODTBKF,TFTABL,MSGTBL,TSTABL,NMTBL .EXTERNAL TSWFLG ODTFLD= . > CLB= CLL CLA /FOR THE AUTHOR. INIWT= RUNWT /START UP IN RUN WAIT.
/ IFZERO RTS8VER-2 <FIELD ODTFLD%10> IFZERO RTS8VER-2 <*ODTLOC> / / / RESIDENT PAGE OF O D T / 8 / / / / CHARACTER INPUT ROUTINE / / / COME HERE TO GET THE NEXT INPUT CHARACTER FROM THE / USER'S DEVICE IN CHARACTER MODE. / / ON CALL: IF THE ACCUMULATOR IS 0, ECHO THE LAST / INPUT CHARACTER. IF THE ACCUMULATOR IS / NON-ZERO, IT CONTAINS A 7 BIT ASCII / CHARACTER TO BE OUTPUT BEFORE REQUESTING / AN INPUT CHARACTER. / / ON RETURN: THE NEW INPUT CHARACTER IS IN THE / ACCUMULATOR, READY TO USE. / / GETCHR, 0 SNA /AC CONTAIN A CHAR TO OUTPUT ? TAD ECHOCR /NO, ECHO THE LAST INPUT CHAR. DCA OUTCHR DCA INCHAR /DELETE THE OLD INPUT CHARACTER. DCA ECHOCR /DELETE THE OLD ECHO CHARACTER. DCA CHRMSG /FIRST CLEAR THE MESSAGE EVENT CAL / FLAG, THEN GO REQUEST ANOTHER SEND / USER INPUT CHARACTER. GETDEV, ODTCDV CHRMSG JMP I (EFWAIT /NOW, GO WAIT FOR THE USER. GETCRT, ISZ CHRMSG /SET THE #@% EVENT FLAG NOW TO / AVOID THE CONFUSION LATER - / IN "EFWAIT". TAD INCHAR /GET THE NEW INPUT CHARACTER, AND (0177) / STRIP OFF THE PARITY BIT THEN TAD (200) / FORCE IT BACK ON TO MAKE THE DCA INCHAR / CHARACTER 8 BIT ASCII. TAD INCHAR /IS THE NEW CHARACTER A LINE TAD (-212) / FEED ? SZA TAD (-3) /OR A CARRIAGE RETURN ? SNA CLA JMP GETC1 /YES, DON'T ECHO EITHER OF THEM.
/ TAD INCHAR /CHECK FOR ALTMODE - ALL 3 AND (0177) / FLAVORS ! TAD (-176) /176 SMA SZA /IF .GT. 176, MUST BE A RUBOUT, JMP GETC2 / SKIP THE REST OF THE CHARACTER SZA / CHECKS. IAC /175 SZA TAD (175-33) /033 SZA CLA JMP .+3 /NOT ALTMODE, GO ON. TAD (244) /CONVERT ALTMODE TO DOLLAR SIGN. DCA INCHAR TAD INCHAR GETC1, DCA ECHOCR /SAVE CHARACTER TO ECHO TO USER. TAD INCHAR /IS THE INPUT CHARACTER A SPACE? TAD (-240) SZA JMP .+3 TAD (253) /YES, CONVERT IT TO A "+". DCA INCHAR TAD (240-341) /INPUT CHARACTER IN LOWER CASE ? SPA JMP .+3 TAD (301) /YES, MAP IT TO UPPER CASE ! DCA INCHAR GETC2, CLB TAD INCHAR /PUT THE NEW CHARACTER IN THE JMP I GETCHR / AC, AND RETURN. CHRMSG, 1; 0; 0 6401 /NOCR+UNPACK+CHAR+1 INCHAR OUTCHR, 0 INCHAR, 0 ECHOCR, 0 /CHARACTER TO ECHO TO USER.
/ / / PUT A CHARACTER IN THE OUTPUT STRING BUFFER / / / ON CALL: IF THE AC IS ZERO, OUTPUT "ECHOCR". IF / THE AC IS NOT ZERO, IT CONTAINS THE / CHARACTER TO OUTPUT. / / PUTCHR, 0 SNA /AC = 0 ? TAD ECHOCR /YES, THEN USE CURRENT "ECHOCR". SNA JMP I PUTCHR /DON'T PUT ZEROES IN THE BUFFER. DCA I SPTR /PUT THE CHAR IN THE BUFFER. ISZ SPTR /INCREMENT THE BUFFER POINTER. DCA ECHOCR /KILL ANY OLD ECHO CHARACTER. JMP I PUTCHR /NOW BACK TO OUR CALLER. SPTR, PUTS1 /OUTPUT STRING BUFFER POINTER. / / / OUTPUT THE STRING BUFFER / / / SEND THE TEXT STRING BUFFER TO THE USER'S OUTPUT / DEVICE WITHOUT A CARRIAGE RETURN OR LINE FEED. / / ON CALL: THE ACCUMULATOR MAY CONTAIN A CHARACTER / TO ADD TO THE STRING BUFFER BEFORE / OUTPUT. / / PUTBUF, 0 JMS PUTCHR /PUT THE LAST CHARACTER TO THE DCA I SPTR / BUFFER AND ADD A ZERO WORD FOR / THE BUFFER TERMINATOR. DCA PUTMSG /FIRST CLEAR THE MESSAGE EVENT CAL / FLAG, THEN GO SEND THE MESSAGE. SEND PUTDEV, ODTCDV PUTMSG JMP I (EFWAIT /NOW GO WAIT UNTIL THE MESSAGE / OUTPUT IS COMPLETED. PUTBRT, ISZ PUTMSG /SET THE #@% EVENT FLAG NOW TO / AVOID THE CONFUSION LATER - / IN "EFWAIT". TAD (PUTS1) /RESET THE OUTPUT STRING BUFFER DCA SPTR / POINTER. JMP I PUTBUF /NOW RETURN TO CALLER.
/ PUTMSG, 1; 0; 0 6000 /UNPACKED ASCII + NO CR-LF. 0 PUTS1, ZBLOCK 14 /THE OUTPUT STRING BUFFER ITSELF. / / / START A NEW INPUT LINE WITH OUR NAME / / LGNAME, 0 JMS I (PRNTCR /DO A CR-LF AND RESET THE BUFFER. JMS I (PRNTCH /NOW PUT OUR NAME IN THE BUFFER. "O^100+"D-300 JMS I (PRNTCH "T^100+">-200 JMS PUTBUF /FINALLY OUTPUT THE BUFFER. JMP I LGNAME /ALL DONE, RETURN. PAGE
/ / / MAIN BODY OF ODT/8 / / START, CLB CDF RTCDF /THE FIRST THING WE DO IS CHECK TAD I (ODTBKF / THE ODT BREAKPOINT "EVENT CDF ODTFLD / FLAG" TO SEE IF A BREAKPOINT SPA SNA CLA / NEEDS SERVICING. JMP DECODE /NOPE, SEE WHAT THE USER WANTS. CDF RTCDF /GOT A BREAKPOINT TO LOOK AT. TAD (4000+TASK) / FIRST WE BETTER RESET OUR DCA I (ODTBKF / EVENT FLAG. (THAT SAVES A LOT CDF ODTFLD / OF GRIEF LATER.) THEN WE GO JMS I (BKPSER / SERVICE THE BREAKPOINT. JMP GOXIT /NOW EXIT ODT SINCE THE BREAK- / POINT EVENT FLAG WOKE US UP. / (THERE IS A VERY SMALL CHANCE / THE USER WOKE US AT THE SAME / TIME A BREAKPOINT CAME ALONG, / SO HE'LL HAVE TO TRY AGAIN. / FORCING THE USER TO WAKE US / AGAIN IS BETTER THAN LEAVING / ODT ACTIVE AFTER A BREAKPOINT / IS SERVICED, IF WE WERE ASLEEP / WHEN THE BREAKPOINT OCCURRED.) / / / START A NEW COMMAND LINE FROM SCRATCH / / DECODE, CLB IAC DCA ODTRUN /SET OUR "USER RUNNING" FLAG. TAD I (DEVCTR /RESET ODT TO USE THE TASK IN DCA I (GETDEV / $0D AS THE CONSOLE DEVICE. TAD I (DEVCTR / (THIS IS USUALLY THE USER DCA I (PUTDEV / TERMINAL.) JMS I (LGNAME /START A NEW OUTPUT LINE. DCA I (OPN /CLEAR THE "LOCATION OPEN" FLAG. DCA I (INTLDP /CLEAR THE "DOUBLE PRECISION / INTERNAL REGISTER OPEN" FLAG. / / / MAINTAIN OPENED LOCATION, RE-INITIALIZE INPUT / / NEWCMD, AC7775 /RESET THE SEMI-COLON FLAG/COUNT. DCA I (SMFD DCA I (ARG2FD /CLEAR THE "SECOND ARGUMENT DCA I (ARG3FD / FOUND" AND "THIRD ARGUMENT / FOUND" FLAGS.
/ / / START NEW SUB-EXPRESSION / / NEWEXP, DCA I (ARGFD /CLEAR THE "ARGUMENT FOUND" FLAG. DCA I (ARG /ZERO THE "EXPRESSION SO FAR" DCA I (ARG+1 / LOCATIONS. / / / GET THE NEXT USER ENTRY / / NEWNUM, DCA I (OP /RESET THE "CURRENT ARTHIMETIC / OPERATOR" FLAG. JMS I (GETNUM /GO GET A NUMERIC ARGUMENT. / / / NON-OCTAL CHARACTER ENTERED, WHAT ARE WE TO DO ? / / CLGL, JMS I (PUTBUF /FIRST ECHO THE COMMAND CHAR. JMS I (LOOKUP /GO COMPARE THE INPUT CHARACTER COMTAB / TO THE LIST OF VALID COMMANDS. COMDIS-COMTAB JMP ERROR /RETURN HERE IF ILLEGAL ENTRY. DCA .+2 /SAVE THE ADDRESS OF THE COMMAND / SERVICE ROUTINE. JMP I .+1 /NOW GO SERVICE THE USER'S HLT / COMMAND. / / / TELL THE USER HE GOOFED / / ERROR, JMS GOOFED /OUTPUT A "?", THEN JMP DECODE / LET THE USER TRY AGAIN. / / / CLEAR THE CURRENT ARGUMENT / / RUBOUT, JMS GOOFED /OUTPUT A "?", THEN JMP NEWEXP / RESTART THE CURRENT EXPSSION.
/ / / OUTPUT A QUESTION MARK TO SHOW ERROR / / GOOFED, 0 CLB JMS I (PUTCHR /TRY TO ECHO THE BAD CHARACTER. JMS I (PSPACE /NOW OUTPUT A SPACE, TAD (277) / AND A "?", THEN JMS I (PUTCHR JMS I (PSPACE / ANOTHER SPACE. JMS I (PUTBUF /PRINT THE OUTPUT BUFFER AND JMP I GOOFED / EXIT. / / / EXIT ODT, LEAVING US IN RUN WAIT. / / ODTXIT, CLB JMS I (PRNTCR /DO A CR-LF FIRST. GOXIT, DCA ODTRUN /CLEAR OUR "USER RUNNING" FLAG. CAL /NOW SUSPEND 'TIL NEEDED. SUSPND JMP START /ALIVE AGAIN, WHAT TO DO ? ODTRUN, 0 /"USER RUNNING" FLAG, SET WHEN / WE ARE TALKING TO THE USER.
/ / / / / EFWAIT, CIF ODTFLD /WE NEED INTERRUPTS OFF FOR TAD ODTRUN / SNA CLA JMP EFW1 / CDF RTCDF / THIS - IT GETS DELICATE !! TAD I (ODTBKF SPA SNA CLA JMP EFW1 TAD (4000+TASK) DCA I (ODTBKF CDF ODTFLD JMS I (BKPSER JMP EFWAIT EFW1, CDF ODTFLD TAD I (CHRMSG /DID THE CHARACTER INPUT EVENT SNA CLA / FLAG FIRE ? JMP I (GETCRT /YES, GO PROCESS THE INPUT. TAD (4000+TASK) /NO, RESET THE EVENT FLAG TO A DCA I (CHRMSG / WAITING STATE. TAD I (PUTMSG /BUFFER OUTPUT EVENT FLAG FIRE ? SNA CLA JMP I (PUTBRT /YES, GO FINISH THE OUTPUT. TAD (4000+TASK) /NO, RESET THE EVENT FLAG TO A DCA I (PUTMSG / WAITING STATE. IOF CIF RTCDF /NOTHING TO DO, SO WE'LL JUST GO WAITM / WAIT FOR SOMETHING TO HAPPEN. EFWT JMP EFWAIT /GO SEE WHO RANG OUR CHIME.
/ / / (,) RELOCATION REGISTER OPERATOR / / RELOP, JMS I (ARGTST /GO GET THE RELOCATION REGISTER ARGFD 0007 /(VALID ENTRY IS .LE. 7.) CLL RAL / NUMBER AND COMPUTE THE ADDRESS TAD (RELT) / OF THE REQUESTED REGISTER. DCA .+2 JMS I (MOVEDAT /MOVE THE CONTENTS OF THE 0000 / RELOCATION REGISTER TO WHERE ARG / WE CAN USE IT. JMP NEWNUM /NOW GET THE REST OF THE / EXPRESSION. PAGE
/ / / BUILD AN OCTAL NUMBER FROM THE USER'S INPUT / / / ON RETURN: / NUM = NUMERIC ENTRY, IF ANY / NUM+1 = FIELD DIGIT, IF ANY / ARGFD = NON ZERO, IF NUMERIC DATA WAS ENTERED / / GETNUM, 0 CLB DCA NUM /CLEAR THE NUMERIC ARGUMENT WORD. DCA NUM+1 /CLEAR THE FIELD ENTERED WORD. GETN1, JMS I (GETCHR /GO GET A CHAR FROM THE USER. TAD (-"7) /TEST FOR NUMERIC INPUT. SMA SZA JMP GETN2 /.GT. NUMBER, GO CHECK FOR A / COMMAND. TAD (7) /COULD STILL BE NUMERIC. SPA JMP GETN2 /NOPE, GO CHECK FOR A COMMAND. DCA ARGFD /SAVE THE NEW DIGIT. TAD NUM /EXTRACT WHAT WILL BE THE MEMORY AND (7000) / FIELD BITS, IF 5 OR 6 DIGITS CLL RAL / ARE ENTERED, TAD NUM+1 RTL / A RAL / N AND (0037) / D DCA NUM+1 / SAVE THEM FOR LATER. TAD NUM /SHIFT THE DEVELOPING NUMBER CLL RAL / LEFT TO ACCEPT THE NEW DIGIT. CLL RAL CLL RAL TAD ARGFD /ADD IN THE NEW DIGIT, DCA NUM / AND SAVE IT AWAY. ISZ ARGFD /SET THE "ARGUMENT FOUND" FLAG. JMP GETN1 /NOW TRY FOR ANOTHER DIGIT. GETN2, CLB /NOW ACCUMULATE THE NEW ARGUMENT JMS EXPCOM / INTO THE CURRENT EXPRESSION. NUM ARG /(ADDRESS OF THE EXPRESSION / BUCKET.) ARG JMP I GETNUM / AND RETURN.
/ / / EXPRESSION COMPUTATION ROUTINE / / / COME HERE TO ADD OR SUBTRACT 2 DOUBLE PRECISION / NUMBERS. THE ARGUMENTS WHICH FOLLOW THE CALL SPECIFY / THE LOCATION OF THE DATA TO USE AND WHERE THE RESULT / SHOULD GO. NOTE THAT THE FIRST ARGUMENT IS ADDED TO OR / SUBTRACTED FROM THE SECOND ARGUMENT. NOTE ALSO THAT / WHEN WE ARE CALLED, THE CONTENTS OF THE ACCUMULATOR / IS ADDED TO THE CURRENT ARITHMETIC OPERATOR FLAG (IN / "OP"), WHICH ALLOWS THE CALLER TO FORCE SUBTRACTION / WITHOUT SETTING "OP" FIRST. / / ON CALL: / AC IF NOT ZERO, FORCES SUBTRACTION MODE !! / OP = THE OPERATOR (+ OR -) / / ON RETURN: / OP = RESET TO "+" OPERATOR / / CALLING SEQUENCE: / / JMS EXPCOM / AAAA ADDRESS OF THE FIRST ARGUMENT / BBBB ADDRESS OF THE SECOND ARGUMENT / CCCC ADDRESS FOR THE RESULT (C=B+-A) / / EXPCOM, 0 TAD OP /COMBINE THE CONTENTS OF THE AC DCA OP / WITH THE CURRENT ARITHMETIC / OPERATOR. CLB /WE NEED THE LINK CLEAR ! TAD I EXPCOM /GET THE ADDRESS OF THE DATA ISZ EXPCOM / PAIR TO ADD OR SUBTRACT (LOW DCA EXPCA / ORDER WORD). TAD I EXPCOM /GET THE ADDRESS OF THE SECOND ISZ EXPCOM / DATA PAIR TO USE. DCA EXPCB TAD I EXPCOM /GET THE ADDRESS WHERE WE WILL ISZ EXPCOM / STORE THE RESULT. DCA EXPCC TAD OP /ADD OR SUBTRACT ? SZA CLA JMP EXPC1 /ARGUMENT SAYS DO SUBTRACTION.
/ TAD I EXPCA /ADD LOW ORDER WORDS. ISZ EXPCA TAD I EXPCB DCA I EXPCC /PUT RESULT WHERE IT BELONGS. RAL /PROPAGATE THE CARRY, IF ANY, TAD I EXPCA / AND ADD HIGH ORDER WORDS. JMP EXPC2 /GO USE SOME COMMON CODE. EXPC1, TAD I EXPCA /SUBTRACT LOW ORDER WORDS. ISZ EXPCA CLL CIA TAD I EXPCB DCA I EXPCC /PUT RESULT WHERE IT BELONGS. CML RAL /PROPAGATE BORROW, IF ANY, AND TAD I EXPCA / SUBTRACT THE HIGH ORDER WORDS. CIA EXPC2, ISZ EXPCB TAD I EXPCB /FINISH THE HIGH ORDER WORDS. ISZ EXPCC DCA I EXPCC /PUT RESULT WHERE IT BELONGS. DCA OP /RESET THE OPERATOR TO "ADD", JMP I EXPCOM / AND RETURN. EXPCA, 0 /LOCAL TEMPORARIES. EXPCB, 0 EXPCC, 0 / / / (;) PUSH MULTIPLE USER ARGUMENTS DOWN THE "STACK" / / SEMI, ISZ SMFD /COUNT THE USER'S SEMI COLONS ON SKP / THIS LINE. JMP I (ERROR /TOO MANY SEMI COLONS, SAY SO. TAD ARG2 /MOVE THE SECOND ARGUMENT SET DCA ARG3 / INTO THE THIRD ARGUMENT SLOT, TAD ARG2+1 / ALONG WITH THE "ARGUMENT DCA ARG3+1 / FOUND" FLAG. TAD ARG2FD DCA ARG3FD TAD ARG /NOW PUT THE CURRENT EXPRESSION DCA ARG2 / INTO THE SECOND ARGUMENT SLOT. TAD ARG+1 DCA ARG2+1 TAD ARGFD /ALSO MOVE THE "ARGUMENT FOUND" DCA ARG2FD / FLAG. JMP I (NEWEXP /GO CONTINUE EXPRESSION INPUT.
/ / / (-) SET EXRESSION OPERATOR TO SUBTRACT / / MINUS, CLB IAC / / / (+) SET EXPRESSION OPERATOR TO ADDITION / / PLUS, JMP I (NEWNUM /LET'S GO AROUND AGAIN. / / / (C) GET THE CONSTANT REGISTER / / CHRCEE, TAD (CONST-QUAN) /GO ADD THE CONSTANT REGISTER / INTO THE CURRENT EXPRESSION. / / / (Q) GET THE QUANTITY REGISTER CONTENTS / / CHRQUE, TAD (QUAN-DOT) /GO ADD THE QUNATITY REGISTER / INTO THE CURRENT EXPRESSION. / / / (.) GET LAST OPENED LOCATION'S ADDRESS / / CHRDOT, TAD (DOT) /GO ADD THE ADDRESS OF THE LAST DCA .+2 / EXPLICITY-OPENED LOCATION TO JMS EXPCOM / THE CURRENT EXPRESSION. 0000 /(WILL BE THE ADDRESS OF THE / DATA TO USE.) ARG /ACCUMULATE RESULT IN THE ARG / CURRENT EXPRESSION BUCKET. ISZ ARGFD /MARK AN ACTIVE EXPRESSION. JMP I (NEWNUM /NOW GET THE REST OF THE / EXPRESSION.
/ / / USER ARGUMENT STORAGE / / / "ARG" AND "ARG+1" ARE USED TO ACCUMULATE THE CURRENT / NUMERIC ARGUMENT EXPRESSION. / / ARGFD, 0 /FIRST ARGUMENT FOUND FLAG. ARG, 0 /LAST NUMERIC ARGUMENT ENTERED. 0 /LAST FIELD DIGIT ENTERED. ARG2FD, 0 /SECOND ARGUMENT FOUND FLAG. ARG2, 0; 0 /SECOND ARGUMENT STORAGE. ARG3FD, 0 /THIRD ARGUMENT FOUND FLAG. ARG3, 0; 0 /THIRD ARGUMENT STORAGE. NUM, 0; 0 /LAST NUMERIC INPUT FROM / "GETNUM". OP, 0 /CURRENT ARITHMETIC OPERATOR. SMFD, 0 /SEMI COLON COUNTER. PAGE
/ / / TEST A LIST FOR A VALID COMMAND CHARACTER / / / COME HERE TO SEARCH A TABLE FOR THE INPUT CHARACTER / IN "INCHAR". / / ON CALL: THE CHARACTER TO SEARCH FOR IN "INCHAR". / / ON RETURN: IF A CHARACTER MATCH WAS FOUND, THE AC / CONTAINS THE ADDRESS ASSOCIATED WITH / THAT CHARACTER. / / CALLING SEQUENCE: / / JMS LOOKUP / COMMAND TABLE ADDRESS / DISPATCH TABLE ADDRESS - COMMAND TABLE ADDRESS / ERROR RETURN / COMMAND FOUND RETURN / / LOOKUP, 0 CLB CMA TAD I LOOKUP /SET UP A POINTER INTO THE ISZ LOOKUP / COMMAND TABLE TO SEARCH. DCA LOOKA LOOK1, ISZ LOOKA TAD I LOOKA /GET A COMMAND LIST CHARACTER. SNA /END OF TABLE ? JMP LOOK2 /YES, TAKE THE ERROR EXIT. AND (0377) /MASK OFF THE CODE BITS AND CIA / MAKE IT NEGATIVE. TAD I (INCHAR /DOES IT MATCH USER'S ENTRY ? SZA CLA JMP LOOK1 /NO, TRY AGAIN. TAD LOOKA /YES, GET THE ADDRESS OF THE TAD I LOOKUP / COMMAND AND ADD IN THE OFFSET ISZ LOOKUP / INTO THE MATCHING DISPATCH DCA LOOKB / TABLE. TAD I LOOKB /NOW GET THE ADDRESS OF THE / COMMAND SERVICE ROUTINE FROM / THE DISPATCH TABLE AND RETURN / IT TO THE CALLER. LOOK2, ISZ LOOKUP /INCREMENT OVER THE ERROR RETURN, JMP I LOOKUP / AND RETURN TO THE CALLER. LOOKA, 0 /LOCAL TEMPORARIES. LOOKB, 0
/ / / TABLE OF DEFINED COMMAND CHARACTERS / / / USED WITH "COMDIS". / / COMTAB, 377 /RUBOUT CANCEL CURRENT INPUT 257 / / OPEN OCTAL WORD 242 / " OPEN PACKED ASCII WORD 247 / ' OPEN UNPACKED ASCII WORD 215 / (CR) CLOSE, NO SUCCESSIVE OPEN 212 / (LF) CLOSE, OPEN NEXT LOCATION 272 / : CLOSE, FILL SEQUENTIAL LOCATIONS 336 / ^ CLOSE, OPEN PREVIOUS LOCATION 300 / @ CLOSE, OPEN INDIRECT 337 / _ CLOSE, OPEN PAGE RELATIVE 274 / < CLOSE, OPEN OLD SEQUENCE 244 / $ INTERNAL REGISTER REFERENCE 275 / = PRINT EXPRESSION IN OCTAL 303 / C CONSTANT REGISTER CONTENTS 321 / Q QUANTITY REGISTER CONTENTS 256 / . LAST OPENED LOCATION'S ADDRESS 273 / ; MULTIPLE ARGUMENT DELIMITER 255 / - ARGUMENT SUBTRACTION OPERATOR 253 / + ARGUMENT ADDITION OPERATOR 254 / , RELOCATION REGISTER OPERATOR IFNZRO TASKNAME < 250 / ( CONVERT TASK NAME OPERATOR >
/ / / TABLE OF DEFINED COMMAND CHARACTERS - CONTINUED / / 302 / B SET / RESET BREAKPOINTS 304 / D LIST THE TASKS IN DEBUG WAIT 307 / G SET BREAKPOINTS AND GO 310 / H HOOK A TASK INTO DEBUG WAIT 320 / P PROCEED WITH USER PROGRAM 322 / R SET / RESET RELOCATION REGISTERS 323 / S SINGLE STEP 324 / T DISPLAY TASK STATE REGISTERS 325 / U UNHOOK A TASK FROM DEBUG WAIT 330 / X EXIT ODT TO RTS/8 IFNZRO ODTFUL < 301 / A LIST REGISTER ASSIGNMENTS 305 / E EFFECTIVE ADDRESS SEARCH 306 / F FILL MEMORY 313 / K KOMPUTE & PRINT RELOCATION DATA 314 / L LIST MEMORY 316 / N NOT THIS WORD SEARCH 327 / W THIS WORD SEARCH > 0 /END OF TABLE TERMINATOR.
/ / / TABLE OF THE ADDRESSES OF THE SERVICE ROUTINES FOR / THE COMMANDS LISTED IN THE COMMAND TABLE "COMTAB". / / / NOTE: THE ORDER OF "COMDIS" AND "COMTAB" MUST MATCH ! / / COMDIS, RUBOUT /RUBOUT CANCEL CURRENT INPUT OPENWD / / OPEN OCTAL WORD OPENPA / " OPEN PACKED ASCII WORD OPENUA / ' OPEN UNPACKED ASCII WORD CLCRET / (CR) CLOSE, NO SUCCESSIVE OPEN CLLNFD / (LF) CLOSE, OPEN NEXT LOCATION CLCOLN / : CLOSE, FILL SEQUENTIAL LOCATIONS CLUPAR / ^ CLOSE, OPEN PREVIOUS LOCATION CLATSG / @ CLOSE, OPEN INDIRECT CLBACK / _ CLOSE, OPEN PAGE RELATIVE CLLSTH / < CLOSE, OPEN OLD SEQUENCE INREGT / $ INTERNAL REGISTER REFERENCE EQUALS / = PRINT EXPRESSION IN OCTAL CHRCEE / C CONSTANT REGISTER CONTENTS CHRQUE / Q QUANTITY REGISTER CONTENTS CHRDOT / . LAST OPENED LOCATION'S ADDRESS SEMI / ; MULTIPLE ARGUMENT DELIMITER MINUS / - ARGUMENT SUBTRACTION OPERATOR PLUS / + ARGUMENT ADDITION OPERATOR RELOP / , RELOCATION REGISTER OPERATOR IFNZRO TASKNAME < TSKNAM / ( CONVERT TASK NAME OPERATOR >
/ / / SERVICE ROUTINE ADDRESSES - CONTINUED / / BREAKP / B SET / RESET BREAKPOINTS DBLIST / D LIST THE TASKS IS DEBUG WAIT GOTOIT / G SET BREAKPOINTS AND GO HOOKDB / H HOOK A TASK INTO DEBUG WAIT PROCED / P PROCEED WITH USER PROGRAM RELOCT / R SET / RESET RELOCATION REGISTERS SINGLE / S SINGLE STEP TASKST / T DISPLAY TASK STATE REGISTERS UNHOOK / U UNHOOK A TASK FROM DEBUG WAIT ODTXIT / X EXIT ODT TO RTS/8 IFNZRO ODTFUL < ASLIST / A LIST REGISTER ASSIGNMENTS SERCHE / E EFFECTIVE ADDRESS SEARCH FILLCR / F FILL MEMORY KOMPUT / K KOMPUTE & PRINT RELOCATION DATA LISTCR / L LIST MEMORY SERCHN / N NOT THIS WORD SEARCH SERCHW / W THIS WORD SEARCH >
/ / / MOVE 2 CONSECUTIVE WORDS, WITH OPTIONAL TEST / / / ON CALL: / AC .EQ. 0 MOVE DATA WITHOUT TEST. / AC .GE. 4000 MOVE DATA ONLY IF THE ADDRESSED / "ARGUMENT FOUND" FLAG IS SET. / / CALLING SEQUENCE: / / JMS MOVEDAT / ADDRESS OF THE DATA TO MOVE (OR ARGUMENT FLAG) / ADDRESS TO MOVE THE DATA TO / / MOVEDAT,0 CLL RAL /SAVE THE CALLING ARGUMENT, IF / ANY, IN THE LINK. TAD I MOVEDAT /GET THE "FROM" ADDRESS FOR AN ISZ MOVEDAT / INDIRECT POINTER. DCA MOVDA TAD I MOVEDAT /DO THE SAME FOR THE "TO" ISZ MOVEDAT / ADDRESS. DCA MOVDB SNL /SHOULD WE TEST IF AN ARGUMENT / WAS ENTERED ? JMP MOVD1 /NO, JUST MOVE THE DATA. TAD I MOVDA /TEST THE SPECIFIED "ARGUMENT ISZ MOVDA / FOUND" FLAG. SNA CLA JMP I MOVEDAT /NO DATA ENTERED, JUST EXIT. MOVD1, TAD I MOVDA /GET THE LOW ORDER WORD OF THE ISZ MOVDA / PAIR, DCA I MOVDB / AND PUT IT SOMEWHERE ELSE. ISZ MOVDB TAD I MOVDA /NOW DO THE HIGH ORDER WORD. DCA I MOVDB JMP I MOVEDAT /THAT'S ALL FOLKS, RETURN. MOVDA, 0 /LOCAL TEMPORARIES. MOVDB, 0 PAGE
/ / / OPEN THE CURRENT ADDRESS / / / ON CALL: "CADDR" CONTAINS THE ADDRESS TO USE. / / ON RETURN: "CDATA" HAS THE DATA WE WANT. / / GETCAD, 0 CLB TAD CADDR+1 IFZERO KT8A < AND (0007) /FIRST TEST IF THE HIGH ORDER TAD (-HGHFLD%10 7000) / ADDRESS IS WITHIN THE SMA SZA CLA / DEFINED MEMORY SPACE. JMP I (ERROR /NOPE, TELL THE USER SO ! TAD CADDR+1 /GET THE HIGH ORDER DATA WORD, AND (0007) / (WE ONLY WANT THE FIELD BITS!) CLL RTL / AND CONVERT IT INTO A CDF RAL / INSTRUCTION. TAD (CDF 0) > IFNZRO KT8A < AND (0037) /CHECK THAT THE FIELD IS WITHIN TAD (-KTFLDS) / THE ENABLED FIELDS FOR THE SMA / KT8A. JMP I (ERROR /TOO BIG, PREVENT WRAP-AROUND. CLL CML RTR /HAD 111 111 1AB CDE. RTR /HAVE CDE 111 111 11A, B IN LINK. BSW /HAVE 111 11A CDE 111, B IN LINK. SZL /SKIP IF B IS ZERO, TAD (4) / OR PUT B INTO PLACE, AND THEN TAD (4^KTFLDS+6172) /[N2] MAKE CDF OUT OF THIS. > DCA CFLD CFLD, HLT TAD I CADDR /GET THE REQUESTED DATA, AND DCA CDATA / SAVE IT FOR ALL TO SEE. TAD INTLDP /IS AN INTERNAL DOUBLE PRECISION SNA CLA / REGISTER OPEN ? JMP GETD1 /NO, GO CLEAR THE HIGH ORDER / DATA STORAGE WORD. CLB IAC /FORM THE ADDRESS OF THE HIGH TAD CADDR / ORDER WORD FOR AN INTERNAL DCA CDATA+1 / DOUBLE PRECISION REGISTER. TAD I CDATA+1 /GET THE CONTENTS OF HIGH ORDER GETD1, DCA CDATA+1 / WORD AND SAVE IT. CDF ODTFLD /RESET THE DATA FIELD TO HERE, JMP I GETCAD / AND RETURN.
/ / / PUT DATA IN THE CURRENT OPEN ADDRESS / / / IF A LOCATION IS OPEN AND IF AN ARGUMENT WAS ENTERED, / PUT THE DATA IN "ARG" IN THE CURRENT OPEN ADDRESS. / ELSE DO NOTHING. / / PUTCAD, 0 TAD OPN /IS A LOCATION OPEN ? SNA CLA JMP PUTD1 /NO, JUST EXIT. TAD I (ARGFD /HAS A NUMERIC ARGUMENT BEEN SNA CLA / ENTERED ? JMP PUTD1 /NO, NOTHING TO PUT AWAY, EXIT. TAD CFLD /GET THE CDF TO THE OPEN ADDRESS, DCA PUTDA / AND SET IT UP TO USE. TAD I (ARG /GET THE DATA FROM "ARG", AND PUTDA, HLT DCA I CADDR / PUT IN THE OPEN LOCATION. CDF ODTFLD DCA OPN /MARK THE LOCATION CLOSED. DCA I (ARGFD /MARK THE ARGUMENT USED. TAD INTLDP /ARE WE DOING A DOUBLE PRECISION SNA CLA / INTERNAL REGISTER ? JMP I PUTCAD /NO, WE CAN EXIT NOW. CLB IAC /CREATE THE ADDRESS OF THE HIGH TAD CADDR / ORDER WORD FOR THIS REGISTER. DCA INTLDP TAD I (ARG+1 /AS WE MOVE THE HIGH ORDER WORD, AND (0037) / WE LIMIT THE DATA TO STAY DCA I INTLDP / WITHIN FIELDS 0 TO 37(8) ! PUTD1, DCA INTLDP /CLEAR THE DOUBLE PRECISION / INTERNAL REGISTER FLAG. JMP I PUTCAD /NOW JUST RETURN TO THE CALLER. CADDR, 0 /ADDRESS OF THE CURRENT OPEN 0 / LOCATION. CDATA, 0 /DATA FROM THE CURRENT OPEN 0 / LOCATION. OPN, 0 /LOCATION OPEN FLAG, 0=NOT OPEN. INTLDP, 0 /DOUBLE PRECISION INTERNAL / REGISTER OPEN FLAG.
/ / / PRINT THE STATE DATA FOR THE SPECIFIED TASK / / / ON CALL: THE ACCUMULATOR CONTAINS THE NUMBER OF / THE TASK TO DO. / / TSKLST, 0 DCA TSKLA /SAVE THE DESIRED TASK NUMBER. IFZERO EAE < TAD (-4) /SET UP A LOOP COUNTER. > IFNZRO EAE < TAD (-5) > DCA TSKLB DCA I (FM /FORCE THE OUTPUT MODE TO OCTAL! JMS I (PSPACE /FIRST OUTPUT A SPACE, IFZERO TASKNAME < JMS I (PRNTWD / THEN OUTPUT THE TASK NUMBER, > IFNZRO TASKNAME < JMS I (PRTNAM / OR MAYBE THE TASK NAME > TSKLA JMS I (PSPACE / AND AN EXTRA SPACE. TAD TSKLA /COMPUTE THE STARTING ADDRESS OF CLL RTL / THE TASK STATE DATA FOR THIS / TASK, IFNZRO EAE < TAD TSKLA / FOR EAE, NEED TASK NUMBER X 5, > TAD (TSTABL) DCA TSKLA / AND SAVE IT. TSKL1, JMS I (PSPACE /OUTPUT A SPACE. CDF RTCDF TAD I TSKLA /GET THE NEXT WORD IN THE STATE CDF ODTFLD / TABLE, AND DCA TSKLC JMS I (PRNTWD / ADD IT TO THE OUTPUT BUFFER. TSKLC ISZ TSKLA ISZ TSKLB /FINISHED ALL THE STATE WORDS ? JMP TSKL1 /NO, DO ANOTHER. JMP I TSKLST /RETURN FROM WHENCE WE CAME. TSKLA, 0 /LOCAL TEMPORARIES. TSKLB, 0 TSKLC, 0
/ / / FIND A TASK IN DEBUG WAIT / / / ON CALL: IF THE AC .NE. 0, INITIALIZE THEN SEARCH. / IF AC .EQ. 0, CONTINUE SEARCH FROM HERE. / / / CALLING SEQUENCE: / / JMS FINDDB / EXIT HERE WHEN THE TABLE IS EXHAUSTED / EXIT HERE WITH TASK NUMBER IN THE AC / / FINDDB, 0 SNA CLA /IS THE ACCUMULATOR = 0 ? JMP FIND1 /YES, LOOK FOR THE NEXT TASK. TAD (TFTABL+1) /REINITIALIZE THE TABLE POINTER, DCA FINDA DCA FINDB / AND CLEAR THE LOOP COUNTER. FIND1, CDF RTCDF /SET THE PROPER DATA FIELD. TAD I FINDA /GET THE NEXT TASK FLAG WORD. CDF ODTFLD /RESET THE DATA FIELD TO HERE. ISZ FINDA ISZ FINDB /INCREMENT THE LOOP COUNTER. AND (DEBWT) /IS THIS TASK IN DEBUG WAIT ? SZA CLA JMP FIND2 /YES, GO ON. TAD FINDB /SEARCHED THE WHOLE TABLE ? TAD (-NTASKS) SPA CLA JMP FIND1 /NO, LOOK AGAIN. JMP I FINDDB /THE TABLE IS EXHAUSTED, TAKE / THE FIRST EXIT. FIND2, TAD FINDB /PUT THE TASK NUMBER WE FOUND IN ISZ FINDDB / THE AC, AND JMP I FINDDB / TAKE THE SECOND EXIT. FINDA, 0 /LOCAL TEMPORARIES. FINDB, 0
/ PAGE
/ / / OPEN AND TYPE CONTENTS COMMAND PROCESSOR / / / FOR: (/) (") (') / / / SYNTAX: / X TYPE LAST OPENED LOCATION IN MODE "X". / AX OPEN LOCATION "A" IN MODE "X". / / OPENUA, IAC /OPEN & PRINT AS UNPACKED ASCII. OPENPA, IAC /OPEN & PRINT AS PACKED ASCII. OPENWD, /OPEN & PRINT AS AN OCTAL WORD. DCA FM /SET THE OUTPUT FORMAT. TAD I (ARGFD /WAS A NUMERIC ARGUMENT ENTERED? SNA CLA JMP OPEN1 /NO, REOPEN THE CURRENT ADDRESS. JMS I (MOVEDAT /YES, USE IT TO UPDATE THE ARG / CURRENT ADDRESS. CADDR JMS I (MOVEDAT /AND UPDATE THE STORAGE FOR THE ARG / "LAST EXPLICIT OPEN" ADDRESS. DOT TAD FM /ALSO SAVE THE CURRENT OUTPUT DCA LFM / FORMAT (MODE). OPEN1, JMS I (GETCAD /GET DATA POINTED TO BY "CADDR". ISZ I (OPN /MARK THIS LOCATION OPEN, AND JMS I (PRNTWD / PUT IT IN THE OUTPUT BUFFER. CDATA JMP I (NEWCMD /NOW GO GET THE NEXT COMMAND. DOT, 0 /STORAGE FOR ADDRESS OF THE LAST 0 / EXPLICIT OPENED LOCATION. FM, 0 /OUTPUT FORMAT (MODE) SWITCH. LFM, 0 /OUTPUT FORMAT (MODE) OF LAST / EXPLICITLY-OPENED LOCATION. ONE, 1; 0 /THE CONSTANT "1".
/ / / CLOSE AND OPEN COMMAND PROCESSORS / / / FOR: (CR) (LF) (^) (@) (_) / / / SYNTAX: / X CLOSE AND OPEN ANOTHER VIA COMMAND "X". / MX UPDATE OPEN LOCATION WITH "M", CLOSE AND / OPEN ANOTHER VIA COMMAND "X". / / / / / (CR) CLOSE THE CURRENT LOCATION / / CLCRET, JMS I (PUTCAD /GO CLOSE THE CURRENT LOCATION. JMP I (DECODE /NOW RETURN TO COMMAND INPUT. / / / (<) CLOSE AND OPEN OLD SEQUENCE / / CLLSTH, JMS I (PUTCAD /GO CLOSE THE CURRENT LOCATION. JMS I (MOVEDAT /RESET THE CURRENT ADDRESS TO DOT / THE ADDRESS OF THE LAST CADDR / EXPLICIT OPEN. JMP CLLN2 / / / (LF) CLOSE AND OPEN NEXT LOCATION / / CLLNFD, JMS I (PUTCAD /GO CLOSE THE CURRENT LOCATION. CLLN1, JMS I (EXPCOM /FORCE ADDITION (SUBTRACTION). ONE /ADD (OR SUBTRACT) ONE TO (FROM) CADDR / THE CURRENT ADDRESS. CADDR JMS I (MOVEDAT /ALSO UPDATE THE STORAGE FOR THE CADDR / "LAST EXPLICIT OPEN" ADDRESS. DOT CLLN2, TAD LFM /RESET THE OUTPUT FORMAT MODE TO DCA FM / THAT OF THE LAST EXPLICIT OPEN. CLLN3, JMS I (PRNTCR /FINISH THIS LINE WITH A CR-LF. JMS I (INTADR /GO CHECK FOR INTERNAL ADDRESS. JMS I (PRTADR /GO OUTPUT THE CURRENT ADDRESS, / AND MAYBE USE ONE OF THE / RELOCATION REGISTERS. JMS I (PRNTMD /GO PRINT THE MODE CHARACTER. JMP OPEN1 /NOW SIMPLY OPEN THIS LOCATION.
/ / / (^) CLOSE AND OPEN PREVIOUS LOCATION / / CLUPAR, JMS I (PUTCAD /GO CLOSE THE CURRENT LOCATION. CLB IAC JMP CLLN1 /NOW GO THRU (LF) CODE WITH / "EXPCOM" SET TO SUBTRACTION / MODE. / / / (@) CLOSE AND OPEN INDIRECT / / CLATSG, JMS I (PUTCAD /GO CLOSE THE CURRENT LOCATION. JMS I (GETCAD /GET THE DATA AT THE CURRENT TAD I (CDATA / ADDRESS. JMP CLBA1 /NOW GO USE SOME COMMON CODE. / / / (_) CLOSE AND OPEN PAGE RELATIVE / / CLBACK, JMS I (PUTCAD /GO CLOSE THE CURRENT LOCATION. JMS I (GETCAD /NOW GET THE DATA AT THE CURRENT TAD I (CDATA / ADDRESS AND FORM A PAGE AND (0177) /[N1] RELATIVE ADDRESS. DCA FM TAD I (CDATA /IS THIS A PAGE ZERO REFERENCE ? AND (0200) SNA CLA JMP .+3 /YES, USE OUR PAGE ADDRESS AS IS. TAD I (CADDR /NO, ADD IN THE PAGE BITS FOR AND (7600) /[N1] THE CURRENT MEMORY PAGE. TAD FM CLBA1, DCA I (CADDR /SAVE IT AS THE CURRENT ADDRESS. DCA FM /FORCE OUTPUT MODE TO OCTAL ! JMP CLLN3 /GO USE SOME SHARED CODE. / / / (=) PRINT THE CURRENT EXPRESSION IN OCTAL / / EQUALS, CLB IAC /(PRINT 5 OR 6 OCTAL DIGITS) JMS PRNTWD /PRINT THE CONTENTS OF "ARG". ARG JMS I (DECODE /GO GET THE NEXT COMMAND.
/ / / (:) CLOSE AND FILL SEQUENTIAL LOCATIONS / / CLCOLN, TAD I (OPN /IS THE CURRENT LOCATION OPEN ? SNA CLA JMP I (ERROR /NO, TELL THE USER (S)HE GOOFED. JMS I (PUTCAD /FIRST CLOSE THE CURRENT / LOCATION. JMS I (EXPCOM /THEN INCREMENT THE CURRENT ONE / ADDRESS BY ONE FOR THE NEXT CADDR / LOCATION, AND CADDR ISZ I (OPN / SAY THIS LOCATION IS OPEN. JMP I (NEWCMD /TRY FOR DATA FOR THIS LOCATION. / / / RELEASE A TASK FROM DEBUG WAIT / / / ON CALL: THE ACCUMULATOR CONTAINS THE NUMBER OF / THE TASK TO RELEASE. / / RELEASE,0 SNA /WAS A TASK NUMBER SPECIFIED ? JMP I RELEASE /NO, JUST RETURN. TAD (TFTABL) /COMPUTE THE ADDRESS OF THE FLAG DCA RELEA / WORD FOR THE SPECIFIED TASK. CDF CIF RTCDF /THE TASK FLAG TABLE IS IN THE / FIELD OF THE RTS/8 EXECUTIVE. / ALSO WE NEED THE INTERRUPTS / OFF FOR THIS ! TAD I RELEA /GET THE TASK'S FLAG WORD, AND RELMSK / MASK OUT SOME BLOCKING BITS, TAD RELBLK / MAYBE ADD IN BLOCKING BITS, DCA I RELEA / AND PUT THE FLAG WORD BACK CDF CIF ODTFLD / WHERE THE EXEC CAN FIND IT. TAD (-DEBWT-1) /RESET THE BLOCKING BIT MASK TO DCA RELMSK / DEBUG WAIT. DCA RELBLK /RESET BLOCKING BITS TO ADD. JMP I RELEASE /NOW THAT WAS EASY, WASN'T IT ? RELEA, 0 /LOCAL TEMPORARY. RELMSK, -DEBWT-1 /MASK FOR REMOVING BLOCKING BITS. RELBLK, 0 /BLOCKING BITS TO ADD, IF ANY.
/ PAGE
/ / / PRINT DATA IN THE CORRECT FORMAT / / / THIS IS THE PRIMARY OUTPUT FORMAT ROUTINE FOR ODT8. IT / CAN PROCESS UP TO 6 OCTAL DIGITS OF NUMERIC DATA, AND / EITHER PACKED OR UNPACKED ASCII DATA. / / ON CALL: / AC IF NON-ZERO, FORCES 5 OR 6 OCTAL DIGITS. / FM CONTAINS THE CURRENT OUTPUT MODE; WHERE / 0=OCTAL, 1=UNPACKED (6 BIT) ASCII, AND / 2=PACKED (8 BIT) ASCII DATA CONVERSION. / INTLDP IF NON-ZERO, FORCES 5 OR 6 OCTAL DIGITS, / FOR INTERNAL DOUBLE PRECISION REGISTERS. / / CALLING SEQUENCE: / / JMS PRNTWD / ADDR ADDRESS OF THE DATA TO OUTPUT. / / PRNTWD, 0 DCA PRN1 /SAVE THE AC FOR LATER. TAD I PRNTWD /GET THE ADDRESS OF THE DATA TO ISZ PRNTWD / OUTPUT, AND DCA .+2 JMS I (MOVEDAT / MOVE IT TO THE "QUANTITY" 0000 / REGISTER. QUAN TAD PRN1 /IF THE AC WAS .GT. 0 ON CALL, TAD I (INTLDP / OR "INTLDP" IS .GT. 0, WE DO 5 SNA CLA / OR 6 OCTAL DIGITS. JMP PRNW1 /NEITHER WAS .GT. 0, GO ON. TAD I (QUAN+1 /GET THE HIGH ORDER DATA, IFNZRO KT8A < AND (0037) /MASK OUT POSSIBLE FIELDS, AND JMS PRNTN2 / PRINT 2 FIELD DIGITS FOR KT8A. > IFZERO KT8A < JMS PRNTN1 /JUST PRINT 1 FIELD DIGIT. > JMP PRNW2 PRNW1, DCA I (QUAN+1 /FOR SINGLE PRECISION DATA, / CLEAR THE HIGH ORDER WORD OF / THE "QUANTIY" REGISTER. TAD I (FM /DETERMINE THE MODE FOR OUTPUT. SZA /MODE = 0 ? JMP PRNW3 PRNW2, JMS PRNTN4 /YES, JUST GO OUTPUT THE DATA AS JMP I PRNTWD / 4 OCTAL DIGITS, AND RETURN.
/ PRNW3, CLL RAR /MODE IS ASCII, UNPACKED ? SZL CLA JMP PRNW4 TAD I (QUAN /YES, JUST PUT THE CHARACTER IN JMS I (PUTCHR / THE OUTPUT STRING BUFFER, JMP PRNW5 /NOW FINISH OUR WORK. PRNW4, TAD I (QUAN /MODE IS PACKED ASCII, GET THE DCA PRN1 / DATA WORD AND GO OUTPUT IT. JMS PRNTCH PRN1, 0000 PRNW5, JMS PSPACE /ADD A SPACE, AND JMS I (PUTBUF / PRINT THE OUTPUT BUFFER. JMP I PRNTWD /TIME TO EXIT. / / / PRINT 2 PACKED ASCII CHARACTERS / / PRNTCH, 0 TAD I PRNTCH /GET THE HIGH ORDER 6 BITS, IFNZRO OMNI < BSW /FOR OMNIBUS PROCESSORS. > IFZERO OMNI < RTR RTR /FOR PRE-OMNIBUS MACHINES. RTR > JMS PRNC1 / AND GO MAKE IT INTO FULL ASCII. TAD I PRNTCH /NOW DO THE LOW ORDER 6 BITS. JMS PRNC1 ISZ PRNTCH /SKIP OVER DATA WORD, JMP I PRNTCH / AND RETURN.. / / / PUT 1 ASCII CHARACTER IN THE OUTPUT BUFFER / / PRNC1, 0 AND (0077) /MAKE 6 BITS INTO A FULL ASCII TAD (240) / TYPE CHARACTER. AND (0077) TAD (240) JMS I (PUTCHR /SEND IT TO THE OUTPUT BUFFER, JMP I PRNC1 / AND RETURN.
/ / / PRINT THE CONTENTS OF THE "QUANTITY" IN OCTAL / / PRNTN4, 0 TAD I (QUAN /FIRST GET THE HIGH ORDER 6 BITS / OF THE "QUANTITY" REGISTER. IFNZRO OMNI < BSW /FOR OMNIBUS MACHINES. > IFZERO OMNI < RTR RTR /FOR PRE-OMNIBUS MACHINES. RTR > JMS PRNTN2 /GO OUTPUT 2 OCTAL DIGITS. TAD I (QUAN /NOW DO THE LOW ORDER 6 BITS. JMS PRNTN2 JMS PSPACE /ADD A SPACE, AND JMS I (PUTBUF / PRINT THE OUTPUT BUFFER. JMP I PRNTN4 /ALL DONE, RETURN. / / / CONVERT 6 BITS INTO 2 OCTAL DIGITS / / PRNTN2, 0 DCA PRN1 /SAVE THE CALLING DATA. TAD PRN1 /GET THE FIRST OCTAL DIGIT. RTR RAR JMS PRNTN1 TAD PRN1 /NOW THE SECOND DIGIT. JMS PRNTN1 JMP I PRNTN2 /RETURNITH... / / / PUT 1 OCTAL DIGIT IN THE OUTPUT BUFFER IN ASCII / / PRNTN1, 0 AND (0007) /CLEAN IT UP, TAD (260) / MAKE IT ASCII, JMS I (PUTCHR / AND PUT IN THE OUTPUT BUFFER. JMP I PRNTN1 /RETURN FOR ANOTHER.
/ / / PRINT THE CURRENT MODE CHARACTER / / PRNTMD, 0 TAD I (FM /COMPUTE THE ADDRESS OF THE MODE TAD (MODTBL+1) / CHARACTER. DCA MODTBL TAD I MODTBL /PUT THE MODE CHARACTER IN THE JMS I (PUTCHR / OUTPUT BUFFER. JMP I PRNTMD /THEN BACK TO CALLER. MODTBL, 0 257 / / OCTAL WORD MODE 242 / " PACKED ASCII MODE 247 / ' UNPACKED ASCII MODE / / / PUT A SPACE IN THE OUTPUT BUFFER / / PSPACE, 0 TAD (240) /PUT A SPACE IN THE OUTPUT JMS I (PUTCHR / BUFFER. JMP I PSPACE /RETURN. / / / PUT 2 SPACES IN THE OUTPUT BUFFER / / P2SPACE,0 JMS PSPACE /PUT A SPACE IN THE BUFFER, JMS PSPACE / AND ONCE MORE. JMP I P2SPACE /RETURN. / / / CARRIAGE RETURN - LINE FEED / / / ADD A CARRIAGE RETURN AND LINE FEED TO THE OUTPUT / STRING BUFFER AND OUTPUT IT. / / PRNTCR, 0 TAD (215) /GO PUT A CARRIAGE RETURN IN THE JMS I (PUTCHR / OUTPUT STRING BUFFER. TAD (212) /ADD A LINE FEED TO THE BUFFER, JMS I (PUTBUF / SEND IT TO THE OUTPUT DEVICE, JMP I PRNTCR / AND RETURN.
/ / / PRINT THE CURRENT ADDRESS IN THE CORRECT FORMAT / / PRTADR, 0 JMS PSPACE /FIRST OUTPUT A SPACE. TAD I (FORM /USE A RELOCATION REGISTER ? SZA CLA JMP PRTA1 /NO, USE STRAIGHT OCTAL. JMS I (LOCATE /GO FIND THE CLOSEST RELOCATION / REGISTER AND USE IT, OR JUST / OUTPUT THE CURRENT ADDRESS. JMP I PRTADR /ALL DONE, RETURN TO CALLER. PRTA1, CLB IAC /(PRINT 5 OR 6 OCTAL DIGITS) JMS PRNTWD /GO OUTPUT THE CURRENT ADDRESS CADDR / IN 5 (OR 6) DIGIT OCTAL. JMP I PRTADR /NOW WE'RE FINISHED, RETURN. PAGE
/ / / ($) (ALT MODE) INTERNAL REGISTER PROCESSOR / / / SYNTAX: / $X OPEN INTERNAL REGISTER "X" / $NX OPEN INTERNAL REGISTER "N" OF SET "X" / / INREGT, JMS I (GETNUM /TRY TO GET AN OCTAL ARGUMENT. TAD XINRE1 /RESET THE HIGH ORDER DATA WORD DCA REGADR+1 / (THE FIELD) TO HERE! JMS I (LOOKUP /GO LOOK FOR THE REQUESTED INTREG / INTERNAL REGISTER. INTTBL-INTREG JMP I (ERROR /NOT HERE, TELL THE USER. INRE1, DCA REGADR /SAVE ARGUMENT AS THE DATA BASE. JMS I (GETCHR /GET THE NEXT INPUT CHARACTER. TAD (-257) /IS IT A "/" ? SZA CLA JMP I (ERROR /NO, GO TELL THE USER HE GOOFED. JMS I (PUTCHR /PUT A "/" IN THE OUTPUT BUFFER. TAD I (LOOKA /GET THE ADDRESS OF THE MATCHING DCA INREA / REGISTER'S IDENTIFIER WORD, TAD I INREA / AND FROM THERE GET THE MAXIMUM AND (3400) / ALLOWABLE INDEX FOR THIS / REGISTER SET. IFNZRO OMNI < CLL RTR BSW /FOR OMNIBUS MACHINES. > IFZERO OMNI < CLL RTL RTL /FOR PRE-OMNIBUS MACHINES. RAL > DCA .+3 JMS I (ARGTST /WAS A VALID INDEX ENTERED ? INRE2, ARGFD 0000 /(WILL BE MAXIMUM VALID INDEX.) DCA INREB /SAVE THE INDEX, IF ANY. WE WILL / NOT RETURN FROM "ARGTST" IF AN / INVALID INDEX WAS ENTERED OR / OR IF ANY INDEX WAS ENTERED / FOR THE NON-INDEXED REGISTERS.
/ TAD I INREA /IS REGISTER DOUBLE PRECISION? SPA CLA TAD INREB /YES, DOUBLE THE INDEX, IF ANY. TAD INREB /ADD THE INDEX TO THE BASE TAD REGADR / ADDRESS OF THIS REGISTER SET. DCA REGADR AC4000 /GET THE BIT THAT DENOTES DOUBLE AND I INREA / PRECISION REGISTERS AND PUT IT DCA I (INTLDP / IN THE DOUBLE PRECISION / INTERNAL REGISTER FLAG FOR / "OPENWD". JMS I (MOVEDAT /MOVE THE DATA ADDRESS POINTER REGADR / INTO THE CURRENT ADDRESS CADDR / LOCATION. DCA I (ARGFD /CLEAR THE "ARGUMENT FOUND" FLAG. IFNZRO TASKNAME < JMS I (PRTACT /CHECK FOR THE ACTIVE TASK #. > JMP I (OPENWD /NOW, GO DIRECTLY TO "OPENWD", / DO NOT PASS GO, DO NOT... REGADR, 0; 0 /LOCAL TEMPORARIES. INREA, 0 INREB, 0 XINRE1, IFZERO ASMVER < ODTFLD%10 > /FOR PAL8. IFNZRO ASMVER < <EDF RTODT8>%10 > /FOR MACREL.
/ / / DISPLAY TASK STATE REGISTERS / / / SYNTAX: / TE LIST ALL STATE WORDS FOR THE ACTIVE TASK / YTE LIST ALL STATE WORDS FOR TASK "Y", "Y" / BECOMES THE ACTIVE TASK NUMBER. / / TX/ OPEN REGISTER "X" OF THE ACTIVE TASK / YTX/ OPEN REGISTER "X" OF TASK "Y", "Y" / BECOMES THE ACTIVE TASK NUMBER. / / TASKST, JMS I (ARGTST /WAS A TASK NUMBER ENTERED ? TSKS1, ARGFD NTASKS /(VALID ENTRY IS .LE. NTASKS.) SZL DCA I (ACTTSK /YES, UPDATE THE ACTIVE TASK / REGISTER. DCA I TSKS1 /CLEAR THE "ARGUMENT FOUND" FLAG. JMS I (GETCHR /GET THE NEXT INPUT CHARACTER, JMS I (LOOKUP / AND SEE WHAT REGISTER THE USER TSKREG / WANTS. TSKTBL-TSKREG JMP I (ERROR /CAN'T FIND IT, GO SAY SO. SZA /IS THE DESCRIPTOR WORD = 0 ? JMP TSKS2 /NO, LOOK ON. JMS I (PUTCHR /FIRST ECHO THE "E", THEN JMS I (PSPACE / ADD A SPACE. IFNZRO TASKNAME < IFNZRO MCRSTR < ISZ I (PRTSTR /SAY WE ALSO WANT THE TASK'S > / STARTING ADDRESS. > TAD I (ACTTSK /USER WANTS TO SEE ALL THE STATE JMS I (TSKLST / DATA FOR THE CURRENT TASK. JMP I (DECODE /GO GET THE NEXT COMMAND. TSKS2, DCA TSKSA /SAVE REGISTER DESCRIPTOR WORD. TAD (RTFLD) /FORCE THE HIGH ORDER DATA WORD DCA REGADR+1 / TO THE FIELD OF THE RTS/8 EXEC. TAD TSKSA /GET THE NUMBER OF THE REQUESTED AND (6000) / STATE TABLE. SZA /IS IT ZERO (TF) ? JMP TSKS3 /NO, GO ON.
/ TAD I (ACTTSK /FOR (TF), USE THE FLAG TABLE. TAD (TFTABL) JMP TSKS5 /GO USE SOME COMMON CODE. TSKS3, SPA CLA /IS THE TABLE CODE 1000 (TQ) ? JMP TSKS4 /NO, GO ON. TAD I (ACTTSK /FOR (TQ), USE THE MESSAGE TABLE. CLL RAL TAD (MSGTBL) JMP TSKS5 /GO USE SOME COMMON CODE. TSKS4, TAD TSKSA /MASK OFF THE REGISTER OFFSET, AND (0007) / AND SAVE IT FOR A MOMENT. DCA TSKSA TAD I (ACTTSK /FOR (TS) (TP) (TA) (TM) (TC), CLL RTL / USE THE TASK STATE TABLE. IFNZRO EAE < TAD I (ACTTSK /FOR EAE, USE TASK NUMBER X 5. > TAD (TSTABL) TAD TSKSA /ADD IN THE REGISTER OFFSET. TSKS5, JMP INRE1 /GO FINISH WITH SOME COMMON CODE. TSKSA, 0 /LOCAL TEMPORARY.
/ / / (D) LIST THE TASKS IN "DEBUG" WAIT AND THEIR STATE / / DBLIST, CLB IAC /SET THE AC TO SAY REINITIALIZE / THE SEARCH ON THE FIRST CALL. DBL1, JMS I (FINDDB /GO LOOK FOR TASK IN DEBUG WAIT. JMP I (DECODE /ALL DONE, GO SEE WHAT'S NEXT. DCA DBLIA /SAVE THE TASK NUMBER FOR A MO. JMS I (PRNTCR /GO OUTPUT A CR-LF. TAD DBLIA /GET THE TASK NUMBER BACK AND JMS I (TSKLST / GO OUTPUT THE STATUS DATA FOR / THIS TASK. JMP DBL1 /GO AROUND AGAIN. DBLIA, 0 /LOCAL TEMPORARY. PAGE
/ / / THE ODT/8 INTERNAL REGISTERS / / / THESE REGISTER DEFINITIONS ARE CONTIGUOUS AND IN THIS / ORDER ON PURPOSE! STRANGE AND WONDEROUS THINGS MAY / HAPPEN IF THIS ORDER IS CHANGED. / / INTBEG, /BEGINNING OF INTERNAL REGISTERS. IFNZRO ODTFUL < SARG, 0 /SEARCH ARGUMENT REGISTER. SMASK, 7777 /SEARCH MASK REGISTER. LOW, 0; 0 /LOW MEMORY LIMIT REGISTER. HIGH, 0; 0 /HIGH MEMORY LIMIT REGISTER. > CONST, 0; 0 /CONSTANT REGISTER. QUAN, 0; 0 /QUANTITY REGISTER. FORM, 0 /ADDRESS FORMAT REGISTER. ACTTSK, 0 /ACTIVE (CURRENT) TASK REGISTER. BKPXIT, 0 /BREAKPOINT SERVICE ROUTINE EXIT.
/ / / THE ODT/8 INTERNAL REGISTERS - CONTINUED / / BKADDR, ZBLOCK 20 /BREAKPOINT ADDRESS REGISTERS. RELT, -1;37; -1;37; /RELOCATION REGISTERS. -1;37; -1;37; -1;37; -1;37; -1;37; -1;37 BKPROC, -1;-1;-1;-1; /BKP PROCEED COUNT REGISTERS. -1;-1;-1;-1 BKUINT, ZBLOCK 10 /BKP INSTRUCTION REGISTERS. UTASKS, ZBLOCK 10 /USER TASK ASSIGNMENT REGISTERS. DEVCTR, ODTCDV /USER TERMINAL DEVICE TASK. ODTLDV /LIST DEVICE TASK. INTEND=.-1 /END OF INTERNAL REGISTERS.
/ / / TABLE OF THE ODT/8 INTERNAL REGISTERS / / / TABLE FORMAT: DII ICC CCC CCC / WHERE: / D IS 1 FOR DOUBLE PRECISION REGISTERS. / III IS THE MAXIMUM INDEX FOR INDEXED REGISTERS. / CCCCCCCC IS THE CHARACTER IDENTIFIER FOR THE REGISTER. / / INTREG, IFNZRO ODTFUL < "A / A SEARCH ARGUMENT REGISTER "M / M SEARCH MASK REGISTER "L+4000 / L LOW MEMORY LIMIT REGISTER "H+4000 / H HIGH MEMORY LIMIT REGISTER > "C+4000 / C CONSTANT REGISTER "Q+4000 / Q QUANTITY REGISTER "F / F ADDRESS FORMAT REGISTER "T / T ACTIVE TASK REGISTER "E / E BREAKPOINT SERVICE ROUTINE EXIT "B+7400 / B BREAKPOINT ADDRESS REGISTERS "R+7400 / R RELOCATION REGISTERS "G+3400 / G BKP PROCEED COUNT REGISTERS "I+3400 / I BREAKPOINT INSTRUCTION REGISTERS "U+3400 / U USER TASK BREAKPOINT ASSIGNMENTS "D+0400 / D DEVICE CONTROL REGISTERS 0 / END OF TABLE TERMINATOR
/ / / DISPATCH TABLE FOR "INTREG" / / THIS TABLE MUST BE IN THE SAME ORDER AS "INTREG". / / INTTBL, IFNZRO ODTFUL < SARG / A SEARCH ARGUMENT REGISTER SMASK / M SEARCH MASK REGISTER LOW / L LOW MEMORY LIMIT REGISTER HIGH / H HIGH MEMORY LIMIT REGISTER > CONST / C CONSTANT REGISTER QUAN / Q QUANTITY REGISTER FORM / F ADDRESS FORMAT REGISTER ACTTSK / T ACTIVE TASK REGISTER BKPXIT / E BREAKPOINT SERVICE ROUTINE EXIT BKADDR / B BREAKPOINT ADDRESS REGISTERS RELT / R RELOCATION REGISTERS BKPROC / G BKP PROCEED COUNT REGISTERS BKUINT / I BREAKPOINT INSTRUCTION REGISTERS UTASKS / U USER TASK BREAKPOINT ASSIGNMENTS DEVCTR / D DEVICE CONTROL REGISTERS DEVCTR+2 / TABLE TERMINATOR FOR "INTADR"
/ / / TABLE OF TASK STATE REGISTERS / / TSKREG, "E / E PRINT ALL THE STATE REGISTERS "F / F TASK FLAG WORD "Q / Q MESSAGE QUEUE HEADER "S / S TASK STATUS REGISTER "P / P TASK PROGRAM COUNTER "A / A TASK ACCUMULATOR "M / M TASK M/Q REGISTER IFNZRO EAE < "C / C EAE STEP COUNTER > 0 / END OF TABLE TERMINATOR / / / DISPATCH TABLE FOR "TSKREG" / / / THIS TABLE MUST BE IN THE SAME ORDER AS "TSKREG" !! / / / TABLE FORMAT: RRR 000 000 III / WHERE: / RRR IS THE REGISTER TYPE: / 0 = LIST ALL REGISTERS / 1 = TASK FLAG WORD / 2 = MESSAGE QUEUE / 3 = TASK STATE REGISTERS / 000000 IS ZERO AND A DON'T CARE. / III IS THE OFFSET FOR THE TASK STATE REGISTER. / / TSKTBL, 0000 / E PRINT ALL THE STATE REGISTERS 1000 / F TASK FLAG WORD 2000 / Q MESSAGE QUEUE HEADER 4000 / S TASK STATUS REGISTER 4001 / P TASK PROGRAM COUNTER 4002 / A TASK ACCUMULATOR 4003 / M TASK M/Q REGISTER IFNZRO EAE < 4004 / C EAE STEP COUNTER > PAGE
/ / / LOOK FOR THE ADDRESS OF AN INTERNAL REGISTER / / / COME HERE FROM "CCLNFD" AND CHECK IF AN INTERNAL / REGISTER IS TO BE OPENED. IF IT IS, PRINT A "$" / FOLLOWED BY THE REGISTER IDENTIFING CHARACTER, / THEN RETURN TO "OPENWD". / / INTADR, 0 TAD I (CADDR+1 /IS THE LOCATION TO OPEN IN OUR TAD XINTA1 / FIELD ? SZA CLA JMP I INTADR /NO, JUST RETURN. TAD I (CADDR /IS THE LOCATION TO OPEN WITHIN TAD XINTA2 / THE INTERNAL REGISTER TABLE ? SPA CLA JMP I INTADR /NO, JUST RETURN NOW. TAD I (CADDR /MAYBE, LOOK SOME MORE. TAD XINTA3 SMA SZA CLA JMP I INTADR /NO, JUST RETURN FROM HERE. TAD ("$) /OUTPUT A "$" TO DENOTE THIS IS JMS I (PUTCHR / AN INTERNAL REGISTER. INTA1, TAD (INTTBL-1) /SET UP A POINTER TO THE TABLE DCA INTAA / OF ADDRESSES FOR THE INTERNAL / REGISTERS. INTA3, ISZ INTAA /NOW TRY TO FIND A MATCH FOR THE TAD I INTAA / CURRENT ADDRESS (IN CADDR) IN CIA / THIS TABLE. THE TABLE IS IN TAD I (CADDR / ASCENDING ORDER. SNA JMP INTA4 /FOUND A MATCH, GO ON. SMA CLA /PASSED IT IF THE AC IS NEGATIVE. JMP INTA3 /OH WELL, TRY AGAIN. CLB CMA /BACK UP THE POINTER. WE NOW TAD INTAA / HAVE THE BASE ADDRESS FOR AN DCA INTAA / INDEXED REGISTER SET. INTA4, TAD INTAA /FORM AN ADDRESS TO THE REGISTER TAD (INTREG-INTTBL) / IDENTIFIER CHARACTER AND DCA INTAB / DESCRIPTION CODES AND SAVE IT.
/ TAD I INTAA /COMPUTE THE OFFSET (OR INDEX) CIA / FOR THIS REGISTER WITHIN THE TAD I (CADDR / REGISTER SET, AND SAVE IT. DCA INTAA TAD I INTAB /THIS REGISTER DOUBLE PRECISION? SMA CLA JMP INTA5 /NO, WE HAVE ALL WE NEED, GO ON. TAD INTAA /DIVIDE THE OFFSET BY 2 TO GET CLL RAR / THE CORRECT INDEX WITHIN THIS DCA INTAA / DOUBLE PRECISION REGISTER SET. SNL /NOW, WAS THERE A REMAINDER ? JMP INTA5 /NO, THEN WE'RE GETTING CLOSE! TAD I (INCHAR /HERE WE ARE 1 LOCATION OFF. TAD (-"^) / CADDR IS POINTING TO THE HIGH SNA CLA / ORDER WORD OF A D.P. REGISTER. AC7776 / NOW WE HAVE TO DECIDE TO ADD 1 IAC / OR SUBTRACT 1 FROM CADDR. SO TAD I (CADDR / WE LOOK AT THE LAST CHARACTER DCA I (CADDR / ENTERED, IF IT'S A "^", JMP INTA1 / SUBTRACT 1, OTHERWISE ADD 1. / THEN SEARCH A SECOND TIME, / WHICH WILL SUCCEED!! INTA5, TAD I INTAB /REGISTER DOUBLE PRECISION ? SPA ISZ I (INTLDP /SET THE DOUBLE PRECISION / INTERNAL REGISTER FLAG. AND (3400) /IS THIS REGISTER PART OF AN SNA CLA / INDEXED REGISTER SET ? JMP INTA6 /NO, GO ON. TAD INTAA /YES, FIRST OUTPUT THE INDEX. JMS I (PRNTN1 INTA6, TAD I INTAB /GET THE REGISTER IDENTIFING AND (0377) / CHARACTER AND OUTPUT IT. JMS I (PUTCHR JMS I (PSPACE /NOW OUTPUT A SPACE, AND THE "/" TAD ("/) / DELIMITER. JMS I (PUTBUF IFNZRO TASKNAME < JMS I (PRTACT /CHECK FOR THE ACTIVE TASK #. > JMP I (OPENWD /WITH THE REGISTER IDENTIFIED, / WE NOW GO OPEN IT. WASN'T THAT / EASY ? INTAA, 0 /LOCAL TEMPORARIES. INTAB, 0 XINTA1, IFZERO ASMVER < -ODTFLD%10+7000 > /FOR PAL8. IFNZRO ASMVER < -<EDF RTODT8>%10+7000 > /FOR MACREL. XINTA2, -INTBEG /FOR MACREL.... XINTA3, -INTEND /FOR MACREL....
/ / / (HU) HOOK OR UNHOOK THE ACTIVE TASK / / / SYNTAX: / H PUT THE ACTIVE TASK IN DEBUG WAIT. / NH PUT TASK NUMBER "N" IN DEBUG WAIT, "N" / BECOMES THE ACTIVE TASK. / / U UNHOOK THE ACTIVE TASK FROM DEBUG WAIT. / NU UNHOOK TASK NUMBER "N" FROM DEBUG WAIT, / "N" BECOMES THE ACTIVE TASK. / M;NU UNHOOK TASK NUMBER "N" FROM WAIT BITS / "M", "N" BECOMES THE ACTIVE TASK. / / HOOKDB, TAD (DEBWT) /PRESET THE BLOCKING BITS, OR UNHOOK, DCA RELBLK / CLEAR THE BLOCKING BITS FOR / "RELEASE". JMS I (ARGTST /WAS A TASK NUMBER ENTERED ? ARGFD NTASKS /(VALID ENTRY IS .LE. NTASKS.) SZL DCA I (ACTTSK /YES, UPDATE THE ACTIVE TASK / REGISTER. TAD I (ACTTSK /DO WE HAVE AN ACTIVE TASK ? SNA CLA JMP HOOK2 /NO, BUT WE MUST HAVE ONE ! TAD RELBLK /ARE WE HOOKING THIS TASK ? SZA CLA JMP HOOK1 /YES, ALL SET, GO ON. JMS I (ARGTST /GO CHECK IF THE USER ENTERED ARG2FD / THE WAIT BITS TO CLEAR. 7777 /(VALID ENTRY IS .LE. 7777). SNL /SKIP IF USER ENTRY. TAD (DEBWT) /USER DIDN'T, USE DEBUG WAIT BIT. CMA DCA RELMSK /SET UP UNBLOCKING BITS FOR / "RELEASE". HOOK1, TAD I (ACTTSK /GET THE ACTIVE TASK NUMBER AND JMS RELEASE / GO RELEASE IT. JMP I (DECODE /THEN GO GET ANOTHER COMMAND. HOOK2, DCA RELBLK /RESET THE BLOCKING BITS FOR / "RELEASE". JMP I (ERROR /NOW GO LOG THE ERROR.
/ PAGE
/ / / (BR) PROCESS RELOCATION AND BREAKPOINT REGISTERS / / / SYNTAX: / B CLEAR ALL BREAKPOINTS / NB CLEAR BREAKPOINT "N" / A;B PUT "A" IN THE NEXT AVAILABLE SLOT / A;NB PUT "A" IN BREAKPOINT SLOT "N" / T;A;NB USE "T" AS THE ACTIVE TASK NUMBER, PUT / "A" IN BREAKPOINT SLOT "N". / / R CLEAR ALL RELOCATION REGISTERS / NR CLEAR RELOCATION REGISTER "N" / A;R PUT "A" IN THE NEXT AVAILABLE REGISTER / A;NR PUT "A" IN REGISTER "N" / / BREAKP, ISZ RELOD /ENTRY TO SET/RESET BREAKPOINTS. TAD (BKADDR-RELT) SKP RELOCT, DCA RELOD /ENTRY FOR RELOCATION REGISTERS. TAD (RELT) DCA RELOA /SAVE THE TABLE BASE ADDRESS. TAD I (ARG2FD /WAS THE "A" ARGUMENT ENTERED ? SZA CLA JMP RELO5 /YES, GO LOAD A REGISTER. / / / CLEAR A REGISTER, OR MAYBE ALL OF THEM / / JMS I (ARGTST /DID THE USER SPECIFY THE ARGFD / REGISTER TO CLEAR ? 0007 /(VALID ENTRY IS .LE. 7.) SNL JMP RELO1 /NO, GO DO FOR ALL. CLL RAL /YES, COMPUTE THE ADDRESS OF THE TAD RELOA / REGISTER TO CLEAR. DCA RELOA AC7777 /SET UP TO CLEAR 2 WORDS. SKP RELO1, TAD (-10) /CLEAR ALL 20 WORDS OF THE TABLE. DCA RELOB RELO2, TAD RELOD /ARE WE DOING A BKP REGISTER? SNA CLA JMP RELO3 /NO, GO ON.
/ JMS RELO4 /GO CLEAN UP THE BKP RELATED / DATA AND REGISTERS. SKP CLA /SKIP TO KEEP ACCUMULATOR ZERO / FOR BREAKPOINT REGISTERS. RELO3, CLB CMA /SET THE ACCUMULATOR TO -1 TO / RESET THE RELOCATION REGISTERS. DCA I RELOA /NOW RESET THE FIRST WORD OF THE TAD I RELOA / REGISTER PAIR, GET THE DATA ISZ RELOA / BACK (FOR RELOCATION REGISTERS, AND (0037) / THE SECOND WORD WANTS TO BE DCA I RELOA / 37) AND RESET THE SECOND WORD. ISZ RELOA ISZ RELOB /RESET ENOUGH WORDS ? JMP RELO2 /NO, DO ANOTHER PAIR. JMP I (DECODE /ALL DONE, GO FOR THE NEXT / COMMAND. / / / CLEAN UP THE BREAKPOINT ASSOCIATED DATA / / RELO4, 0 TAD RELOA /COMPUTE THE INDEX FOR THIS TAD XRELO1 / BREAKPOINT REGISTER. CLL RAR DCA RELOE /SAVE THE INDEX. TAD RELOE /GET THE INDEX AND GO REMOVE JMS I (REMABK / THIS BREAKPOINT IF IT'S STILL / IN PLACE. TAD RELOE /USE THE BKP INDEX TO COMPUTE TAD (BKPROC) / THE CORRESPONDING ADDRESS IN DCA RELOD / THE BREAKPOINT PROCEED TABLE, AC7777 / AND SET IT TO -1. DCA I RELOD TAD RELOE /NOW USE THE BREAKPOINT INDEX TO TAD (UTASKS) / COMPUTE THE CORRESPONDING DCA RELOD / ADDRESS IN THE USER TASK / ASSIGNMENT TABLE. DCA I RELOD /CLEAR THE USER TASK ASSIGNMENT. JMP I RELO4 /ALL CLEANED UP, RETURN.
/ / / SET/RESET A REGISTER / / RELO5, JMS I (ARGTST /DID THE USER SPECIFY THE ARGFD / REGISTER TO USE ? 0007 /(VALID ENTRY IS .LE. 7.) SZL JMP RELO9 /YES, USE THE USER'S CHOICE. TAD (-10) /FIND AN UNUSED ONE. DCA RELOB RELO6, TAD RELOD /ARE WE DOING A BKP REGISTER? SNA CLA JMP RELO7 /NO, GO DO A RELOCATION REGISTER. TAD I RELOA /IS THIS BKP REGISTER FREE ? ISZ RELOA /(A FREE REGISTER = 0000 0000.) SNA TAD I RELOA /(CHECK BOTH WORDS.) SNA CLA JMP RELO10 /YES, GO USE IT. JMP RELO8 /NO, GO ON. RELO7, TAD I RELOA /THIS RELOCATION REGISTER FREE ? ISZ RELOA /(A FREE REGISTER = 0037 7777.) IAC SZA CLA JMP RELO8 /NO, GO ON. TAD I RELOA /HOW ABOUT THE MOST SIGNIFICANT TAD (-37) / WORD ? SNA CLA JMP RELO10 /YES, GO USE IT. RELO8, ISZ RELOA /NO, INCREMENT THE POINTER. ISZ RELOB /TABLE EXHAUSTED ? JMP RELO6 /NO, LOOK AGAIN. JMP I (ERROR /NO MORE TABLE, SAY ERROR.
/ RELO9, CLL RAL /COMPUTE THE OFFSET FOR THE SKP / REQUESTED REGISTER. RELO10, AC7777 /BACK UP THE POINTER. TAD RELOA DCA RELOA TAD RELOD /ARE WE DOING A BKP REGISTER? SNA CLA JMP RELO11 /NO, GO FINISH A RELOCATION / REGISTER. JMS I (ARGTST /WAS A TASK NUMBER ENTERED ? ARG3FD NTASKS /(VALID ENTRY IS .LE. NTASKS.) SZL DCA I (ACTTSK /YES, UPDATE THE ACTIVE TASK / REGISTER. JMS RELO4 /GO CLEAN UP THE BKP RELATED / DATA AND REGISTERS. TAD I (ACTTSK /IS AN ACTIVE TASK DEFINED ? SNA JMP I (ERROR /NO, BUT WE NEED ONE, SAY SO. DCA I RELOD /YES, PUT IT IN THE USER TASK / ASSIGNMENT TABLE. AC4000 /MARK THE NEW BKP ADDRESS TO TAD I (ARG2+1 / SAY IT IS A NEW AND AS YET DCA I (ARG2+1 / UNUSED BKP. RELO11, JMS I (MOVEDAT /NOW LOAD THE REGISTER. ARG2 RELOA, 0000 JMP I (DECODE /NO, ALL DONE, ON TO THE NEXT.. RELOB, 0 /LOCAL TEMPORARIES. RELOD, 0 /BREAKPOINT OR RELOCATION FLAG. RELOE, 0 XRELO1, -BKADDR /FOR MACREL.....
/ PAGE
/ / / PRINT THE CURRENT ADDRESS USING THE RELOCATION / REGISTERS / / / COME HERE TO FIND THE RELOCATION REGISTER WHICH IS / NEAREST TO, BUT STILL LESS THAN, THE CURRENT ADDRESS. / IF WE FIND ONE, OUTPUT THE REGISTER NUMBER FOLLOWED / BY THE OFFSET TO THE CURRENT ADDRESS. IF NO USEABLE / RELOCATION REGISTER IS FOUND, JUST OUTPUT THE CURRENT / ADDRESS AS AN ABSOLUTE ADDRESS. / / LOCATE, 0 DCA LOCE /IF NOT ZERO, THE AC SPECIFIES / THE RELOCATION REGISTER TO USE. TAD LOCE /COMPUTE THE ADDRESS OF THE CLL RAL / FIRST RELOCATION REGISTER TO TAD (RELT) / LOOK AT. DCA LOC2 / AND PUT IT WHERE WE NEED IT. CLB CMA /PRESET "LOCA" TO THE MAXIMUM DCA LOCA / POSSIBLE DISTANCE. TAD (37) DCA LOCA+1 TAD LOCE /ADD IN THE CALLER'S INDEX WHEN TAD (-10) / WE SET UP A LOOP COUNTER. DCA LOCC DCA LOCD /CLEAR THE FOUND REGISTER NUMBER. TAD I (CADDR+1 /MASK OFF THE HIGH ORDER BITS AND (0037) / OF THE FIELD WORD, WE COULD DCA I (CADDR+1 / BE DOING A BKP REGISTER. LOC1, CLB IAC /(FORCE "EXPCOM" TO SUBTRACT.) JMS I (EXPCOM LOC2, 0 /COMPARE THE RELOCATION REGISTER CADDR / TO THE CURRENT ADDRESS. LOCB /(THE RESULT GOES HERE.) TAD LOCB+1 /IF THIS REGISTER .GT. THE SPA CLA / CURRENT ADDRESS, THE RESULT IS JMP LOC3 / NEGATIVE, TRY ANOTHER REGISTER. CLB IAC /(FORCE "EXPCOM" TO SUBTRACT.) JMS I (EXPCOM LOCA /COMPARE THE NEW OFFSET WITH THE LOCB / CURRENT SMALLEST OFFSET. ARG TAD I (ARG+1 /IF THIS RESULT IS NEGATIVE, THE SMA CLA / NEW OFFSET IS CLOSER THAN WHAT JMP LOC3 /WE HAD. NOPE, TRY ANOTHER
/ TAD LOCB /UPDATE SMALLEST OFFSET STORAGE DCA LOCA / WITH THE NEW FOUND VALUE. TAD LOCB+1 DCA LOCA+1 TAD LOCC /SAVE NUMBER OF THIS RELOCATION DCA LOCD / REGISTER. LOC3, TAD LOCE /DID THE CALLER SPECIFY WHICH SZA CLA / RELOCATION REGISTER TO USE ? JMP LOC4 /YES, GO USE WHAT WE HAVE. ISZ LOC2 /NO, INCREMENT THE REGISTER ISZ LOC2 / POINTER TWICE. ISZ LOCC /ANY MORE REGISTERS TO LOOK AT ? JMP LOC1 /YES, LOOK AGAIN. LOC4, TAD LOCD /DID WE FIND A USEABLE RELOC- SZA / ATION REGISTER ? JMP LOC5 /YES, GO OUTPUT AS RELOCATED. TAD BKPLST /NO, ARE WE PRINTING THE BKP SZA CLA / REGISTER TABLE (ASLIST) ? JMS I (P2SPACE /YES, ADD 2 SPACES TO KEEP THE DCA BKPLST / TABLE COLUMNS ALIGNED. CLB IAC /(PRINT 5 OR 6 OCTAL DIGITS) JMS I (PRNTWD /NOW OUTPUT THE CURRENT ADDRESS CADDR / AS A 5 DIGIT ABSOLUTE NUMBER. JMP I LOCATE /ALL DONE, BACK TO OUR CALLER. LOC5, TAD (270) /REFORM THE RELOCATION REGISTER JMS I (PUTCHR / NUMBER AND OUTPUT IT, TAD (254) / FOLLOWED BY A COMMA. JMS I (PUTCHR CLB IAC /(PRINT 5 OR 6 OCTAL DIGITS) JMS I (PRNTWD /NOW OUTPUT THE DISTANCE BETWEEN LOCA / THE RELOCATION REGISTER AND / THE CURRENT ADDRESS. JMP I LOCATE / AND RETURN FROM WHENCE WE CAME. LOCA, 0; 0 /CURRENT SMALLEST ADDRESS OFFSET. LOCB, 0; 0 /TRIAL OFFSET GOES HERE. LOCC, 0 /LOOP COUNTER. LOCD, 0 /NUMBER OF THE CLOSEST REGISTER. LOCE, 0 /REGISTER THE CALLER ASKED FOR, / IF HE SPECIFIED ONE. BKPLST, 0 /FLAG SET BY "ASLIST" TO SAY WE / ARE PRINTING THE BKP TABLE. / OUTPUT 7 CHARACTERS IN EITHER / FORMAT TO KEEP THE OUTPUT / PRETTY.
/ / / CHECK THAT A USER'S ARGUMENT IS IN THE ALLOWABLE RANGE / / / ON RETURN: IF A VALID ARGUMENT WAS FOUND, THE LINK / IS SET AND THE ARGUMENT IS IN THE AC. / IF NO ARGUMENT WAS FOUND, THE LINK AND / THE ACCUMULATOR ARE CLEAR. / IF AN INVALID ARGUMENT WAS FOUND, WE / EXIT THROUGH "ERROR". / / CALLING SEQUENCE: / / JMS ARGTST / ARGFLAG THE ARGUMENT FLAG TO TEST. / LIMIT THE MAXIMUM LEGAL VALUE FOR THE / ARGUMENT. / / ARGTST, 0 CLB TAD I ARGTST /GET THE ADDRESS OF THE ARGUMENT ISZ ARGTST / FLAG TO TEST. DCA ARGTA TAD I ARGTA /WAS AN ARGUMENT ENTERED ? ISZ ARGTA SNA CLA JMP ARGT1 /NONE THERE, JUST EXIT. TAD I ARGTST /GET THE CALLERS ARGUMENT LIMIT. SNA JMP I (ERROR /A ZERO LIMIT SAYS NO ARGUMENT / IS ALLOWED. CLL CMA TAD I ARGTA /IS THE ARGUMENT WITHIN THE SZL CLA / ALLOWABLE LIMITS ? JMP I (ERROR /NO, GO TELL THE USER HE GOOFED. CLB IAC /NOW FORM A POINTER TO THE HIGH TAD ARGTA / ORDER WORD OF THIS ARGUMENT. DCA ARGTB TAD I ARGTB /IS THE HIGH ORDER WORD ZERO ? SZA CLA JMP I (ERROR /NO, NOW THAT'S NOT NICE. TAD I ARGTA /YES, PUT THE ARGUMENT IN THE AC, STL /SET THE LINK TO SAY WE HAVE / DATA. ARGT1, ISZ ARGTST /INCREMENT THE RETURN ADDRESS, JMP I ARGTST / AND RETURN FROM WHENCE.... ARGTA, 0 /LOCAL TEMPORARIES. ARGTB, 0
/ PAGE
/ / / 21-SEP-83 7:40 / / (G) SET BREAKPOINTS AND GO TO THE USERS'S TASKS / / (P) PROCEED FROM A BREAKPOINT / / / SYNTAX: / G SET BREAKPOINTS AND RELEASE THE TASKS / FROM DEBUG WAIT. / MG SET BREAKPOINTS AND RELEASE THE TASKS / FROM WAIT STATE "M". / / / P PROCEED FROM EXPIRED BREAKPOINTS ONCE. / MP PROCEED FROM EXPIRED BREAKPOINTS "M" / TIMES. / N;MP PROCEED FROM EXPIRED BREAKPOINT "N", / "M" TIMES. / / GOTOIT, AC4000 /ENTRY FOR SET AND GO. PROCED, TAD (2000) /ENTRY FOR PROCEED. DCA PROCB /SAVE COMMAND CODE MASK. / / / SCAN THE BKP TABLE TO SEE IF THERE ARE ANY / BREAK POINTS TO SERVICE. / / TAD (-10) /SET UP A LOOP COUNTER. DCA PROCC TAD (BKADDR+1) /SET UP A POINTER FOR THE HIGH DCA PROCD / ORDER WORD IN THE BKP TABLE. PROC1, TAD I PROCD /GET BKP WORD AND LOOK FOR NEW AND PROCB / OR COMPLETED MARKS. SZA CLA JMP PROC2 /FOUND ONE, GO ON. ISZ PROCD /THIS BKP NOT MARKED, MOVE THE ISZ PROCD / POINTER TO THE NEXT. ISZ PROCC /LOOKED AT ALL THE TABLE ? JMP PROC1 /NO, DO ANOTHER. JMP I (ERROR /YES, NOTHING TO DO, SAY SO. PROC2, DCA PROCD /CLEAR THE BREAKPOINT INDEX. DCA I (SISTEP /CLEAR THE SINGLE STEP FLAG. TAD PROCB /WAS THE "C" COMMAND ENTERED ? SMA CLA JMP PROC3 /NO, GO ON.
/ / / PROCESS ARGUMENTS FOR THE G COMMAND / / TAD I (ARG /GET THE BLOCKING BITS THE USER DCA PROCF / SAID TO REMOVE, IF ANY. DCA PROCC /CLEAR THE PROCEED COUNT DATA. JMP PROC4 / / / PROCESS ARGUMENTS FOR THE P COMMAND / / PROC3, TAD I (ARG /GET THE PROCEED COUNT THE USER DCA PROCC / ENTERED, IF ANY. DCA PROCF /CLEAR UNBLOCKING BIT DATA. JMS I (ARGTST /DID THE USER SPECIFY THE BKP ARG2FD / REGISTER FOR US TO USE ? 0007 /(VALID ENTRY IS .LE. 7.) SNL JMP PROC4 /NO, GO DO THEM ALL. DCA PROCD /YES, SAVE THE BPT NUMBER. AC7777 /FORCE THE LOOP COUNTER TO 1. SKP PROC4, TAD (-10) /SET UP A LOOP COUNTER. DCA PROCE JMS I (PRNTCR /PRINT A CR-LF NOW TO AVOID A / POSSIBLE RACE CONDITION AS WE / RELEASE THE TASK(S) TO RUN. TAD PROCF /DID THE USER ENTER BLOCKING SNA / BITS TO USE (FOR "G") ? TAD (DEBUG) /NO, JUST USE DEBUG WAIT. CMA DCA PROCF /SAVE FOR "RELEASE". TAD PROCC /DID THE USER ENTER A PROCEED SNA / COUNT TO USE (FOR "P"). AC0001 /NO, THEN USE 1. CIA DCA PROCC /SAVE FOR LATER. CDF RTCDF /NOW, CLEAR THE TASK SWITCHING DCA I (TSWFLG / ENABLED FLAG IN THE RTS/8 CDF ODTFLD / EXECUTIVE. THIS HOLDS OFF / THE TASKS WE RELEASE UNTIL WE / HAVE FINISHED HERE AND EXITED.
/ PROC5, TAD PROCD /USE THE TABLE INDEX TO COMPUTE CLL RAL / THE LOCATION OF THE HIGH TAD (BKADDR+1) / ORDER WORD OF THE BKP PAIR. DCA PROCA TAD I PROCA /IS THE BKP MARKED AS NEW OR AND PROCB / COMPLETE ? SNA CLA JMP PROC7 /NO, GO ON. TAD I PROCA /REMOVE THE MARKS FROM THE BKP. AND (0037) DCA I PROCA TAD PROCD /USE THE TABLE INDEX TO COMPUTE TAD (BKPROC) / LOCATION OF THE PROCEED CTR DCA PROCA / TO UPDATE. TAD PROCC /NOW PUT THE NEW VALUE IN THE DCA I PROCA / PROCEED COUNTER TABLE. TAD PROCB /WAS THE "G" COMMAND ENTERED ? SMA CLA JMP PROC6 /NO, GO ON. TAD PROCD /YES, GET THE TABLE INDEX AND JMS I (SETABK / GO SET THE BKP IN THE / USER'S TASK. PROC6, TAD PROCF /GET THE BLOCKING BITS TO REMOVE DCA I (RELMSK / AND LEAVE THEM FOR "RELEASE". TAD PROCD /USE THE TABLE INDEX TO COMPUTE TAD (UTASKS) / THE LOCATION OF THE TASK # DCA PROCA / WHICH IS ASSIGNED TO THE BKP. TAD I PROCA /GET THE TASK NUMBER AND GO JMS I (RELEASE / RELEASE THE TASK FROM DEBWT. PROC7, ISZ PROCD /INCREMENT THE TABLE INDEX. ISZ PROCE /ARE WE DONE ? JMP PROC5 /NO, GO AROUND AGAIN. JMP I (GOXIT /ALL DONE, GO SUSPEND ODT. PROCA, 0 /LOCAL TEMPORARY. PROCB, 0 /FLAG FOR WHICH COMMAND TO DO, = / 4000 FOR GO, 2000 FOR PROCEED. PROCC, 0 /PROCEED COUNT TO USE. PROCD, 0 /TABLE INDEX. PROCE, 0 /LOCAL TEMPORARY. PROCF, 0 /BLOCKING BITS TO CLEAR.
/ PAGE
/ / / (S) EXECUTE A SINGLE INSTRUCTION IN A TASK / / / SYNTAX: / S EXECUTE ONE INSTRUCTION FOR THE ACTIVE / TASK / MS EXECUTE "M" INSTRUCTIONS FOR THE ACTIVE / TASK / N,MS EXECUTE "M" INSTRUCTIONS FOR TASK "N", / "N" BECOMES THE ACTIVE TASK. / / SINGLE, CLB IAC /SET THE SINGLE STEP FLAG. DCA I (SISTEP JMS I (ARGTST /GO SEE IF THE USER ENTERED A ARG2FD / TASK NUMBER FOR US TO USE. -NTASKS /(VALID ENTRY IS .LE. NTASKS). SZL DCA I (ACTTSK /(S)HE DID, UPDATE THE ACTIVE / TASK REGISTER. TAD I (ACTTSK /IS THERE AN ACTIVE TASK ? SNA JMP I (ERROR /NO, BUT WE NEED ONE. TAD (TFTABL) /COMPUTE THE LOCATION OF THE DCA SINGB / FLAG WORD FOR THIS TASK. CDF RTCDF /NOW CHECK THAT THE TASK IS TAD I SINGB / IN DEBUG WAIT O N L Y. CDF ODTFLD TAD (-DEBWT) SZA CLA JMP I (ERROR /NO, TELL THE USER TO TRY AGAIN. JMS I (ARGTST /GO SEE IF THE USER SPECIFIED ARGFD / THE NUMBER OF INSTRUCTIONS TO / SIMULATE. 7777 /(VALID ENTRY IS .LE. 7777). SNL AC0001 /NO, THEN DO 1 INSTRUCTION. CIA DCA SINGB /SAVE THE LOOP COUNTER. TAD I (ACTTSK /GET THE ACTIVE TASK NUMBER FOR DCA SINGA / THE SIMULATOR. SING1, JMS I (SIMLAT /GO SIMULATE THE NEXT SINGA, 0000 / INSTRUCTION FOR THIS TASK. ISZ SINGB /DONE ENOUGH ? JMP SING1 /NO, DO ANOTHER.
/ TAD I (ACTTSK /MOVE THE ACTIVE TASK NUMBER. DCA SINGD TAD SINGE+1 /GET THE FIELD OF THE INSTRUCTION / AND SET IT UP FOR PRINTING. IFZERO KT8A < /[N2] AND (0070) CLL RTR RAR > IFNZRO KT8A < /[N2] RACC BSW CLL RTL RTL SZL TAD (10) > DCA SINGE+1 JMS I (LOGBKP /GO TO THE BKP LOGGER AND TELL 0 / USER WHERE WE ARE. SINGE+1 SINGD, 0000 JMP I (DECODE /ON TO THE NEXT COMMAND. SINGB, 0 /LOCAL TEMPORARY. SINGE, 0; 0 /ADDRESS OF THE LAST / INSTRUCTION PROCESSED.
/ / / SET A SPECIFIED BREAKPOINT / / ON CALL: THE AC CONTAINS THE INDEX OF THE / BREAKPOINT TO DO. / / SETABK, 0 JMS SETUBK /GO USE SOME COMMON CODE, ON / RETURN, THE AC IS ZERO IF A / BKP IS ALREADY IN PLACE. SNA CLA JMP I SETABK /IT IS, DON'T SET IT AGAIN !! / JUST RETURN NOW. TAD (CALODT) /PRESET "ARG" WITH THE BKP HOOK DCA I (ARG / SO "PUTCAD" CAN FIND IT. TAD I (CDATA /GET THE USER'S INSTRUCTION, AND DCA I SETUA / SAVE IT IN THE BKP INSTRUCTION / TABLE. ISZ I (ARGFD /SET THE "ARGUMENT FOUND" AND ISZ I (OPN / "LOCATION OPEN" FLAGS, AND JMS I (PUTCAD / THEN LET "PUTCAD" DO IT'S / THING. JMP I SETABK /ALL DONE, RETURN. / / / REMOVE A SPECIFIED BREAKPOINT / / / ON CALL: THE AC CONTAINS THE INDEX OF THE / BREAKPOINT TO DO. / / REMABK, 0 JMS SETUBK /GO USE SOME COMMON CODE, ON / RETURN, TH AC IS ZERO IF A / BKP ACTUALLY WAS IN PLACE. SZA CLA JMP I REMABK /IT WASN'T, WE CAN'T REMOVE IT / IF WE DID NOT SET IT !! TAD I SETUA /NOW GET THE INSTRUCTION AND PUT DCA I (ARG / IT WHERE "PUTCAD" CAN FIND IT. ISZ I (ARGFD /SET THE "ARGUMENT FOUND" AND ISZ I (OPN / "LOCATION OPEN" FLAGS, SO THAT JMS I (PUTCAD / "PUTCAD" CAN DO IT'S THING. JMP I REMABK /'TIS DONE, RETURN TO OUR CALLER.
/ SETUBK, 0 DCA SETUA /SAVE THE BREAKPOINT INDEX. TAD SETUA /COMPUTE THE ADDRESS OF THE BKP CLL RAL / IN THE BREAKPOINT TABLE, AND TAD (BKADDR) / SAVE IT FOR "MOVEDAT" TO USE. DCA SETU1 TAD SETUA /USE THE CALLER'S INDEX AGAIN TAD (BKUINT) / TO SET UP A POINTER TO THE DCA SETUA / INSTRUCTION WE WANT TO PUT / BACK IN THE USER'S TASK. JMS I (MOVEDAT /MOVE THE BREAKPOINT ADDRESS TO SETU1, 0000 / "CADDR". CADDR JMS I (GETCAD /GET THE INSTRUCTION AT THE BKP, TAD I (CDATA / AND CHECK THAT IT IS THE TAD (-CALODT) / BREAKPOINT INSTRUCTION ! JMP I SETUBK /RETURN. SETUA, 0 /LOCAL TEMPORARY. PAGE
/ / / BREAKPOINT SERVICE ROUTINE / / BKPSER, 0 DCA BKPDON /CLEAR BKP COMPLETE COUNTER. CLB IAC /(SAYS: RESET BEFORE SEARCH). BKPS1, JMS I (FINDDB /FIND NEXT TASK IN DEBUG WAIT. JMP BKPS7 /ALL DONE, SEE HOW WE EXIT. DCA BKPS5 TAD BKPS5 /SET UP A POINTER TO THE PROGRAM CLL RTL / COUNTER WORD FOR THIS TASK. TAD (TSTABL+1) DCA BKPSA CLB CMA /NOW A POINTER TO THE STATUS TAD BKPSA / WORD FOR THE TASK. DCA BKPSB TAD (BKADDR) /AND A POINTER TO THE BREAKPOINT DCA BKPSC / TABLE. TAD (-10) /LASTLY, SET UP A LOOP COUNTER. DCA BKPSD BKPS2, TAD I BKPSC /TEST IF THE TASK'S PROGRAM ISZ BKPSC / COUNTER MATCHES THIS BKP CMA / ADDRESS. CDF RTCDF TAD I BKPSA SZA CLA JMP BKPS3 /NO, TRY ANOTHER BREAKPOINT. TAD I BKPSB /THE PROGRAM COUNTER MATCHES, / DOES THE MEMORY FIELD MATCH ? IFZERO KT8A < CLL RTR STL RAR AND (0007) > IFNZRO KT8A < RACC BSW CLL RTL RTL SZL TAD (10) > CIA CDF ODTFLD TAD I BKPSC SNA CLA JMP BKPS4 /WE FOUND THE BPT FOR THIS TASK, / GO CHECK THE PROCEED COUNTER.
/ BKPS3, CDF ODTFLD ISZ BKPSC /MOVE THE BKP POINTER ALONG. ISZ BKPSD /LOOKED AT ALL 8 BREAKPOINTS ? JMP BKPS2 /NO, TRY THE NEXT BREAKPOINT. JMP BKPS1 /BREAKPOINT TABLE EXHAUSTED, TRY / THE NEXT TASK IN DEBUG WAIT. / THIS IS ACTUALLY AN ERROR, AND / SHOULD NOT HAPPEN, BUT .... BKPS4, CDF ODTFLD TAD BKPSD /COMPUTE THE ADDRESS OF THE TAD (10) / PROCEED COUNTER FOR THIS BKP. TAD (BKPROC) DCA BKPSB TAD BKPSD /COMPUTE THE INDEX FOR THIS TAD (10) / BKP, AND GO SIMULATE THE USER JMS I (SIMLAT / TASKS INSTRUCTION. BKPS5, 0000 /(THE CURRENT TASK NUMBER.) ISZ I BKPSB /INCREMENT THE PROCEED COUNTER. SKP JMP BKPS6 / TAD BKPS5 /NOW RELEASE THIS TASK FROM JMS I (RELEASE / DEBUG WAIT, AND LET IT RUN. JMP BKPS1
/ / / FINISH THE COMPLETED BREAKPOINT PROCESSING / / BKPS6, TAD (2000) /MARK THIS BKP AS COMPLETED ! TAD I BKPSC DCA I BKPSC ISZ BKPDON /BUMP THE BKP COMPLETE COUNTER. TAD I (ODTRUN /ARE WE TALKING TO THE USER ? SZA CLA JMP BKPS1 /YES, DON'T LOG THIS BKP. TAD BKPS5 DCA BKPSX JMS LOGBKP BKPSD, 0000 BKPSC, 0000 BKPSX, 0000 JMP BKPS1 BKPS7, TAD BKPDON /DID ANY BKP'S COMPLETE ? SNA CLA JMP I BKPSER /NO, JUST RETURN AND WAIT. TAD I (BKPXIT /YES, ARE WE SUPPOSED TO WAKE SNA CLA / UP ODT ? JMP I (DECODE /YES, ON TO THE NEXT COMMAND. JMP I BKPSER /NO, JUST RETURN. BKPDON, 0 /BREAKPOINTS COMPLETE COUNTER. BKPSA, 0 /LOCAL TEMPORARIES. BKPSB, 0
/ / / / / LOGBKP, 0 JMS I (LGNAME /START THE LINE WITH OUR NAME. JMS I (PSPACE /AND A SPACE. TAD I LOGBKP /COMPUTE THE BREAKPOINT INDEX, ISZ LOGBKP TAD (30) / AND OUTPUT IT. JMS I (PSPACE TAD ("B) /ADD A "B" TO SAY BREAKPOINT. JMS I (PUTBUF JMS I (PSPACE /AND ANOTHER SPACE. AC7777 TAD I LOGBKP ISZ LOGBKP DCA BKPSY JMS I (MOVEDAT / BKPSY, 0000 CADDR JMS I (PRTADR TAD I LOGBKP /NO, NOW GO OUTPUT THE ACTIVE ISZ LOGBKP JMS I (TSKLST / REGISTER DATA FOR THIS TASK. JMP I LOGBKP /RETURN. PAGE
/ / / SIMULATE AN INSTRUCTION FOR A BREAKPOINTED TASK / / / ON CALL: THE AC CONTAINS THE INDEX OF THE / BREAKPOINT DATA TO WORK ON. THE TASK / NUMBER IS IN THE LOCATION FOLLOWING / THE CALL. / / CALLING SEQUENCE: / / JMS SIMLAT / TASK NUMBER TO USE. / / SIMLAT, 0 DCA SIMINX /SAVE THE BKP INDEX TO USE. TAD I SIMLAT /GET THE TASK NUMBER FOR US TO ISZ SIMLAT / USE AND SAVE IT. DCA SIMTSK / / / / CONCEPTS OF "SIMLAT" / / / ON CALL: INDEX TO USE INTO THE BKP TABLE IS IN / THE AC, THE TASK NUMBER IS IN THE / LOCATION FOLLOWING THE CALL. THE TASK / TO DO IS BLOCKED IN DEBWT / / / SIMLAT: / 1) SAVE INDEX AND GET TASK # / 2) GET TASK REGISTERS / 3) GET INSTRUCTIONS AT TASK'S PC AND FIELD / 4) DO IT / 5) SAVE TASK REGISTERS / 6) RETURN /
/ / / GET A TASKS STATE DATA FROM THE EXECUTIVES TABLES / / TAD SIMTSK /GET THE NUMBER OF THE TASK OF CLL RTL / INTEREST AND COMPUTE THE IFNZRO EAE < / LOCATION OF THE TASKS DATA IN TAD SIMTSK / THE EXECUTIVES TASK STATE > / TABLE. TAD (TSTABL) DCA SIMLA CDF RTCDF /SET THE DATA FIELD TO THE EXEC. TAD I SIMLA /GET THE TASKS STATUS WORD AND ISZ SIMLA / STORE IT LOCALLY. DCA SIMSAT TAD SISTEP /ARE WE SINGLE STEPPING ? SNA CLA / CMA /GET THE TASK'S PC, SUBTRACT 1 TAD I SIMLA / (SINCE RTS/8 ADDED 1 WHEN IT ISZ SIMLA / PUT THE TASK IN DEBUG WAIT), DCA SIMPC / AND SAVE IT LOCALLY. TAD I SIMLA /NOW THE TASKS AC, DCA SIMAC IFNZRO MQ < ISZ SIMLA TAD I SIMLA /MAYBE THE TASKS MQ, DCA SIMMQ > IFNZRO EAE < ISZ SIMLA TAD I SIMLA /AND MAYBE THE TASKS STEP DCA SIMEAE / COUNTER. > JMS I (SIMGIA /GO GET THE ADDRESS OF THE USER DCA SIMLA / TASK'S INSTRUCTION. TAD I SIMLA /NOW GET THE USER TASK'S CDF ODTFLD / INSTRUCTION TO SIMULATE AND DCA SIMIST / SAVE IT LOCALLY.
/ / / EMULATE THE USER TASKS INSTRUCTION / / TAD SIMIST /GET THE INSTRUCTION TO DO. SPA /IS THE INSTRUCTION AN IOT OR CLL RAL / OPERATE ? SPA JMP SIMD3 /YES, GO ON. CLB /NO, GO COMPUTE THE EFFECTIVE JMS I (SIMEFA / ADDRESS REFERENCED BY THIS / INSTRUCTION. TAD SIMIST /NOW DO WE HAVE A CONTROL OR SPA / MEMORY REFERENCE INSTRUCTION ? JMP SIMD1 /CONTROL, EITHER JMP OR JMS. AND (7000) /REFORM THE MEMORY REFERENCE TAD (AND I SIMADR) / INSTRUCTION FOR LOCAL DCA SIMIST / SIMULATION. JMP SIMD6 /NOW GO DO IT TO IT. SIMD1, CLL RTL /IS THIS A JMP OR JMS ? SPA CLA JMP SIMD2 /'TIS A JMP (JMP'S ARE EASIER). JMS I (SIMTJS /GO CHECK FOR INVALID JMS. CLB IAC /GET THE TASK'S PC+1 AND PUT IT TAD SIMPC / WHERE THE JMS WOULD. JMS SIMCDF /SET DATA FIELD TO USER TASK. DCA I SIMADR CLB IAC SIMD2, TAD SIMADR /PUT THE TARGET ADDRESS IN THE DCA SIMPC / TASK'S PC. JMS I (SIMCIF /GO CHECK IF WE NEED TO UPDATE / USER TASK'S INSTRUCTION FIELD. JMP SIMD7 /ALL DONE, SKIP THE SIMULATOR. SIMD3, CLL RAL /NOW WE HAVE EITHER IOT OR OPR ! SMA CLA JMP SIMD5 /'TIS AN IOT. / / / GO TEST FOR SPECIAL OPERATE INSTRUCTIONS. / / JMS I (SIMTOP /GO DO SPECIAL OPR TESTS. JMP SIMD6
/ / / GO TEST FOR SPECIAL IOT INSTRUCTIONS, PRIMARY FOR / CIF AND/OR CDF INSTRUCTIONS. THESE ARE PROCESSED / DIFFERENTLY FROM OTHER IOT INSTRUCTIONS. / / SIMD5, JMS I (SIMTCF /GO DO SPECIAL IOT TESTS. / / / / N N OOO W W / NN N O O W W / N N N O O W W W WE CAN DO THE ACTUAL SIMULATION ! / N NN O O WW WW / N N OOO W W / / / SIMD6, TAD SIMSAT /GET THE TASK'S LINK, CLL RAL DCA SIMSAT IFNZRO MQ < TAD SIMMQ / AND MAYBE MQ. MQL > TAD SIMAC /GET THE TASK'S ACCUMULATOR. JMS SIMCDF /SET THE DATA FIELD PROPERLY. SIMIST, 0 /NOW DO IT !!! SKP ISZ SIMPC NOP DCA SIMAC /SAVE THE TASK'S ACCUMULATOR, IFNZRO MQ < MQA / AND MAYBE THE MQ, DCA SIMMQ > TAD SIMSAT / BUT DEFINITLY THE LINK. RAR DCA SIMSAT / SIMD6A, ISZ SIMPC /ADJUST PC, SINCE WE SUBTRACTED NOP / 1 WHEN WE GOT THE PC DATA / FROM THE TASK'S STATE TABLE. SIMD7, CDF ODTFLD /RESTORE THE DATA FIELD TO HERE.
/ / / REPLACE A TASKS STATE DATA IN THE EXECUTIVES TABLE / / TAD SIMTSK /GET THE NUMBER OF THE TASK OF CLL RTL / INTEREST AND COMPUTE THE IFNZRO EAE < / LOCATION OF THE TASKS DATA IN TAD SIMTSK / THE EXECUTIVES TASK STATE > / TABLE. TAD (TSTABL) DCA SIMLA CDF RTCDF /SET THE DATA FIELD TO THE EXEC. TAD SIMSAT /GET THE TASKS CURRENT STATUS DCA I SIMLA / WORD AND PUT IT BACK. ISZ SIMLA TAD SIMPC /REPLACE THE TASK'S PC, DCA I SIMLA ISZ SIMLA TAD SIMAC /NOW THE AC, DCA I SIMLA IFNZRO MQ < ISZ SIMLA TAD SIMMQ /MAYBE THE TASKS MQ, DCA I SIMLA > IFNZRO EAE < ISZ SIMLA TAD SIMEAE /AND MAYBE THE STEP COUNTER. DCA I SIMLA > CDF ODTFLD /RESET THE DATA FIELD TO HERE. JMP I SIMLAT /AND RETURN. / / / SET THE PROPER DATA FIELD / / SIMCDF, 0 NOP /(WILL BE PROPER CDF.) JMP I SIMCDF
/ SIMLA, 0 /LOCAL TEMPORARY. SIMINX, 0 /INDEX FOR BKP DATA. SIMTSK, 0 /TASK NUMBER OF INTEREST. SIMADR, 0 /EFFECTIVE INSTRUCTION ADDRESS. SIMSAT, 0 /LOCAL STORAGE FOR TASKS STATE SIMPC, 0 / DATA. SIMAC, 0 SIMMQ, 0 SIMEAE, 0 SISTEP, 0 /SINGLE STEPPING FLAG. PAGE
/ / / COMPUTE THE EFFECTIVE ADDRESS FOR AN INSTRUCTION / / SIMEFA, 0 TAD I (SIMIST /GET THE INSTRUCTION FOR US TO AND (0177) / SIMULATE. DCA I (SIMADR /SAVE PAGE RELATIVE ADDRESS. TAD I (SIMIST /FORM THE EFFECTIVE ADDRESS. AND (0200) CIA AND I (SIMPC /GET THE PAGE ADDRESS AND ADD TAD I (SIMADR / IN THE PAGE RELATIVE ADDRESS. DCA I (SIMADR TAD I (SIMSAT /IF NO INDIRECT ADDRESSING, THE / OPERAND FIELD IS THE TASK'S / CURRENT INSTRUCTION FIELD. IFZERO KT8A < AND (0070) /OLD 32K STYLE. > IFNZRO KT8A < RACC /KT8A STYLE. > TAD (CDF 0) DCA I (SIMCDF+1 TAD I (SIMIST /TEST FOR INDIRECT ADDRESSING. AND (0400) SNA CLA JMP I SIMEFA /NO, WE'RE ALL SET, RETURN. TAD I (SIMADR /MOVE EFFECTIVE ADDRESS LOCALLY DCA SIMEA / SO WE CAN DO INDIRECT. TAD I (SIMIST /NOW TEST FOR REFERENCES TO THE / AUTO-INDEX REGISTERS. JMS I (SIMCDF /SET DATA FIELD PROPERLY ! AND (7770) TAD (7770) SNA CLA ISZ I SIMEA NOP TAD I SIMEA /GET THE TARGET ADDRESS AND CDF ODTFLD / SAVE IT FOR EMULATION. DCA I (SIMADR
/ TAD I (SIMSAT /IF INDIRECT ADDRESSING, THE / OPERAND FIELD IS THE TASKS / CURRENT DATA FIELD. IFZERO KT8A < CLL RTL RAL AND (0070) > IFNZRO KT8A < RACB RACC > TAD (CDF 0) DCA I (SIMCDF+1 JMP I SIMEFA /RETURN. SIMEA, 0
/ / / TEST FOR AND PROCESS CIF AND/OR CDF INSTRUCTIONS / / SIMTCF, 0 TAD I (SIMIST /IS THE INSTRUCTION TO SIMULATE / EITHER A CDF OR A CIF ? IFZERO KT8A < AND (7704) > IFNZRO KT8A < AND (7600) > TAD (-6200) SZA CLA JMP I SIMTCF /NO NEITHER, RETURN. AC0001 /IS THIS A CDF INSTRUCTION ? AND I (SIMIST SNA CLA JMP SIMT1 /NO, LOOK FOR CIF INSTRUCTION. TAD I (SIMIST /MASK OUT THE NEW DATA FIELD / BITS, SHIFT TO WHERE NEEDED, IFZERO KT8A < AND (0070) CLL RTR RAR > IFNZRO KT8A < RACA > DCA SIMTA / AND SAVE THEM. TAD I (SIMSAT /REMOVE THE DATA FIELD BITS FROM IFZERO KT8A < AND (7770) / THE TASK'S STATUS WORD, AND > IFNZRO KT8A < AND (7170) > TAD SIMTA / ADD IN THE NEW DATA FIELD. DCA I (SIMSAT
/ SIMT1, AC0002 /IS THIS A CIF INSTRUCTION ? AND I (SIMIST SNA CLA JMP I (SIMD6A /NO, ALL DONE, SKIP AROUND THE / INSTRUCTION SIMULATION. TAD I (SISTEP /YES, ARE WE SINGLE STEPPING ? SNA CLA JMP I (SIMD6A /NO, WE ARE PROCESSING A BKP, / REJOIN THE MAIN CODE AFTER THE / INSTRUCTION SIMULATOR - WE WILL / NOT SIMULATE THE USER TASK'S / CIF, IT COULD MAKE A BIG MESS / AND WOULD LIKELY CRASH THE RTS8 / SYSTEM! TAD I (SIMIST /GET THE USER TASK'S STATUS WORD, DCA I (SIMIFD / AND SAVE THE IF FOR LATER. JMP I (SIMD6A /REJOIN OUR CALLER AFTER THE / INSTRUCTION SIMULATOR. SIMTA, 0 /LOCAL TEMPORARY.
/ / / TEST FOR AND PROCESS SPECIAL OPERATE INSTRUCTIONS / / SIMTOP, 0 JMP I SIMTOP /NONE FOR NOW / / / TEST FOR JMS'S INTO THE LINKAGE AREA FOR RST8. / / SIMTJS, 0 TAD I (SISTEP /ARE WE SINGLE STEPPING ? SNA CLA JMP I SIMTJS /NO, JUST RETURN. TAD I (SIMIST /CHECK IF JMS IS TO A BAD PLACE. TAD (-4035) SMA CLA JMP I SIMTJS /IT'S OK, RETURN. JMP I (ERROR /YES, TELL THE USER S(HE) GOOFED, / WE CANNOT SIMULATE A CAL!!
/ / / COMPUTE THE ADDRESS OF THE USER TASK'S INSTRUCTION / TO SIMULATE / / SIMGIA, 0 CDF ODTFLD /RESET THE DATA FIELD TO HERE. TAD I (SISTEP /ARE WE SINGLE STEPPING ? SZA CLA JMP SIMG1 /YES, GO ON. TAD I (SIMINX /NO, THE INSTRUCTION WE WANT IS TAD (BKUINT) / STORED IN THE "BKP INSTRUCTION JMP I SIMGIA / REGISTER" TABLE. SIMG1, TAD I (SIMPC /SAVE THE TASK'S PC FOR DCA I (SINGE / LOGGING. TAD I (SIMSAT /ALSO SAVE THE TASK'S DCA I (SINGE+1 TAD I (SIMSAT /CREATE A CDF INSTRUCTION TO THE IFZERO KT8A < / USER TASK'S FIELD. AND (0070) > IFNZRO KT8A < RACC > TAD (CDF 0) DCA .+2 TAD I (SIMPC /GET THE TASK'S PC AND RETURN HLT / WITH THE DATA FIELD SET TO THE JMP I SIMGIA / TASK'S FIELD.
/ PAGE
/ / / WE ARE SIMULATING A JMP OR JMS, CHECK IF WE FOUND A / CIF WHILE SINGLE STEPPING AND NEED TO UPDATE THE / INSTRUCTION FIELD IN THE USER TASKS' STATUS WORD. / / SIMCIF, 0 CDF ODTFLD /RESTORE THE DATA FIELD TO HERE. TAD SIMIFD /IS A CIF PENDING ? SNA JMP I SIMCIF /NO, JUST RETURN NOW. IFZERO KT8A < AND (0070) /YES, ISOLATE THE IF BITS AND DCA SIMIFD / SAVE IT A MO. TAD I (SIMSAT /GET THE USER TASK'S STATUS WORD, AND (7707) / AND CLEAR OUT THE OLD IF BITS. > IFNZRO KT8A < /IF NOW IN --- --A CDE B-- FORM. RACA /IF NOW IN --- AB- --- CDE FORM. RACB /IF NOW IN -AB --- CDE --- FORM. DCA SIMIFD /SAVE THIS FOR A MO... TAD I (SIMSAT /GET THE USER TASK'S STATUS WORD, AND (4707) / AND CLEAR OUT THE OLD IF BITS. > TAD SIMIFD /NOW MERGE IN THE NEW IF BITS, DCA I (SIMSAT / AND PUT THE STATUS WORD BACK IN / LOCAL STORAGE. DCA SIMIFD /CLEAR THE CIF PENDING FLAG. JMP I SIMCIF /NOW WE CAN RETURN. SIMIFD, 0 /CIF CHANGE PENDING FLAG. PAGE
/ 09-SEP-83 12:30 / IFNZRO TASKNAME < / / / / (() ACCEPT A TASK NAME / / / THIS ROUTINE REQUIRES RTS/8 VERSION 3 OR LATER, WHICH / HAS THE MCR NAME TABLE LIST AS A PUBLIC TABLE. / / COME HERE WHEN THE USER ASKS TO ENTER A TASK NAME. / COLLECT THE NAME AND SEARCH THE MCR NAME TABLE / (NMTBL) FOR A MATCH. IF THE NAME EXISTS, SUBSTITUTE / THE TASK NUMBER AND EXIT FOR MORE COMMAND INPUT. / / TSKNAM, TAD (-7) /SET UP A LOOP COUNTER. DCA TSKNA TAD (TSKNC) /SET UP A POINTER TO THE BUFFER DCA TSKNB / FOR THE TASK NAME. TAD (TSKN9) /RESET THE CHARACTER PACKER. DCA TSKN8 TAD (4040) /SET THE SECOND AND THIRD WORDS DCA TSKND / OF THE NAME BUFFER TO SPACES, TAD (4040) / A LA MCR. DCA TSKNE TSKN1, JMS I (GETCHR /GET THE NEXT INPUT CHARACTER. TAD (-")) /IS IT A ")", (A TERMINATOR) ? SNA JMP TSKN3 /YES, GO ON TO TABLE SEARCH. TAD (")-"Z-1) /NO, TEST FOR VALID LETTERS IN CLL / THE INPUT. TAD ("Z-"A+1) SZL CLA JMP TSKN2 /GOT A LETTER, GO ADD TO BUFFER. TAD I (INCHAR /NOT A LETTER, TEST FOR A NUMBER TAD (-"9-1) / IN THE INPUT. CLL TAD ("9-"0+1) SNL CLA JMP TSKN3 /NOT A NUMBER EITHER, GO SEARCH. TSKN2, TAD I (INCHAR /GET THE NEW CHARACTER AGAIN, JMS TSKN6 / AND GO PUT IT IN THE BUFFER. JMP TSKN1 /GO AROUND AGAIN. TSKN3, TAD (NMTBL+1) /SET UP A POINTER FOR MCR'S DCA TSKNA / NAME TABLE. TAD (-NTASKS-1) /SET UP A LOOP COUNTER. DCA TSKNB
/ TSKN4, ISZ TSKNA /INCREMENT THE TABLE POINTER. TSKN5, ISZ TSKNA /AND AGAIN. IFNZRO MCRSTR < ISZ TSKNA /AND MAYBE TWICE MORE. ISZ TSKNA > ISZ TSKNB /IS MCR'S NAME TABLE EXHAUSTED ? SKP JMP TSKN7 /YES, NO MATCH, USE ERROR EXIT. CDF NMTBL /SET DATA FIELD TO NAME TABLE. TAD I TSKNA /GET THE FIRST DATA WORD OF ISZ TSKNA / THE NAME FROM MCR'S TABLE. CIA TAD TSKNC /DOES IT MATCH OUR NAME ? SZA CLA JMP TSKN4 /NO, GO TRY THE NEXT NAME. TAD I TSKNA /THE FIRST 2 LETTERS MATCH, ISZ TSKNA / HOW ABOUT THE NEXT 2 ? CIA TAD TSKND SZA CLA JMP TSKN5 /NOPE, TRY AGAIN. TAD I TSKNA /WE'RE GETTING CLOSER, THE CIA / FIRST FOUR LETTERS MATCH. TAD TSKNE /HOW ABOUT THE LAST 2 LETTERS ? SZA CLA JMP TSKN5 /NO, BUT IT WAS CLOSE. CDF ODTFLD /WE FOUND THE USER'S ENTRY IN TAD TSKNB / MCR'S NAME TABLE, NOW COMPUTE TAD (NTASKS+1) / THE NUMBER FOR THIS TASK, AND DCA TSKNB DCA TSKNC JMS I (EXPCOM / GO ADD THE TASK NUMBER INTO TSKNB / THE CURRENT ARGUMENT. ARG ARG ISZ I (ARGFD /SAY WE FOUND AN ARGUMENT. TAD I (INCHAR /WAS THE TERMINATOR A ")" ? TAD (-")) SNA CLA JMS I (GETCHR /YES, GO GET THE REST OF THE / COMMAND LINE FROM THE USER. JMP I (CLGL /NO, GO EVALUATE THE TERMINATOR.
/ TSKN6, 0 /BUFFER PACKER SUBROUTINE. AND (0077) /MASK OUT WHAT WE WANT. ISZ TSKNA /DO WE HAVE TOO MANY LETTERS ? JMP I TSKN8 /NO, FINISH THIS ONE. TSKN7, CDF ODTFLD /YES, TELL THE USER THAT S(HE) JMP I (ERROR / GOOFED....AGAIN.... TSKN8, TSKN9 JMP I TSKN6 /RETURN FOR ANOTHER. TSKN9, /HERE FOR THE FIRST CHARACTER / OF EACH PAIR. IFNZRO OMNI < BSW /FOR OMNIBUS MACHINES > IFZERO OMNI < CLL RTL /FOR PRE-OMNIBUS MACHINES RTL RTL > TAD (40) /ADD IN A SPACE, A LA MCR. DCA I TSKNB /SAVE THE DATA IN OUR BUFFER. JMS TSKN8 /RETURN, MARKING OUR PLACE. TAD (-40) /HERE FOR THE SECOND LETTER /OF EACH PAIR. FIRST REMOVE THE /SPACE WE ADDED LAST TIME THRU. TAD I TSKNB /COMBINE THE NEW LETTER WITH DCA I TSKNB / THE LAST LETTER. JMS TSKN8 /RETURN, MARKING OUR PLACE. ISZ TSKNB /INCREMENT THE BUFFER POINTER. JMP TSKN9 /FIRST LETTER AGAIN. TSKNA, 0 /LOCAL TEMPOARIES. TSKNB, 0 TSKNC, 0 /NEXT 3 ARE THE NAME BUFFER. TSKND, 0 TSKNE, 0
/ PAGE > /END IF "TASKNAME" CONDITIONAL / FOR TSKNAM.
/ / IFNZRO TASKNAME < / / / / PRINT THE TASK NAME FROM A TASK NUMBER / / / THIS ROUTINE REQUIRES RTS/8 VERSION 3 OR LATER, WHICH / HAS THE MCR TASK NAME LIST AS A PUBLIC TABLE. / / COME HERE TO OUTPUT A TASK NAME, USING THE TASK NUMBER / AS THE INDEX INTO THE TASK NAME TABLE. IF THE NAME / IS NOT DEFINED, PRINT THE TASK NUMBER. / / / ON CALL: THE ACCUMULATOR IS IGNORED / / CALLING SEQUENCE: / / JMS PRTNAM / ADDR ADDRESS OF THE TASK NUMBER / TO USE / / PRTNAM, 0 CLB TAD I PRTNAM /GET THE ADDRESS OF THE TASK ISZ PRTNAM / NUMBER TO PRINT. DCA PRTNA TAD I PRTNA /IS THE TASK NUMBER = 0 ? SNA JMP PRTN3 /YES, PRINT THE TASK NUMBER. IFZERO MCRSTR < CLL RAL > IFNZRO MCRSTR < CLL RTL > TAD I PRTNA /COMPUTE AN INDEX FOR THE TASK TAD (NMTBL) / NAME IN MCR'S TABLE. DCA PRTNB CDF NMTBL /SET DATA FIELD TO NAME TABLE. TAD I PRTNB /IS THE NAME DEFINED ? CDF .FLD SNA CLA JMP PRTN3 /NO, JUST PRINT THE TASK NUMBER. PRTN1, AC7775 /AH, WE HAVE A NAME, SET UP A DCA PRTNC / LOOP COUNTER.
/ PRTN2, CDF NMTBL /SET DATA FIELD TO NAME TABLE. TAD I PRTNB /GET THE NEXT TWO CHARACTERS ISZ PRTNB / IN THE TASK NAME, AND CDF .FLD DCA .+2 / SAVE IT LOCALLY. JMS I (PRNTCH /GO OUTPUT THE NAME CHARACTERS. 0000 ISZ PRTNC /ARE WE FINISHED ? JMP PRTN2 /NO, GET THE NEXT PAIR. JMS I (PUTBUF /YES, OUTPUT THE BUFFER. IFNZRO MCRSTR < TAD PRTSTR /SHOULD WE PRINT THE TASK'S SNA CLA / STARTING ADDRESS ALSO ? JMP PRTN4 /NO, ALL DONE. CDF NMTBL /YES, GET THE DATA LOCALLY, TO TAD I PRTNB / USE SOME COMMON CODE. ISZ PRTNB DCA PRTNC /SAVE TASK'S MEMORY FIELD. TAD I PRTNB DCA PRTNB /SAVE TASK'S STARTING ADDRESS. CDF ODTFLD /DATA FIELD BACK TO HERE. JMS I (P2SPACE /FIRST ADD 2 SPACES. CLB IAC /(SAYS PRINT 5 OR 6 DIGITS.) JMS I (PRNTWD /GO PRINT THE ADDRESS. PRTNB DCA PRTSTR /CLEAR OUR DO-IT FLAG. > JMP PRTN4 /ALL DONE.
/ / / PRINT THE TASK NUMBER IF NO NAME FOUND / / PRTN3, TAD PRTNONE /DID CALLER SAY NAME ONLY ? SZA CLA JMP PRTN4 /YES, DON'T PRINT TASK NUMBER. JMS I (PRNTWD /HERE TO PRINT A TASK NUMBER PRTNA, 0000 / WHEN THE NAME WAS NOT DEFINED. JMS I (PSPACE /BE NICE AND ADD A SPACE. PRTN4, DCA PRTNONE /CLEAR OUR DON'T DO IT FLAG. JMS I (PUTBUF /BE NICE AND EMPTY THE OUTPUT / BUFFER BEFORE WE LEAVE! [N2] JMP I PRTNAM /ALL DONE, RETURN. PRTNB, 0 /LOCAL TEMPORARIES. PRTNC, 0 PRTSTR, 0 /SET NON-ZERO TO PRINT TASK / STARTING ADDRESS. PRTNONE,0 /SET NON-ZERO IF TASK NUMBER IS / NOT TO BE PRINTED IF THE TASK / NAME IS UNDEFINED.
/ / / PRINT THE TASK NAME FOR THE ACTIVE TASK / / / COME HERE FROM "INREGT" AND "INTADR", WHICH OPEN / INTERNAL ODT REGISTERS, AND TEST IF THE ACTIVE / TASK NUMBER IS BEING OPENED. IF SO, PRINT THE / TASK NAME. / / ON CALL: THE ADDRESS TO CHECK IS IN "CADDR". / / PRTACT, 0 TAD I (CADDR /ARE WE OPENING THE ACTIVE TASK TAD XPRTA1 / NUMBER REGISTER ? SZA CLA JMP I PRTACT /NO, RETURN. ISZ PRTNONE /YES, SET THE NAME ONLY FLAG. TAD I (CADDR /GET THE ADDRESS OF THE ACTIVE DCA PRTCA / TASK REGISTER, AND JMS PRTNAM / CALL THE NAME PRINTER. PRTCA, 0000 JMS I (PSPACE /ADD A SPACE. JMS I (PUTBUF /BE NICE AND EMPTY THE OUTPUT / BUFFER BEFORE WE LEAVE! [N2] JMP I PRTACT /ALL DONE, GO BACK TO CALLER. XPRTA1, -ACTTSK /FOR MACREL... PAGE > /END OF "TASKNAME" CONDITIONAL / FOR PRTNAM.
/ / IFNZRO ODTFUL < / / / / (EWN) EXECUTE THE SEARCH COMMANDS / / / SYNTAX: / E EFFECTIVE ADDRESS SEARCH - USE CURRENT DATA / KE "K" TO "SARG", THEN SEARCH / M;E "M" TO "SMASK", THEN SEARCH / M;KE "M" TO "SMASK", "K" TO "SARG", THEN SEARCH / N;M;KE "N" FOR "LISTDV", "M" AND "K" AS ABOVE / / W MATCHING SEARCH - USE CURRENT DATA / KW "K" TO "SARG", THEN SEARCH / M;W "M" TO "SMASK", THEN SEARCH / M;KW "M" TO "SMASK", "K" TO "SARG", THEN SEARCH / N;M;KW "N" FOR "LISTDV", "M" AND "K" AS ABOVE / / N NOT MATCHING SEARCH - USE CURRENT DATA / KN "K" TO "SARG", THEN SEARCH / M;N "M" TO "SMASK", THEN SEARCH / M;KN "M" TO "SMASK", "K" TO "SARG", THEN SEARCH / N;M;KN "N" FOR "LISTDV", "M" AND "K" AS ABOVE / / SERCHE, TAD (0377) /ENTRY FOR EFFECTIVE ADDRESS DCA I (SMASK / SEARCH. SERCHW, TAD (SZA-SNA) /ENTRY FOR MATCHING SEARCH. SERCHN, TAD (SNA CLA) /ENTRY FOR NON MATCHING SEARCH. DCA SERC2 JMS I (ARGTST /GO SEE IF A NEW SEARCH ARGUMENT ARGFD / WAS ENTERED. 7777 /(VALID ENTRY IS .LE. 7777.) SZL /WAS AN ARGUMENT ENTERED ? DCA I (SARG /YES, UPDATE THE SEARCH ARGUMENT. JMS I (ARGTST /GO SEE IF A NEW SEARCH MASK WAS ARG2FD / ENTERED. 7777 /(VALID ENTRY IS .LE. 7777.) SZL /WAS AN ARGUMENT ENTERED ? DCA I (SMASK /YES, UPDATE THE SEARCH MASK. TAD I (SARG /PREPARE THE USER'S SEARCH AND I (SMASK / ARGUMENT FOR USE, DCA SERCA / AND SAVE IT. JMS I (RANGEC /GO COMPUTE THE RANGE TO SEARCH. JMS I (LISTDV /GO SET UP THE PROPER OUTPUT / DEVICE.
/ SERC1, JMS I (GETNXA /GET THE NEXT WORD OF DATA. JMP SERC3 /ALL DONE, GO CLEAN UP AND EXIT. TAD I (CDATA /GET THE NEW DATA WORD, AND AND I (SMASK / MASK OFF DON'T CARE BITS. CIA TAD SERCA /COMPARE TO THE USER'S ARGUMENT. SERC2, HLT /(CORRECT SKIP PUT HERE ON ENTRY.) JMP SERC1 /NOT WHAT WE WANT, TRY AGAIN. JMS I (PRNTCR /DO A CR-LF TO START A NEW LINE. JMS I (PRTADR /GO PRINT THE CURRENT ADDRESS, / AND MAYBE USE ONE OF THE / RELOCATION REGISTERS. TAD (257) /PUT A "/" IN THE OUTPUT BUFFER. JMS I (PUTCHR JMS I (PRNTWD /PRINT THE CURRENT DATA AS 4 CDATA / OCTAL DIGITS. JMP SERC1 /DONE WITH THIS ONE, TRY ANOTHER. SERC3, JMS I (PRNTCR /FINISH WITH A CR-LF. JMP I (DECODE /NOW GO TRY FOR ANOTHER COMMAND. SERCA, 0 /LOCAL TEMPORARY. / / / (F) FILL MEMORY WITH A CONSTANT / / / SYNTAX: / F FILL MEMORY - USE CURRENT DATA / MF "M" TO "SARG", THEN FILL MEMORY / / FILLCR, JMS I (ARGTST /GO SEE IF A NEW SEARCH ARGUMENT FILL1, ARGFD / WAS ENTERED. 7777 /(VALID ENTRY IS .LE. 7777.) SZL /WAS AN ARGUMENT ENTERED ? DCA I (SARG /YES, UPDATE THE SEARCH ARGUMENT. JMS I (RANGEC /GO INITIALIZE "RANGE" FOR / "GETNXA". TAD I (SARG /PUT THE CONSTANT TO USE IN DCA I (ARG / FILLING MEMORY WHERE "PUTCAD" / CAN FIND IT. FILL2, JMS I (GETNXA /GO OPEN THE NEXT LOCATION. JMP I (DECODE /ALL DONE, GET ANOTHER COMMAND. ISZ I FILL1 /SAY "ARGUMENT FOUND" AND ISZ I (OPN / "LOCATION OPEN" FOR "PUTCAD". JMS I (PUTCAD /LET "PUTCAD" STORE THE DATA. JMP FILL2 /GO AROUND 'TIL DONE.
/ / / (L) LIST MEMORY DATA / / / SYNTAX: / L LIST MEMORY - USE CURRENT DATA / AL "A" TO HIGH LIMIT REGISTER, THEN LIST / A;L "A" TO LOW LIMIT REGISTER, THEN LIST / A1;A2L "A1" TO LOW LIMIT, "A2" TO HIGH LIMIT / N;A1;A2L "N" FOR "LISTDV", "A1" AND "A2" AS ABOVE / / LISTCR, AC4000 /(MOVE 2 WORDS IF ENTERED.) JMS I (MOVEDAT /GO UPDATE THE HIGH LIMIT, IF ARGFD / THE USER ENTERED A NEW ONE. HIGH AC4000 /(MOVE 2 WORDS IF ENTERED.) JMS I (MOVEDAT /GO UPDATE THE LOW LIMIT, IF ARG2FD / THE USER ENTERED A NEW ONE. LOW JMS I (RANGEC /GO INITIALIZE "RANGE" FOR / "GETNXA". JMS I (LISTDV /GO SET UP THE OUTPUT DEVICE. JMS I (GETNXA /GO GET THE FIRST WORD OF DATA. JMP I (DECODE /NOTHING TO DO, NEXT COMMAND.. JMP LIST2 /NOW WE'RE READY, JUMP INTO IT. LIST1, ISZ LISTA /HAVE WE LISTED 8 LINES ? JMP LIST3 JMS I (PRNTCR /YES, ADD A CR-LF FOR SEPARATION. LIST2, TAD (-10) /RESET THE LINE COUNTER. DCA LISTA LIST3, JMS I (PRNTCR /DO A CR-LF TO START A NEW LINE. JMS I (PRTADR /GO OUTPUT THE CURRENT ADDRESS, / AND MAYBE USE A RELOCATION / REGISTER. JMS I (PRNTMD /ADD THE OUTPUT MODE CHARACTER. TAD (-10) /RESET THE LOOP COUNTER, WE DO 8 DCA LISTB / WORDS PER LINE.
/ LIST4, JMS I (PSPACE /ADD A SPACE. JMS I (PRNTWD /NOW ADD THE MEMORY DATA TO THE CDATA / OUTPUT BUFFER. JMS I (GETNXA /GO GET THE NEXT WORD OF DATA. JMP LIST5 /ALL DONE, GO CLEAN UP AND EXIT. ISZ LISTB /IS THIS LINE DONE (FULL) ? JMP LIST4 /NO, DO ANOTHER WORD OF DATA. JMP LIST1 /YES, GO START ANOTHER LINE. LIST5, JMS I (PRNTCR /FINISH WITH A CR-LF. JMP I (DECODE /NOW GO TRY FOR ANOTHER COMMAND. LISTA, 0 /LOCAL TEMPORARIES. LISTB, 0 / / / (K) KOMPUTE AND PRINT RELOCATION DISTANCE / / / SYNTAX: / K COMPUTE THE DISTANCE BETWEEN THE CURRENT / ADDRESS AND THE CLOSEST RELOCATION / REGISTER / NK COMPUTE THE DISTANCE BETWEEN THE CURRENT / ADDRESS AND RELOCATION REGISTER "N" / A;NK MOVE "A" TO THE CURRENT ADDRESS, THEN DO AS / FOR "NK" ABOVE. / / KOMPUT, AC4000 /(MOVE 2 WORDS IF ENTERED.) JMS I (MOVEDAT /GO MOVE THE ENTERED ADDRESS, IF ARG2FD / ANY, TO THE CURRENT ADDRESS. CADDR TAD (275) /PUT A "=" IN THE OUTPUT BUFFER. JMS I (PUTCHR JMS I (ARGTST /DID THE USER SPECIFY THE ARGFD / RELOCATION REGISTER TO USE ? 0007 /(VALID ENTRY IS .LE. 7.) SNL JMP KOMP1 /NO, WE CAN USE OUR OWN CHOICE. CLL RAL /YES, FORCE THE SIGN BIT ON TO STL RAR / SAY A REGISTER WAS SPECIFIED. KOMP1, JMS I (LOCATE /NOW WE CAN GO DO OUR THING. JMP I (DECODE /GO GET ANOTHER COMMAND.
/ PAGE
/ / / (A) PRINT THE ASSIGNED REGISTER SETS / / / OUTPUT A TABLE CONTAINING THE USER TASK ASSIGNMENTS, / AND THE BREAKPOINT ADDRESS, RELOCATION, AND BREAKPOINT / PROCEED COUNTER REGISTERS. / / / SYNTAX: / A LIST THE TABLE ON THE CURRENT LIST DEVICE / N;;A CHANGE THE LIST DEVICE TO "N", THEN LIST / / ASLIST, JMS LISTDV /GO SET UP THE OUTPUT DEVICE. TAD (-10) /SET UP A LOOP COUNTER. DCA ASLA TAD (UTASKS) /CREATE A POINTER FOR THE USER DCA ASL2 / TASK ASSIGNMENT TABLE. TAD (BKADDR) /SET UP THE ADDRESS OF THE DCA ASL3 / BREAKPOINT REGISTER TABLE. TAD (BKPROC) /DO THE SAME FOR THE BREAKPOINT DCA ASL4 / PROCEED COUNTER TABLE. TAD (RELT) /AND FINALLY SET UP A POINTER DCA ASL5 / FOR THE RELOCATION REGISTER / TABLE. DCA ASLB /CLEAR THE LINE COUNTER. DCA I (FM /FORCE OUTPUT MODE TO OCTAL. ASL1, JMS I (PRNTCR /START A NEW LINE WITH A CR-LF. JMS I (PSPACE /FIRST PUT A SPACE IN THE BUFFER. TAD ASLB /THEN OUTPUT THE LINE COUNTER. ISZ ASLB JMS I (PRNTN1 JMS I (P2SPACE /ADD 2 SPACES. IFZERO TASKNAME < JMS I (PRNTWD /OUTPUT THE NEXT ENTRY IN THE > IFNZRO TASKNAME < JMS I (PRTNAM / (MAYBE BY TASK NAME) > ASL2, 0000 / USER TASK ASSIGNMENT TABLE. ISZ ASL2 JMS I (PSPACE /ADD A SPACE. JMS I (MOVEDAT /MOVE THE NEXT BREAKPOINT ASL3, 0000 / ASSIGNMENT TO WHERE WE CAN CADDR / PRINT IT USING RELOCATION / REGISTER OFFSETS. ISZ I (BKPLST /SET THE FLAG FOR "LOCATE" TO / SAY PRINT 7 DIGITS, AND JMS I (PRTADR / GO PRINT IT.
/ ISZ ASL3 TAD I ASL3 /IS THE BKP MARKED AS NEW OR ISZ ASL3 / COMPLETE ? AND (6000) SNA JMP ASL3A /NO, GO ON. CLL RTL SNL CLA TAD ("N-"C) / TAD ("C-240) / ASL3A, JMS I (P2SPACE / AND 2 SPACES. JMS I (PRNTWD /NOW OUTPUT THE NEXT BREAKPOINT ASL4, 0000 / PROCEED COUNTER, ISZ ASL4 JMS I (P2SPACE / AND 2 MORE SPACES. CLB IAC /(PRINT 5 OR 6 OCTAL DIGITS) JMS I (PRNTWD /FINALLY, OUTPUT THE NEXT ASL5, 0000 / RELOCATION REGISTER. ISZ ASL5 ISZ ASL5 ISZ ASLA /HAVE WE FINISHED THE LIST ? JMP ASL1 /NO, DO ANOTHER LINE. JMS I (PRNTCR /YES, NOW CLOSE WITH A CR-LF. JMP I (DECODE /ALL DONE, BACK TO COMMAND INPUT. ASLA, 0 /LOCAL TEMPORARIES. ASLB, 0
/ / / SET UP OUTPUT LISTING DEVICE / / / USED BY (E) (L) (N) (W) (A) / / LISTDV, 0 JMS I (ARGTST /WAS A LISTING DEVICE SPECIFIED? ARG3FD 0001 /(VALID ENTRY IS .LE. 1.) SNL JMP LDV1 /NO, USE THE CURRENT DEVICE. TAD (DEVCTR) /YES, FORM AN ADDRESS TO THE DCA LDVA / SPECIFIED OUTPUT CONTROL / REGISTER ($ND), AND SAVE IT. LDV1, TAD I LDVA /MOVE THE LISTING DEVICE TASK DCA I (PUTDEV / NUMBER FROM THE DEVICE CONTROL JMP I LISTDV / REGISTER TO THE OUTPUT ROUTINE, / AND EXIT. LDVA, DEVCTR /INITIALLY $0D. / / / GET THE NEXT CONSECUTIVE MEMORY DATA WORD / / / USED BY (E) (F) (L) (N) (W) / / CALLING SEQUENCE: / / JMS GETNXA / RETURN WHEN "RANGE" IS EXHAUSTED / NORMAL RETURN, DATA IN "CDATA" / / GETNXA, 0 ISZ RANGE /INCREMENT THE LOW ORDER COUNTER. SKP ISZ RANGE+1 /INCREMENT THE HIGH ORDER AS SKP / NEEDED. JMP I GETNXA /RANGE IS EXHAUSTED, TAKE FIRST / EXIT. ISZ I (CADDR /INCREMENT THE CURRENT ADDRESS. SKP ISZ I (CADDR+1 /INCREMENT FIELD WORD AS NEEDED. JMS I (GETCAD /GO GET THE DATA AT THE CURRENT ISZ GETNXA / ADDRESS, AND TAKE THE SECOND JMP I GETNXA / EXIT WITH THE DATA IN "CDATA".
/ / / COMPUTE THE RANGE FOR LOOPING COMMANDS / / / USED BY (E) (F) (L) (N) (W) / / RANGEC, 0 CLB IAC /(FORCE "EXPCOM" TO SUBTRACT.) JMS I (EXPCOM /SET THE CURRENT ADDRESS TO ONE / "LOW"-1. LOW CADDR CLB IAC /(FORCE "EXPCOM" TO SUBTRACT.) JMS I (EXPCOM /COMPUTE MINUS THE NUMBER OF HIGH / WORDS WE NEED TO LOOK AT CADDR / AND SAVE THIS VALUE IN "RANGE". RANGE CLB IAC /(FORCE "EXPCOM" TO SUBTRACT.) JMS I (EXPCOM /WE NEEDED TO COMPUTE "-RANGE-1" ONE / BECAUSE "GETNXA" INCREMENTS RANGE / THE RANGE COUNTER BEFORE IT RANGE / OGES TO "GETCAD" FOR DATA. TAD RANGE+1 /IS "HIGH" .GE. "LOW" ? SMA CLA JMP I (ERROR /NO, TELL USER HE GOOFED AGAIN. JMP I RANGEC /ALL READY FOR "GETNXA", RETURN. RANGE, 0; 0 /LOOP COUNTER FOR "GETNXA".
/ PAGE / / > /END OF "ODTFUL" CONDITIONAL. / / $=$=LHN=$=$