*    MOVE STACK DOWN 2 PLACES
*
 DES . MAKE ROOM ON STACK FOR ADDRESS OF PART #2
 DES
 TSX . POINT AT DATA ON STACK
 LDAB #7 . 7 BYTES TO MOVE
GO$SBL LDAA 2,X . GET A BYTE
 STAA 0,X
 INX
 DECB 
 BNE GO$SBL
 LDX #GO$SB2 . POINT AT PART #2
 STX TMP$00
 TSX
 LDAB TMP$00 . POINT AT PART #2 (MSB)
 LDAA TMP$00+1 . (LSB)
 STAB 7,X . SET 'RETURN' ADDRESS
 STAA 8,X
 LDAB VALUE . USER'S ADDRESS
 LDAA VALUE+1
 STAB 5,X . SET 'PC'
 STAA 6,X
 BRA GOU$DO
 SPC 1
*
*     SUB-ROUTINE PART #2
*
GO$SB2 SWI . CAUSE A BREAKPOINT CHECK
SUB$RK EQU *
 SPC 1
*
*    PART THREE OF SUB-ROUTINE CALL
*
GO$SB3 STS USTACK . RESTORE USER'S STACK
 TSX
 LDS #STACK . GET THE DEBUG STACK
 LDAB VALUE
 LDAA VALUE+1
 STAB 5,X . PUT CALLED ADDRESS IN PC
 STAA 6,X
 JSR DSPRTS
 JSR CLRBRK . GO RESET THE BREAK POINTS
 JMP MON$
 SPC 1
*
*      CAN'T DO IT
*
GO$BAD LDS #STACK . RESET DEBUG STACK
 JSR WHATER . CANT DO IT
 JMP MON$
 SPC 1
*
*     CONTINUE WITH USER'S PROGRAM
*
GO$CON LDX USTACK
 LDX 6,X . GET USER'S PC
 INC VFLAG . SET THE FLAG
 STX VALUE . SET PC
 JMP GO$USR . GO TO USER'S PROGRAM
 SPC 1
*
*     SET/DISPLAY THE OFFSET
*
OFS$RT TST VFLAG . SET OR DISPLAY
 BEQ OFS$DS . DISPLAY
 LDX VALUE . GET THE NEW OFFSET
 STX OFFSET
 RTS
 SPC 1
*
OFS$DS LDAA #'= . SEND AN EQUAL SIGN
 JSR OUTCH
 LDX #OFFSET . POINT AT THE OFFSET VALUE
 JMP OUT4HS
 SPC 1
*
*      SET/DISPLAY BREAK-POINTS
*
SBKRTN TST VFLAG . SEE IF DISPLAY OR SET
 BEQ BK$DSP
 SPC 1
*
*      SET A BREAK POINT
*
 LDX #BRKPTS . FIND EMPTY BREAK POINT AREA
 LDAB #3 . 3 PLACES TO CHECK
BRK$L0 LDAA 0,X . SEE IF EMPTY
 ORAA 1,X
 BEQ BRK$00
 INX . MOVE TO NEXT PLACE
 INX
 INX
 INX
 DECB
 BNE BRK$L0
 SPC 1
*
BRK$00 LDAB VALUE . POINT AT ADDRESS OF BREAK POINT
 LDAA VALUE+1
 STAB 0,X . SAVE THIS AREA
 STAA 1,X
 CLR 2,X
 CLR 3,X
 RTS
 SPC 1
*
*     DISPLAY THE BREAK POINTS
*
BK$DSP LDX #BRKSTG . SEND THE STRING MESSAGE
 JSR PDATA
 LDX #BRKPTS . POINT AT THE BREAK POINT ADDRESSES
 LDAB #4 . 4 TO DISPLAY
 SPC 1
*
BK$DL0 JSR OUT4HS . PRINT THE ADDRESS
 INX
 INX
 DECB
 BNE BK$DL0
 RTS
 SPC 1
*
*     CLEAR BREAK POINTS
*
CBKRTN TST VFLAG . DO ALL OR ONE?
 BEQ CBK$AL . ALL
 SPC 1
*
*     SEARCH FOR BREAK POINT ADDRESS
*
 LDX #BRKPTS . POINT AT THE TABLE
 LDAB #4 . 4 PLACES TO CHECK
 STAA TMP$00
 LDAB VALUE 
 LDAA VALUE+1
CBK$L0 CMPB 0,X . CHECK MSB
 BNE CBK$NX . NOT THIS ONE
 CMPA 1,X . CHECK LSB
 BEQ CBK$CL . CLEAR THIS LOCATION
CBK$NX INX . MOVE TO NEXT LOCATION
 INX
 INX
 INX
 DEC TMP$00 . DECR. COUNTER
 BNE CBK$L0
 RTS
 SPC 1
*
CBK$CL CLR 0,X . CLEAR THIS LOCATION
 CLR 1,X
 CLR 2,X
 CLR 3,X
 RTS
 SPC 1
*
*     CLEAR ALL BREAK POINTS
*
CBK$AL LDX #BRKPTS . POINT AT TABLE
 LDAB #4*4 . 4 SETS
CBK$L1 CLR 0,X
 INX
 DECB
 BNE CBK$L1
 RTS
 SPC 1
*
*       SET BREAK POINTS IN MEMORY
*
SETBRK LDX #BRKPTS . POINT AT BREAK POINT TABLE
 LDAB #4
SET$B0 STX TMP$03 . SAVE THE POINTER
 LDX 0,X . GET ADDRESS
 BEQ SET$NX . DO NEXT
 LDAA 0,X . GET THE BYTE
 LDX TMP$03 . RESTORE THE POINTER
 STAA 2,X . SAVE IT
 LDX 0,X . POINT AT ADDRESS AGAIN
 LDAA #$3F . SET BREAK POINT IN THIS LOCATION
 STAA 0,X
SET$NX LDX TMP$03 . MOVE TO NEXT LOCATION
 INX
 INX
 INX
 INX
 DECB
 BNE SET$B0
 RTS
 SPC 1
*
*     RESTORE THE BREAK POINT VALUES
*
CLRBRK LDX #BRKPTS . POINT AT TABLE
 LDAB #4
CLR$B0 STX TMP$03 . SAVE THE POINTER
 LDAA 2,X . GET THE OPCODE
 LDX 0,X . POINT AT THE OPCODE ADDRESS
 BEQ CLR$NY 
 STAA 0,X . RESTORE IT
CLR$NY LDX TMP$03 . MOVE TO NEXT LOCATION
 INX
 INX
 INX
 INX
 DECB
 BNE CLR$B0
 RTS
 SPC 1
*
*     GET BEGIN AND END ADDRESSES
*
BEGEND LDX #BEGMSG . SEND THE QUESTION
 JSR BEGVAL . GET A VALUE AND A CHAR.
 BNE BEGEXT . NO
 STX BEGADR . SAVE THE VALUE
 LDX #ENDMSG . SEND THE QUESTION
 BSR BEGVAL . GET THE VALUE
 BNE BEGEXT . NO
 STX ENDADR . SAVE THE 'END' ADDRESS
 CLC
 RTS
 SPC 1
*
*   SEND STRING AND GET THE VALUE
*
BEGVAL JSR PDATA . SEND STRING TO DISPLAY
 LDX #DUMTBL . POINT AT DUMMY TABLE
 JSR GETCMD . GET A VALUE
 LDX VALUE
 CMPA #CR . SEE IF GOOD VALUE
 RTS
 SPC 1
*
*   ERROR EXIT FROM BEGEND ROUTINE
*
BEGEXT SEC
 RTS
 SPC 1
*
*     FILL MEMORY FROM XXXX TO YYYY WITH ZZ
*
FILMEM LDAA VALUE+1 . GET THE FILL VALUE
 PSHA . SAVE IT
 BSR BEGEND . GET THE ADDRESSES
 BCS FIL$EX . FORGET IT
 LDAB OFFSET . ADD THE OFFSET
 LDAA OFFSET+1
 ADDA ENDADR+1 . SET THE FROM ADDRESS
 ADCB ENDADR
 ADDA #1 . SET STOP ADDRESS
 ADCB #0
 STAB ENDADR
 STAA ENDADR+1
 LDAB OFFSET
 LDAA OFFSET+1
 ADDA BEGADR+1 . SET THE TO ADDRESS
 ADCB BEGADR
 STAB BEGADR
 STAA BEGADR+1
 PULA . GET FILL CHAR.
 LDX BEGADR . GET 'FROM' ADDRESS
 SPC 1
*
FIL$L0 STAA 0,X . STORE THE BYTE
 INX
 CPX ENDADR . DONE?
 BNE FIL$L0 . NO
 RTS
 SPC 1
*
FIL$EX PULA . RESTORE THE STACK
 RTS
 SPC 1
*
*     COMPARE MEMORY FROM XXXX TO YYYY WITH ZZ
*
CMPMEM LDAA VALUE+1 . GET THE COMPARE VALUE
 PSHA . SAVE IT
 BSR BEGEND . GET THE ADDRESSES
 BCS CMP$EX . FORGET IT
 LDAB OFFSET . ADD THE OFFSET
 LDAA OFFSET+1
 ADDA ENDADR+1 . SET THE FROM ADDRESS
 ADCB ENDADR
 ADDA #1 . SET STOP ADDRESS
 ADCB #0
 STAB ENDADR
 STAA ENDADR+1
 LDAB OFFSET
 LDAA OFFSET+1
 ADDA BEGADR+1 . SET THE TO ADDRESS
 ADCB BEGADR
 STAB BEGADR
 STAA BEGADR+1
 PULA . GET COMPARE CHAR.
 LDX BEGADR . GET 'FROM' ADDRESS
 SPC 1
*
CMP$L0 LDAB 0,X . GET THE BYTE
 CBA . COMPARE THE BYTES
 BEQ CMP$NX . DATA COMPARED, MOVE ON
 SPC 1
*
*    SEND AN ERROR MESSAGE
*
CMP$ER STX TMP$00 . SAVE THE ADDRESS
 STAB TMP$01 . SAVE IT
 PSHA . SAVE THE COMPARE VALUE
 LDX #CMPMSG . SEND THE MESSAGE
 JSR PDATA 
 LDX #TMP$00 . POINT AT THE ADDRESS
 JSR OUT4HS  . SEND THE ADDRESS
 JSR OUT2HS  . SEND THE BAD DATA
 LDX TMP$00  . GET THE POINTER
 PULA . RESTORE THE COMPARE VALUE
 SPC 1
*
CMP$NX INX . MOVE TO NEXT LOCATION
 CPX ENDADR . DONE?
 BNE CMP$L0 . NO
 RTS
 SPC 1
*
CMP$EX PULA . RESTORE THE STACK
 RTS
 SPC 1
*
*    MOVE DATA FROM XXXX TO YYYY
*
MOVMEM LDX VALUE . GET DESTINATION
 STX TMP$00 SAVE IT
 TST VFLAG . WAS A VALUE ENTERED?
 BEQ MOVEXT . NO
 JSR BEGEND . GET ADDRESSES
 BCS MOVEXT . FORGET IT
 LDX ENDADR
 INX . BUMP ADDRESS FOR COMPARISON
 STX ENDADR
 LDX BEGADR . GET 'FROM' ADDRESS
 SPC 1
*
MOVLP0 LDAA 0,X . GET A BYTE
 INX
 STX BEGADR
 LDX TMP$00 . GET DESTINATION ADDRESS
 STAA 0,X . STORE IT
 INX
 STX TMP$00
 LDX BEGADR . FROM ADDRESS
 CPX ENDADR . DONE?
 BNE MOVLP0 . NO
MOVEXT RTS
 SPC 1
*
*    SET/RESET/PRINT IRQ FLAG
*
IRQ$RT TST VFLAG . SET/RESET OR PRINT
 BEQ PRTIRQ . PRINT IT
 LDAA VALUE+1 . GET THE VALUE
 ANDA #%1 . SAVE THE BIT 0 ONLY
 STAA IRQFLG
 RTS
 SPC 1
*
*    PRINT THE FLAG
*
PRTIRQ LDAA #'= . SEND AN EQUAL SIGN
 JSR OUTCH
 LDX #IRQFLG . POINT AT THE FLAG
 JMP OUT2H
 SPC 1
*
*     CHECK FOR OPERATOR INTERVENTION
*
CKBRK LDAA ACSTAT . CHECK FOR CHARACTER
 BITA #RDRF . RDRF TRUE?
 BEQ CKBRKN . NOT YET
 STAA AECHO . NO ECHO
 JSR INCHNP . GET THE CHARACTER
CKBRKL CMPA #$17 . <CNTRL-W>
 BNE CKBRKN . NO
 SPC 1
*
*    WAIT FOR ANOTHER CHARACTER
*
CKBKL JSR INCHNP . WAIT FOR ANOTHER CHARACTER
 CMPA #$18 . <CNTRL-X>
 BNE CKBRKL . DONT ABORT YET
 SEC
 RTS
 SPC 1
*
*    NO INTERVENTION
*
CKBRKN CLR AECHO . CLEAR THE ECHO FLAG
 RTS
 SPC 1
*
*    DISPLAY MEMORY LOCATIONS
*
DSPMEM JSR BEGEND . GET THE BEG-END ADDRESSES
 BCC DMP$00 . OK TO DUMP
 JMP DMP$EX . EXIT
 SPC 1
*
*    DUMP THE MEMORY
*
DMP$00 LDAB BEGADR . SET ON EVEN BOUNDRY
 LDAA BEGADR+1
 ANDA #%11110000 . ZERO OUT LSN
 ADDA OFFSET+1 . ADD THE OFFSET
 ADCB OFFSET
 STAB BEGADR
 STAA BEGADR+1
 LDAB ENDADR
 LDAA ENDADR+1
 ORAA #%1111 . END ON EVEN 16
 ADDA OFFSET+1 . ADD THE OFFSET
 ADCB OFFSET
 ADDA #1 . AND ADD 1
 ADCB #0
 STAB ENDADR
 STAA ENDADR+1
 SPC 1
*
*     MAKE ROOM FOR ASCII DATA ON STACK
*
 LDAB #17 . 17 PLACES
DM$PL0 DES
 DECB
 BNE DM$PL0
 SPC 1
*
*     RESET ASCII BUFFER
*
DMP$L0 BSR CKBRK . CHECK FOR USER INTERVENTION
 BCS DMP$BK . EXIT THE PROGRAM
 TSX . POINT AT THE ASCII BUFFER
 STX TMP$00 . RESET THE POINTER
 SPC 1
*
*     OUTPUT MEMORY DATA
*
DMP$L2 LDX #BEGADR . POINT AT DATA ADDRESS
 JSR PCRLF . NEW LINE
 JSR OUT4HS . PRINT ADDRESS
 LDAB #16 . 16 BYTES TO PRINT
 LDX BEGADR . POINT AT THE DATA
 SPC 1
*
DMP$L3 LDAA 0,X . GET THE BYTE
 STX BEGADR
 CMPA #$7F . SEE IF ASCII
 BHI DMP$NA . NOT ASCII
 CMPA #SPACE-1
 BHI DMP$IA . IT IS ASCII
DMP$NA LDAA #'. . SET TO ASCII <.>
DMP$IA LDX TMP$00 . STORE OUT THE CHAR.
 STAA 0,X
 INX
 STX TMP$00
 LDX BEGADR . POINT AT THE DATA AGAIN
 JSR OUT2HS
 DECB
 BNE DMP$L3
 SPC 1
*
*     PRINT ASCII DATA
*
 STX BEGADR . SAVE POINTER
 LDX TMP$00 . SET END OF STRING
 LDAA #4
 STAA 0,X
 TSX . POINT AT DATA
 JSR PDATA1 . PRINT THE STRING
 LDX BEGADR . POINT AT THE DATA
 CPX ENDADR . ARE WE DONE?
 BNE DMP$L0
DMP$BK LDAB #17 . RESTORE THE STACK
DMP$L4 INS
 DECB
 BNE DMP$L4
DMP$EX RTS
 SPC 1
*
*     'S1' RECORD LOADER
*
LOAD LDAA #$11 . SEND DEVICE ON
 STAA AECHO . TURN OFF ECHO
 JSR OUTCH
 SPC 1
*
*     MAKE ROOM ON THE STACK FOR HEADER
*
 LDAB #26
LOD$L0 DES
 DECB
 BNE LOD$L0
 LDAA #4 . SET END OF RECORD
 TSX
 STAA 0,X
 SPC 1
*
*     WAIT FOR RECORD INDICATOR
*
LOAD00 JSR INCHNP . GET A BYTE
 CMPA #'S . IS IT AN 'S'
 BNE LOAD00 . NO
 SPC 1
*
*     WAIT FOR RECORD TYPE
*
 LDX #RECTYP . POINT AT THE RECORD TABLE
 JSR CHKCMD . PROCESS IT
 BCS LOAD00 . NOT A GOOD
 LDX 1,X . GET TASK ADDRESS
 JMP 0,X . JUMP TO IT!
 SPC 1
*
*     RECORD TYPE TABLE
*
RECTYP FCB '0 . HEADER RECORD
 FDB LOADHD
 FCB '1 . DATA RECORD
 FDB LOADRC
 FCB '9 . END OF FILE RECORD
 FDB LOADED 
DUMTBL FCB 0 . TERMINATOR
 SPC 1
*
*      LOAD THE END OF RECORD
*
LOADED JSR LD$SET . GET THE SETUP 
 JSR IN2HEX . GET THE CHECKSUM
 DEC BYTECT . SEE IF LEGAL
 BNE LD$EDE . NOT LEGAL START ADDRESS
 INC CHKSUM
 BNE LD$EDE . ILLEGAL ADDRESS
 STX TMP$00
 LDX USTACK . PUT START ADDRESS IN USER'S PC
 LDAB TMP$00
 LDAA TMP$00+1
 STAB 6,X
 STAA 7,X
LD$EDE LDAA #$13 . TURN OFF READER
 JSR OUTCH
 LDX #0 . DELAY SOME
LOD$L1 DEX
 BNE LOD$L1
 TSX . POINT AT THE HEADER
 JSR PDATA
LOD$EX LDAB #26 . RESTORE THE STACK
LOD$L2 INS
 DECB
 BNE LOD$L2
 JMP MON$
 SPC 1
*
*     LOAD THE HEADER
*
LOADHD JSR LD$SET . SET-UP LOAD
 LDAB BYTECT . CHECK BYTE COUNT
 CMPB #25
 BHI LOAD00 . FORGET IT
 TSX . POINT AT THE STACK
 SPC 1
*
*     READ IN THE HEADER
*
LD$HD0 JSR IN2HEX . GET A CHAR.
 STAA 0,X . STORE IT
 INX
 DEC BYTECT . DONE?
 BNE LD$HD0
 DEX . BACK-UP 1 BYTE
 LDAA #4 . SET E.O.T.
 STAA 0,X
 JMP LOAD00 . CONTINUE THE LOAD
 SPC 1
*
*     LOAD A RECORD
*
LOADRC JSR LD$SET . GET SETUP
LOADR0 JSR IN2HEX . GET A BYTE
 DEC BYTECT . DONE?
 BEQ LD$CHK
 STAA 0,X
 CMPA 0,X
 BNE MEMER$
 INX
 BRA LOADR0
 SPC 1
*
*    ERRORS DURING LOAD
*
MEMER$ LDX #MEMERR . MEMORY NO-CHANGE
 BRA LERR$R
 SPC 1
*
CHKER$ LDX #CHKERR . CHECK-SUM ERROR
LERR$R JSR PDATA
 BRA LOD$EX
 SPC 1
*
*    CHECK FOR PROPER SUM
*
LD$CHK INC CHKSUM
 BNE CHKER$
 JMP LOAD00
 SPC 1
*
*     RECORD SET-UP
*
LD$SET CLR CHKSUM . ZERO CHECK SUM
 JSR IN2HEX . GET BYTE COUNT
 BCS STP$LD . STOP LOADER
 SUBA #2 . REMOVE ADDRESS
 STAA BYTECT . SAVE THE COUNT
 JSR IN4HEX . GET LOAD ADDRESS
 BCS STP$LD
 RTS
 SPC 1
*
*     STOP LOADER
*
STP$LD LDX #LOADER
 JSR PDATA1
 BRA LOD$EX
 SPC 1
*
*     SWI ENTRY POINT
*
SWI1 TSX . GET THE P.C.
 LDX 5,X
 CPX #SUB$RK
 BNE NOT$SB . NOT SUB-ROUTINE CALL
 JMP GO$SB3 . WAS SUB-ROUTINE CALL
 SPC 1
*
*    GET ADDRESS OF SWI
*
NOT$SB TSX
 LDAB #4 . 4 PLACES TO LOOK
 STAB TMP$00
 LDAB 5,X . GET PC
 LDAA 6,X
 SUBA #1 . POINT AT THE 'SWI'
 SBCB #0
 LDX #BRKPTS . POINT AT THE TABLE
 SPC 1
*
*     CHECK TABLE AGAINST PC-1
*
BP$LOP CMPB 0,X . IS THIS THE ADDRESS
 BNE BP$NXT
 CMPA 1,X . LSB
 BEQ BP$FND . YES
BP$NXT INX . MOVE TO NEXT LOCATION
 INX
 INX
 INX
 DEC TMP$00
 BNE BP$LOP
 BRA SWIX . GO TO USER'S 'SWI'
 SPC 1
*
*   IF HERE, WE FOUND A BREAK-POINT
*
BP$FND  TSX
 STAB 5,X . PUT NEW PC ON STACK
 STAA 6,X
 STS USTACK . SAVE USER'S STACK
 LDX #STACK . GET THE DEBUG STACK
 JSR CLRBRK . RESTORE THE BREAK POINTS
 JSR DSPBRK . DISPLAY THE BREAK POINT
 JMP MON$ . GO TO MONITOR ENTRY
 SPC 1
*
*      VECTOR ENTRIES
*
.SWI1 LDAA #'0
 FCB $8C . SKIP 2
.IRQ LDAA #'1
 FCB $8C . SKIP 2
.NMI LDAA #'2
 SPC 1
*
*      DISPLAY THE REGISTERS
*
 STS USTACK . SAVE USER'S STACK
 LDS #STACK . GET MONITOR STACK
 LDX #DSPTBL . POINT AT COMMAND TABLE
 JSR CHKCMD . PROCESS THE COMMAND
 BCS DSPMON . JUST ENTER MONITOR
 LDX 1,X . GET ROUTINE
 JSR 0,X . PRINT THE REGISTERS
DSPMON JMP MON$ . ENTER THE MONITOR
 SPC 1
*
*    DISPLAY TABLE
*
DSPTBL FCB '0 . SWI
 FDB DSPSWI
 FCB '1 . IRQ
 FDB DSPIRQ
 FCB '2 . NMI
 FDB DSPNMI
 FCB 0 . TERMINATOR
 SPC 1
*
*    TABLE OF VECTOR ENTRIES
*
VECTBL FDB .IRQ,.IRQ,.IRQ,.IRQ
 FDB .IRQ,.SWI1,.NMI
*
*    VECTOR ROUTINES
*
IRQ3 LDX #IRQSCI . 'SCI'
 BRA VECT$
IRQ2 LDX #IRQTOF . 'TOF'
 BRA VECT$
IRQ1 LDX #IRQOCF . 'OCF'
 BRA VECT$
IRQ0 LDX #IRQICF . 'ICF'
 BRA VECT$
IRQ LDX #IRQ$VC . 'IRQ'
 BRA VECT$
SWIX LDX #SWI$VC . 'SWI'
 BRA VECT$
NMI LDX #NMI$VC . 'NMI'
 SPC 1
*
*     VECTOR ENTRY
*
VECT$ LDAB 0,X . GET THE VECTOR
 LDAA 1,X
 PSHA . SAVE IT ON THE STACK
 PSHB
 TSX . POINT AT THE STACK DATA
 LDAA 4,X . GET THE AREG
 LDAB 3,X . GET THE BREG
 PSHA . SAVE THE AREG
 LDAA 2,X . GET CC'S
 ORAA #%00010000 . SET THE 'I' BIT
 LDX 5,X . GET XREG
 TAP . SET THE CC'S
 PULA . RESTORE THE AREG
 RTS
 SPC 1
*
*      VECTORS
*
 ORG ROMSTR+$7F0
 FDB IRQ3,IRQ2,IRQ1,IRQ0
 FDB IRQ,SWI1,NMI,COLD$
 SPC 1
 END