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