.TITLE ORCSUB ORC SUBROUTINES .IDENT /V01.7/ ; MODIFICATIONS RECORD ; ==================== ; V01.3 CJD ; ADD SPECIAL 11/60 INSTRUCTIONS. ; PUT ^O BEFORE FLOATING-POINT IMMEDIATE VALUE, OR MAC WILL ASSUME ^F! ; RECOGNISE CODE 260 (NON-STANDARD NOP), PREVIOUSLY IGNORED COMPLETELY, ; NOW TREAT IT AS ILLEGAL, BECAUSE MAC WON'T ASSEMBLE IT. ; ; V01.4 5-May-83 CJD ; Output ASCII codes for all printing data words, including lower-case ; letters, not just space to _. ; ; V01.5 14-Aug-85 CJD ; Use UNsigned branches after CMP's with OBJLEN and OBLEN2, for safety. ; Check for a .WORD x (where x may be a local symbol, or .GLOBL) before ; assuming that an instruction is one. Also handle TRAP/EMT global. ; Try to correct word references to (R1), where R1 may be odd. (There is ; a note about this in the original, but insufficient heed was taken of ; it!) Short of altering everything, the philosophy is to change ; anything that is found to do an odd address trap, or can be changed ; without increasing the code size. Make a few code improvements to ; try to recover the extra space needed. This applies predominantly to ; RLD record handling, when complex relocation is used. Note that it ; may affect registers other than R1, e.g. R0 in GETPS. ; ; V01.6 20-Dec-85 CJD ; Correct missing +n on GLOBAL+n, induced by above -- need to TST OCOBUF ; after it has been filled by 2 MOVBs at RLD6. ; ; V01.7 14-Oct-86 CJD ; Correct bugs induced by "efficiency" mods in V01.5!! ; Handle .BYTE global in I PSECT. ; Show .PSECT . ABS.,... as .ASECT ; Split out PSECT header to a subroutine for use in ORCP3 also. ; Preventative correction to output of blank line in RLDPS -- should set ; MACPS and MACLC to -1 BEFORE blank line output. FTAB not required. ; Handle condition where a PSECT change, EOM, etc occurs in the middle of ; an instruction, which was presumably really data. ; This used to cause invalid disassembly, or infinite looping. ; ; ORC SUBROUTINES FOR PASS 2 ; THESE SUBROUTINES ARE USED IN PASS 2 OF ORC ; .MACRO FTAB JSR PC,TAB8 .ENDM FTAB ; ; AMODE - INTERPRET OPERAND IN R0 ; REG - INTERPRET REGISTER IN R0 ; R1 = CURRENT POSITION IN INPUT LINE ; R2 = CURRENT POSITION IN OUTPUT LINE ; AMODE:: REG:: MOV R0,R4 BIC #70,R4 ; ISOLATE REGISTER IN R4 ASH #-2,R0 BIC #61,R0 ; AND MODE*2 IN R0 CMP R4,#7 ; REGISTER = PC? BNE 5$ MOVB #'P,R3 ; SET REGISTER NAME IN R3/R4 MOVB #'C,R4 JMP @PCMODE(R0) ; BRANCH ACCORDING TO MODE 5$: CMP R4,#6 ; REGISTER = SP ? BEQ 10$ ADD #60,R4 ; NO - SET "RN" IN R3/R4 MOVB #'R,R3 BR 20$ 10$: MOVB #'S,R3 ; YES - SET "SP" IN R3/R4 MOVB #'P,R4 20$: JMP @MODES(R0) ; BRANCH ACCORDING TO MODE ; .PSECT ORCDAT,D MODES: .WORD M0,M1,M2,M3,M4,M5,M6,M7 PCMODE: .WORD M0,M1,PCM2,PCM3,M4,M5,PCM6,PCM7 ; .PSECT ; ; NORMAL REGISTER MODES ; M0: MOVB R3,(R2)+ ; MODE 1 - REGISTER MOVB R4,(R2)+ BR MDONE MCOM: MOVB #'(,(R2)+ ; COMMON CODE FOR ALL OTHER MODES MOVB R3,(R2)+ MOVB R4,(R2)+ MOVB #'),(R2)+ RTS PC M1: JSR PC,MCOM ; MODE 1 - REGISTER DEFERRED BR MDONE M2: JSR PC,MCOM ; MODE 2 - AUTO-INCREMENT MOVB #'+,(R2)+ BR MDONE M3: MOVB #'@,(R2)+ ; MODE 3 - AUTO-INC. DEFERRED BR M2 M4: MOVB #'-,(R2)+ ; MODE 4 - AUTO-DECREMENT BR M1 M5: MOVB #'@,(R2)+ ; MODE 5 - AUTO-DEC. DEFERRED BR M4 M6: CMP R1,OBJLEN ; MODE 6 - INDEX BLO 5$ JSR PC,NOMORE BCS MDONE ; Trap error (EOF?) ;V1.07 5$: MOV (R1)+,OCOBUF ; GET NEXT WORD (=INDEX) JSR PC,SRCHRD ; CHECK FOR RELOCATION TST R0 ; BRANCH IF RELOCATION DONE BEQ 15$ JSR PC,OCO ; NO RELOCN - CONVERT OCTAL VALUE MOV #OCOBUF,R5 10$: MOVB (R5)+,(R2)+ ; AND OUTPUT IT SOB R0,10$ 15$: ADD #2,NXTLC ; UPDATE NEXT LC BR M1 M7: MOVB #'@,(R2)+ ; MODE 7 - INDEX DEFERRED BR M6 ; PROCESS AS FOR INDEX MODE ; ; PC REGISTER MODES ; PCM2: MOVB #'#,(R2)+ ; PC MODE 2 - IMMEDIATE CMP CURINS,#170400 ; FLOATING-POINT INSTRUCTION? BLO PCM2B ; NO, OCTAL IS DEFAULT PCM2A: MOVB #'^,(%2)+ ; YES, DEFAULT IS DECIMAL MOVB #'O,(%2)+ ; SO PREFIX VALUE WITH ^O PCM2B: CMP R1,OBJLEN BLO 5$ JSR PC,NOMORE BCS MDONE ; Trap error (EOF?) ;V1.07 5$: MOV (R1)+,OCOBUF ; GET NEXT WORD (=VALUE) JSR PC,SRCHRD ; CHECK FOR RELOCATION TST R0 BEQ 15$ ; BRANCH IF RELOCATION DONE JSR PC,OCO ; OTHERWISE - CONVERT OCTAL VALUE MOV #OCOBUF,R5 10$: MOVB (R5)+,(R2)+ ; AND OUTPUT IT SOB R0,10$ 15$: ADD #2,NXTLC ; UPDATE NEXT LC BR MDONEC ; Return cc ;V01.7 PCM3: MOVB #'@,(R2)+ ; PC MODE 3 - ABSOLUTE BR PCM2 ; PROCESS AS FOR IMMEDIATE MODE PCM6: CMP R1,OBJLEN ; PC MODE 6 - RELATIVE BLO 5$ JSR PC,NOMORE BCS MDONE ; Trap error (EOF?) ;V1.07 5$: MOV (R1)+,OCOBUF ; GET NEXT WORD (=ADDRESS) JSR PC,SRCHRD ; CHECK FOR RELOCATION ADD #2,NXTLC ; UPDATE NEXT LC ADD NXTLC,OCOBUF ; CALC ADDR = LC + 4 + REL ADDR TST R0 ; RELOCATION DONE ? BEQ 10$ JSR PC,PLANTL ; NO - PLANT LABEL 10$: MDONEC: CLC ; All OK ;V01.7 BR MDONE PCM7: MOVB #'@,(R2)+ ; PC MODE 7 - RELATIVE DEFERRED BR PCM6 ; PROCESS AS FOR RELATIVE MODE MDONE: RTS PC ; ; CHECK LOCATION COUNTER ; CHKLC:: MOV R1,-(SP) ; SAVE REGISTERS MOV R3,-(SP) MOV #OBLIN2,R1 CMP (R1)+,#4 ; RLD RECORD? BNE 100$ ; EXIT IF NOT 10$: CMP R1,OBLEN2 ; END OF RECORD? BHIS 100$ ; BRANCH IF YES 20$: MOVB (R1),R3 BIC #177600,R3 ; ISOLATE RLD TYPE CMP R3,#10 ; LC MODIFICATION ? BNE 30$ JSR PC,RLDLC ; YES - PROCESS MODIFICATION 30$: JSR PC,INCREL ; STEP ON TO NEXT RLD ENTRY BR 10$ ; AND REPEAT 100$: MOV (SP)+,R3 ; RESTORE REGISTERS MOV (SP)+,R1 RTS PC ; ; PROCESS LC MODIFICATION ; ON ENTRY: R1 POINTS TO RLD ENTRY ; RLDLC:: MOV #OCOBUF,R5 MOV 2(R1),(R5) ; SET NEW LC SUB MACLC,(R5) ; FIND THE DIFFERENCE JSR PC,MODLC ; MODIFY LC MOV PSNUM,MACPS ; RESTORE PS/LC MOV 2(R1),MACLC MOV 2(R1),NXTLC ADD #2,NXTLC RTS PC ; ; CHECK PSECT ; CHKPS:: MOV R1,-(SP) ; SAVE REGISTERS MOV R3,-(SP) MOV #OBLIN2,R1 CMP (R1)+,#4 ; RLD RECORD? BNE 100$ 10$: CMP R1,OBLEN2 ; END OF RECORD? BHIS 80$ 20$: MOVB (R1),R3 BIC #177600,R3 ; ISOLATE RLD TYPE CMP R3,#7 ; PSECT DEFINITION? BEQ 70$ 30$: JSR PC,INCREL ; INCREMENT REL POINTER BR 10$ 70$: CMP OBJLIN,#4 ; OBJLIN CONTAINS RLD RECORD BNE 75$ ; NO CMP #7,OBJLIN+2 ; PSECT DEFINITION? BNE 75$ ; NO MOV #OBJLIN+4,R1 ; YES RESET R1 JSR PC,RLDPS BR 100$ ; NOW EXIT 75$: CMPB (R1)+,(R1)+ ; POINT TO PSECT NAME JSR PC,RLDPS 80$: MOV #OBLIN2,R1 MOV #OBLEN2,R2 JSR PC,RD$OBJ ; READ A LINE BCC 90$ JMP EOM 90$: MOV #OBLIN2,R1 CMP (R1)+,#4 ; IS IT RLD? BNE 100$ CMP (R1)+,#7 ; IS IT A PSECT DEFINITION? BNE 100$ JSR PC,RLDPS ; PROCESS IT 100$: MOV (SP)+,R3 MOV (SP)+,R1 RTS PC ; ; GET INSTRUCTION ; GETINS::CMP R1,OBJLEN BLO 10$ JSR PC,CHKLC ; CHECK FOR LC MOD JSR PC,CHKPS ; CHECK FOR NEW PSECT JSR PC,NOMORE ; READ IN MORE OBJECT CODE BCS 100$ ; BRANCH IF EOM SEEN CMP LOADAD,MACLC ; LOAD ADDRESS NOT WHAT WE EXPECTED? BEQ 10$ ; BRANCH IF OK MOV LOADAD,R4 ; SAVE NEW LC MOV #OCOBUF,R5 MOV R4,(R5) ; CALCULATE AMOUNT TO UPDATE LC SUB MACLC,(R5) JSR PC,MODLC ; MODIFY LC MOV #MACPS,R2 ; SET UP PS/LC IN MACRO LINE MOV PSNUM,(R2)+ MOV R4,(R2)+ MOV R4,NXTLC ADD #2,NXTLC 10$: MOVB (R1)+,CURINS MOVB (R1)+,CURINS+1 MOV #MACLIN,R2 FTAB ; .IF DF O$$FLP MOV FLIPS,R0 ; CHECK FOR A FLIP BEQ 50$ MOV #FLIPS+2,R3 20$: CMP MACPS,(R3)+ BNE 30$ CMP MACLC,(R3) BEQ 40$ 30$: TST (R3)+ SOB R0,20$ BR 50$ 40$: INC DIFLAG ; FLIP DIFLAG BIC #177776,DIFLAG 50$: .ENDC ; DF O$$FLP ; CLC 100$: RTS PC ; ; INCREL - INCREMENT RLD POINTER ; ON ENTRY: R1 POINTS TO RLD RECORD ; R3 IS RLD TYPE ; INCREL:: CMP R3,#17 ; COMPLEX REL? BEQ 10$ MOVB INCRLD-1(R3),R3 ADD R3,R1 BR 100$ 10$: CMPB (R1)+,(R1)+ ; STEP OVER RLD TYPE AND DISP 20$: MOVB (R1)+,R3 ; STEP THROUGH RECORD CMP R3,#12 ; TERMINATOR? BEQ 100$ ; YES - EXIT BLT 20$ ; OPERATOR - NEXT BYTE CMP R3,#13 ; TERMINATOR? BEQ 100$ ; YES - EXIT NEG R3 ; FETCH TYPE COMMAND - 16-20 ADD #22,R3 ; CONVERT TO RANGE 2-4 ADD R3,R1 ; STEP ON POINTER BR 20$ ; NEXT BYTE 100$: RTS PC ; ; DEFINE MACRO TO SEARCH OP TABLE ; .MACRO SEARCH,XOPTAB MOV #XOPTAB,R3 JSR PC,SRCHOP .ENDM SEARCH ; ; INTERPRET TEXT RECORDS ; INTTXT:: MOV (R1),MACLC ; SET UP CURRENT LC MOV (R1),LOADAD MOV (R1)+,NXTLC GO: ADD #2,NXTLC JSR PC,GETINS ; GET AN INSTRUCTION BCC 1$ RTS PC ; RETURN IF EOM SEEN ; 1$: TST DIFLAG ; DATA OR INSTRUCTION? BEQ 2$ JMP DATAPS ; Try doing a .WORD x, where x may be a local or global symbol, before ;V01.5 ; assuming that this is (really) an instruction. ;V01.5 2$: MOV R2,-(SP) ; Save line pointer ;V01.5 JSR PC,DOTWRD ; Insert ".WORD " ;V01.5 JSR PC,SDATRD ; Check for relocation ;V01.5 TST R0 ; Was it? ;V01.5 BMI 4$ ; No, process instruction ;V01.7 BEQ 3$ ; Yes, 0 is word, done ;V01.7 MOV (SP),R0 ; No, 1 = byte, fetch line pointer ;V01.7 MOV #".B,(R0)+ ; Change .WORD to .B ;V01.7 MOV #"YT,(R0)+ ; YT ;V01.7 INCB (R0) ; E (was D) ;V01.7 DEC R1 ; Step back object pointer ;V01.7 DEC NXTLC ; and location counter ;V01.7 3$: TST (SP)+ ; Leave R2 updated ;V01.5 BR 8$ ; All done ;V01.5 4$: MOV (SP)+,R2 ; No, lose ".WORD " ;V01.5 MOV CURINS,R0 ; INSTRUCTION PROCESSING BIC #107777,R0 SEARCH OPTAB1 ; SEARCH TABLE 1 BCS 10$ MOV CURINS,R0 ; OPCODE FOUND JSR PC,WB ; CHECK IF WORD OR BYTE FORM 5$: MOV CURINS,R0 ; ISOLATE SOURCE OPERAND ASH #-6,R0 BIC #177700,R0 JSR PC,AMODE ; PROCESS IT 6$: BCS 8$ ; Trap error (EOF?) ;V01.7 MOVB #',,(R2)+ ; INSERT A COMMA 7$: MOV CURINS,R0 ; ISOLATE DEST OPERAND BIC #177700,R0 JSR PC,AMODE ; PROCESS IT 8$: ;V01.5 JMP OPMACR ; OUTPUT MACRO LINE ;V01.7 ; 10$: MOV CURINS,R0 BIC #7777,R0 SEARCH OPTAB2 ; SEARCH TABLE 2 BCC 5$ ; MOV CURINS,R0 BIC #777,R0 SEARCH OPTAB3 BCS 30$ MOV CURINS,R0 BIC #177700,R0 JSR PC,AMODE BCS 8$ ; Trap error (EOF?) ;V01.7 MOVB #',,(R2)+ MOV CURINS,R0 ASH #-6,R0 BIC #177770,R0 JSR PC,REG JMP OPMACR ;V01.7 ; 30$: MOV CURINS,R0 BIC #777,R0 SEARCH OPTAB4 BCS 35$ MOV CURINS,R0 ASH #-6,R0 BIC #177770,R0 JSR PC,REG BR 6$ ; 35$: MOV CURINS,R0 BIC #777,R0 SEARCH OPTAB5 BCS 40$ MOV CURINS,R0 ASH #-6,R0 BIC #177770,R0 JSR PC,REG BCS 37$ ; Trap error (EOF?) ;V1.07 MOVB #',,(R2)+ MOV CURINS,R0 BIC #177700,R0 NEG R0 JSR PC,OFFSET 37$: JMP OPMACR ;V1.07 ; 40$: MOV CURINS,R0 CLRB R0 SEARCH OPTAB6 BCS 45$ MOVB CURINS,R0 JSR PC,OFFSET JMP OPMACL ; 45$: MOV CURINS,R0 CLRB R0 SEARCH OPTAB7 BCS 50$ MOV R2,R5 ; Save line pointer ;V01.5 JSR PC,SDATRD ; Check for .GLOBL EMT/TRAP arg ;V01.5 TST R0 ; If it is, will be byte ;V01.5 BGT 49$ ; which returns R0=1 ;V01.5 MOV R5,R2 ; Else, reset line pointer ;V01.5 CLR OCOBUF MOVB CURINS,OCOBUF 46$: JSR PC,OCO MOV #OCOBUF,R5 48$: MOVB (R5)+,(R2)+ SOB R0,48$ 49$: JMP OPMACL ; 50$: MOV CURINS,R0 CLRB R0 SEARCH OPTAB8 BCS 55$ MOV CURINS,R0 BIC #177700,R0 JSR PC,AMODE BCS 53$ ; Trap error (EOF?) ;V01.7 MOVB #',,(R2)+ MOV CURINS,R0 ASH #-6,R0 BIC #177774,R0 JSR PC,REG 53$: JMP OPMACR ;V1.07 ; 55$: MOV CURINS,R0 CLRB R0 SEARCH OPTAB9 BCS 59$ MOV CURINS,R0 ASH #-6,R0 BIC #177774,R0 JSR PC,REG JMP 6$ ; 59$: MOV CURINS,R0 BIC #100077,R0 SEARCH OPTABA BCS 60$ MOV CURINS,R0 JSR PC,WB JMP 7$ ; 60$: MOV CURINS,R0 BIC #77,R0 SEARCH OPTABB BCS 65$ JMP 7$ ; 65$: MOV CURINS,R0 BIC #77,R0 SEARCH OPTABC BCS 70$ MOV CURINS,OCOBUF BIC #177700,OCOBUF BR 46$ ; 70$: MOV CURINS,R0 BIC #7,R0 SEARCH OPTABD BCS 75$ MOV CURINS,R0 BIC #177770,R0 JSR PC,REG 79$: JMP OPMACR ;V1.07 ; 75$: MOV CURINS,R0 BIC #7,R0 SEARCH OPTABE BCS 80$ MOV CURINS,OCOBUF BIC #177770,OCOBUF BR 46$ ; 80$: MOV CURINS,R0 SEARCH OPTABF BCC 79$ ; CCODES: MOV CURINS,R0 ; TRY FOR SET/CLEAR CONDITION CODES CMP R0,#240 BLE INVOP CMP R0,#300 BGE INVOP BIT #20,R0 BNE 10$ MOVB #'C,R3 MOVB #'L,R4 BR 20$ 10$: MOVB #'S,R3 MOVB #'E,R4 20$: BIC #177760,R0 BEQ INVOP ; TREAT 260 (NOP) AS INVALID CMP R0,#17 BNE 30$ MOVB R3,(R2)+ MOVB #'C,(R2)+ MOVB #'C,(R2)+ BR OPMACL 30$: MOV R1,-(SP) ; SAVE R1 CLR OCOBUF ; USE OCOBUF AS FLAG MOV #1,R1 ; BIT TO BE TESTED MOV #4,R5 ; LOOP COUNTER 40$: BIT R1,R0 BEQ 50$ CMP OCOBUF,#1 BLT 45$ BGT 44$ MOVB -(R2),-(SP) ; PUT THE INSTRUCTION ON THE STACK MOVB -(R2),-(SP) MOVB -(R2),-(SP) JSR PC,DOTWRD ;V01.5 MOVB (SP)+,(R2)+ ; NOW PUT IT BACK AGAIN MOVB (SP)+,(R2)+ MOVB (SP)+,(R2)+ 44$: MOVB #'!,(R2)+ 45$: MOVB R3,(R2)+ MOVB R4,(R2)+ MOVB CCS-1(R5),(R2)+ INC OCOBUF 50$: ASL R1 SOB R5,40$ MOV (SP)+,R1 ; RESTORE R1 BR OPMACL ; ; INVALID OPCODE - OUTPUT OCTAL VALUE AND COMMENT ; INVOP: MOV CURINS,OCOBUF JSR PC,OCO MOV #OCOBUF,R5 MOV #6,R4 SUB R0,R4 BEQ 7$ 6$: MOVB #'0,(R2)+ SOB R4,6$ 7$: MOVB (R5)+,(R2)+ SOB R0,7$ MOV #INVOPL,R3 MOV #28.,R0 10$: MOVB (R3)+,(R2)+ SOB R0,10$ ; OPMACL: JSR PC,WR$SCR ; OUTPUT MACRO LINE MOV NXTLC,MACLC ; UPDATE LC JMP GO ; GO AGAIN ; OPMACR: BCC OPMACL ; Just write out if OK ;V01.7 ; Come here if an "instruction" turns out to be incomplete -- an immediate ;V01.7 ; immediate word or offset was required, but ;V01.7 ; offset. Display as .WORD(s) instead: We must always show CURINS and, if ;V01.7 ; MACLIN contains a comma, there may have been a second word of the instruction ;V01.7 ; which was successfully decoded, so show that too. ;V01.7 MOV NXTLC,R4 ; Operand end pointer ;V01.7 SUB MACLC,R4 ; If there is a code-generating operand ;V01.7 SUB #2,R4 ; I.e. LC has advanced beyond instruction ;V01.7 BEQ 50$ ; No, no expression ;V01.7 5$: CMP R2,#MACLIN+16. ; Checked all operand files? ;V01.7 BLOS 50$ ; Yes, no operand expression ;V01.7 CMPB -(R2),#', ; No, look for comma ;V01.7 BNE 5$ ; Until found or end ;V01.7 CMPB -1(R2),#') ; Register offset stored? ;V01.7 BNE 30$ ; No ;V01.7 20$: CMPB -(R2),#'( ; Yes, look for start of offset ;V01.7 BNE 20$ ;V01.7 ; Shift text of 1st word expression (could be a real expression, with globals, ;V01.7 ; not just a value) up 6 bytes to make room for octal value of CURINS. ;V01.7 30$: MOV R2,R4 ; Save pointer to end of 1st argument ;V01.7 ADD #6,R4 ; + 6 spaces ;V01.7 INC R2 ; Allow for pre-decrement ;V01.7 40$: MOVB -(R2),6(R2) ; Copy text up ;V01.7 CMP R2,#MACLIN+16. ; Until all operand done ;V01.7 BHI 40$ ;V01.7 ; Now output .WORD CURINS. ;V01.7 50$: MOV #MACLIN+8.,R2 ; Address line buffer ;V01.7 JSR PC,DOTWRD ; Insert " .WORD " ;V01.7 MOV CURINS,OCOBUF ; Get CURINS ;V01.7 JSR PC,OCO ; as an octal word ;V01.7 MOV #OCOBUF,R1 ; Load buffer pointer ;V01.7 60$: MOVB (R1)+,(R2)+ ; Copy text ;V01.7 SOB R0,60$ ;V01.7 JSR PC,WR$SCR ; Output CURINS line ;V01.7 ADD #2,MACLC ; Update LC ;V01.7 TST R4 ; Is that all? ;V01.7 BEQ 100$ ; Yes, done ;V01.7 MOV #MACLIN+16.,R2 ; Point to required position for argument ;V01.7 MOV #MACLIN+16.+6,R3 ; and current operand start ;V01.7 CMPB (R3),#'@ ; If operand started @ ;V01.7 BNE 70$ ;V01.7 INC R3 ; Skip it ;V01.7 70$: CMPB (R3),#'# ; # (or @#) ;V01.7 BNE 90$ ;V01.7 INC R3 ; also ;V01.7 90$: MOVB (R3)+,(R2)+ ;V01.7 CMP R3,R4 ; Copy until we reach old end ;V01.7 BLO 90$ ;V01.7 JSR PC,WR$SCR ; Write macro line ;V01.7 ADD #2,MACLC ; Update LC ;V01.7 100$: JMP GO ; Try next record ;V01.7 ; DATAPS:: CMP R1,OBJLEN ; CHECK FOR ONLY ONE BYTE LEFT TO DO BHI 5$ ; BRANCH IF SO BIT #1,MACLC ; IS LC ODD? BEQ 30$ 5$: DEC R1 ; REPOSITION POINTER MOV #BYTXT,R4 MOV #8.,R0 10$: MOVB (R4)+,(R2)+ ; " .BYTE " SOB R0,10$ JSR PC,SDATRD ; CHECK FOR RELOCATION TST R0 BPL 20$ ; YES - BRANCH CLR OCOBUF MOVB CURINS,OCOBUF JSR PC,OCO ; OTHERWISE OUTPUT OCTAL NUMBER MOV #OCOBUF,R5 15$: MOVB (R5)+,(R2)+ SOB R0,15$ CMPB CURINS,#40 ; COULD IT BE ASCII? BLT 20$ CMPB CURINS,#176 BGT 20$ MOV #ASCLIN,R4 ; IF SO, OUTPUT ASCII AS COMMENT MOV #13.,R0 18$: MOVB (R4)+,(R2)+ SOB R0,18$ MOVB CURINS,(R2)+ MOVB #'/,(R2)+ 20$: DEC NXTLC ; NXTLC BR 100$ ; EXIT ; 30$: JSR PC,DOTWRD ; Assume ".WORD" ;V01.5 JSR PC,SDATRD ; CHECK FOR RELOCATION TST R0 BEQ 100$ ; WORD RELOCATED BPL 50$ ; BYTE RELOCATED INC NXTLC ; NO RELOCATION - JSR PC,SDATRD ; CHECK SECOND BYTE DEC NXTLC TST R0 BMI 38$ ; NO RELOCATION CLR OCOBUF ; 2ND BYTE RELOCATED MOVB CURINS,OCOBUF ; PUT OUT FIRST BYTE JSR PC,OCO MOV #OCOBUF,R5 MOV #MACLIN+16.,R2 36$: MOVB (R5)+,(R2)+ SOB R0,36$ BR 50$ ; NOW DO SECOND BYTE ; 38$: MOV CURINS,OCOBUF ; NO RELOCATION JSR PC,OCO ; PUT OUT WORD MOV #OCOBUF,R5 40$: MOVB (R5)+,(R2)+ SOB R0,40$ MOV CURINS,R0 CMP R0,#20040 ; TWO SPACES? BEQ 44$ ; YES - OUTPUT ASCII MOV #2,R4 ; CHECK FOR ASCII 41$: CMPB R0,#40 BLT 42$ CMPB R0,#176 BLE 43$ 42$: CLRB R0 BISB #40,R0 ; CONVERT NON-ASCII CHARS TO SPACES 43$: SWAB R0 ; TRY THE SECOND BYTE SOB R4,41$ CMP R0,#20040 ; IF SPACES BEQ 100$ ; ... THEN NOT ASCII 44$: MOV R0,-(SP) ; SAVE ASCII CHARS MOV #ASCLIN,R4 ; PUT OUT ASCII COMMENT MOV #13.,R0 45$: MOVB (R4)+,(R2)+ SOB R0,45$ MOV (SP)+,R0 ; ASCII MOVB R0,(R2)+ SWAB R0 MOVB R0,(R2)+ MOVB #'/,(R2)+ BR 100$ 50$: MOV #MACLIN+8.,R5 MOV #BYTXT,R4 ; OVERWRITE WORD WITH BYTE MOV #5,R0 55$: MOVB (R4)+,(R5)+ SOB R0,55$ MOVB #',,(R2)+ ; COMMA INC NXTLC JSR PC,SDATRD ; CHECK DEC NXTLC TST R0 BPL 100$ CLR OCOBUF MOVB CURINS+1,OCOBUF ; NO REL JSR PC,OCO MOV #OCOBUF,R5 60$: MOVB (R5)+,(R2)+ SOB R0,60$ 100$: JSR PC,WR$SCR MOV NXTLC,MACLC JMP GO ; ; ; MODLC - MODIFY LOCATION COUNTER BY OUTPUTTING ; .=.+NNNN IF NNNN IS NEGATIVE ; .BLKB NNNN IF NNNN POSITIVE ; ON ENTRY: R5 -> OCOBUF WHICH CONTAINS OFFSET ; R0 IS CORRUPTED BY THIS ROUTINE ; MODLC: MOV #MACPS,R2 ; OUTPUT LINE TST (R5) ; OFFSET NEGATIVE? BMI 45$ ; BRANCH IF YES BEQ 70$ ; DON'T BOTHER IF ZERO CMP (R2)+,(R2)+ ; POINT TO TEXT PART OF LINE FTAB MOV #".B,(R2)+ ; > 0 - USE BLKB MOV #"LK,(R2)+ MOV #"B ,(R2)+ MOV #" ,(R2)+ BR 60$ ; PUT IN VALUE 45$: MOV #-1,(R2) MOV (R2)+,(R2)+ ;V01.5 MOV #".=,(R2)+ ; < 0 TST (R5) ; USE .=.+NNNN BMI 50$ MOV #".+,(R2)+ BR 60$ 50$: MOV #".-,(R2)+ NEG (R5) 60$: JSR PC,OCO ; CONVERT TO ASCII 65$: MOVB (R5)+,(R2)+ ; MOVE INTO LINE SOB R0,65$ JSR PC,WR$SCR ; OUTPUT LINE 70$: RTS PC ; ; NOMORE - TXT LINE EXHAUSTED - GET SOME MORE ; NOMORE:: MOV R2,-(SP) ; SAVE R2 MOV #OBJLIN,R1 MOV #OBLIN2,R2 CMP (R2),#3 BNE 10$ MOV #101,R0 ; LINE 2 IS TXT 5$: MOV (R2)+,(R1)+ ; MOV LINE 2 INTO LINE 1 SOB R0,5$ SUB #202,-(R1) BR 100$ ; GO TO GET NEW LINE 2 ; 10$: CMP (R2),#6 ; LINE 2 = EOM? BEQ 200$ ; IF SO - FINISHED CMP (R2)+,#4 ; Line 2 = relocation record? ;V01.7 BNE 200$ ; (Should be, but make sure) ;V01.7 CMP (R2),#7 ; Yes, was it really relocation info? ;V01.7 BLO 20$ ; Replace it if so ;V01.7 CMP (R2),#11 ; But types 7, 10, and 11 are LC changes ;V01.7 BLOS 200$ ; They should be handled as such ;V01.7 20$: MOV #OBJLIN,R1 ; READ NEW LINE 1 MOV #OBJLEN,R2 ; JSR PC,RD$OBJ BCS 200$ MOV #OBJLIN,R1 CMP (R1),#3 ; IS IT TXT? BEQ 100$ CMP (R1),#6 ; IS IT EOM? BEQ 200$ CMP (R1),#4 ; IS IT RLD? BNE 20$ ; NO - READ ANOTHER RECORD TST (R1)+ ; POINT TO FIRST RLD ENTRY 30$: CMP R1,OBJLEN ; FINISHED PROCESSING? BHIS 20$ MOVB (R1),R3 ; GET RLD TYPE BIC #177600,R3 CMP R3,#7 ; LC DEFINITION? BNE 40$ MOV R1,-(SP) CMPB (R1)+,(R1)+ ; YES - POINT TO PSECT NAME JSR PC,RLDPS ; PROCESS LC DEFINITION MOV (SP)+,R1 BR 50$ 40$: CMP R3,#10 ; LC MODIFICATION? BNE 50$ ; NO OTHER TYPE ALLOWED JSR PC,RLDLC ; PROCESS LC MODIFICATION 50$: JSR PC,INCREL ; STEP TO NEXT RLD ENTRY BR 30$ ; AND REPEAT 100$: MOV #OBLIN2,R1 MOV #OBLEN2,R2 JSR PC,RD$OBJ BCS 200$ MOV #OBJLIN+2,R1 MOV (R1)+,LOADAD CLC BR 300$ 200$: SEC ; EOM SEEN 300$: MOV (SP)+,R2 ; RESTORE R2 RTS PC ; ; OFFSET::ASL R0 ; R0 CON ADD #2,R0 ADD MACLC,R0 MOV R0,OCOBUF PLANTL: CMP LABELS,#LABMAX BGE 20$ INC LABELS MOV LABELS,R0 ASH #2,R0 MOV MACPS,LABELS-2(R0) MOV OCOBUF,LABELS(R0) ; SET LABEL TST OCOBUF BNE 40$ INC OCOBUF ; 0$ NOT VALID - CALL IT 1$ 40$: JSR PC,OCO MOV #OCOBUF,R5 10$: MOVB (R5)+,(R2)+ SOB R0,10$ MOVB #'$,(R2)+ RTS PC ; 20$: BIT #OV$LAB,$OVSTS ; LABEL BNE 30$ MOV #ERR16,MESNO ; TELL USER JSR PC,MOCALL BIS #OV$LAB,$OVSTS 30$: CLR OCOBUF BR 40$ ; ; ; PROCESS PSECT DEFINITION ; ON ENTRY: (R1),2(R1) = PSECT NAME (RAD50) ; 4(R1) = LOCATION COUNTER ; RLDPS:: MOV R3,-(SP) ; SAVE R3 MOV #PSECTS,R4 MOV (R4)+,R3 MOV PSNUM,R0 ; GET PSECT NO. BEQ 5$ ; BRANCH IF FIRST TIME THROUGH ASL R0 MOV MACLC,PSECLC-2(R0); SAVE CURRENT MACLC FOR PSECT MOV MACLC,OLDLC ; SAVE IN OLDLC TOO MOV PSNUM,R0 ; SAVE CURRENT PSECT NO. CLR PSNUM 5$: INC PSNUM CMP (R1),(R4)+ BNE 10$ CMP 2(R1),(R4) BEQ 20$ 10$: ADD #6,R4 SOB R3,5$ 20$: CMP PSNUM,R0 ; SAME PSECT AS BEFORE? BNE 21$ JMP 50$ ; CHECK LC 21$: TST (R4)+ ; Point to flags word ;V01.7 MOV #MACPS,R2 ;V01.7 MOV #-1,(R2) ;V01.7 MOV (R2)+,(R2)+ ;V01.7 JSR PC,WR$SCR ; OUTPUT BLANK LINE MOV #MACLIN,R2 TST LSB ; IN LSB? BEQ 25$ ; BRANCH IF NOT MOV #DSLSB,R3 MOV #11.,R5 22$: MOVB (R3)+,(R2)+ SOB R5,22$ JSR PC,WR$SCR CLR LSB 25$: MOV #MACLIN,R2 ; OUTPUT SEMICOLON MOVB #';,(R2)+ JSR PC,WR$SCR ; PUT OUT SEMICOLON JSR PC,DOPSCT ; Set up PSECT header ;V01.7 BCC 38$ ; Branch if met this PSECT before ;V01.7 CLR OLDLC ; PREVIOUS OFFSET = 0 BR 40$ 38$: MOV PSNUM,R0 ; NOT A NEW PSECT - ASL R0 MOV PSECLC-2(R0),OLDLC ; SET OLD LC 40$: JSR PC,WR$SCR TSTB (R4) ; Check bit 7 ;V01.7 BPL 45$ ; (D/I flag) ;V01.7 MOV #1,DIFLAG BR 50$ 45$: CLR DIFLAG MOV #1,LSB ; SET UP A LSB MOV #MACLIN,R2 MOVB #';,(R2)+ JSR PC,WR$SCR MOV #MACLIN,R2 MOV #ENLSB,R3 MOV #11.,R5 46$: MOVB (R3)+,(R2)+ SOB R5,46$ JSR PC,WR$SCR 50$: MOV PSNUM,MACPS CMP (R1)+,(R1)+ MOV (R1),MACLC MOV (R1),NXTLC CMP OLDLC,MACLC ; DOES LC NEED MODIFICATION? BEQ 60$ ; BRANCH IF NO MOV #OCOBUF,R5 MOV MACLC,(R5) ; CALCULATE AMOUNT TO UPDATE LC SUB OLDLC,(R5) MOV OLDLC,MACLC ; SET OLD LC JSR PC,MODLC ; AND MODIFY IT MOV #MACPS,R2 ; SET PS/LC IN MACRO LINE MOV PSNUM,(R2)+ MOV NXTLC,(R2)+ 60$: ADD #2,NXTLC ; UPDATE NEXT LC MOV (SP)+,R3 ; RESTORE R3 RTS PC ; ; Fill in PSECT header for above, and ORCP3. ;V01.7 ; On entry, R1,2(R1) = name (Radix-50) ;V01.7 ; (R4) is flags word ;V01.7 ; R2 addresses line to fill in ;V01.7 ; On exit, R2 is updated ;V01.7 ; carry is set if first time around, else clear ;V01.7 DOPSCT:: ;V01.7 MOV #MACLIN,R2 FTAB MOV #".P,(R2)+ MOV #"SE,(R2)+ MOV #"CT,(R2)+ CMP PSNUM,ASNUM ; .ASECT? ;V01.7 BNE 26$ ; No ;V01.7 MOVB #'A,-5(R2) ; Yes, change to .ASECT, because ;V01.7 BR 37$ ; .PSECT . ABS.,... won't assemble correctly ;V01.7 26$: MOV #" ,(R2)+ MOV R1,-(SP) MOV R2,R0 JSR PC,R50ASC ; CONVERT NAME TO ASCII MOV R0,R2 ; UPDATE MACRO LINE POINTER MOV (SP)+,R1 ; RESTORE OBJECT LINE POINTER TSTB 1(R4) BEQ 38$ MOV #",R,(R2)+ ; RW OR RO BIT #20,(R4) BNE 30$ MOV #"W,,(R2)+ BR 31$ 30$: MOV #"O,,(R2)+ 31$: BIT #200,(R4) ; I OR D BNE 32$ MOV #"I,,(R2)+ BR 33$ 32$: MOV #"D,,(R2)+ 33$: BIT #100,(R4) ; LCL OR GBL BNE 34$ MOV #"LC,(R2)+ BR 35$ 34$: MOV #"GB,(R2)+ 35$: MOV #"L,,(R2)+ BIT #40,(R4) ; ABS OR REL BNE 36$ MOV #"AB,(R2)+ MOV #"S,,(R2)+ BR 361$ 36$: MOV #"RE,(R2)+ MOV #"L,,(R2)+ 361$: BIT #4,(R4) ; CON OR OVR BNE 362$ MOV #"CO,(R2)+ MOVB #'N,(R2)+ BR 37$ 362$: MOV #"OV,(R2)+ MOVB #'R,(R2)+ 37$: CLRB 1(R4) SEC ;V01.7 38$: RTS PC ;V01.7 ; ; SDATRD:: MOV R1,-(SP) MOV R3,-(SP) MOV NXTLC,R0 SUB LOADAD,R0 ADD #2,R0 ; CALCUL MOV #OBLIN2,R1 CMP (R1)+,#4 BNE 90$ 10$: CMP R1,OBLEN2 BHIS 90$ 20$: MOVB (R1),R3 CMPB 1(R1),R0 BEQ 40$ BIC #177600,R3 JSR PC,INCREL BR 10$ 40$: CMPB (R1)+,(R1)+ CLR R0 ; ANSWER 0 FOR WORD TST R3 BPL 45$ ; WORD RELOCATABLE INC R0 ; BYTE RELOCATABLE = 1 45$: MOV R0,-(SP) ; SAVE ANSWER BIC #177600,R3 ASL R3 JSR PC,@RLDTYP-2(R3) MOV (SP)+,R0 ; RESTORE ANSWER BR 100$ 90$: MOV #-1,R0 ; NO RELOCATION = -1 100$: MOV (SP)+,R3 ; RESTORE REGISTERS MOV (SP)+,R1 RTS PC ; ; SRCHOP - SEARCH OP TABLE FOR OPCODE ; ON ENTRY: R0 = OPCODE ; R2 -> OUTPUT LINE ; R3 -> OP TABLE ; ON EXIT: CC IF OP FOUND (INSERTED IN LINE) ; CS IF NOT FOUND ; SRCHOP::MOV (R3)+,R4 ; GET NO OF CODES IN TABLE 10$: CMP (R3)+,R0 ; COMPARE CODES BEQ 20$ ADD #6.,R3 SOB R4,10$ SEC ; CODE NOT FOUND BR 30$ 20$: MOV (R3)+,(R2)+ ; MOVE MNEMONIC INTO LINE MOV (R3)+,(R2)+ MOV (R3)+,(R2)+ MOV #" ,(R2)+ ; NEXT TAB POSITION CLC ; SHOW CODE FOUND 30$: RTS PC ; ; SRCHRD - SEARCH RLD RECORD FOR REFERENCES TO CURRENT TXT WORD ; ON EXIT: R0 = 0 IF RELOCATION DONE ; = 1 IF NO RELOCATION ; SRCHRD:: MOV R1,-(SP) ; SAVE R1 AND R3 MOV R3,-(SP) MOV NXTLC,R0 SUB LOADAD,R0 ; GET DISPLACEMENT OF CURRENT WORD ADD #4,R0 MOV #OBLIN2,R1 ; CHECK WHETHER RLD RECORD EXISTS CMP (R1)+,#4 BNE 100$ ; BRANCH IF NO 10$: CMP R1,OBLEN2 ; END OF RECORD? BHIS 100$ 20$: MOVB (R1),R3 BIC #177600,R3 ; GET RLD ENTRY DISPLACEMENT CMPB 1(R1),R0 ; DISP SAME? BNE 30$ ; BRANCH IF NO CMPB (R1)+,(R1)+ ; NOTE: R1 MAY BE ODD ASL R3 JSR PC,@RLDTYP-2(R3) ; PROCESS RLD ENTRY BR 110$ 30$: JSR PC,INCREL ; INCREMENT REL POINTER BR 10$ ; 100$: MOV #1,R0 ; RETURN - NO RELOCATION BR 120$ 110$: CLR R0 ; RETURN - RELOCATION DONE 120$: MOV (SP)+,R3 ; RESTORE REGISTERS MOV (SP)+,R1 RTS PC ; ; SWITCH LIST FOR RLD TYPES ; .PSECT ORCDAT,D RLDTYP: .WORD RLD1,RLD2,RLD3,RLD4,RLD5,RLD6,RLD7,RLD10 .WORD RLD11,RLD12,RLD13,RLD14,RLD15,RLD16,RLD17 ; .PSECT ; RLD1: MOVB (R1),OCOBUF ; TYPE 1 - INTERNAL RELOCATION ;V01.5 MOVB 1(R1),OCOBUF+1 ;V01.5 TST DIFLAG ; DATA OR INSTRUCTION? BEQ 10$ MOV PSNUM,R0 ; FOR DATA - GO TO PLANT LABEL BR RLDX 10$: JSR PC,PLANTL ; FOR INST - PLANT LOCAL SYMBOL RTS PC RLD2: RLD4: MOV R1,-(SP) MOV R2,R0 JSR PC,R50ASC ; CONVERT NAME TO ASCII MOV R0,R2 MOV (SP)+,R1 10$: CMPB -(R2),#40 ; SQUEEZE OUT THE SPACES BEQ 10$ TSTB (R2)+ RTS PC RLD3: ; MOVB (R1),OCOBUF ;V01.5 MOVB 1(R1),OCOBUF+1 ;V01.5 JSR PC,OCO MOV #OCOBUF,R5 10$: MOVB (R5)+,(R2)+ SOB R0,10$ RTS PC RLD7: ; PSECT DEFINITION - DONE ELSEWHERE RLD10: ; LC MOD - DONE ELSEWHERE RLD11: ; PROGRAM LIMITS - IGNORED RLD13: ; RLD TYPE 13 - UNUSED RTS PC .ENABL LSB RLD5: RLD6: JSR PC,RLD4 ; GET GL ADD #4,R1 ; POINT ;V01.5 MOVB (R1),OCOBUF ;V01.5 MOVB 1(R1),OCOBUF+1 ;V01.5 TST OCOBUF ;V01.6 BEQ 30$ BLT RLDM MOVB #'+,(R2)+ BR 20$ RLDM: MOVB #'-,(R2)+ NEG OCOBUF 20$: JSR PC,OCO MOV #OCOBUF,R5 25$: MOVB (R5)+,(R2)+ SOB R0,25$ 30$: RTS PC .DSABL LSB RLD12: RLD14: CLR OCOBUF ; OFFSET = 0 BR RLDP ; REST IS LIKE TYPES 15/16 RTS PC RLD15: RLD16: MOVB 4(R1),OCOBUF ; OFFSET ;V01.5 MOVB 5(R1),OCOBUF+1 ;V01.5 RLDP: MOV R1,R0 JSR PC,GETPS ; GET IT RLDX: MOV OCOBUF,R3 BPL 5$ CLR OCOBUF 5$: BIC #1,OCOBUF ; MAKE SURE ADDRESS IS EVEN JSR PC,PLLL ; PLANT A LOCAL SYMBOL ADD #100,R0 ; CONVERT PSECT TO A LETTER MOVB R0,(R2)+ ; INSERT IN LINE BIS #100000,OCOBUF ; ENSURE 6 CHARACTERS JSR PC,OCO MOV #OCOBUF+1,R5 DEC R0 10$: MOVB (R5)+,(R2)+ SOB R0,10$ MOV R3,OCOBUF BMI RLDM BIT #1,R3 ; WAS IT AN ODD ADDRESS ? BEQ 20$ MOVB #'+,(R2)+ ; NEED "+1" MOVB #'1,(R2)+ 20$: RTS PC .ENABL LSB RLD17: MOV R4,-(SP) ; SAVE R4 MOV #CXSTK1,R4 ; POINT TO COMPLEX STACK 1 10$: MOVB (R1)+,R0 ; GET OPERATOR ASL R0 JMP @CXOP(R0) ; PROCESS IT CX0: BR 10$ ; NO OP CX1: CLR (R4)+ ; 0 = OPERATOR MOV #'+,(R4)+ ; NAME OF OPERATOR 20$: MOV #2,(R4)+ ; NO. OF OPERANDS BR 10$ CX2: CLR (R4)+ ; SUBTRACT MOV #'-,(R4)+ BR 20$ CX3: CLR (R4)+ ; MULTIPLY MOV #'*,(R4)+ BR 20$ CX4: CLR (R4)+ ; DIVIDE MOV #'/,(R4)+ BR 20$ CX5: CLR (R4)+ ; LOGICAL AND MOV #'&,(R4)+ BR 20$ CX6: CLR (R4)+ ; LOGICAL OR MOV #'!,(R4)+ BR 20$ CX10: CLR (R4)+ ; NEGATE MOV #'-,(R4)+ 30$: MOV #1,(R4)+ ; NO. OF OPERANDS BR 10$ CX11: CLR (R4)+ ; COMPLEMENT MOV #"^C,(R4)+ BR 30$ CX12: CX13: BR 100$ ; COMMAND TERMINATORS CX16: MOV #CXNAME,R0 JSR PC,R50ASC ; CONVERT RAD50 NAME MOV #CXNAME,R0 ; PUT ON TO STACK 1 MOV (R0)+,(R4)+ MOV (R0)+,(R4)+ MOV (R0)+,(R4)+ BR 10$ CX17: MOVB (R1)+,R0 ; GET PSECT NO. INC R0 MOVB (R1)+,OCOBUF ; GET OFFSET MOVB (R1)+,OCOBUF+1 JSR PC,PLLL ; PLANT LOCAL SYMBOL ADD #100,R0 ; CONVERT PSECT TO A LETTER MOVB R0,(R4)+ ; INSERT IN LINE BIS #100000,OCOBUF ; ENSURE 6 CHARACTERS JSR PC,OCO MOV #OCOBUF+1,R5 DEC R0 50$: MOVB (R5)+,(R4)+ SOB R0,50$ BR 10$ CX20: MOVB (R1)+,OCOBUF MOVB (R1)+,OCOBUF+1 JSR PC,OCO MOV #6,R3 MOV #OCOBUF,R5 60$: MOVB (R5)+,(R4)+ DEC R3 SOB R0,60$ TST R3 BEQ 10$ 70$: MOVB #40,(R4)+ ; PAD OUT WITH SPACES SOB R3,70$ BR 10$ 100$: MOV #1,-(SP) ; ONE OPERATOR TO REVERSE MOV #CXSTK2,R5 ; COMPLEX STACK 2 JSR PC,REVSTK ; REVERSE THE STACK TST (SP)+ ; LOSE PARAMETER JSR PC,PRTITM ; PRINT THE COMPLEX ITEM MOV (SP)+,R4 ; RESTORE R4 RTS PC .DSABL LSB ; .PSECT ORCDAT,D CXOP: .WORD CX0,CX1,CX2,CX3,CX4,CX5,CX6,CX0 .WORD CX10,CX11,CX12,CX13,CX0,CX0,CX16,CX17,CX20 CXSTK1: .BLKB 20.*6 CXSTK2: .BLKB 20.*6 CXNAME: .BLKB 6 ; .PSECT ; ; REVSTK - COPY STACK 1 TO STACK 2, CONVERTING FROM REVERSE POLISH ; TO FORWARD POLISH. ; R4 -> STACK 1, R5 -> STACK 2 ; REVSTK: MOV -(R4),-(SP) ; GET AN ITEM OFF STACK 1 MOV -(R4),-(SP) MOV -(R4),-(SP) BNE 10$ ; BRANCH IF ITS AN OPERAND MOV 4(SP),-(SP) ; OPERATOR - GET NO. OF OPERANDS JSR PC,REVSTK ; COPY THE OPERANDS FIRST TST (SP)+ 10$: MOV (SP)+,(R5)+ ; NOW COPY THE ITEM MOV (SP)+,(R5)+ MOV (SP)+,(R5)+ DEC 2(SP) ; DEC ITEM COUNT BGT REVSTK ; DO NEXT ITEM RTS PC ; ; PRTITM - PRINT THE ITEM ON COMPLEX STACK 2 ; R5 -> STACK 2, R2-> OUTPUT LINE ; PRTITM: MOV -(R5),-(SP) ; GET ITEM OFF STACK 2 MOV -(R5),-(SP) MOV -(R5),-(SP) BEQ 100$ ; BRANCH IF ITS AN OPERATOR MOV #6,R0 ; OPERAND - OUTPUT IT MOV SP,R4 10$: MOVB (R4)+,(R2)+ SOB R0,10$ 20$: CMPB -(R2),#40 ; SQUEEZE OUT THE SPACES BEQ 20$ TSTB (R2)+ ADD #6,SP BR 900$ ; FINISH 100$: CMP 4(SP),#2 ; OPERATOR - HOW MANY OPERANDS? BNE 200$ MOVB #'<,(R2)+ ; 2 OPERANDS JSR PC,PRTITM ; OUTPUT FIRST OPERAND TST (SP)+ MOVB (SP)+,(R2)+ ; OUTPUT THE OPERATOR TST (SP)+ JSR PC,PRTITM ; OUTPUT SECOND OPERAND MOVB #'>,(R2)+ BR 900$ ; FINISH 200$: TST (SP)+ ; 1 OPERAND MOVB (SP),(R2)+ ; OUTPUT OPERATOR TSTB 1(SP) BEQ 210$ MOVB 1(SP),(R2)+ 210$: CMP (SP)+,(SP)+ JSR PC,PRTITM ; OUTPUT OPERAND 900$: RTS PC ; ; GET THE PSECT NUMBER ; ON ENTRY: R0 -> PSECT NAME (may start at odd address) ;V01.5 ; ON EXIT: R0 = PSECT NUMBER ; GETPS:: MOV R1,-(SP) ; SAVE R MOV R2,-(SP) MOV #PSECTS,R2 MOV (R2)+,R1 10$: CMPB (R0),(R2)+ ;V01.5 BNE 20$ CMPB 1(R0),(R2) ;V01.5 BNE 20$ ;V01.5 CMPB 2(R0),1(R2) ;V01.5 BNE 20$ ;V01.5 CMPB 3(R0),2(R2) ;V01.5 BEQ 40$ 20$: ADD #7,R2 ;V01.5 SOB R1,10$ 40$: MOV PSECTS,R0 INC R0 SUB R1,R0 MOV (SP)+,R2 MOV (SP)+,R1 RTS PC ; ; PLANT A LOCAL SYMBOL ; ON ENTRY: R0 = PSECT NUMBER, OCOBUF = LOCATION COUNTER ; PLLL:: MOV R1,-(SP) CMP LLLABS,#LLLMAX BGE 10$ INC LLLABS MOV LLLABS,R1 ASH #2,R1 MOV R0,LLLABS-2(R1) MOV OCOBUF,LLLABS(R1) BR 20$ ; 10$: BIT #OV$LLL,$OVSTS ; LLLAB BNE 20$ MOV #ERR17,MESNO ; TELL USER JSR PC,MOCALL BIS #OV$LLL,$OVSTS 20$: MOV (SP)+,R1 RTS PC ; ; WORD OR BYTE CHECK ; IF TOP BIT OF INSTRUCTION (R0) IS SET - APPEND "B" TO OPCODE ; WB:: TST R0 BPL 10$ MOVB #'B,-5(R2) 10$: RTS PC ; ; Insert ".WORD " where R2 points. ;V01.5 DOTWRD: MOV R0,-(SP) ; Save regs ;V01.5 MOV R4,-(SP) ;V01.5 MOV #WOTXT,R4 ;V01.5 MOV #8.,R0 ;V01.5 35$: MOVB (R4)+,(R2)+ ;V01.5 SOB R0,35$ ;V01.5 MOV (SP)+,R4 ;V01.5 MOV (SP)+,R0 ;V01.5 RTS PC ;V01.5 .END