thomasw@vlsi1.CS.Concordia.CA (Thomas Wieland 1728423) (10/18/89)
#! /bin/sh # This is a shell archive, meaning: # 1. Remove everything above the #! /bin/sh line. # 2. Save the resulting text in a file. # 3. Execute the file with /bin/sh (not csh) to create: # mon68.csub.s # mon68.exce.s # mon68.dasm.s # mon68.spec.s # mon68.io.s # This archive created: Tue Oct 17 19:47:34 1989 export PATH; PATH=/bin:/usr/bin:$PATH echo shar: "extracting 'mon68.csub.s'" '(11276 characters)' if test -f 'mon68.csub.s' then echo shar: "will not over-write existing file 'mon68.csub.s'" else cat << \SHAR_EOF > 'mon68.csub.s' **************************** * * * MON68K * * * * A 68000 Monitor Program * * * * VERSION 2.2 15-JUL-84 * * * **************************** * * * mon68.csub.s: aux. subroutines used by monitor command subroutines * * * Source code donated to the public domain, 17 Oct 1989 * * You may use this code in any way you see fit, including * incorporating some or all of it into a project of your own, * commercial or otherwise. I would appreciate receiving some * credit if you decide to use some of my code, but as this is * quite unenforceable it remains a wish, not a condition. * * Naturally, I can make no guarantees as to the code's correctness * or suitability for any purpose, although I would hope that it is * both reasonably correct and suitable for something, and I know * that it works on my equipment. * * If you wish to contact me, you can write to me at the address * below or send me e-mail (until April 90) at: * * thomasw@jupiter.cs.concordia.ca * or: thomasw@concour.cs.concordia.ca * * Written by: Thomas Wieland * 4615 Walkley #21 * Montreal, PQ * H4B 2K7 * Canada * * * * * GET ADDRESS AND SIZE FROM INPUT LINE * GETADRS BSR GETNUM ;RESULT IN D1.L BTST #NUMFND,D7 BEQ GETADRS2 ;NO ADR GIVEN MOVEQ #2,D2 ;DEFAULT SIZE = WORD JSR GETCHRNS ;GET SIZE BVS GETADRS2 CMPI.B #'.',D0 BNE.L GETNEND ;NO SIZE GIVEN JSR GETCHRNS ;GET SIZE CHAR. BVS GETADRS2 ;SIZE MUST FOLLOW '.' CMPI.B #'B',D0 BNE GETADRS1 MOVEQ #1,D2 ;SIZE = BYTE BRA GETADRS2 GETADRS1 CMPI.B #'L',D0 BNE GETADRS2 ;ANY OTHER => WORD MOVEQ #4,D2 ;SIZE = LONG GETADRS2 RTS * * PARSE 32-BIT NUMBER FROM INPUT LINE * GETNUM MOVEQ #0,D0 ;CLEAR INPUT REG. MOVEQ #0,D1 ;CLEAR RESULT REG. BCLR #NUMFND,D7 ;NO NUMBER FOUND YET BTST #DELIM,D7 BEQ GETNUM1 BTST #ASCLST,D7 BNE.L ASCCON1 ;INSIDE ASCII LIST GETNUM1 JSR GETCHRNS ;SKIP LEADING BLANKS BVS COMPADR1 ;EXIT CMPI.B #SQT,D0 ;LOW ASCII CONST ? BEQ.L LASCCON CMPI.B #DQT,D0 ;HIGH ASCII CONST ? BEQ.L HASCCON CMPI.B #'%',D0 BEQ BINNUM ;BINARY NUMBER CMPI.B #'#',D0 BEQ DECNUM ;DECIMAL NUMBER CMPI.B #'$',D0 ;OPTIONAL PREFIX FOR HEX BNE HEXNUM0 ;NUMBER MUST BE HEX NOW * ASCII -> HEX HEXNUM BSR COMPADR MOVE.B (A5)+,D0 ;GET CHAR. HEXNUM0 CMPI.B #'0',D0 BCS HEXEND ;CHAR.<'0', MAY BE BLANK CMPI.B #'9',D0 BLS HEXNUM1 ;'0'<=CHAR.<='9' CMPI.B #'A',D0 BCS GETNEND ;CHAR.<'A' CMPI.B #'F',D0 BHI GETNEND ;CHAR.>'F' SUBQ #7,D0 ;ADJUST FOR HEX HEXNUM1 ANDI.B #$0F,D0 ;MASK OFF UPPER NIBBLE ASL.L #4,D1 ;SHIFT RESULT UP ONE NIBBLE OR.B D0,D1 ;ADD DIGIT TO RESULT BSET #NUMFND,D7 ;SIGNAL NUMBER FOUND BRA HEXNUM HEXEND JSR SPCTST ;IS THERE A BLANK ? BEQ HEXNUM ;IGNORE BLANKS * GETNEND SUBQ #1,A5 RTS * COMPADR CMPA A5,A6 ;BUFFER EMPTY ? ANDI #$FD,CCR ;CLEAR V BHI COMPADR1 ;RETURN TO CALLER ORI #$02,CCR ;SET V, SIGNAL BUFFER EMPTY ADDQ #4,SP ;DROP RETURN ADDRESS COMPADR1 RTS * ASCII -> DEC DECNUM BSR COMPADR MOVE.B (A5)+,D0 ;GET CHAR. CMPI.B #'0',D0 BCS DECEND ;CHAR.<'0', MAY BE BLANK CMPI.B #'9',D0 BHI GETNEND ;CHAR>'9' ANDI.B #$0F,D0 ;MASK OFF UPPER NIBBLE MOVE.L D1,D2 ;COPY RESULT ADD.L D1,D1 ;DOUBLE D1 ASL.L #3,D2 ;8*RESULT ADD.L D2,D1 ;RESULT:=RESULT*10 ADD.L D0,D1 ;ADD NEXT DECIMAL BSET #NUMFND,D7 ;SIGNAL NUMBER FOUND BRA DECNUM DECEND JSR SPCTST BEQ DECNUM BRA GETNEND * ASCII -> BIN BINNUM BSR COMPADR MOVE.B (A5)+,D0 ;GET CHAR. CMPI.B #'0',D0 BCS BINEND ;CHAR.<'0', MAY BE BLANK CMPI.B #'1',D0 BHI GETNEND ;CHAR.>'1' ADD.L D1,D1 ;SHIFT LEFT CMPI.B #'0',D0 BEQ BINNUM ;ALL DONE ADDQ #1,D1 ;ADD ONE TO RESULT BSET #NUMFND,D7 ;SIGNAL NUMBER FOUND BRA BINNUM BINEND JSR SPCTST BEQ BINNUM BRA GETNEND * ASCII -> CONSTANT LASCCON BCLR #ASCTYP,D7 ;LOW ASCII BRA ASCCON HASCCON BSET #ASCTYP,D7 ;HIGH ASCII ASCCON BTST #DELIM,D7 BEQ ASCCON1 BSET #ASCLST,D7 ;FROM NOW ON INSIDE LIST ASCCON1 BSR COMPADR MOVE.B (A5)+,D0 ;GET CHAR. CMPI.B #SQT,D0 ;SINGLE QUOTE ? BEQ ASCCON2 CMPI.B #DQT,D0 ;DOUBLE QUOTE ? BNE ASCCON3 ;NO QUOTE ASCCON2 BTST #DELIM,D7 BEQ ASCEND ;CLOSING QUOTE BCLR #ASCLST,D7 ;END OF LIST BRA GETNUM1 ;WE STILL NEED A BYTE ASCCON3 BSET #NUMFND,D7 BTST #ASCTYP,D7 BEQ ASCCON4 ORI.B #$80,D0 ;CONVERT TO HIGH ASCII ASCCON4 ASL.L #8,D1 ;MOVE UP ONE CHAR. MOVE.B D0,D1 BTST #DELIM,D7 BEQ ASCCON1 RTS ;DELIM=1 => RETURN ONLY ONE CHAR. ASCEND MOVE.B (A5)+,D0 ;GET CHAR. AFTER QUOTE BRA GETNEND * SPCTST BTST #DELIM,D7 BNE SPCTST1 ;SPACE IS DELIMITER CMPI.B #SPC,D0 SPCTST1 RTS ;Z=1 IF END OF NUMBER * * TEST & GET START ADR (PC) * SADRPC BTST #SADR,D7 BEQ SADRPC1 ;GET DEFAULT SADR MOVE.L A1,D0 ;GET SADR MOVE.L D0,PCADR ;UPDATE PC BRA SADRPC2 SADRPC1 MOVE.L PCADR,D0 ;GET NEXT PC SADRPC2 BCLR #0,D0 ;SADR MUST BE EVEN MOVEA.L D0,A1 ;SET SADR RTS * * TEST & GET START ADR (MEMORY) * SADRNXT BTST #SADR,D7 BNE SADRNXT1 ;STARTADR. GIVEN MOVEA.L NXTADR,A1 ;GET NEXT MEMORY ADR SADRNXT1 RTS * * GET START- & END ADR (TOP OF COMMANDS) AND BYTELIST * EADRLST BSR SADRNXT ;GET START ADDRESS BTST #EADR,D7 BNE EADRLST1 MOVEA.L CMDHIGH,A2 ;GET DEFAULT ENDADDRESS EADRLST1 ADDQ #1,A5 ;UPDATE TXTPTR BSR GETLIST ;GET BYTELIST TST.B D2 BNE EADRLST2 ADDQ #4,SP ;EMPTY LIST, RETURN TO COMPROC EADRLST2 RTS * * TEST & GET END ADR OR COUNT * EADRCNT ADDQ #1,A5 BTST #EADR,D7 BNE EADRCNT2 ;ENDADR GIVEN JSR GETNUM MOVEA.L A1,A2 ;EDR=SADR BTST #NUMFND,D7 ;COUNT GIVEN ? BNE EADRCNT1 ;YES MOVEQ #8,D1 ;DEFAULT: SHOW 8 BYTES EADRCNT1 SUBQ.L #1,D1 ;ADJUST COUNT ADDA.L D1,A2 ;EADR=SADR+CNT EADRCNT2 RTS * * TEST FOR START- & END ADR, GET DESTINATION ADR * DESTADR BTST #SADR,D7 BEQ DESTADR1 ;NO STARTADR BTST #EADR,D7 BEQ DESTADR1 ;NO ENDADR ADDQ #1,A5 JSR GETNUM BTST #NUMFND,D7 BEQ DESTADR1 ;NO DESTADR MOVE.L D1,A3 ;DESTADR RTS DESTADR1 ADDQ #4,SP ;DROP RETURN TO CALLER BRA ERROR2 ;RETURNS TO CMDPROC * * GET BYTELIST & SAVE IN LSTBUFFER * GETLIST MOVE #LSTBUF,D3 ;BYTELIST MOVE #BITBUF,D4 ;BITLIST, SIGNALS WILDCARDS MOVEA D3,A3 MOVEQ #0,D0 MOVEQ #32-1,D1 MOVEA D4,A0 GETLIST1 MOVE.B D0,(A0)+ ;CLEAR BITBUFFER DBF D1,GETLIST1 BSET #DELIM,D7 ;BLANKS ARE DELIMITERS BCLR #ASCLST,D7 ;NOT IN ASCII LIST AT START GETLIST2 JSR GETNUM ;RESULT IN D1.L BTST #NUMFND,D7 BNE GETLIST3 ;ADD BYTE TO BUFFER BVS GETLIST4 ;END OF INPUT CMPI.B #'*',D0 BNE GETLIST4 ;NOT WILDCARD MOVE A3,D0 ;POSITION IN LISTBUFFER BSR TSTWCD0 ;CALCULATE BIT & BYTE OFFSETS BSET D0,$0(A0,D4) ;SIGNAL WILDCARD ADDQ #1,A5 ;ADVANCE TO NEXT ITEM GETLIST3 MOVE.B D1,(A3)+ ;ADD BYTE TO LSTBUF BRA GETLIST2 ;NEXT BYTE GETLIST4 MOVEA A3,A4 ;SET POINTER TO END MOVE A3,D2 MOVEA D3,A3 ;RESET POINTER TO START SUB D3,D2 ;NUMBER OF BYTES IN LIST BCLR #DELIM,D7 ;BACK TO NORMAL RTS * * TEST IF CURRENT BYTE IN BYTELIST IS A WILDCARD * TSTWCD MOVE A3,D0 ;CALCULATE BYTE & BIT NO. IN BITBUF SUBQ #1,D0 ;ADJUST FOR (A2)+ TSTWCD0 SUB D3,D0 ;NO. OF BYTES IN LSTBUF MOVE D0,-(SP) ASR #3,D0 MOVE D0,A0 ;BYTE NO. IN BITBUF ASL #3,D0 SUB (SP)+,D0 NEG D0 ;BIT NO. IN BYTE BTST D0,$0(A0,D4) ;TEST BIT ASSOCIATED TO CURRENT BYTE RTS * * GET LIST OF REGISTERS * GETRLST MOVE A5,-(SP) ;SAVE IN CASE OF ERROR MOVEQ #0,D6 ;CLEAR REG.MASK GETRLST1 BSR GETRNAM BMI GETRLST8 JSR GETCHRNS ;GET NEXT CHAR. BVS GETRLST3 CMPI.B #'-',D0 BEQ GETRLST5 ;REG RANGE FOLLOWS GETRLST2 CMPI.B #'/',D0 BEQ GETRLST4 SUBQ #1,A5 ;POINT TO NEXT CHAR. GETRLST3 BSET D1,D6 ADDQ #2,SP ;DROP SAVED TXTPTR RTS GETRLST4 BSET D1,D6 BRA GETRLST1 ;GET NEXT ITEM GETRLST5 MOVE D1,D2 ;SAVE START BIT BSR GETRNAM BMI GETRLST8 CMP D1,D2 BLS GETRLST6 ;START<=END REGISTER EXG D1,D2 GETRLST6 CMP D1,D2 BEQ GETRLST7 ;ALL BITS SET (EXCEPT D1), GET NEXT CHAR. BSET D1,D6 SUBQ #1,D1 BRA GETRLST6 GETRLST7 JSR GETCHRNS BVS GETRLST3 ;AT END OF INPUT BRA GETRLST2 ;TEST NEXT CHAR GETRLST8 MOVEQ #0,D6 ;ERROR IN LIST MOVE (SP)+,A5 ;RESTORE INITIAL TXTPTR RTS * * GET REGISTER NAME & SET BIT OFFSET * GETRNAM MOVEQ #0,D1 ;SET INITIAL OFFSET JSR GETCHRNS ;GET NAME BVS GETRNAM2 MOVEM D0/D7/A5,-(SP) ;SAVE I/O REGS CMPI.B #'A',D0 BEQ GETRNAM3 ;ADDRESS REGISTER CMPI.B #'D',D0 BEQ GETRNAM4 ;DATA REGISTER CMPI.B #'S',D0 BEQ GETRNAM6 ;'SP' OR 'SR' GETRNAM1 MOVEM (SP)+,D0/D7/A5 ;RESTORE TO FIRST CHAR SUBQ #1,A5 ;POINT TO FIRST CHAR GETRNAM2 MOVEQ #$FF,D1 ;ERROR: NOT REG NAME RTS GETRNAM3 MOVEQ #8,D1 ;SET OFFSET FOR A-REG GETRNAM4 JSR GETNUM07 BTST #NUMFND,D7 BEQ GETRNAM1 ;MUST BE FOLLOWED BY REG.NUMBER ADD.B D0,D1 ;SET BIT POSITION GETRNAM5 ADDQ #6,SP ;DROP I/O REGS RTS GETRNAM6 JSR GETCHRNS BVS GETRNAM1 ;MUST BE FOLLOWED BY CHAR. CMPI.B #'P',D0 BNE GETRNAM7 ;NOT 'SP' MOVEQ #15,D1 ;SP=A7=BIT 15 BRA GETRNAM5 GETRNAM7 CMPI.B #'R',D0 BNE GETRNAM1 ;NOT 'SP' OR 'SR' MOVEQ #31,D1 ;SR=BIT 31 BRA GETRNAM5 * * CLEAR ALL ENTRIES IN A TABLE * CLRTBL MOVEQ #$FF,D0 MOVEQ #NTBL-1,D1 CLRTBL1 MOVE.L D0,(A3)+ ;DELETE ADDRESS MOVE D0,(A3)+ ;DELETE TAGFIELD BTST #EXTTBL,D7 BEQ CLRTBL2 MOVE.L D0,(A4)+ ;CLEAR EXTENDED FIELD CLRTBL2 DBF D1,CLRTBL1 RTS * * ADD ENTRY (<ADR>&<TAG>(<EXT>)) TO TABLE * ADDTBL MOVEQ #NTBL-1,D0 ;ENTRIES/TABLE ANDI #$00FF,D2 ;SET TAG=USED BCLR #TBLERR,D7 ;NO ERROR ADDTBL1 TST.B 4(A3) BMI ADDTBL3 ;UNUSED ENTRY FOUND CMP.L (A3)+,D1 BEQ ADDTBL4 ;SAME ADR, SET NEW TAG ADDQ #2,A3 ;ADVANCE TO NEXT ENTRY BTST #EXTTBL,D7 BEQ ADDTBL2 ADDQ #4,A4 ;ADVANCE EXTTBL PTR ADDTBL2 DBF D0,ADDTBL1 ;CHECK ALL ENTRIES BSET #TBLERR,D7 ;NO ROOM IN TABLE RTS ADDTBL3 MOVE.L D1,(A3)+ ;SET NEW ADDRESS ADDTBL4 MOVE D2,(A3) ;SET NEW TAGFIELD BTST #EXTTBL,D7 BEQ ADDTBL5 MOVE.L D3,(A4) ;SET EXTENDED TABLE ADDTBL5 RTS * * SEARCH FOR AN ENTRY IN A TABLE * SRCTBL MOVEQ #NTBL-1,D0 BCLR #TBLERR,D7 SRCTBL1 CMP.L (A3),D1 BNE SRCTBL2 ;ENTRY NOT FOUND TST.B 4(A3) BPL SRCTBL4 ;ACTIVE ENTRY FOUND SRCTBL2 ADDQ #6,A3 ;ADVANCE TO NEXT ENTRY BTST #EXTTBL,D7 BEQ SRCTBL3 ;NO EXT TABLE ADDQ #4,A4 SRCTBL3 DBF D0,SRCTBL1 BSET #TBLERR,D7 SRCTBL4 RTS * * DELETE TABLE ENTRY & PACK TABLE * DELTBL BSR SRCTBL BTST #TBLERR,D7 BNE DELTBL4 ;ENTRY NOT FOUND MOVEM.L A1-A2,-(SP) ;SAVE REGISTERS LEA 6(A3),A1 ;SET TO NEXT ENTRY LEA 4(A4),A2 BRA DELTBL2 DELTBL1 MOVE.L (A1)+,(A3)+ ;MOVE ADR FIELD ONE UP MOVE.W (A1)+,(A3)+ ;MOVE TAG FIELD ONE UP BTST #EXTTBL,D7 BEQ DELTBL2 MOVE.L (A2)+,(A4)+ ;MOVE CONT FILED UP DELTBL2 DBF D0,DELTBL1 ;MOVE REST OF TABLE MOVEQ #$FF,D0 MOVE.L D0,(A3)+ ;DELETE LAST ADR FIELD MOVE.W D0,(A3) ;DELETE LAST TAG FIELD BTST #EXTTBL,D7 BEQ DELTBL3 MOVE.L D0,(A4) ;DELETE LAST CONT FIELD DELTBL3 MOVEM.L (SP)+,A1-A2 ;RESTORE REGISTERS DELTBL4 RTS * * GET NUMBER BETWEEN 0 & 1 * GETNUM01 MOVEQ #1,D3 BRA GETNUM0X * * GET NUMBER BETWEEN 0 & 7 * GETNUM07 MOVEQ #7,D3 * * GET NUMBER BETWEEN 0 & (D3) * GETNUM0X BCLR #NUMFND,D7 BSR GETCHRNS BVS GETNUM0X1 SUBI.B #'0',D0 BCS GETNUM0X1 CMP.B D3,D0 BHI GETNUM0X1 BSET #NUMFND,D7 GETNUM0X1 RTS * * GET CHARACTER BUT NO SPACES * GETCHRNS CMPA A5,A6 BLS GETCHRNS1 ;END OF INPUT MOVE.B (A5)+,D0 CMPI.B #SPC,D0 BEQ GETCHRNS ;IGNORE BLANKS ANDI #$FD,CCR RTS GETCHRNS1 ORI #$02,CCR RTS * * SKIP TO NEXT COMMAND * SKIPNXT CMPA A5,A6 BLS GETCHRNS1 MOVE.B (A5)+,D0 CMPI.B #';',D0 BNE SKIPNXT ANDI #$FD,CCR RTS ;A5 POINTS TO NEXT CHAR * * CHAIN MON68.EXCE.S SHAR_EOF if test 11276 -ne "`wc -c < 'mon68.csub.s'`" then echo shar: "error transmitting 'mon68.csub.s'" '(should have been 11276 characters)' fi fi echo shar: "extracting 'mon68.exce.s'" '(8040 characters)' if test -f 'mon68.exce.s' then echo shar: "will not over-write existing file 'mon68.exce.s'" else cat << \SHAR_EOF > 'mon68.exce.s' **************************** * * * MON68K * * * * A 68000 Monitor Program * * * * VERSION 2.2 15-JUL-84 * * * **************************** * * * mon68.exce.s: exception handlers * * * Source code donated to the public domain, 17 Oct 1989 * * You may use this code in any way you see fit, including * incorporating some or all of it into a project of your own, * commercial or otherwise. I would appreciate receiving some * credit if you decide to use some of my code, but as this is * quite unenforceable it remains a wish, not a condition. * * Naturally, I can make no guarantees as to the code's correctness * or suitability for any purpose, although I would hope that it is * both reasonably correct and suitable for something, and I know * that it works on my equipment. * * If you wish to contact me, you can write to me at the address * below or send me e-mail (until April 90) at: * * thomasw@jupiter.cs.concordia.ca * or: thomasw@concour.cs.concordia.ca * * Written by: Thomas Wieland * 4615 Walkley #21 * Montreal, PQ * H4B 2K7 * Canada * * * * ********************** * EXCEPTION HANDLERS * ********************** * * * SPURIOUS INTERRUPT OR BUS ERROR * SPURHDL JSR SAVEUSR JSR DMPDISAS MOVEQ #0,D1 MOVEA #APRTXT,A3 ;PC MAY BE WRONG ! JSR EXCMSG * FLUSH BUFFER & WARMSTART MONITOR ABORT MOVEQ #$18,D0 ;CTRL-X JSR SENDBYTE JMP WRMSTRT * * ADDRESS ERROR * AERRHDL MOVEM.L D0-A6,USRREG MOVE.L SP,A6 ADDQ.L #8,A6 ;SET TO SR BTST #5,(A6) BNE AERRHDL1 MOVE USP,A0 ;USER MODE MOVE.L A0,USRSP BRA AERRHDL2 AERRHDL1 MOVE.L A6,D0 ADDQ.L #6,D0 ;RESET SP MOVE.L D0,USRSP AERRHDL2 MOVE (A6)+,USRSTAT ;SAVE SR JSR DMPREG MOVE.L (A6),A2 ;GET APPROXIMATE PC SUBQ.L #4,A6 MOVE (A6),D2 ;GET OPWORD JSR FNDINST BMI AERRHDL3 ;OPCODE NOT FOUND MOVE.L A2,A1 JSR DISASM JSR PRTCR AERRHDL3 MOVEQ #1,D1 JSR EXCMSG JSR PRTTEXT ;SEND ACCESS ADDRESS MOVE.L -(A6),D2 JSR PRTLHEX JSR PRTCR JSR PRTTEXT ;SEND FUNCTION CODES MOVE (SP),D1 ANDI.B #%00011111,D1 JSR PRTBIN JSR PRTCR BRA ABORT * * ILLEGAL INSTRUCTION * ILINHDL JSR SAVEUSR JSR DMPREG MOVEQ #2,D1 JSR ATMSG MOVEA #OPCODTXT,A0 JSR PRTTEXT ;PRINT OPCODE MOVE (A2)+,D2 ;GET OPCODE & ADVANCE TO NEXT INSTR. JSR PRTWHEX JSR PRTCR JSR CONTEX ;RETURNS ONLY IF 'YES' MOVE.L A2,2(SP) ;ADVANCE PC BRA CONTINUE2 * * DIVISION BY ZERO * ZDIVHDL JSR SAVEUSR JSR DMPREG MOVE #$F1C0,D1 ;%1111 0001 1100 0000, MASK FOR 'DIV.' MOVE #$80C0,D2 ;'DIVU' JSR FNDINST0 BPL ZDIVHDL1 ;DIVU WAS FOUND MOVE #$81C0,D2 ;'DIVS' JSR FNDINST0 BMI ZDIVHDL2 ;OPCODE NOT FOUND ZDIVHDL1 MOVE.L A2,A1 JSR DISASM JSR PRTCR ZDIVHDL2 MOVEQ #3,D1 * CONTINUE JSR EXCMSG CONTINUE1 JSR CONTEX CONTINUE2 MOVEM.L USRREG,D0-A6 ;RESTORE USER REGISTERS RTE * CONTINUE0 JSR ATMSG BRA CONTINUE1 * CHK EXCEPTION CHKHDL JSR SAVEUSR JSR DMPREG MOVE #$F1C0,D1 ;MASK FOR CHK INSTR. MOVE #$4180,D2 ;'CHK' JSR FNDINST0 BMI CHKHDL1 ;OPCODE NOT FOUND MOVE.L A2,A1 JSR DISASM JSR PRTCR CHKHDL1 MOVEQ #4,D1 BRA CONTINUE * * TRAP ON OVERFLOW * TRPVHDL JSR SAVEUSR SUBQ.L #2,A2 ;TRAPV=$4E76 JSR DMPDISAS MOVEQ #5,D1 BRA CONTINUE0 * * PRIVILEGE VIOLATION * PRIVHDL JSR SAVEUSR JSR DMPDISAS MOVE (A2),D0 ;GET OPCODE MOVEQ #2,D1 ;CALCULATE OPERATION LENGTH, BTST #30,D0 ;REPLACE BY MOVE.L A1,2(SP) BNE PRIVHDL1 ;INSTRUCTION HAS ONLY ONE WORD MOVEQ #4,D1 PRIVHDL1 ADD.L D1,2(SP) ;ADVANCE PC TO NEXT INSTRUCTION MOVEQ #6,D1 BRA CONTINUE0 * * OPCODE 1010 & 1111 EMULATION * EMULHDL JSR SAVEUSR JSR DMPDISAS MOVE.L A1,2(SP) ;UPDATE PC MOVEQ #7,D1 BRA CONTINUE0 * * TRAP #N EXCEPTION * TRAPHDL JSR SAVEUSR SUBQ.L #2,A2 ;POINT TO TRAP INSTRUCTION JSR DMPDISAS MOVEQ #8,D1 BRA CONTINUE0 * * TRACE EXCEPTION * TRACHDL JSR SAVEUSR CMPA.L #RTNUSR,A2 BEQ.L RTNUSR TST.B TRCFLAG BEQ BREAK ;'INVISIBLE' TRACE JSR BRKDREG0 TST.B TRCFLAG BMI TRACHDL1 ;SINGLE STEP MOVE.B STATUS,D0 ;TRACE, CHECK FOR INPUT BPL TRACHDL4 ;NO INPUT TRACHDL1 JSR GETBYTE ;GET INPUT CMPI.B #SPC,D0 BCS TRACHDL5 ;CONTROL CHAR.=> EXIT BEQ TRACHDL2 ;SET SINGLE STEP MOVEQ #1,D0 ;SET TRACE BRA TRACHDL3 TRACHDL2 MOVEQ #$FF,D0 TRACHDL3 MOVE.B D0,TRCFLAG TRACHDL4 CMP.L SYSREG+40,A2 ;SYSREG+40 = EADR BLS BREAK ;SADR<=EADR => CONTINUE TRACHDL5 MOVE.L USRSP,D0 ADDQ.L #4,D0 ;ADJUST FOR RETURN ADDRESS MOVE.L D0,USRSP BRA.L TRACEXIT * CHECK FOR BREAKCONDITION BREAK CMP.L LWLIM,A2 BCS BRKLLIM ;PC < LOWER LIMIT CMP.L HILIM,A2 BHI BRKHLIM ;PC > UPPER LIMIT MOVE.L A2,D1 MOVEA #BRKTBL,A3 MOVEQ #0,D7 ;CLEAR FLAGS JSR SRCTBL BTST #TBLERR,D7 BNE BREAK1 ;PC NOT IN BREAKPOINT TABLE MOVE 4(A3),D2 ;GET TAG FIELD TST.B D2 BEQ BRKPNT ;COUNT=0 SUBQ.B #1,D2 ;DECR. COUNT MOVE D2,4(A3) ;RESTORE TAG FIELD MOVEA #MBRKTBL,A3 ;SET TO START OF MBRKTBL BREAK1 MOVEA #MBRKXTBL,A4 MOVEQ #NTBL-1,D0 BREAK2 MOVE.L (A3)+,A0 ;GET ADR FIELD MOVE (A3)+,D2 ;GET TAG FIELD BMI BREAK6 ;UNUSED ENTRY, END OF TABLE MOVE.L (A4)+,D3 ;GET CONT FIELD SUBQ.B #2,D2 BHI BREAK4 ;SIZE = LONG BEQ BREAK3 ;SIZE = WORD CMP.B (A0),D3 ;SIZE = BYTE BRA BREAK5 BREAK3 CMP.W (A0),D3 BRA BREAK5 BREAK4 CMP.L (A0),D3 BREAK5 BEQ BRKMBRK ;MEMORY BREAK DBF D0,BREAK2 BREAK6 BRA CONTINUE2 * BRKLLIM BSR BRKDREG MOVEA #LLIMTXT,A0 BRA BRKHLIM1 BRKHLIM BSR BRKDREG MOVEA #HLIMTXT,A0 BRKHLIM1 JSR PRTTEXT BRA TRACEXIT * BRKMBRK MOVE.L A0,-(SP) ;SAVE MEMORY ADDRESS BSR BRKDREG MOVE.L (SP)+,D2 ;SET TO MEMORY ADDRESS MOVEA #MBRKTXT1,A0 BRA BRKPNT1 * BRKPNT BSR BRKDREG MOVE.L A2,D2 MOVEA #BRKTXT1,A0 BRKPNT1 JSR PRTTEXT JSR PRTBEL MOVEQ #NTBL,D1 ;CALCULATE ENTRY NO.,1..NTBL SUB.B D7,D1 ;SAVED BY BRKDREG JSR PRTDEC ;PRINT ENTRY NO. JSR PRTTEXT JSR PRTLHEX ;PRINT PC JSR PRTCR TRACEXIT MOVE.L A2,PCADR ;UPDATE PC JMP WRMSTRT * DUMP SELECTED REGISTERS & MEMORY BRKDREG MOVE.B D0,D7 ;SAVE TABLE-COUNT TST.B TRCFLAG BNE BRKDREG1 * BRKDREG0 MOVEA #REGMASK,A3 MOVEA #USRREG,A4 JSR PRTMREG MOVE.L A2,A1 JSR DISASM JSR PRTCR BRKDREG1 RTS * * SAVE USERREGISTERS, GET PC OF EXCEPTION * SAVEUSR MOVEM.L D0-A6,USRREG BTST #5,4(SP) ;TEST S-BIT OF SR BNE SAVEUSR1 ;SUPERVISOR MODE MOVE USP,A0 BRA SAVEUSR2 SAVEUSR1 MOVE.L SP,A0 ADDA.L #10,A0 ;ADJUST FOR TRACE-EXCEPTION & JSR SAVEUSR2 MOVE.L A0,USRSP ;SAVE USER SP (USP OR SSP) MOVE 4(SP),USRSTAT ;SAVE USER STATUSREGISTER MOVE.L 6(SP),A2 ;GET PC OF TRACE-EXCEPTION RTS * * FIND INSTRUCTION PATTERN * FNDINST MOVEQ #$FF,D1 ;CLEAR MASK FNDINST0 MOVE.L A2,A1 ;COPY PC SUBQ.L #2,A2 ;^ INSTRUCTION CAUSING THE EXCEPTION MOVEQ #8-1,D3 ;MAXIMUM 8 WORDS FROM PC FNDINST1 MOVE (A2),D0 AND D1,D0 ;MASK OUT INSIGNIFICANT BITS CMP D2,D0 BEQ FNDINST2 ;OPCODE FOUND SUBQ.L #2,A2 DBF D3,FNDINST1 MOVE.L A1,A2 ;PATTERN NOT FOUND, RESTORE PC MOVE #APRTXT,A3 ;ONLY APPROXIMATE LOCATION MOVEQ #$FF,D0 ;SIGNAL OPCODE NOT FOUND RTS FNDINST2 MOVE #ATTXT,A3 ;EXACT LOCATION (N-FLAG RESET) RTS * * DUMP REGISTERS & DISASSEMBLE INSTRUCTION * DMPDISAS BSR DMPREG ;DUMP ALL REGISTERS MOVE.L A2,A1 BSR DISASM ;DISASM INSTRUCTION AT PC (A1) JMP PRTCR * DUMP ALL REGISTERS DMPREG JSR PRTCR MOVEQ #$FF,D6 MOVEA #USRREG,A4 JMP PRTREG ;DUMP ALL REGISTERS * * PRINT EXCEPTION MESSAGE * ATMSG MOVEA #ATTXT,A3 * EXCMSG MOVEA #EXCEPTXT,A0 BRA EXCMSG2 EXCMSG1 MOVE.B (A0)+,D0 BNE EXCMSG1 ;SKIP THIS TEXT EXCMSG2 DBF D1,EXCMSG1 JSR PRTTEXT ;SEND EXCEPTION MESSAGE JSR PRTBEL MOVE A3,A0 JSR PRTTEXT ;SEND (APPROX.) AT MOVE.L A2,D2 JSR PRTLHEX ;SEND PC JMP PRTCR * * ASK USER IF PROGRAM EXECUTION IS TO CONTINUE * CONTEX MOVE #ERRTXT1,A0 JSR PRTTEXT MOVEQ #6,D0 JSR PRTSFCT ;6=GET 'Y' OR 'N' JSR GETBYTE JSR SENDBYTE ;ECHO INPUT JSR PRTCR CMPI.B #'Y',D0 BNE ABORT ;'N' => ABORT EXECUTION JMP PRTCR * * RETURN TO MONITOR FROM SUPERVISOR MODE * RTNSUP MOVEM.L D0-A7,USRREG ;SAVE USER REGS MOVE SR,USRSTAT ;AND USER STATUS * RETURN FROM USER PROGRAM RTNUSR MOVEM.L SYSREG,D0-A7 ;RESTORE MONITOR REGS MOVE SYSSTAT,SR RTS ;RETURN TO CMDPROC * * CHAIN MON68.DASM.S SHAR_EOF if test 8040 -ne "`wc -c < 'mon68.exce.s'`" then echo shar: "error transmitting 'mon68.exce.s'" '(should have been 8040 characters)' fi fi echo shar: "extracting 'mon68.dasm.s'" '(17308 characters)' if test -f 'mon68.dasm.s' then echo shar: "will not over-write existing file 'mon68.dasm.s'" else cat << \SHAR_EOF > 'mon68.dasm.s' **************************** * * * MON68K * * * * A 68000 Monitor Program * * * * VERSION 2.2 15-JUL-84 * * * **************************** * * * mon68.dasm.s: disassembler & disasm support routines * * * Source code donated to the public domain, 17 Oct 1989 * * You may use this code in any way you see fit, including * incorporating some or all of it into a project of your own, * commercial or otherwise. I would appreciate receiving some * credit if you decide to use some of my code, but as this is * quite unenforceable it remains a wish, not a condition. * * Naturally, I can make no guarantees as to the code's correctness * or suitability for any purpose, although I would hope that it is * both reasonably correct and suitable for something, and I know * that it works on my equipment. * * If you wish to contact me, you can write to me at the address * below or send me e-mail (until April 90) at: * * thomasw@jupiter.cs.concordia.ca * or: thomasw@concour.cs.concordia.ca * * Written by: Thomas Wieland * 4615 Walkley #21 * Montreal, PQ * H4B 2K7 * Canada * * * * * DISASSEMBLE ONE INSTRUCTION * DISPLAY OPCODE & UPDATE POINTER * Input: A1 : POINTER TO FIRST WORD OF INSTRUCTION * * Note: A1 is used as the 'program counter' for * the instruction to be disassembled * DISASM MOVEM.L D0-A0/A2-A6,-(SP) ;SAVE ALL REGS EXCEPT 'PC' MOVE.L SP,DISASMSP ;SAVE SSP (FOR ILLEGAL INSTRUCTIONS) MOVE.L A1,D2 ;GET PC ADDRESS JSR PRTADR ;PRINT ADDRESS OF INSTRUCTION MOVEA #LSTBUF,A6 BSR GETOPC ;GET & PRINT OPWORD MOVE D7,D5 ;COPY OPCODE TO WORKAREA MOVE D7,D0 ;CALC. OFFSET ANDI #$F000,D0 ;SEPARATE OPCODE GROUP ROL #5,D0 ;GET OPGROUP AS INDEX MOVEA #GRADRTBL,A0 MOVEA 0(A0,D0),A0 JMP (A0) ;GO TO GROUP HANDLER * * GET WORD AT (PC)+ & PRINT IT * GETOPC MOVE.W (A1)+,D7 MOVE D7,D2 JSR PRTWHEX JMP PRTSPC * * OPCODE GROUP 0: BIT MANIP./IMMEDIATE/MOVEP * GR0 JSR TST53001 BEQ.L MOVEP BTST #8,D5 BNE.L BITREG JSR GET119 CMPI.B #7,D4 BEQ.L ILLOPC CMPI.B #4,D4 BEQ.L BITIMM BCS GR01 SUBQ #1,D4 GR01 MOVEQ #5,D3 ADD.B D4,D3 JSR PUTOPC JSR TSTIMM BEQ CHGSR ;IMMEDIATE=> CCR/SR JSR ILL53XX ;NOW XXXI.S #<DATA>,<EA> JSR TST76 BEQ.L ILLOPC JSR PUTBWL TST.B D4 BMI GR03 BEQ GR02 JSR GPILONG BRA GR04 GR02 JSR GPIWORD BRA GR04 GR03 JSR GPIBYTE GR04 BRA.L DESTEA * CHANGE CCR / SR CHGSR ADDQ #1,A6 BTST #7,D7 BNE.L ILLOPC BTST #6,D7 BEQ CHGSR1 MOVEQ #69,D3 ;'SR' JSR GPIWORD BRA CHGSR2 CHGSR1 MOVEQ #68,D3 ;'CCR' JSR GPIBYTE CHGSR2 MOVE.B #',',(A6)+ JSR PUTOPC JMP PRTBUF * BIT MANIP., COUNT IN DN BITREG BSR BITCHK BRA.L D119EA * BIT MANIP., IMMEDIATE COUNT BITIMM BSR BITCHK JSR GPIBYTE BRA.L DESTEA * CHECK ADR MODE FOR BIT MANIP. BITCHK MOVEQ #1,D3 JSR TST76 ADD.B D4,D3 JSR PUTOPCI TST.B D4 BEQ BITCHK1 JSR ILL53XX BRA BITCHK2 BITCHK1 JSR ILLIMM ;'BTST' BITCHK2 RTS * MOVE PERIPHERAL DATA MOVEP BTST #8,D5 BEQ.L ILLOPC MOVEQ #0,D3 JSR PUTWL6 BTST #7,D5 BEQ MOVEP1 JSR DREG119 MOVE.B #',',(A6)+ JSR AREGID JMP PRTBUF MOVEP1 JSR AREGID BRA.L DESTD119 * * OPCODE GROUP 1: MOVE.B * GR1 BSR GR123A JSR ILL53001 ;NO MOVEA.B XXX,AN MOVE D7,D5 JSR ILL53001 ;NO MOVE.B AN,XXX MOVE.B #'B',(A6)+ BRA GR123B * * OPCODE GROUP 2: MOVE.L * GR2 BSR GR123A MOVE.B #'L',(A6)+ BRA GR123B * * OPCODE GROUP 3: MOVE.W * GR3 BSR GR123A MOVE.B #'W',(A6)+ * TEST FOR SOURCE IMMEDIATE ADDRESSING, CORRECT SIZE BITS GR123B CLR.B (A6)+ MOVE D7,D5 JSR TSTIMM BNE GR123C MOVE D5,D4 ANDI #$003F,D5 ;ISOLATE SOURCE <EA> ANDI #$3000,D4 ;ISOLATE SIZE BITS LSR #6,D4 OR D4,D5 ;COMBINE SIZE & <EA> BTST #6,D5 BEQ GR123C ;SIZE = L BTST #7,D5 BEQ GR123B1 BCLR #7,D5 ;SIZE = W BRA GR123C GR123B1 BCLR #6,D5 ;SIZE = B * PUT SOURCE & DESTINATION <EA>S -> BUFFER GR123C JSR PUTEA ;SOURCE <EA> MOVE D6,D5 ;XXXXRRRMMMXXXXXX (OPWORD) LSR #1,D5 ;0XXXXRRRMMMXXXXX LSR.B #5,D5 ;0XXXXRRR00000MMM LSL #5,D5 ;RRR00000MMM00000 LSR.B #5,D5 ;RRR0000000000MMM ROL #3,D5 ;0000000000MMMRRR JSR ILL53XX ;TEST DEST <EA> BRA.L DESTEA * PUT 'MOVE(A)' -> BUFFER GR123A MOVEQ #11,D3 ;SET 'MOVE' LSR #3,D5 ;BIT 8-6 -> BIT 5-3 JSR TST53001 BNE GR123A1 MOVEQ #12,D3 ;SET 'MOVEA' GR123A1 JSR PUTOPC MOVE.B #'.',(A6)+ RTS * * OPCODE GROUP 4: MISCELLANEOUS * GR4 CMPI #$4AFC,D5 BEQ ILLEGAL MOVEA #GR4TBL,A0 MOVEA #AND4TBL,A4 MOVEA #CMP4TBL,A5 MOVEQ #9-1,D0 GR41 MOVE D7,D5 ;GET OPCODE AND (A4)+,D5 CMP (A5)+,D5 BEQ GR42 DBF D0,GR41 GR42 MOVE D7,D5 ;RESTORE OPWORD ADDQ #1,D0 ;SKIP FIRST ADDRESS LSL #1,D0 MOVEA 0(A0,D0),A0 JMP (A0) * ILLEGAL MOVEQ #54,D3 JMP PUTOPCX * GROUP $4EXX GR4E MOVEA #GR4ETBL,A0 MOVEA #AND4ETBL,A4 MOVEA #CMP4ETBL,A5 MOVEQ #5-1,D0 BRA GR41 * GR4STD MOVEQ #41,D3 JSR GET119 ;CALC. OFFSET FROM B11-B9 ADD D4,D3 JSR PUTOPC JSR TPBWL * B5-B0: DEST <EA>, NOT AN, D(PC), D(PC,RI), IMMEDIATE GR4STD1 JSR ILL53001 JSR ILL53XX BRA.L DESTEA0 LEACHK BTST #7,D5 BEQ.L ILLOPC BTST #6,D5 BEQ CHK MOVEQ #48,D3 BSR GR4STD30 BRA.L DESTA119 CHK MOVEQ #47,D3 JSR PUTOPCI BCLR #7,D5 BSET #6,D5 ;SIZE=WORD (IMMEDIATE) BRA.L ILLSRCAN MOVSPEC JSR GET119 SUBQ.B #1,D4 BEQ.L ILLOPC MOVEQ #11,D3 ;'MOVE' JSR PUTOPCI MOVEQ #69,D3 ;'SR' TST.B D4 BMI MOVSR SUBQ.B #1,D4 BNE MOVSPEC1 MOVEQ #68,D3 ;'CCR' ANDI #$FF3F,D5 ;CLEAR SIZE BITS MOVSPEC1 JSR ILL53001 JSR PUTEA MOVE.B #',',(A6)+ JMP PUTOPCX MOVSR JSR PUTOPC MOVE.B #',',(A6)+ BRA GR4STD1 NBCD MOVEQ #49,D3 JSR PUTOPCI BRA GR4STD1 PEASW JSR GET53 BEQ SWAP MOVEQ #51,D3 BCLR #6,D5 BSET #7,D5 ;SIZE=LONG (IMMEDIATE ADR.) GR4STD3 BSR GR4STD30 JMP PRTBUF GR4STD30 JSR ILL5400 JSR ILLIMM JSR GET53 CMPI.B #3,D4 BEQ.L ILLOPC ;(AN)+ CMPI.B #4,D4 BEQ.L ILLOPC ;-(AN) JSR PUTOPCI JMP PUTEA SWAP MOVEQ #50,D3 JSR PUTOPCI BRA.L DESTD200 EXT MOVEQ #52,D3 JSR PUTWL6 BRA.L DESTD200 MOVEM MOVEQ #53,D3 JSR PUTWL6 JSR ILL5400 JSR ILLIMM JSR GET53 BTST #10,D5 BNE MOVEM2 SUBQ.B #3,D4 ;REG -> <EA> BEQ.L ILLOPC JSR GPIWORD BRA.L DESTEA MOVEM2 SUBQ.B #4,D4 ;<EA> -> REG BEQ.L ILLOPC JSR GETOPC ;GET REGISTER MASK JSR PUTEA MOVE.B #',',(A6)+ MOVE D6,D7 ;REG.MASK JSR PUTPND JSR PUTWORD JMP PRTBUF TAS MOVEQ #45,D3 JSR PUTOPCI BRA GR4STD1 JUMP MOVEQ #55,D3 BTST #6,D5 BEQ JUMP1 ADDQ #1,D3 JUMP1 BRA GR4STD3 TRAP MOVEQ #57,D3 JSR PUTOPCI ANDI #$000F,D7 JSR PUTPBYTE JMP PRTBUF ULINK MOVEQ #58,D3 BTST #3,D5 BEQ ULINK1 MOVEQ #59,D3 ULINK1 JSR PUTOPCI JSR AREGD BTST #3,D5 BNE ULINK2 MOVE.B #',',(A6)+ JSR GPIWORD ULINK2 JMP PRTBUF MOVUSP MOVEQ #11,D3 ;'MOVE' JSR PUTOPCI MOVEQ #70,D3 ;'USP' BTST #3,D5 BEQ MOVUSP1 JSR PUTOPC MOVE.B #',',(A6)+ JSR AREGD JMP PRTBUF MOVUSP1 JSR AREGD MOVE.B #',',(A6)+ JMP PUTOPCX GR4E7 MOVEQ #60,D3 ANDI #$000F,D5 CMPI #4,D5 BEQ.L ILLOPC CMPI #7,D5 BHI.L ILLOPC ADD.B D5,D3 JSR PUTOPCI CMPI #2,D5 BNE GR4E71 JSR GPIWORD GR4E71 JMP PRTBUF * * OPCODE GROUP 5: ADDQ/SUBQ/SCC/DBCC * GR5 MOVEQ #13,D3 JSR TST76 BEQ DBSCC MOVEQ #2,D2 ;'ADDQ' BTST #8,D5 BEQ GR51 MOVEQ #3,D2 ;'SUBQ' GR51 JSR T53PBWL JSR ILL53XX JSR DAT119 BRA.L DESTEA DBSCC JSR TST53001 BEQ DBCC JSR ILL53XX MOVEQ #14,D3 JSR PUTOPC JSR PUTCOND BRA.L DESTEA0 DBCC JSR PUTOPC JSR PUTCOND JSR DREGD MOVE.B #',',(A6)+ * GET DISPLACEMENT, CALC. ADDRESS GETDISP MOVE.L A1,D3 ;SAVE PC FOR <EA> JSR GETOPC ;GET DISPLACEMENT GETDISP1 EXT.L D7 ADD.L D3,D7 ;<EA>=PC+DISP JSR PUTLONG JMP PRTBUF * * OPCODE GROUP 6: BRANCH INSTRUCTIONS * GR6 JSR GET119 TST.B D4 BEQ GR61 MOVE.B #'B',(A6)+ JSR PUTCOND BRA GR63 GR61 MOVEQ #17,D3 BTST #8,D7 BEQ GR62 MOVEQ #18,D3 GR62 JSR PUTOPCI ;'BRA'/'BSR' GR63 TST.B D7 BEQ GETDISP ;LONG BRANCH MOVE.B #'.',-1(A6) MOVE.B #'S',(A6)+ CLR.B (A6)+ MOVE.L A1,D3 ;SET PC EXT D7 BRA GETDISP1 * * OPCODE GROUP 7: MOVEQ * GR7 BTST #8,D5 BNE.L ILLOPC MOVEQ #19,D3 JSR PUTOPCI JSR PUTPBYTE ;BYTE IN OPCODE BRA.L DESTD119 * * OPCODE GROUP 8: OR/DIV/SBCD * GR8 MOVEQ #20,D2 ;GROUP OFFSET JSR TR89CD TST.B D3 BEQ DIVMUL ;B7-B6=11 BMI ILLSRCAN ;B8=0, D3=$FFFF JSR TST76 TST.B D4 BNE.L ILLOPC ;B8-B4=1XX00 & B7-B6<>00 BCD ADD.B D2,D3 JSR PUTOPCI * ADR MODE: DI,DJ OR -(AI),-(AJ) XTEND BTST #3,D5 BNE XTEND1 * B2-B0: SOURCE DI, B11-B9: DEST. DJ D20D119 JSR DREGD DESTD119 MOVE.B #',',(A6)+ DESTD1190 JSR DREG119 JMP PRTBUF * B2-B0: SOURCE -(AI), B11-B9: DEST. -(AJ) XTEND1 JSR AREGPD MOVE.B #',',(A6)+ JSR GET119 MOVE D4,D5 JSR AREGPD JMP PRTBUF * DIVMUL MOVE D2,D3 ;OFFSET=0 JSR PUTOPC MOVEQ #'U',D0 BTST #8,D5 BEQ DIVMUL1 ;B8=0 MOVEQ #'S',D0 DIVMUL1 MOVE.B D0,(A6)+ CLR.B (A6)+ ;END OF MNEMNONIC * SOURCE <EA> <> AN ILLSRCAN JSR ILL53001 * B5-B0: SOURCE <EA>, B11-B9: DEST. DN EAD119 JSR PUTEA BRA DESTD119 * * OPCODE GROUP D: ADD * GRD MOVEQ #34,D2 BRA GR90 * * OPCODE GROUP 9: SUB * GR9 MOVEQ #23,D2 ;GROUP OFFSET GR90 JSR TR89CD TST.B D3 BEQ AREGOP ;BIT 7-6=11 BMI EAD119 ;B8=0, D3=$FFFF ADD.B D2,D3 JSR PUTOPC JSR TPBWL BRA XTEND * W/L OPERATION TO ADR REGISTER AREGOP MOVE D2,D3 ;OFFSET=0 JSR PUTOPC MOVEQ #8,D1 JSR PUTWL EAA119 JSR PUTEA BRA.L DESTA119 * * OPCODE GROUP B: CMP/EOR * GRB MOVEQ #26,D2 JSR TST76 BEQ AREGOP ;'CMPA' MOVEQ #1,D3 BTST #8,D5 BEQ GRBA JSR TST53001 BEQ CMPMEM MOVEQ #29,D3 ;'EOR' BRA.L TR89CD3 ;RIGHTMOST SUBTREE, PRINT 'EOR' & EXIT GRBA JSR T53PBWL BRA EAD119 CMPMEM MOVEQ #28,D3 JSR PUTOPC JSR TPBWL JSR AREGPI ;SOURCE ADR MODE: (AN)+ MOVE.B #',',(A6)+ ROL #7,D5 ;GET B11-B9 JSR AREGPI ;DEST. ADR MODE: (AN)+ JMP PRTBUF * * OPCODE GROUP C: AND/MULT/ABCD/EXG * GRC MOVEQ #30,D2 ;GROUP OFFSET JSR TR89CD TST.B D3 BEQ DIVMUL ;BIT 7-6=11 BMI ILLSRCAN ;B8=0, OFFSET=$FFFF JSR TST76 SUBQ.B #1,D4 BMI BCD MOVEQ #33,D3 ;'EXG' JSR PUTOPCI TST.B D4 BEQ EXGDDAA BTST #3,D5 BEQ.L ILLOPC JSR AREGD BRA DESTD119 EXGDDAA BTST #3,D5 BEQ D20D119 A20A119 JSR AREGD DESTA119 MOVE.B #',',(A6)+ DESTA1190 JSR AREG119 JMP PRTBUF * * DECISION TREE FOR GROUPS 8,9,C,D * TR89CD MOVEQ #0,D3 JSR TST76 BEQ TR89CD1 ;B7-6=11, OFFSET=0 MOVEQ #1,D3 ADD.B D2,D3 BTST #8,D5 BEQ TR89CD2 ;B8=0 JSR TST5400 BNE TR89CD3 ;B5-4<>00 MOVEQ #2,D3 ;B8-4=1XX00, OFFSET=2 TR89CD1 RTS TR89CD2 JSR PUTOPC JMP PUTBWL ;B8-4=0XXXX, OFFSET=D2+1 TR89CD3 JSR PUTOPC JSR TPBWL * DEST <EA> <> D(PC), D(PC,RI), IMMEDIATE ILLDEST JSR ILL53XX * BIT 11-9: SOURCE DN, BIT 5-0: DEST. <EA> D119EA JSR DREG119 DESTEA MOVE.B #',',(A6)+ DESTEA0 JSR PUTEA ;SOURCE <EA> JMP PRTBUF * * OPCODE GROUP E: SHIFT/ROTATE * GRE JSR TST76 BEQ SHRMEM MOVE D5,D4 BSR SHTYPE JSR TPBWL BTST #5,D5 BEQ GRE1 D119D20 JSR DREG119 ;COUNT REG DESTD20 MOVE.B #',',(A6)+ DESTD200 JSR DREGD JMP PRTBUF GRE1 JSR DAT119 BRA DESTD20 SHRMEM BTST #11,D5 BNE.L ILLOPC JSR ILL5400 JSR ILL53XX MOVE D5,D4 LSR #6,D4 BSR SHTYPE CLR.B (A6)+ BRA DESTEA0 * DECODE & PUT MNEMNONIC SHTYPE ANDI #%00011000,D4 LSR #3,D4 MOVEQ #37,D3 ADD.B D4,D3 JSR PUTOPC MOVEQ #'R',D0 BTST #8,D5 BEQ SHTYPE1 MOVEQ #'L',D0 SHTYPE1 MOVE.B D0,(A6)+ RTS * GET COUNT 1..8 FROM BIT 11-9 DAT119 JSR GET119 TST.B D4 BNE DAT1191 MOVEQ #8,D4 DAT1191 EXG D4,D7 JSR PUTPBYTE MOVE D4,D7 ;RESTORE OPWORD RTS * PUT OPCODE, SIZE IN B6 PUTWL6 JSR PUTOPC MOVEQ #6,D1 * PUT W/L -> BUFFER, D1: BITNUMBER PUTWL MOVE.B #'.',(A6)+ MOVEQ #'W',D0 BTST D1,D5 BEQ PUTWL1 MOVEQ #'L',D0 PUTWL1 MOVE.B D0,(A6)+ CLR.B (A6)+ RTS * PUT OPCODE, TEST FOR BYTE->AN & PUT SIZE T53PBWL ADD.B D2,D3 JSR PUTOPC TST.B D4 ;D4=BIT 7-6 BNE TPBWL BSR ILL53001 * TEST B7-6, PUT SIZE -> BUFFER TPBWL BSR TST76 ;TEST BITS, FALL THROUGH * PUTBWL MOVE.B #'.',(A6)+ MOVEQ #'W',D0 SUBQ.B #1,D4 BEQ PUTBWL2 ;SIZE = WORD BPL PUTBWL1 ;SIZE = LONG MOVEQ #'B',D0 BRA PUTBWL2 PUTBWL1 MOVEQ #'L',D0 PUTBWL2 MOVE.B D0,(A6)+ CLR.B (A6)+ ;SIZE IS LAST OF MNEMNONIC RTS * TEST BIT 7-6 OF D5 TST76 MOVE D5,D4 ANDI #$00C0,D4 ROL.B #2,D4 CMPI.B #%00000011,D4 RTS * ILLEGAL <EA> IF IMMEDIATE ADDRESSING ILLIMM BSR TSTIMM BEQ.L ILLOPC RTS * TEST FOR IMMEDIATE ADDRESSING TSTIMM MOVE D5,D4 MOVEQ #$3C,D0 AND D0,D4 CMP D0,D4 RTS * ILLEGAL <EA> IF B5-B3=001 (AN) ILL53001 BSR TST53001 BEQ ILL53XX1 RTS * ILLEGAL <EA> IF B5-B3=111 & B2-B0<>00X ILL53XX BSR TST53111 BNE ILL53XX2 BSR GET20 SUBQ.B #1,D4 BLS ILL53XX2 ILL53XX1 BRA.L ILLOPC ILL53XX2 RTS * TEST B5-B3 OF D5 FOR 001 TST53001 BSR GET53 CMPI #1,D4 RTS * TEST B5-B3 OF D5 FOR 111 TST53111 BSR GET53 CMPI #7,D4 RTS * GET BIT 5-3 OF D5 GET53 MOVE D5,D4 ANDI #$0038,D4 LSR #3,D4 RTS * GET BIT 2-0 OF D5 GET20 MOVE D5,D4 ANDI #$0007,D4 RTS * ILLEGAL <EA> IF B5-B4=00 (REG. DIRECT) ILL5400 BSR TST5400 BEQ.L ILLOPC RTS * TEST B5-B4 FOR 00 TST5400 MOVE D5,D4 ANDI #$0030,D4 RTS ;Z=1 IF BIT 5-4=00 * * CONDITIONAL (B11-B8) -> BUFFER * PUTCOND MOVE D7,D3 ANDI #$0F00,D3 ;SEPARATE CONDITION CODES LSR #8,D3 ;SET COUNT MOVEA #CONDTBL,A0 BRA PUTOPCI2 * * OPCODE -> BUFFER (OFFSET IN D3) * PUTOPCI MOVEA #OPCTBL,A0 BRA PUTOPCI2 PUTOPCI1 MOVE.B (A0)+,D0 BNE PUTOPCI1 PUTOPCI2 DBF D3,PUTOPCI1 PUTOPCI3 MOVE.B (A0)+,(A6)+ ;TRANSFER BYTE TO BUFFER BNE PUTOPCI3 RTS * PUT OPCODE & DECREMENT A6 PUTOPC BSR PUTOPCI SUBQ #1,A6 RTS * PUT OPCODE & EXIT DISASSEMBLER PUTOPCX BSR PUTOPCI BRA.L PRTBUF * * DECODE EFFECTIVE ADDRESS IN B5-B0 OF D5 * PUTEA MOVE D7,D6 ;SAVE OPWORD MOVE D5,D4 ANDI #$003F,D4 ;ISOLATE <EA> MOVE D4,D0 ANDI #7,D4 ;ISOLATE REG. FIELD LSR #3,D0 ;ISOLATE MODE FIELD LSL #1,D0 ;CALC. OFFSET CMPI #$E,D0 BNE PUTEA1 LSL #1,D4 ;SPECIAL ADDRESS MODE ADD D4,D0 PUTEA1 MOVEA #EATBL,A0 MOVEA 0(A0,D0),A0 JMP (A0) ;PUT <EA> -> BUFFER * BIT 11-9 OF D5: DN DREG119 BSR GET119 MOVE.B #'D',(A6)+ BRA PUT200 * BIT 11-9 OF D5: AN AREG119 BSR GET119 MOVE.B #'A',(A6)+ BRA PUT200 * B11-B9 OF D5 -> B2-B0 OF D4 GET119 MOVE D5,D4 ANDI #$0E00,D4 ROL #7,D4 RTS * DATA REG. DIRECT DREGD MOVE.B #'D',(A6)+ BRA PUT20 * ADR REG. DIRECT AREGD MOVE.B #'A',(A6)+ * PUT REG. NUMBER (B2-B0) IN BUFFER PUT20 MOVE D5,D4 PUT200 ANDI #$0007,D4 ADDI.B #$30,D4 ;CONVERT TO ASCII MOVE.B D4,(A6)+ ;ADD TO BUFFER RTS * ADR REG. POSTINCREMENT AREGPI BSR AREGIND MOVE.B #'+',(A6)+ RTS * ADR REG. PREDECREMENT AREGPD MOVE.B #'-',(A6)+ * ADR REG. INDIRECT AREGIND MOVE.B #'(',(A6)+ BSR AREGD * PUT RIGHT BRACKET -> BUFFER PUTRBR MOVE.B #')',(A6)+ RTS * ADR REG IND WITH DISPLACEMENT AREGID BSR GPIWORD0 ;GET DISPLACEMENT BRA AREGIND * PUT 8 BIT DISPLACEMENT GPDISP8 BSR GETOPC ;GET EXTENSION WORD BSR PUTBYTE ;PUT 8 BIT DISPLACEMENT RTS * ADR REG IND WITH INDEX & DISPL. AREGII BSR GPDISP8 BSR AREGIND ;PUT ADDRESS REGISTER PUTINDX MOVE.B #',',-1(A6) ;REPLACE ')' BY ',' EXG D5,D7 ROL #4,D5 BTST #3,D5 ;D/A FLAG BNE PUTINDX1 BSR DREGD BRA PUTINDX2 PUTINDX1 BSR AREGD PUTINDX2 MOVEQ #15,D1 JSR PUTWL EXG D7,D5 BRA PUTRBR * PC INDIRECT WITH DISPLACEMENT PCINDD BSR GPIWORD0 ;16 BIT DISPLACEMENT PUTPC MOVE.B #'(',(A6)+ MOVE.B #'P',(A6)+ MOVE.B #'C',(A6)+ BRA PUTRBR * PC INDIRECT WITH INDEX & DISPL. PCINDI BSR GPDISP8 BSR PUTPC BRA PUTINDX * IMMEDIATE DATA (B/W/L IN BIT 8-6) IMMDAT JSR TST76 BNE IMMDAT1 ;B/W/L, NO ADDRESS MOVEQ #1,D4 ;SIZE = W BTST #8,D5 BEQ IMMDAT1 MOVEQ #2,D4 ;SIZE = L IMMDAT1 SUBQ #1,D4 BMI GPIBYTE ;SIZE = BYTE BEQ GPIWORD ;SIZE = WORD * GET & PUT IMMEDIATE LONG GPILONG BSR PUTPND GPILONG0 JSR GETOPC ;GET FIRST DATA WORD SWAP D7 JSR GETOPC ;GET SECOND DATA WORD * PUT HEX LONGWORD -> BUFFER PUTLONG MOVEQ #4,D0 BSR PUTNO ;SIGNAL HEX FIELD MOVE.L D7,(A6)+ RTS * GET & PUT IMMEDIATE WORD GPIWORD BSR PUTPND GPIWORD0 JSR GETOPC ;GET DATA WORD * PUT HEX WORD -> BUFFER PUTWORD MOVEQ #2,D0 BSR PUTNO MOVE.W D7,(A6)+ RTS * PUT '#', THEN PUT BYTE PUTPBYTE BSR PUTPND BRA PUTBYTE * GET & PUT IMMEDIATE BYTE GPIBYTE BSR PUTPND GPIBYTE0 JSR GETOPC ;GET DATA WORD, USE ONLY LOW BYTE * PUT HEX BYTE -> BUFFER PUTBYTE MOVEQ #1,D0 BSR PUTNO MOVE.B D7,(A6)+ RTS * SIGNAL HEX FIELD PUTNO MOVE.B #'$',(A6)+ CLR.B (A6)+ ;END OF TEXT ST (A6)+ ;$FF => NUMBER FOLLOWS MOVE.B D0,(A6)+ ;OPERAND SIZE MOVE.L A6,D0 BTST #0,D0 BEQ PUTNO1 ;EVEN ADDRESS ADDQ #1,A6 ;MAKE A6 EVEN PUTNO1 RTS * PUT '#' -> BUFFER PUTPND MOVE.B #'#',(A6)+ RTS * * PRINT DISASSEMBLED INSTRUCTION * PRTBUF CLR.B (A6)+ ;SIGNAL END OF BUFFER CLR.B (A6) MOVEA #LSTBUF,A0 BSR OPCLIN MOVEQ #16,D0 JSR HTABN PRTBUF1 MOVE.B (A0),D0 BEQ DISASMX ;END OF BUFFER BMI PRTBUF2 JSR PRTTEXT ;DISPLAY CHAR. BRA PRTBUF1 PRTBUF2 ADDQ #1,A0 ;ADVANCE TO SIZE BYTE MOVE.B (A0)+,D0 ;GET SIZE BYTE MOVE.L A0,D1 BTST #0,D1 BEQ PRTBUF3 ;EVEN ADDRESS ADDQ.L #1,A0 ;MAKE ADDRESS EVEN PRTBUF3 SUBQ.B #2,D0 BHI PRTBUF5 ;SIZE = LONG BEQ PRTBUF4 ;SIZE = WORD MOVE.B (A0)+,D1 JSR PRTHEX BRA PRTBUF1 PRTBUF4 MOVE.W (A0)+,D2 JSR PRTWHEX BRA PRTBUF1 PRTBUF5 MOVE.L (A0)+,D2 JSR PRTLHEX BRA PRTBUF1 * * OPCODE GROUP A: UNASSIGNED * GRA NOP ;FALL THROUGH TO GROUP F * * OPCODE GROUP F: UNASSIGNED * GRF MOVEA #UNIMPTXT,A0 BRA ILLOPC0 * * ERROR EXIT : ILLEGAL OPCODE * ILLOPC MOVEA #ILLOPTXT,A0 ILLOPC0 BSR OPCLIN JSR PRTSPC ;PRINT 'TEXT' + ' : $' + OPCODE JSR PRTCOL JSR PRTSPC JSR PRTDOL MOVE D7,D2 JSR PRTWHEX ;PRINT OPCODE * EXIT DISASSEMBLER DISASMX MOVE.L DISASMSP,SP ;RESTORE SP MOVEM.L (SP)+,D0-A0/A2-A6 ;RESTORE REGISTERS JMP PRTCR ;NEW LINE & EXIT * PRINT FIRST PART OF DISASM TEXT OPCLIN JSR PRTCR ;FINISH OBJECT LINE MOVEQ #7,D0 JSR HTABN JMP PRTTEXT ;PRINT MNEMNONIC * * CHAIN MON68.SPEC.S SHAR_EOF if test 17308 -ne "`wc -c < 'mon68.dasm.s'`" then echo shar: "error transmitting 'mon68.dasm.s'" '(should have been 17308 characters)' fi fi echo shar: "extracting 'mon68.spec.s'" '(3606 characters)' if test -f 'mon68.spec.s' then echo shar: "will not over-write existing file 'mon68.spec.s'" else cat << \SHAR_EOF > 'mon68.spec.s' **************************** * * * MON68K * * * * A 68000 Monitor Program * * * * VERSION 2.2 15-JUL-84 * * * **************************** * * * mon68.spec.s: hardware-specific subroutines; these rely on/are * used by support routines on the host (6502) side * * * Source code donated to the public domain, 17 Oct 1989 * * You may use this code in any way you see fit, including * incorporating some or all of it into a project of your own, * commercial or otherwise. I would appreciate receiving some * credit if you decide to use some of my code, but as this is * quite unenforceable it remains a wish, not a condition. * * Naturally, I can make no guarantees as to the code's correctness * or suitability for any purpose, although I would hope that it is * both reasonably correct and suitable for something, and I know * that it works on my equipment. * * If you wish to contact me, you can write to me at the address * below or send me e-mail (until April 90) at: * * thomasw@jupiter.cs.concordia.ca * or: thomasw@concour.cs.concordia.ca * * Written by: Thomas Wieland * 4615 Walkley #21 * Montreal, PQ * H4B 2K7 * Canada * * * * *************************** * DTACK SPECIFIC ROUTINES * *************************** * * TEST MONITOR CODE & SEND RESULT TO 6502 * STEST68 MOVEQ #0,D0 ;CLEAR I/O REGISTER FOR LONG ADD * MOVEQ #0,D1 ;SUM * MOVEQ #0,D2 ;EOR * MOVEA #CODEST1,A0 * MOVEA #CODEND1,A1 * BSR STEST683 ;TEST FIRST PART OF CODE * MOVE.L D1,D3 ;SAVE RESULTS * MOVE.B D2,D4 * MOVEQ #0,D1 * MOVEQ #0,D2 * MOVEA #CODEST2,A0 * MOVEA #CODEND2,A1 * BSR STEST683 ;TEST SECOND PART OF CODE * ADD.L D3,D1 * EOR.B D4,D2 * CMP.L TSTSUM,D1 ;COMPARE WITH TESTDATA * BNE STEST681 ;WRONG CHECKSUM * CMP.B TSTEOR,D2 * BNE STEST681 ;WRONG EOR MOVEQ #$FF,D0 ;RESULT CORRECT BRA STEST682 *STEST681 MOVEQ #0,D0 ;WRONG CHECKSUM OR EOR **STEST681 MOVEQ #$FF,D0 ;FOR TEST ONLY STEST682 MOVEQ #3,D3 JSR PRTNCHR ;SEND RESULT THREE TIMES JMP IDLE ;RETURN TO ROM MONITOR * *STEST683 MOVE.B (A0)+,D0 ;GET BYTE * ADD.L D0,D1 ;D1 IS CHECKSUM * EOR.B D0,D2 ;D2 IS ACCUM. EOR * CMPA A0,A1 * BCC STEST683 * RTS * * DETERMINE SYSTEM MEMORY SIZE * MEMSIZE MOVEA #0,A0 ;INITIALIZE BASE ADDRESS MOVE #$4000,D2 ;INITIALIZE STEPSIZE MEMSIZE1 ADDA D2,A0 ;GET NEXT BASE ADDRESS MOVE.B (A0),D0 ;GET TESTBYTE MOVE.B D0,D1 ;COPY THE ORIGINAL NOT.B D1 ;COMPLEMENT ORIGINAL MOVE.B D1,(A0) ;CHANGE MEMORY IF RAM ROL.B #8,D0 ;INSERT 22 WAITCYCLES CMP.B (A0),D1 ;TEST IF RAM BNE MEMSIZE2 ;THERE IS NO RAM MOVE.B D0,(A0) ;RESTORE ORIGINAL BYTE BRA MEMSIZE1 ;TAKE NEXT STEP MEMSIZE2 SUBA D2,A0 ;RESTORE PREVIOUS ADDRESS LSR #1,D2 ;REDUCE STEPSIZE BNE MEMSIZE1 ;AND START OVER RTS ;HIGHEST RAM ADDRESS IN A0 * * I/O HANDLER FOR USER PROGRAMS * IOHDL CHK #25,D4 ;CHECK ARGUMENT RANGE MOVE.L A1,-(SP) ADD D4,D4 ;DOUBLE TO USE AS INDEX MOVEA D4,A1 MOVEA IOTBL(A1),A1 ;GET I/O ROUTINE ADDRESS JSR (A1) MOVE.L (SP)+,A1 RTS * * DETERMINE MONITOR ENTRY POINTS * MONENTP MOVE VERSION,D0 ;VERSION NUMBER MOVE.L RAMLOW,D1 ;LOWEST USER RAM MOVE.L RAMHIGH,D2 ;HIGHEST USER RAM MOVEA #CLDSTRT,A0 ;MONITOR COLDSTART MOVEA #WRMSTRT,A1 ;MONITOR WARMSTART MOVEA #IOHDL,A2 ;MONITOR I/O HANDLER (by number) MOVEA #IOTBL,A3 ;VECTORS TO I/O ROUTINES MOVEA #JMPTBL,A4 ;VECTORS TO MONITOR COMMANDS MOVEA #MOVE0,A5 ;ENTRYPOINT FOR MEMORY MOVE MOVEA #DISASM,A6 ;ENTRYPOINT FOR DISASSEMBLER RTS * * CHAIN MON68.IO.S SHAR_EOF if test 3606 -ne "`wc -c < 'mon68.spec.s'`" then echo shar: "error transmitting 'mon68.spec.s'" '(should have been 3606 characters)' fi fi echo shar: "extracting 'mon68.io.s'" '(16417 characters)' if test -f 'mon68.io.s' then echo shar: "will not over-write existing file 'mon68.io.s'" else cat << \SHAR_EOF > 'mon68.io.s' **************************** * * * MON68K * * * * A 68000 Monitor Program * * * * VERSION 2.2 15-JUL-84 * * * **************************** * * * mon68.io.s: line editor & I/O subroutines * * * Source code donated to the public domain, 17 Oct 1989 * * You may use this code in any way you see fit, including * incorporating some or all of it into a project of your own, * commercial or otherwise. I would appreciate receiving some * credit if you decide to use some of my code, but as this is * quite unenforceable it remains a wish, not a condition. * * Naturally, I can make no guarantees as to the code's correctness * or suitability for any purpose, although I would hope that it is * both reasonably correct and suitable for something, and I know * that it works on my equipment. * * If you wish to contact me, you can write to me at the address * below or send me e-mail (until April 90) at: * * thomasw@jupiter.cs.concordia.ca * or: thomasw@concour.cs.concordia.ca * * Written by: Thomas Wieland * 4615 Walkley #21 * Montreal, PQ * H4B 2K7 * Canada * * * * ******************* * I/O SUBROUTINES * ******************* * * * GET & EDIT ONE LINE OF INPUT, * HANDLE CONTROL CHARACTERS * * Note: this routine implements a simple line editor * GETLIN BSR.L PRTPRMPT ;SEND CURRENT PROMPT GETLIN0 MOVEQ #0,D1 ;INITIALIZE CURSOR CHAR. MOVEQ #0,D2 ;INITIALIZE COUNT MOVEQ #0,D7 ;CLEAR FLAGS MOVEA #INBUF,A4 ;CURRENT CHARACTER MOVEA A4,A5 ;START OF INPUT BUFFER MOVEA A4,A6 ;END OF INPUT BUFFER GETLIN1 MOVE.B STATUS,D0 BMI GETLIN5 ;CHAR. IS WAITING * WAIT FOR CHARACTER BTST #CURSOR,D7 ;CURSOR CHAR. VALID ? BNE GETLIN4 ;YES CMPA A4,A6 ;AT END OF BUFFER ? BLS GETLIN2 ;YES, GET CHAR. FROM SCREEN MOVE.B (A4),D1 ;NO, GET CHAR. FROM BUFFER BRA GETLIN3 GETLIN2 MOVEQ #$15,D0 BSR.L SENDBYTE ;SEND CTRL-U BSR.L GETBYTE MOVE.B D0,D1 ;SAVE CURSOR CHAR. GETLIN3 BSET #CURSOR,D7 ;CURSOR CHAR. VALID GETLIN4 MOVEQ #2,D0 BSR.L PRTSFCT ;2=INVERSE MOVE.B D1,D0 BSR.L SENDBYTE ;MARK CURSOR BSR.L PRTBS MOVEQ #1,D0 BSR.L PRTSFCT ;1=NORMAL BRA GETLIN1 * GET & PROCESS INPUT CHARACTER GETLIN5 BSR.L GETBYTE ;GET CHARACTER GETLIN50 CMPI.B #SPC,D0 BCS GETCTRL ;CONTROL CHARACTER GETLIN6 BTST #INSMOD,D7 ;ARE WE IN INSERT MODE ? BEQ GETLIN8 ;NO ADDQ.B #1,D2 BCS BUFFOVL ;NO ROOM IN BUFFER CMPA A4,A6 BLS GETLIN9 ;AT END OF BUFFER, JUST ADD CHAR. MOVE A6,A3 ;COPY OLD EOB PTR ADDQ #1,A6 ;ADD NEW CHAR. GETLIN7 MOVE.B -(A3),1(A3) ;MOVE CHAR.S UP FROM BACK CMPA A3,A4 BNE GETLIN7 ;MOVE UP TO CURSOR MOVE.B D0,(A4)+ ;INSERT CHAR. & MOVE CURSOR PTR MOVE A4,A0 SUBQ #1,A0 ;SET A0 TO START OF TEXT CLR.B (A6) ;DELIMIT TEXT BSR.L PRTTEXT ;PRINT NEW LINE MOVE A6,D3 SUB A4,D3 ;CALC. NO. OF BS MOVEQ #BS,D0 BSR.L PRTNCHR ;BACKSPACE TO CURSOR POSITION BRA GETLIN1 * GETLIN8 CMPA A4,A6 ;AT END OF BUFFER ? BNE GETLIN10 ;NO ADDQ.B #1,D2 BCS BUFFOVL ;BUFFER OVERFLOW GETLIN9 ADDQ #1,A6 ;INCREMENT END PTR GETLIN10 MOVE.B D0,(A4)+ ;ADD CHAR. TO BUFFER BCLR #CURSOR,D7 ;NEED NEW CURSOR CHAR. GETLIN11 BSR.L SENDBYTE ;ECHO CHARACTER BRA GETLIN1 ;GET NEXT BYTE * * BUFFER OVERFLOW * BUFFOVL BCLR #INSMOD,D7 ;CANCEL INSERT MODE SUBQ.B #1,D2 ;ADJUST COUNT BSR.L PRTBEL BRA GETLIN1 ;GET NEXT CHAR. * * HANDLE CONTROL CHARACTERS * GETCTRL CMPI.B #$1A,D0 ;CTRL-Z BHI GETLIN1 ;IGNORE CHAR.S > CTRL-Z BCLR #INSMOD,D7 ;CTRL-CHAR.S END INSERT ANDI #%00011111,D0 ;CLEAR HIGH BITS MOVEA D0,A3 ;USE CTRL-CHAR. AS INDEX ADDA A3,A3 ;DOUBLE INDEX MOVE CTRLTBL(A3),A3 ;GET SUBROUTINE ADDRESS JSR (A3) ;EXECUTE SUBROUTINE BRA GETLIN11 ;ECHO CHARACTER * * CONTROL CHARACTER SUBROUTINES * IGNORECC ADDQ #4,SP ;DROP RETURN ADDRESS BRA GETLIN1 ;GET NEXT CHARACTER * ECHOCC RTS ;ECHO CHAR. IN D0.B * CTRLA BSET #INSMOD,D7 ;INSERT MODE FROM NOW ON BRA IGNORECC * CTRLB CMPA A4,A5 ;CURSOR AT BEGINNING ? BEQ IGNORECC ;YES BSR REPLCRS MOVE A4,D3 SUB A5,D3 ;CALC. NO. OF BS MOVEQ #BS,D0 BSR.L PRTNCHR ;BACKSPACE TO START MOVE A5,A4 ;SET CURSOR TO SOB BRA IGNORECC * CTRLC BTST #CURSOR,D7 BEQ IGNORECC MOVE.B D1,D0 ;GET CHAR. UNDER CURSOR CMPI.B #'@',D0 BCS CTRLC1 ;CHAR. NOT CONVERTIBLE EORI.B #%00100000,D0 ;CONVERT TO OPPOSITE CASE CTRLC1 ADDQ #4,SP ;DROP RETURN ADDRESS BRA GETLIN8 ;ADD CHAR. TO BUFFER * CTRLD CMPA A4,A6 ;IS CURSOR AT END ? BEQ IGNORECC ;DON'T HAVE TO DELETE SUBQ #1,A6 ;ADJUST EOI PTR SUBQ #1,D2 ;ADJUST COUNT BCLR #CURSOR,D7 ;NEED NEW CURSOR MOVEA A4,A3 ;COPY CURRENT CURSOR CTRLD1 CMPA A3,A6 BEQ CTRLD2 ;ALL CHAR.S MOVED MOVE.B 1(A3),(A3)+ ;MOVE CHAR.S BACK BRA CTRLD1 CTRLD2 CLR.B (A6) ;MARK END OF BUFFER MOVEA A4,A0 ;SET A0 TO CURSOR POSITION BSR.L PRTTEXT ;DISPLAY REST OF BUFFER BSR.L PRTSPC ;BLANK OUT LAST CHAR. MOVE A6,D3 SUB A4,D3 ;CALC. NUMBER OF BACKSPACES MOVEQ #BS,D0 BSR.L PRTNCHR0 ;BACKSPACE TO CURSOR BRA IGNORECC * CTRLE BSR.L NEWCNT ;CLEAR BUFFER RIGHT OF CURSOR BRA REPLCRS ;REPLACE CURSOR & ECHO CTRL-CHAR. * CTRLJ MOVEQ #BS,D0 ;CTRL-H * CTRLH CMPA A4,A5 BEQ IGNORECC ;DON'T BACKSPACE OVER PROMPT SUBQ #1,A4 ;SET CURSOR PTR BACK BRA REPLCRS ;REPLACE CURSOR & BACKSPACE * CTRLI TST.B D2 ;TEST COUNT BNE IGNORECC ;MOVE CURSOR ONLY IF COUNT=0 * REPLACE CURSOR & ECHO CTRL-CHAR. IN D0 REPLCRS MOVE D0,-(SP) ;SAVE CTRL-CHAR. BTST #CURSOR,D7 BNE REPLCRS1 ;CURSOR CHAR. SAVED MOVEQ #SPC,D0 ;TO BLANK OUT CURSOR BRA REPLCRS2 REPLCRS1 MOVE.B D1,D0 ;GET CHAR. UNDER CURSOR BCLR #CURSOR,D7 REPLCRS2 BSR.L SENDBYTE ;REPLACE CURSOR BSR.L PRTBS ;BACKSPACE ONCE MOVE (SP)+,D0 ;RESTORE CTRL-CHAR. RTS * CTRLM BSR REPLCRS ;REPLACE CURSOR MARKER CTRLM1 MOVEA A5,A3 ;SET A3 TO START OF BUFFER BCLR #ASCLST,D7 ;NO LIST AT START CTRLM2 CMPA A3,A6 ;ALL DONE WITH INPUT ? BLS CTRLM5 MOVE.B (A3)+,D0 ;GET CHAR. FROM BUFFER CMPI.B #SQT,D0 ;SINGLE QUOTE ? BEQ CTRLM3 CMPI.B #DQT,D0 ;DOUBLE QUOTE ? BNE CTRLM4 ;NO QUOTE CTRLM3 BCHG #ASCLST,D7 ;TOGGLE FLAG BRA CTRLM2 CTRLM4 BTST #ASCLST,D7 BNE CTRLM2 ;INSIDE LIST CMPI.B #$5F,D0 BLS CTRLM2 ;CHAR. IS UPPERCASE ANDI #%11011111,D0 ;CONVERT TO UPPERCASE MOVE.B D0,-1(A3) ;REPLACE LOWERCASE CHAR. BRA CTRLM2 CTRLM5 BSR.L CANCEL1 ;SEND CR'S MOVE.B D0,(A6) ;MARK END OF INPUT LINE ADDQ #4,SP ;DROP RETURN ADDRESS BRA.L SENDBYTE ;SEND CR & EXIT GETLIN * CTRLN CMPA A4,A6 ;CURSOR AT END ? BEQ IGNORECC ;YES MOVEA A4,A0 CLR.B (A6) ;DELIMIT TEXT BSR.L PRTTEXT MOVE A6,A4 ;SET CURSOR TO EOB BCLR #CURSOR,D7 BRA IGNORECC * CTRLQ MOVE A6,D3 ;CHAR.S FROM CURSOR TO LAST CHAR SUB A4,D3 ;SET COUNT BEQ CTRLQ1 ;COUNT IS ZERO MOVEQ #SPC,D0 BSR.L PRTNCHR ;BLANK OUT LINE CTRLQ1 BSR.L PRTEOL ;CLEAR REST OF LINE BSR.L NEWCNT BRA CTRLM1 ;REST SAME AS CTRLM * CTRLR MOVE A4,-(SP) ;SAVE CURRENT POSITION CTRLR1 MOVE.B (A4)+,D0 ;GET CHAR. FROM BUFFER BMI CTRLR2 ;INVALID CHAR. IN BUFFER CMPI.B #CR,D0 BEQ CTRLR3 ;FOUND END OF INPUT CMPI.B #SPC,D0 BCS CTRLR2 ;CTRL CHAR. IN BUFFER ADDQ.B #1,D2 ;INCR. CHAR.COUNT BCC CTRLR1 ;STILL ROOM IN BUFFER CTRLR2 BSR.L PRTBEL MOVE (SP)+,A4 ;RESTORE CURSOR POSITION BRA IGNORECC ;LINE CANNOT BE RESTORED CTRLR3 SUBQ #1,A4 ;POINT A4 TO CR MOVE A4,A6 ;SET END OF BUFFER CLR.B (A4) ;DELIMIT BUFFERTEXT MOVE (SP)+,A0 ;SET TO START OF BUFFER BSR.L PRTTEXT ;PRINT RESTORED LINE BCLR #CURSOR,D7 BRA IGNORECC * CTRLL MOVEQ #$15,D0 ;CTRL-U * CTRLU CMPA A4,A6 BLS CTRLU1 ;CURSOR AT END OF BUFFER MOVE.B (A4)+,D0 ;GET CHAR. FROM BUFFER BRA CTRLU5 CTRLU1 ADDQ.B #1,D2 BCC CTRLU2 ;STILL ROOM IN BUFFER ADDQ #4,SP ;DROP RETURN ADDRESS BRA BUFFOVL ;BUFFER FULL CTRLU2 ADDQ #1,A6 ;ADVANCE EOB PTR BTST #CURSOR,D7 BNE CTRLU3 BSR.L SENDBYTE ;SEND CTRL-U BSR.L GETBYTE ;GET CHAR. AT CURSOR BRA CTRLU4 CTRLU3 MOVE.B D1,D0 ;GET SAVED CURSOR CHAR. CTRLU4 MOVE.B D0,(A4)+ ;ADD CHAR. & ADVANCE CURSOR CTRLU5 BCLR #CURSOR,D7 ;NEED NEW CURSOR RTS ;SEND BYTE IN D0 * CTRLV ADDQ #4,SP ;DROP RETURN ADDRESS BSR.L GETBYTE ;GET NEXT CHAR. CMPI.B #']',D0 BEQ CTRLV1 CMPI.B #'.',D0 BEQ CTRLV2 CMPI.B #'/',D0 BNE GETLIN50 ;TREAT ALL OTHERS LIKE NORMAL INPUT MOVEQ #'\',D0 ;REPLACES '/' BRA CTRLV3 CTRLV1 MOVEQ #'[',D0 ;REPLACES ']' BRA CTRLV3 CTRLV2 MOVEQ #'_',D0 ;REPLACES '.' CTRLV3 BRA GETLIN8 ;ADD CHAR. TO BUFFER * CTRLX BSR CANCEL ;CANCEL DISPLAY LINE CTRLX1 ADDQ #4,SP ;DROP RETURN ADDRESS BRA GETLIN ;START NEW INPUT LINE * CANCEL MOVEQ #'\',D0 BSR.L SENDBYTE CANCEL1 MOVEQ #CR,D0 MOVEQ #0,D3 ;CLEAR D3 MOVE A6,D3 ;CALC. CHAR.S SUB A4,D3 ;FROM CURSOR TO END DIVU #40,D3 ;40 CHAR.S PER LINE BEQ RTS1 ;STILL ON SAME LINE JMP PRTNCHR ;SEND CR'S & EXIT * NEWCNT MOVEA A4,A6 ;CURRENT=LAST CHAR. MOVE A4,D2 SUB A5,D2 ;CALC. NEW CHAR. COUNT RTS * * SEND CURRENT PROMPT CHARACTER * PRTPRMPT TST.B PROMPT BEQ RTS1 ;0 => NO PROMPT WANTED BSR.L PRTCR ;SEND CR MOVE.B PROMPT,D0 ;GET CURRENT PROMPT BSR.L SENDBYTE MOVEQ #'>',D0 BRA.L SENDBYTE ;SEND PROMPT & RETURN * * SEND STRING POINTED TO BY A0 * PRTTEXT MOVE.B (A0)+,D0 ;GET ONE CHARACTER BEQ RTS1 ;ASCII NUL IS DELIMITER BSR.L SENDBYTE ;SEND BYTE TO 6502 BRA PRTTEXT * * PRINT N = (D3) CHARACTERS * PRTNCHR BRA PRTNCHR1 ;LET DBF DECREMENT COUNT PRTNCHR0 BSR.L SENDBYTE ;SEND CHAR. IN D0 PRTNCHR1 DBF D3,PRTNCHR0 ;LOOP UNTIL DONE RTS1 RTS * * REQUEST SPECIAL FUNCTION * D0: FUNCTION CODE * PRTSFCT MOVE D0,-(SP) ;SAVE FUNCTION CODE MOVEQ #$FF,D0 ;SPECIAL FUNCTION TOKEN BSR.L SENDBYTE MOVE (SP)+,D0 ;RESTORE CODE BRA.L SENDBYTE * * REGISTER & MEMORY DUMP * A3 : ^ REGMASK & ADR TABLE * A4 : ^ START OF REG SAVE AREA * PRTMREG MOVE.L (A3)+,D6 ;GET OUTPUT REGISTER MASK BSR PRTREG ;PRINT REGISTERS MOVEQ #0,D4 ;START OUT IN NEW LINE MOVEQ #NTBL-1,D5 ;NO. OF ENTRIES PRTMREG1 MOVE.L (A3)+,D2 ;GET ADDRESS MOVE (A3)+,D3 ;GET TAGFIELD BMI PRTMREG7 ;UNUSED FIELD => END OF ENTRIES BSR.L PRTADR ;PRINT MEMORY ADDRESS MOVEA.L D2,A4 ;SET POINTER CMPI.B #2,D3 BHI PRTMREG3 ;SIZE = LONG BEQ PRTMREG2 ;SIZE = WORD MOVE.B (A4),D1 ;SIZE = BYTE BSR.L PRTHEX BRA PRTMREG4 PRTMREG2 MOVE (A4),D2 BSR.L PRTWHEX BRA PRTMREG4 PRTMREG3 MOVE.L (A4),D2 BSR.L PRTLHEX PRTMREG4 TST D4 BNE PRTMREG5 ;NOT AT START OF LINE MOVEQ #20,D0 BSR.L HTABN ;HTAB TO RIGHT HALF OF SCREEN MOVEQ #$FF,D4 BRA PRTMREG6 PRTMREG5 BSR.L PRTCR ;START NEW LINE MOVEQ #0,D4 PRTMREG6 DBF D5,PRTMREG1 PRTMREG7 SUBI #NTBL-1,D5 BEQ RTS2 ;NO MEM. LOCATION PRINTED JSR PRTCR TST D4 BEQ RTS2 ;WE WERE ALREADY IN NEW LINE JSR PRTCR RTS2 RTS * * REGISTER DUMP * D6 : REGISTER SELECT MASK * A4 : ^ START OF REG SAVE AREA * PRTREG MOVEQ #'D',D5 BSR PRT8REG ;PRINT SELECTED DATA REGS MOVEQ #'A',D5 BSR PRT8REG ;PRINT SELECTED ADDRESS REGS TST.L D6 BPL RTS2 ;DON'T DISPLAY STATUS REGISTER MOVEA #FLGXLST,A1 ;EXTENDED FLAGNAMES LIST MOVEA #FLAGTXT,A0 BSR.L PRTTEXT MOVE.B (A4),D2 ;GET SYSTEM BYTE MOVEQ #4,D3 BSR PRTFLG ;5 BITS, T-S-- MOVEQ #'I',D0 BSR.L SENDBYTE MOVEQ #'=',D0 BSR.L SENDBYTE MOVE.B (A4)+,D0 ;GET SYSTEM BYTE AGAIN ANDI.B #%00000111,D0 BSR.L PRT1HEX ;PRINT INTERRUPT MASK AS NUMBER BSR PRT7SPC ;TAB TO NEXT COLUMN BSR.L PRTTEXT ;PRINT 'CCR: ' MOVE.B (A4)+,D2 ;GET CONDITION CODES MOVEQ #7,D3 BSR PRTFLG ;8 BITS, ---XNZVC JMP PRT2CR * PRINT FLAGS NAMES & SETTINGS PRTFLG MOVE.B (A1)+,D1 ;GET FLAGNAME LSL.B #1,D2 BCC PRTFLG1 ;FLAG NOT SET MOVEQ #2,D0 BSR.L PRTSFCT ;SET INVERSE PRTFLG1 MOVE.B D1,D0 BSR.L SENDBYTE ;SEND FLAGNAME MOVEQ #1,D0 BSR.L PRTSFCT ;SET NORMAL AGAIN DBF D3,PRTFLG RTS * PRINT 8 REGISTERS PRT8REG MOVE.L A4,-(SP) ;SAVE ^ REG.SAVE AREA MOVEQ #'0',D4 ;INIT REG NUMBER PRT8REG1 TST.B D6 BEQ PRT8REG2 ;ALL REGS DONE BSR PRT2REG ;PRINT 2 REGS, SHIFT MASK BRA PRT8REG1 PRT8REG2 LSR #8,D6 ;MOVE MASK DOWN ONE BYTE MOVE.L (SP)+,A4 MOVEQ #8*4,D0 ADDA.L D0,A4 ;ADVANCE POINTER BY 8 REG.S BSR.L PRTBS ;PRINT ONE BLANK LINE JMP PRT2CR ;NEW LINE & EXIT * PRINT UP TO TWO REGISTERS PRT2REG JSR PRT1REG ;MUST BE 'JSR' PRT1REG LSR.B #1,D6 ;LSB->CARRY BCC PRT1REG1 ;DON' PRINT THIS REG MOVE.B D5,D0 BSR.L SENDBYTE ;SEND 'D' OR 'A' MOVE.B D4,D0 BSR.L SENDBYTE ;SEND REG.NUMBER BSR.L PRTSPC BSR.L PRTMIN BSR.L PRTSPC MOVE.L (A4)+,D2 BSR.L PRTLHEX ;PRINT REG CONTENTS ADDQ #1,D4 ;UPDATE REG NUMBER PRT7SPC MOVEQ #SPC,D0 MOVEQ #7,D3 JMP PRTNCHR ;TAB TO NEXT REG.POSITION & EXIT PRT1REG1 ADDQ #4,A4 ;ADVANCE TO NEXT REGISTER ADDQ #1,D4 ;UPDATE REG.NUMBER RTS * * PRINT D2.L AS 4 ASCII CHAR.S * PRTLASC SWAP D2 BSR PRTWASC ;PRINT UPPER WORD SWAP D2 * * PRINT D2.W AS 2 ASCII CHAR.S * PRTWASC MOVE D2,D1 LSR #8,D1 ;SHIFT UPPER CHAR. DOWN BSR PRTASC ;SEND UPPER CHAR. MOVE.B D2,D1 * * PRINT D1.B AS 1 ASCII CHAR. * PRTASC ANDI.B #$7F,D1 ;MASK OFF MSB CMPI.B #SPC,D1 BCS PRTASC1 ;CTRL CHAR. MOVE.B D1,D0 BRA.L SENDBYTE PRTASC1 MOVEQ #2,D0 BSR PRTSFCT ;SET INVERSE MOVE.B D1,D0 ORI.B #%01000000,D0 ;CONVERT TO UPPERCASE BSR.L SENDBYTE MOVEQ #1,D0 BRA PRTSFCT ;SET NORMAL & EXIT * * PRINT D2.L AS 10 DECIMAL DIGITS * PRTLDEC MOVEM.L D2-D6,-(SP) BSR BINDEC MOVE D6,D2 BSR PRTWASC ;PRINT HIGH TWO DIGITS MOVE.L D5,D2 BSR PRTLASC ;PRINT MIDDLE 4 DIGITS BRA PRTWDEC1 * * PRINT D2.W AS 5 DECIMAL DIGITS * PRTWDEC MOVEM.L D2-D6,-(SP) SWAP D2 ;CLEAR HIGH WORD CLR.W D2 SWAP D2 BSR BINDEC MOVE.B D5,D1 BSR PRTASC ;PRINT HIGH DIGIT PRTWDEC1 MOVE.L D4,D2 BSR PRTLASC ;PRINT LOW FOUR DIGITS MOVEM.L (SP)+,D2-D6 RTS * * PRINT D1.B AS 3 DECIMAL DIGITS * PRTDEC MOVEM.L D1-D6,-(SP) MOVEQ #0,D2 ;CLEAR HIGH BYTES MOVE.B D1,D2 ;SET UP BYTE TO CONVERT BSR BINDEC SWAP D4 MOVE.B D4,D1 BSR PRTASC ;PRINT HIGH DIGIT SWAP D4 MOVE.W D4,D2 BSR PRTWASC ;PRINT LOW TWO DIGITS MOVEM.L (SP)+,D1-D6 RTS * * CONVERT D2.L INTO 10 DECIMAL DIGITS IN * D6.W & D5.L & D4.L (HIGH/MID/LOW DIGITS) * BINDEC MOVEQ #10-1,D0 ;SET COUNTER (10 DEC. DIGITS) BINDEC1 MOVEQ #0,D1 ;CLEAR MULT REG. TST.L D2 BEQ BINDEC3 ;WHOLE NUMBER IS ZERO SWAP D2 MOVE D2,D1 BEQ BINDEC2 ;UPPER HALF IS ZERO DIVU #10,D1 MOVE D1,D2 BINDEC2 SWAP D2 MOVE D2,D1 DIVU #10,D1 ;REM. OF UPPER HALF & LOWER HALF MOVE D1,D2 SWAP D1 ;GET TOTAL REMAINDER BINDEC3 ADDI.B #$30,D1 ;CONVERT TO ASCII LSL #8,D1 ;MOVE DIGIT TO UPPER BYTE MOVEQ #8-1,D3 BINDEC4 LSR #1,D6 ;SHIFT RESULT DOWN ONE BYTE ROXR.L #1,D5 ROXR.L #1,D4 DBF D3,BINDEC4 ADD D1,D6 ;ADD DIGIT TO RESULT DBF D0,BINDEC1 RTS * * PRINT D2.L AS 32 BITS * PRTLBIN SWAP D2 BSR PRTWBIN SWAP D2 * * PRINT D2.W AS 16 BITS * PRTWBIN MOVE D2,D1 LSR #8,D1 BSR PRTBIN MOVE D2,D1 * * PRINT D1.B AS 8 BITS * PRTBIN MOVEQ #7,D3 ;SET COUNT PRTBIN1 ASL.B #1,D1 ;MSB TO CARRY BCS PRTBIN2 MOVEQ #'0',D0 BRA PRTBIN3 PRTBIN2 MOVEQ #'1',D0 PRTBIN3 BSR SENDBYTE DBF D3,PRTBIN1 BRA PRTSPC ;SEND BLANK & RETURN * * PRINT ADDRESS IN D2 AS 6 HEX DIGITS * PRTADR SWAP D2 MOVE D2,D1 BSR PRTHEX ;PRINT LOW BYTE OF HIGH WORD SWAP D2 BSR PRTWHEX ;PRINT WORD BRA PRTCOL ;PRINT ':' & EXIT * * PRINT D2.L AS 8 HEX DIGITS * PRTLHEX SWAP D2 BSR PRTWHEX ;FIRST PRINT HIGH WORD SWAP D2 ;THEN PRINT LOW WORD * * PRINT D2.W AS 4 HEX DIGITS * PRTWHEX MOVE D2,D1 LSR #8,D1 ;SHIFT HIGH BYTE DOWN BSR PRTHEX ;FIRST PRINT HIGH BYTE MOVE D2,D1 ;THEN PRINT LOW BYTE * * PRINT D1.B AS 2 HEX DIGITS * PRTHEX MOVE.B D1,D0 LSR.B #4,D0 ;CLEARS UPPER NIBBLE ! BSR PRT1HEX ;FIRST PRINT UPPER NIBBLE MOVE.B D1,D0 * * PRINT LOWER NIBBLE OF D0.B AS 1 HEX DIGIT * PRT1HEX ANDI.B #$0F,D0 ;MASK OFF UPPER NIBBLE ADDI #'0',D0 ;CONVERT TO ASCII CMPI.B #'9',D0 BLS PRT1HEX1 ;CHAR. IS <= "9" ADDQ #7,D0 ;ADJUST A-F PRT1HEX1 BRA SENDBYTE * * SINGLE CHARACTER PRINT ROUTINES * PRTEOL MOVEQ #$05,D0 ;CTRL-E BRA SENDBYTE * PRTEOP MOVEQ #$06,D0 ;CLEAR TO END OF PAGE BRA SENDBYTE * PRTBEL MOVEQ #BEL,D0 BRA SENDBYTE * PRTBS MOVEQ #BS,D0 BRA SENDBYTE * PRTLF MOVEQ #$0B,D0 ;LINE FEED BRA SENDBYTE * PRTCLSC MOVEQ #$0C,D0 ;CTRL-L=CLEAR SCREEN BRA SENDBYTE * PRT2CR JSR PRTCR PRTCR MOVEQ #CR,D0 BRA SENDBYTE * PRT2SPC JSR PRTSPC PRTSPC MOVEQ #SPC,D0 BRA SENDBYTE * PRTPND MOVEQ #'#',D0 BRA SENDBYTE * PRTDOL MOVEQ #'$',D0 BRA SENDBYTE * PRTPCT MOVEQ #'%',D0 BRA SENDBYTE * PRTMIN MOVEQ #'-',D0 BRA SENDBYTE * PRTCOL MOVEQ #':',D0 BRA SENDBYTE * NOP ;PATCH * * **************************** * DTACK BOARD I/O ROUTINES * **************************** * * * SEND BYTE FROM D0.B TO 6502 * SENDBYTE BTST #6,STATUS ;RECEIVER READY ? BNE SENDBYTE ;6502 NOT READY MOVE.B D0,DATOUT ;SEND BYTE RTS * * GET BYTE FROM 6502 INTO D0.B * GETBYTE MOVE.B STATUS,D0 BPL GETBYTE ;NO BYTE RECEIVED MOVE.B DATIN,D0 ;GET BYTE RTS * * CHAIN MON68K.TBL.S SHAR_EOF if test 16417 -ne "`wc -c < 'mon68.io.s'`" then echo shar: "error transmitting 'mon68.io.s'" '(should have been 16417 characters)' fi fi exit 0 # End of shell archive