SYM06 B *1 RETURN TO CALLER (DECODE) FMTTXT LI R1,2 SET BYTE COUNTER. TXT02 MOVB R0,*R10+ STORE A DATA BYTE. CB R0,CQUOTE TEST FOR SPECIAL CASE. JNE TXT03 JUMP IF NOT SPECIAL. MOVB R0,*R10+ QUOTES ARE STORED TWICE. TXT03 SWPB R0 INTERCHANGE THE DATA BYTES. DEC R1 DECREMENT THE COUNTER. JGT TXT02 REPEAT FOR ALL BYTES. RT RETURN TO CALLER. PAGE * 'OPTION' SUBROUTINE * THIS SUBROUTINE SETS UP THE USER OPTION SELECTIONS. ************************* R0 - R4 ************************************** OPTTAB DATA OPTMEM,'M ' DISASSEMBLE MEMORY. DATA OPTSRC,'S ' PRODUCE SOURCE. DATA OPTSDS,'D ' SDSMAC FORMAT OPTION. DATA 0 OPTION CLR LSTFLG INITIALIZE THE LIST FLAG. SETO FILE INITIALIZE THE FILE FLAG. SETO TXFLAG INITIALIZE THE TXMIRA FLAG. SVC GETPRM GET INITIAL BID VALUES. MOV GETPRM+2,DX10 TEST THE OS FLAG (1=DX10). JEQ OPT00 JUMP IF TXDS SYSTEM. * DX10 OPTION CODE : CLR TXFLAG RESET THE TXMIRA FLAG. MOV GETPRM+2,LSTFLG TEST FOR 'SOURCE' OPTION. DEC LSTFLG ADJUST THE FLAG. JEQ OPT05 JUMP IF 'LIST' CHOSEN. SETO LINCNT INHIBIT HEADINGS FROM SOURCE. JMP OPT05 END OF OPTION CODE. * TXDS OPTION CODE : OPT00 SVC COMN GET SYSTEM COMMON ADDRESS. MOV R9,R4 COPY THE ADDRESS OF COMMON. AI R4,112 ADD OPTION BIAS TO COMMON ADDRESS. LI R0,3 SET COUNTER FOR TESTING 3 BYTES. OPT01 LI R1,OPTTAB SET POINTER TO THE TABLE. MOVB *R4,R2 TEST THE OPTION BYTE FOR >00. JEQ OPT05 EXIT IF NO MORE OPTIONS. OPT04 MOV *1+,R2 FETCH A VECTOR WORD. JEQ OPT03 JUMP IF TABLE FINISHED. MOV *R1+,R3 GET THE TABLE KEY CHARACTER. CB *R4,R3 TEST FOR MATCHING CODE. JNE OPT04 JUMP IF NO MATCH B *R2 PROCESS THE OPTION. OPTMEM CLR FILE CLEAR THE FILE FLAG. JMP OPT03 TEST NEXT OPTION BYTE. OPTSRC SETO LSTFLG SET THE SOURCE FORMAT FLAG. SETO LINCNT INHIBIT THE HEADINGS. JMP OPT03 OPTSDS CLR TXFLAG RESET THE TXMIRA FLAG. OPT03 INC R4 MOVE POINTER TO NEXT OPTION BYTE. DEC R0 DECREMENT THE COUNTER. JNE OPT01 LOOP IF TABLE NEEDS TESTED. OPT05 RT RETURN TO MAIN LINE PROGRAM. PAGE * SUBROUTINE TO GET NEXT DATA WORD * THIS ROUTINE FETCHES FROM MEMORY OR READS AND DECODES * OBJECT RECORDS, PASSING THE DATA BACK TO THE CALLER * IN R0. THE DATA IS ALSO STORED IN PC0(INSTSZ). * IF A TYPE 'A' TAG IS READ, THE PC IS UPDATED. * THIS ROUTINE GENERATES 'BSS' RECORDS AND 'EQU'S * AS NECESSARY. NXTWP BSS 32 WORKSPACE FOR NEXTWD. NXTPC2 SETO R9 SET THE ASCII ONLY FLAG. JMP NX001 ..ENTER COMMON CODE. NXTWD CLR R9 CLEAR THE ASCII FLAG. NX001 CLR ETAG CLEAR THE E-TAG FLAG. MOV FILE,0 TEST FOR MEMORY ACCESS JEQ NX050 JUMP IF MEMORY MOV OPENIN,0 TEST WHETHER INPUT OPENED YET JEQ NX010 JUMP IF IT IS CLR OPENIN CLEAR THE SVC CODE. CLR FRMT INITIALIZE THE COMPRESSED FLAG. SVC OPENIN OPEN THE INPUT FILE MOV OPENIN,0 TEST FOR ERRORS JEQ EOR READ THE FIRST RECORD NOW ERR B EXIT QUIT ON ANY ERROR SKIP10 AI R8,6 BUMP POINTER PAST SYMBOL FIELD. SKIP4 INCT R8 SKIP (COMPRESSED) VALUE FIELD. MOV FRMT,R10 TEST WHETHER COMPRESSED IS OK. JNE NX010 YES, GET NEXT FIELD. INCT R8 NO, SKIP TWO MORE BYTES. JMP NX010 NOW PROCESS NEXT TAG. SKIP8 AI 8,2 BUMP POINTER PAST SKIP6 AI 8,6 FIELDS WE WILL IGNORE. XXX NX010 C 8,ICNT TEST WHETHER INPUT BUFFER EMPTY JL NX020 JUMP IF NOT EOR NX015 SVC RDIN READ A RECORD INTO INPUT BUFFER MOV RDIN,0 TEST FOR READ ERRORS JNE ERR JUMP TO ABORT LI 8,IBUF SET THE INPUT POINTER A 8,ICNT MODIFY THE ENDING VALUE NX020 MOV 8,12 SAVE THE BUFFER POINTER MOVB *8+,1 GET A TAG CHAR FROM BUFFER SRL 1,8 SHIFT DOWN TO BOTTOM CI 1,TTBLSZ+>30 TEST UPPER LIMIT OF TAGS. JGT ERR JUMP IF BAD TAG READ. AI 1,->30 CONVERT ASCII DIGIT TO BCD JLT CMPIDT JUMP IF COMPRESSED ID TAG CI 1,10 TEST FOR ASCII LETTER JEQ QUIT JUMP IF ':' TAG WAS READ JLT NX025 JUMP IF ASCII DIGIT AI 1,-7 BIAS THE LETTER -> HEX DIGIT NX025 SLA 1,1 DOUBLE THE TAG MOV INSTSZ,2 GET THE CURRENT INSTRUCTION NUMBER. CI R2,MAXSIZ TEST FOR LONG TEXT STRING. JGT NX026 JUMP IF SUBSCRIPT OUT OF RANGE. MOV RELTAG(1),RELWD(2) FLAG THE RELOCATABILITY. NX026 MOV @TTBL(1),10 GET THE TAG PROCESSOR ADDRESS * EVALUATE THE SECOND OBJECT FIELD MOVB *8+,0 GET A CHAR FROM RECORD SWPB 0 MOVB *8+,0 SECOND CHAR SWPB 0 MOV FRMT,1 TEST FOR COMPRESSED FORMAT JNE NX030 JUMP IF COMPRESSED MOVB *8+,3 THIRD CHAR SWPB 3 MOVB *8+,3 FOURTH SWPB 3 MOV 0,2 COPY THE FIRST TWO LI 1,>D00 GENERATE THE SVC 'CHAB' SVC R1 CONVERT THE DIGITS TO BINARY NX030 B *10 PROCESS THE FIELD QUIT MOV IDTVAL,R0 GET THE OBJECT LENGTH. MOV 12,8 RESET THE TAG POINTER. MOV INSTSZ,R1 GET CURRENT INSTRUCTION LENGTH. A PC,R1 ADD STARTING ADDRESS. C R1,R0 COMPARE TO MODULE END ADDRESS. JL ADDR JUMP IF THERE SHOULD BE A BSS. MOV R9,R9 TEST WHETHER PROCESSING ASCII. JNE NODATA YES?, TAKE 'NOT ASCII' RETURN. NEXIT LI 14,EXIT2 TERMINATE NORMALLY RTWP TAKE ALTERNATE RETURN. CMPIDT SETO FRMT SET COMPRESSED FORMAT FLAG CLR 1 PRELOAD THE TAG INDEX JMP NX025 PROCESS THE FIELD LIKE IDT * MEMORY DISASSEMBLY NX050 MOV PC,0 GET THE PC VALUE. C 0,14(13) COMPARE PC TO END ADDRESS. JH NEXIT TERMINATE IF FINISHED. MOV INSTSZ,1 GET CURRENT INSTRUCTION NUMBER. A 1,0 ADD TO PC. MOV *0,0 GET DATA WORD FROM MEMORY. NX055 CI R1,MAXSIZ TEST SUBSCRIPT VALUE. JGT DATA JUMP IF OUT OF RANGE. CLR RELWD(1) FLAG AS ABSOLUTE VALUE. DATA MOV INSTSZ,1 GET CURRENT INSTRUCTION NUMBER. CI R1,MAXSIZ TEST FOR MAXIMUM VALUE. JGT DATA2 SKIP IF SUBSCRIPT OUT OF RANGE. MOV 0,PC0(1) STORE THE DATA WORD IN PC0 DATA2 MOV R9,R9 TEST WHETHER ASCII REQUESTED. JEQ NX060 JUMP IF ANYTHING GOES. MOV RELWD(1),2 TEST RELOCATABILITY. JNE NODATA JUMP IF RELOCATABLE (NOT TEXT). BL @ASCLIM TEST THE BYTES. DATA NODATA ..RETURN IF NOT ASCII. NX060 MOV 0,*13 PASS BACK TO R0 INCT INSTSZ INCREMENT THE INSTRUCTION NUMBER. SOC EQMSK,R15 SET THE 'EQUAL' STATUS. RTWP RETURN TO CALLER NOW. NODATA MOV R12,R8 RESTORE THE PRE-TAG POINTER. SZC EQMSK,R15 CLEAR THE 'EQUAL' STATUS. RTWP RETURN TO CALLER WITHOUT DATA. IDT MOV 0,IDTVAL SAVE THE OBJECT LENGTH. LI 2,IDTSYM SET POINTER TO BUFFER. LI 3,MSG0I SET POINTER TO SECOND BUFFER. LI 1,8 SELECT LENGTH OF FIELD. IDT01 MOVB *8+,R0 MOVE IDT NAME INTO REGISTER 0. MOVB R0,*R2+ STORE INTO IDT RECORD BUFFER MOVB R0,*R3+ AND HEADING. DEC 1 DECREMENT THE COUNTER. JGT IDT01 JUMP UNTIL FINISHED. JMP NX010 PROCESS NEXT FIELD. ADDR MOV INSTSZ,1 TEST FOR INSTR ALIGNMENT. JEQ ADDR2 JUMP IF STARTING NEW INST. MOV R1,R2 COPY THE INSTRUCTION SIZE. A PC,R2 FIND THE CURRENT ADDRESS. C 0,R2 COMPARE WITH THE 'A' TAG. JEQ NX070 DISREGARD IF EQUAL. MOV 12,8 RESTORE PRE-TAG BUFFER POINTER. LI 0,>DADA GENERATE DUMMY DATA. JMP NX055 PROCESS AS ABSOLUTE DATA. ADDR2 MOV PASS,1 TEST FOR PASS 2. JEQ ADDR4 JUMP TO PROCESS PASS 1. MOV 0,1 SAVE THE NEW ADDRESS. S PC,1 FIND THE BSS VALUE. JGT ADDR3 JUMP IF POSITIVE. NX070 B NX010 IGNORE IF ZERO OR NEGATIVE. ADDR3 MOV 1,INSTSZ SAVE BSS VALUE AS INST LENGTH. MOV 1,PC0 STORE THE VALUE AS 'DATA'. CLR 0 CLEAR THE INDEX OF 'PC0'. BL @LIST INITIALIZE THE OUTPUT BUFFER. BYTE 0,1 ..INHIBIT THE 'DATA' VALUE. DATA 3,BSSNAM ..TEXT LENGTH AND POINTER. INCT 10 SKIP TWO SPACES. MOV PC0,0 GET THE BSS VALUE AGAIN. CLR 2 CLEAR THE 'INDEX REG'. BL SYM01 FORMAT THE (HEX) VALUE. BL @LENGTH WRITE THE LINE OUT. BL @OUT75 PROCESS ALL INTERMEDIATE EQU'S. A INSTSZ,PC NOW MODIFY THE PC FOR 'A' TAG. CLR INSTSZ CLEAR THE INSTRUCTION SIZE. CLR LINNUM CLEAR THE PRINT COUNTER. JMP NX070 PROCESS NEXT TAG FIELD. ADDR4 MOV 0,PC UPDATE THE PROGRAM COUNTER. JMP NX070 PROCESS NEXT TAG FIELD. REFX SETO ETAG SET THE E-TAG FLAG. MOV R0,R1 COPY THE INDEX VALUE. SLA R1,3 MULTIPLY THE INDEX BY 8. A RTBL,R1 ADD REF TABLE ADDRESS. MOV PC,*R1 MOVE CURRENT PC INTO REFTBL. A INSTSZ,*R1 COMPLETE WITH CURRENT OFFSET. INCT R8 SKIP THE 'MODULE' CODE. MOV FRMT,R1 TEST THE COMPRESSED FLAG. JNE REFX2 JUMP IF COMPRESSED IS OK. INCT R8 SKIP MORE FOR ASCII CODE. REFX2 JMP DATA PROCESS 'E' TAG DATA. DEF MOV PASS,1 TEST WHICH PASS WE ARE DOING. JEQ DEFP01 JUMP IF IT IS PASS ONE. LI 1,DEFNAM SET POINTER TO THE TEXT. DEFP04 SETO R0 PROHIBIT THE LABEL SEARCH. BL @LIST INITIALIZE THE BUFFER & R10. BYTE 1,1 ..INHIBIT PC AND INSTRUCTION. DATA 0,0 ..USE R1 FOR MNEMONIC POINTER. INC R10 SKIP A SPACE. LI R1,6 SET COUNTER FOR SYMBOL. DEFP02 MOVB *8+,*10+ COPY THE SYMBOL. DEC R1 DECREMENT THE LOOP COUNTER. JGT DEFP02 LOOP FOR SIX CHARS. BL @LENGTH WRITE THE LINE OUT. CLR LINNUM RESET THE LINE COUNTER. JMP NX070 PROCESS THE NEXT FIELD. DEFP00 MOV PASS,1 TEST WHICH PASS WE ARE DOING. JNE DEFP03 JUMP IF IT IS PASS 2. DEFP01 MOV RELWD,1 TEST WHETHER RELOCATABLE SYMBOL. JEQ DEFP03 JUMP IF ABSOLUTE. BLWP DEFSYM DEFINE THE SYMBOL. DEFP03 B SKIP6 SKIP THE SYMBOL, GET NEXT FIELD. REF MOV PASS,1 TEST WHETHER PASS 1 OR 2. JEQ REFP01 DEFINE IF PASS 1. LI 1,REFNAM SET POINTER TO OPCODE TEXT. JMP DEFP04 JUMP TO GENERATE THE OUTPUT. REFP01 MOV R0,R0 TEST THE VALUE OF THE REF. JEQ REFP02 JUMP IF NO VALUE EXISTS. CLR REFTYP RESET THE SPECIAL REF TYPE FLAG. REFP02 BLWP DEFREF DEFINE THE SYMBOL & VALUE. JMP DEFP03 SKIP THE SYMBOL FIELD. * TAG TABLE TTBL DATA IDT TAG 0 DATA XXX,XXX 1, 2 DATA REF,REF 3, 4 DATA DEF,DEF 5, 6 DATA XXX,XXX 7, 8 DATA ADDR,ADDR 9, A DATA DATA,DATA B, C DATA XXX,REFX D, E DATA EOR,DEFP00 F, G DATA SKIP6,SKIP8 H, I DATA SKIP10,ERR J, K DATA ERR,SKIP10 L, M DATA XXX,ERR N, O DATA SKIP4,ERR P, Q DATA SKIP4,XXX R, S DATA XXX,SKIP6 T, U DATA SKIP6,SKIP10 V, W DATA XXX X TTBLSZ EQU $-TTBL RELTAG DATA 0 TAG 0 (1=RELOCATABLE) DATA 0,1 1, 2 DATA 1,0 3, 4 DATA 1,0 5, 6 DATA 0,0 7, 8 DATA 0,1 9, A DATA 0,1 B, C DATA 0,0 D, E DATA 0,1 F, G DATA 0,1 H, I PAGE * ROUTINE TO TEST ASCII VALUES * ENTRY : BL @ASCLIM R0 = DATA * DATA NOTASC NON ASCII RETURN VECTOR * ... ASCII RETURN POINT ************************* R0, R2, R11 ********************************** ASCII BYTE >20,>5F LIMITS OF ASCII ASCLIM CB 0,ASCII TEST FIRST BYTE VALUE. JLT ASC02 JUMP IF TOO LOW. CB 0,ASCII+1 TEST UPPER LIMIT. JGT ASC02 JUMP IF TOO HIGH. MOV R0,R2 COPY THE DATA SWPB R2 POSITION THE SECOND BYTE. CB 2,ASCII TEST LOW LIMIT. JLT ASC02 JUMP IF TOO LOW. CB 2,ASCII+1 TEST UPPER LIMIT. JGT ASC02 JUMP IF TOO HIGH. B 2(11) RETURN TO CALLER, GOOD TEXT. ASC02 MOV *R11,R11 GET ERROR VECTOR. RT RETURN TO ALTERNATE EXIT. PAGE * GETLBL GETCRU GETREF * ENTRY : BLWP GETLBL * RETURN : EQ SET IF LABEL FOUND. * NE SET IF LABEL NOT FOUND. * R0 = CHARACTER COUNT * *R10+ = LABEL ************************* R0-R8, R10, R13-R15 ************************** GETWP BSS 32 WORKSPACE FOR GETLBL. ATFLAG EQU GETWP+6 R3 ERRFLG EQU GETWP+12 R6 NXTLBL EQU GETWP+16 R8 GETPC MOV LTBL,R1 SET POINTER TO THE TABLE. MOV LCNT,2 GET SIZE OF TABLE. MOV R3,R4 ALLOW CALLER TO RESTRICT '@'. JMP GET01 JUMP TO COMMON CODE. GETPC2 MOV BTBL,R1 SET POINTER TO THE CRU TABLE. MOV BCNT,2 GET SIZE OF TABLE. SETO R4 INHIBIT '@' FOR CRU SYMBOLS. JMP GET01 JUMP TO COMMON PROCESSING. GETPC3 MOV RTBL,R1 SET POINTER TO THE REF TABLE. MOV RCNT,R2 GET THE TABLE COUNTER. CLR R7 INITIALIZE THE TEMP FLAG. MOV *R13,R0 TEST THE DATA WORD. JEQ $+4 JUMP IF END OF REF CHAIN. SETO R7 SET THE ERROR FLAG TEMP. MOV R3,R4 CALLER CAN BLOCK '@'. CLR R5 FORCE USAGE OF '@' IF NOT BLOCKED. MOV ETAG,R10 TEST FOR INDEXED REF TABLE. JEQ GET00 JUMP IF STANDARD REFS. * INDEXED REF LOOKUP CLR R7 CLEAR THE ERROR FLAG SLA R0,3 MULTIPLY INDEX BY 8. A R0,R1 ADD TO THE TABLE ADDRESS. INCT R1 SKIP THE VALUE WORD. MOV INSTSZ,R10 GET CURRENT INSTRUCTION SIZE. CLR PC0-2(R10) FORCE DATA TO APPEAR ZERO. JMP GET03 PROCESS THE SYMBOL TEXT. GET00 MOV PC,R0 USE THE LOCATION, NOT DATA. A INSTSZ,R0 ADD THE WORD OFFSET. DECT R0 DECREMENT TO GET CURRENT LOCN. JMP GET02 ENTER COMMON PROCESSING. GET01 MOV *R13,R0 GET VALUE FROM CALLER. SETO R5 ALLOW FORWARD REFERENCE TEST. CLR R7 NO REF ERROR POSSIBLE. MOV FIELD,R10 TEST FOR LABEL FIELD. JNE GET02 JUMP IF NOT LABEL FIELD. SETO R8 INITIALIZE THE NEXT LABEL LOCN. GET02 MOV 2,2 TEST FOR END OF TABLE. JEQ GET09 TABLE END, LABEL NOT FOUND. C 0,*1+ TEST FOR VALUE MATCH. JEQ GET03 JUMP IF WE FOUND LABEL. JL GET08 JUMP IF WE PASSED IT. AI 1,6 SKIP THE (WRONG) LABEL. DEC 2 DECREMENT THE REMAINING COUNT. JMP GET02 LOOP TO CONTINUE SEARCH. * VALUES MATCH, COPY LABEL TO TEXT. GET03 MOV FIELD,R10 TEST FOR LABEL FIELD. JNE GET10 JUMP IF NOT LABEL FIELD. DEC R2 SEE IF ANY MORE LABELS IN TABLE. JEQ GET10 JUMP IF TABLE EMPTY. MOV 6(1),R8 GET NEXT LABEL LOCATION. GET10 MOV 20(13),10 GET R10 FROM CALLER. LI 2,6 SET MAXIMUM LABEL LENGTH. MOV FIELD,FIELD TEST FOR THE LABEL FIELD. JEQ GET04 OMIT '@' IF LABEL FIELD. MOV R4,R4 TEST WHETHER '@' IS ALLOWED. JNE GET04 JUMP IF NOT ALLOWED. MOV R5,R5 TEST WHETHER '@' IS FORCED. JEQ GET07 INSERT '@' BEFORE REF SYMBOL. MOV TXFLAG,TXFLAG TEST WHETHER '@' IS REQUIRED. JNE GET07 FORCE '@' FOR TXMIRA SOURCE. C 0,PC TEST FOR FORWARD REFERENCE. JLE GET04 JUMP IF NOT FWD REF. GET07 MOVB CAT,*R10+ INSERT THE '@' SYMBOL. GET04 CLR R0 CLEAR THE CHAR COUNTER. GET05 MOVB *1+,0 GET A CHARACTER. JEQ GET06 JUMP IF NULL. MOVB 0,*10+ STORE IN OUTPUT BUFFER. INC 0 INCREMENT THE CHAR COUNTER. DEC 2 DECREMENT THE COUNTER. JGT GET05 JUMP IF MORE IN TABLE. GET06 MOV 10,20(13) UPDATE CALLER'S R10. SB 0,0 CLEAR THE UPPER BYTE. MOV 0,*13 PASS THE COUNT TO CALLER R0. SOC R7,R6 COMBINE THE ERROR FLAGS. SOC EQMSK,15 SET STATUS 'EQUAL'. RTWP RETURN TO CALLER. * LABEL NOT FOUND, ANNOUNCE AND RETURN. GET08 MOV FIELD,R10 TEST FOR LABEL FIELD. JNE GET09 JUMP IF NOT LABEL FIELD. MOV -2(1),R8 GET THE NEXT LABEL ADDRESS. GET09 SZC EQMSK,15 RESET THE 'EQUAL' STATUS. RTWP RETURN TO CALLER. PAGE * DEFLBL DEFCRU DEFSYM DEFREF * ENTRY : BLWP DEFLBL ************************* R0-R4, R11-R15 ******************************* DEFWP BSS 32 WP FOR DEFLBL & DEFCRU. DEFPC3 CLR R4 SET THE FLAG 'EXPLICIT NAME'. JMP DEF00 PROCESS LIKE DEFLBL. DEFPC LI 4,'L ' LABELS START WITH 'L'. DEF00 LI 12,LCNT SET POINTER TO COUNTER. JMP DEF01 ENTER COMMON CODE. DEFPC2 LI 12,BCNT SET POINTER TO COUNTER. LI 4,'B ' BITS START WITH 'B'. JMP DEF01 ENTER COMMON PROCESSING. DEFPC4 CLR R4 FLAG EXPLICIT NAME. LI 12,RCNT SET POINTER TO TABLE COUNT. MOV REFTYP,R0 TEST FOR INDEX-TYPE REFS. JEQ DEF01 JUMP IF STANDARD TYPE. * DEFINE 'INDEXED REF' MOV *R12,R11 GET THE TABLE SIZE. C R11,2(R12) TEST WHETHER TABLE IS FULL. JEQ DEF09 DON'T ADD IF FULL. SLA R11,3 MULTIPLY BY ENTRY SIZE. A 4(R12),R11 ADD THE TABLE ADDRESS. INC *R12 INCREMENT THE TABLE COUNTER. JMP DEF05 DEFINE THE SYMBOL NOW. DEF01 MOV 4(R12),R1 PUT TABLE ADDRESS IN R1. MOV *R13,R0 GET VALUE FROM CALLER'S R0. C *12,2(12) TEST FOR ROOM IN TABLE. JEQ DEF09 JUMP IF TABLE IS FULL. MOV *12,2 SAVE THE TABLE SIZE. DEF02 JEQ DEF03 JUMP IF LABEL NOT IN TABLE. C 0,*R1 TEST FOR VALUE MATCH. JEQ DEF12 JUMP IF LABEL IS DEFINED. JL DEF03 JUMP IF LABEL SHOULD BE INSERTED. AI 1,8 SKIP THE LABEL VALUE & TEXT. DEC 2 DECREMENT THE COUNTER. JMP DEF02 JUMP TO CONTINUE SEARCH. DEF03 INC *R12 INCREMENT THE SYMBOL COUNTER. MOV 1,11 SAVE THE ENTRY POINTER. MOV 2,3 GET NUMBER TO BUMP UPWARDS. JEQ DEF05 JUMP IF NONE TO BUMP. LI 2,BUF TEMPORARY STORAGE LOCATION. MOV *1+,*2+ MOVE FIRST MOV *1+,*2+ ENTRY INTO MOV *1+,*2+ TEMPORARY MOV *1+,*2+ STORAGE. DEF04 MOV *1+,*2+ SAVE NEXT MOV *1+,*2+ ENTRY (TEMP 2) MOV *1+,*2+ FOR A MOV *1+,*2+ MOMENT. LI 2,BUF RESET THE TEMPORARY POINTER. AI 1,-8 BACK THE TABLE POINTER DOWN. MOV *2+,*1+ MOVE THE MOV *2+,*1+ TEMP 1 MOV *2+,*1+ INTO THE MOV *2+,*1+ NEW LOCATION. LI 2,BUF RESET POINTER TO TEMP1. MOV 8(2),*2+ MOVE TEMP 2 MOV 8(2),*2+ ENTRY MOV 8(2),*2+ INTO MOV 8(2),*2+ TEMP 1. DEC 3 DECREMENT THE LOOP COUNTER. JGT DEF04 JUMP IF MORE TO BUMP UPWARDS. DEF05 MOV 0,*11+ STORE NEW VALUE IN TABLE. MOV 4,4 TEST FOR EXPLICIT NAME. JEQ DEF10 JUMP IF NAME SUPPLIED TO US. MOV *12,0 GET NEW SYMBOL COUNT. LI 2,CBDA SET SVC POINTER. SVC *2+ CONVERT COUNT TO ASCII. CLR 2(11) INITIALIZE THE NAME CLR 4(11) LAST 4 CHARS. MOVB 4,*11+ STORE FIRST CHARACTER OF LABEL. INC R2 BUMP THE SOURCE POINTER. LI 4,5 SET REMAINING LENGTH. LI 3,' ' SET COMPARISON CONSTANT VALUE. DEF07 MOVB *2+,0 GET ASCII CHARACTER. CB 0,3 TEST FOR A SPACE. JEQ DEF06 DON'T INCLUDE SPACES IN NAME. MOVB 0,*11+ STORE OTHER CHARACTERS. DEF06 DEC 4 DECREMENT THE LOOP COUNTER. JGT DEF07 LOOP FOR FULL NAME. DEF09 RTWP RETURN TO CALLER, NAME DEFINED. DEF10 MOV 16(13),1 GET R8 FROM CALLER. LI 4,6 SET MAXIMUM LABEL SIZE. LI 3,' ' GENERATE CONSTANT BLANK. DEF11 MOVB *1+,0 GET CHARACTER FROM BUFFER. CB 0,3 TEST FOR BLANK, IE END OF SYMBOL. JNE $+4 JUMP IF NON BLANK. CLR 0 CHANGE BLANK TO NULL. MOVB 0,*11+ STORE CHARACTER INTO TABLE. DEC 4 DECREMENT THE COUNTER. JGT DEF11 LOOP UNTIL SIX CHARS MOVED. RTWP RETURN TO CALLER NOW. DEF12 MOV 1,11 POSITION THE TABLE POINTER. INCT R11 SKIP THE SYMBOL VALUE. MOV 4,4 TEST FOR EXPLICIT NAME. JEQ DEF10 JUMP TO MODIFY EXISTING LABEL. RTWP RETURN, LABEL PREDEFINED. PAGE * LIST * ENTRY : BL @LIST R0 = INDEX FOR PC0 * BYTE PC,INST FLAGS * DATA N,TEXT COUNT AND POINTER * SETUP BUFFER AND R10, 'PC' IS THE FLAG * FOR FORMATTING THE PC VALUE, 'INST' IS * THE FLAG FOR FORMATTING THE DATA VALUE. * RETURN R10 = POINTER BEYOND OPCODE FIELD. ************************* R0-R2, R10, R11 ****************************** LIST MOV 0,LINTMP SAVE THE INDEX VALUE. MOV 1,MNEMNC SAVE THE MNEMONIC POINTER. MOV PASS,0 TEST FOR PASS 2. JNE LIST02 JUMP IF PASS 2. B 6(11) RETURN IF PASS 1. LIST02 LI 0,OPEN SET POINTER TO SVC BLOCK. MOV *0,*0 TEST WHETHER FILE OPEN YET. JEQ LIST20 JUMP IF OPEN. CLR *R0 CLEAR THE SVC CODE. SVC *0 DO THE OPEN/REWIND. MOV *0,*0 TEST SUCCESS OF OPERATION. JEQ LIST20 JUMP IF OPENED OKAY. B EXIT ABORT ON ANY ERRORS. LIST20 LI 1,BUF SET POINTER TO THE BUFFER. LI 2,' ' GENERATE TWO BLANKS. LI 0,80 SET LINE SIZE. LIST03 MOV 2,*1+ STORE TWO BLANKS. DECT 0 DECREMENT THE COUNTER. JGT LIST03 CONTINUE UNTIL ALL BLANKED. LI 10,BUF INITIALIZE THE BUFFER POINTER. MOV LSTFLG,0 TEST THE LIST/SOURCE FLAG. JEQ LIST01 JUMP IF LISTING REQUESTED. INCT R11 BUMP THE RETURN ADDRESS. JMP LIST07 TEST FOR A LABEL. LIST01 MOVB *11+,0 TEST THE 'PC' FLAG. JEQ LIST04 JUMP IF PC TO BE FORMATTED. AI 10,5 BUMP THE BUFFER POINTER, JMP LIST05 AND CONTINUE PROCESSING. LIST04 MOV PC,0 GET THE PC VALUE. A LINNUM,0 ADD THE PRINT COUNTER. MOV 11,2 SAVE THE RETURN LINKAGE. BL HXN FORMAT A HEX NUMBER *R10+. INC 10 SKIP A SPACE. MOV 2,11 RESTORE THE RETURN LINKAGE. LIST05 MOVB *11+,0 TEST THE 'INST' FLAG. JEQ LIST06 JUMP IF DATA TO BE DISPLAYED. AI 10,6 BUMP THE BUFFER POINTER. JMP LIST07 CONTINUE PROCESSING. LIST06 MOV LINTMP,1 GET THE PRINT INDEX. MOV PC0(1),0 GET THE DATA WORD. MOV 11,2 SAVE THE RETURN LINKAGE. BL HXN FORMAT THE HEX NUMBER. MOV 2,11 RESTORE THE RETURN LINKAGE. MOV LINTMP,1 GET THE PRINT INDEX. LI 0,''' ' GENERATE CONSTANTS. MOV RELWD(1),1 TEST THE RELOCATABILITY FLAG. JNE $+4 JUMP IF RELOCATABLE. SWPB 0 REVERSE THE CONSTANTS. MOVB 0,*10+ PUT CONSTANT INTO BUFFER. INC 10 SKIP A SPACE. LIST07 SETO R2 SET FLAG, LABEL NOT FOUND. MOV LINTMP,1 TEST THE PRINT COUNTER. JNE LIST08 JUMP IF NOT FIRST LINE. MOV 10,1 SAVE THE POINTER. MOV PC,0 GET THE PC VALUE. A LINNUM,0 ADD THE INTERMEDIATE VALUE. BLWP GETLBL TRY TO ADD A LABEL TO LINE. JNE $+4 JUMP IF LABEL NOT FOUND. CLR R2 ELSE, CLEAR THE FLAG. MOV 1,10 RESTORE THE BUFFER POINTER. LIST08 AI 10,7 BUMP TO MNEMONIC FIELD. MOV *R11+,1 GET THE MNEMONIC TEXT LENGTH. JEQ LIST09 JUMP IF VARIABLE MNEMONIC. MOV *R11+,0 GET THE MNEMONIC POINTER. JMP LIST10 COPY IT TO OUTPUT. LIST09 LI R1,4 SET TEXT LENGTH = 4. MOV MNEMNC,R0 GET POINTER TO TEXT. INCT R11 SKIP LAST DATA WORD. LIST10 MOVB *R0+,*R10+ COPY THE TEXT TO OUTPUT. DEC R1 DECREMENT THE COUNTER. JGT LIST10 LOOP FOR ENTIRE FIELD. MOV R2,R2 SET STATUS FOR LABEL FIELD. RT RETURN TO CALLER. PAGE * OUTPUT ROUTINE * ENTRY : BL OUTPUT * PRIMARY LINE IS FORMATTED. * RETURN : PRIMARY AND SECONDARY LINES PRINTED. * EQU LINES GENERATED AND PRINTED.