forked from amberisvibin/chibi-pc09
1738 lines
74 KiB
NASM
1738 lines
74 KiB
NASM
*************************************
|
|
* COPYRIGHT (C) MOTOROLA, INC. 1979 *
|
|
*************************************
|
|
|
|
*************************************
|
|
* THIS IS THE BASE ASSIST09 ROM.
|
|
* IT MAY RUN WITH OR WITHOUT THE
|
|
* EXTENSION ROM WHICH
|
|
* WHEN PRESENT WILL BE AUTOMATICALLY
|
|
* INCORPORATED BY THE BLDVTR
|
|
* SUBROUTINE.
|
|
*************************************
|
|
|
|
*********************************************
|
|
* GLOBAL MODULE EQUATES
|
|
********************************************
|
|
ROMBEG EQU $F800 ; ROM START ASSEMBLY ADDRESS
|
|
RAMOFS EQU -$1900 ; ROM OFFSET TO RAM WORK PAGE
|
|
ROMSIZ EQU 2048 ; ROM SIZE
|
|
ROM2OF EQU ROMBEG-ROMSIZ ; START OF EXTENSION ROM
|
|
ACIA EQU $E008 ; DEFAULT ACIA ADDRESS
|
|
PTM EQU $E000 ; DEFAULT PTM ADDRESS
|
|
DFTCHP EQU 0 ; DEFAULT CHARACTER PAD COUNT
|
|
DFTNLP EQU 5 ; DEFAULT NEW LINE PAD COUNT
|
|
PROMPT EQU '> ; PROMPT CHARACTER
|
|
NUMBKP EQU 8 ; NUMBER OF BREAKPOINTS
|
|
*********************************************
|
|
|
|
*********************************************
|
|
* MISCELANEOUS EQUATES
|
|
*********************************************
|
|
EOT EQU $04 ; END OF TRANSMISSION
|
|
BELL EQU $07 ; BELL CHARACTER
|
|
LF EQU $0A ; LINE FEED
|
|
CR EQU $0D ; CARRIAGE RETURN
|
|
DLE EQU $10 ; DATA LINK ESCAPE
|
|
CAN EQU $18 ; CANCEL (CTL-X)
|
|
|
|
* PTM ACCESS DEFINITIONS
|
|
PTMSTA EQU PTM+1 ; READ STATUS REGISTER
|
|
PTMC13 EQU PTM ; CONTROL REGISTERS 1 AND 3
|
|
PTMC2 EQU PTM+1 ; CONTROL REGISTER 2
|
|
PTMTM1 EQU PTM+2 ; LATCH 1
|
|
PTMTM2 EQU PTM+4 ; LATCH 2
|
|
PTMTM3 EQU PTM+6 ; LATCH 3
|
|
SKIP2 EQU $8C ; "CMPX #" OPCODE - SKIPS TWO BYTES
|
|
|
|
*******************************************
|
|
* ASSIST09 MONITOR SWI FUNCTIONS
|
|
* THE FOLLOWING EQUATES DEFINE FUNCTIONS PROVIDED
|
|
* BY THE ASSIST09 MONITOR VIA THE SWI INSTRUCTION.
|
|
******************************************
|
|
INCHNP EQU 0 ; INPUT CHAR IN A REG - NO PARITY
|
|
OUTCH EQU 1 ; OUTPUT CHAR FROM A REG
|
|
PDATA1 EQU 2 ; OUTPUT STRING
|
|
PDATA EQU 3 ; OUTPUT CR/LF THEN STRING
|
|
OUT2HS EQU 4 ; OUTPUT TWO HEX AND SPACE
|
|
OUT4HS EQU 5 ; OUTPUT FOUR HEX AND SPACE
|
|
PCRLF EQU 6 ; OUTPUT CR/LF
|
|
SPACE EQU 7 ; OUTPUT A SPACE
|
|
MONITR EQU 8 ; ENTER ASSIST09 MONITOR
|
|
VCTRSW EQU 9 ; VECTOR EXAMINE/SWITCH
|
|
BRKPT EQU 10 ; USER PROGRAM BREAKPOINT
|
|
PAUSE EQU 11 ; TASK PAUSE FUNCTION
|
|
NUMFUN EQU 11 ; NUMBER OF AVAILABLE FUNCTIONS
|
|
|
|
* NEXT SUB-CODES FOR ACCESSING THE VECTOR TABLE.
|
|
* THEY ARE EQUIVALENT TO OFFSETS IN THE TABLE.
|
|
* RELATIVE POSITIONING MUST BE MAINTAINED
|
|
|
|
_AVTBL EQU 0 ; ADDRESS OF VECTOR TABLE
|
|
_CMDL1 EQU 2 ; FIRST COMMAND LIST
|
|
_RSVD EQU 4 ; RESERVED HARDWARE VECTOR
|
|
_SWI3 EQU 6 ; SWI3 ROUTINE
|
|
_SWI2 EQU 8 ; SWI2 ROUTINE
|
|
_FIRQ EQU 10 ; FIRQ ROUTINE
|
|
_IRQ EQU 12 ; IRQ ROUTINE
|
|
_SWI EQU 14 ; SWI ROUTINE
|
|
_NMI EQU 16 ; NMI ROUTINE
|
|
_RESET EQU 18 ; RESET ROUTINE
|
|
_CION EQU 20 ; CONSOLE ON
|
|
_CIDTA EQU 22 ; CONSOLE INPUT DATA
|
|
_CIOFF EQU 24 ; CONSOLE INPUT OFF
|
|
_COON EQU 26 ; CONSOLE OUTPUT ON
|
|
_CODTA EQU 28 ; CONSOLE OUTPUT DATA
|
|
_COOFF EQU 30 ; CONSOLE OUTPUT OFF
|
|
_HSDTA EQU 32 ; HIGH SPEED PRINTDATA
|
|
_BSON EQU 34 ; PUNCH/LOAD ON
|
|
_BSDTA EQU 36 ; PUNCH/LOAD DATA
|
|
_BSOFF EQU 38 ; PUNCH/LOAD OFF
|
|
_PAUSE EQU 40 ; TASK PAUSE ROUTINE
|
|
_EXPAN EQU 42 ; EXPRESSION ANALYZER
|
|
_CMDL2 EQU 44 ; SECOND COMMAND LIST
|
|
_ACIA EQU 46 ; ACIA ADDRESS
|
|
_PAD EQU 48 ; CHARACTER PAD AND NEW LINE PAD
|
|
_ECHO EQU 50 ; ECHO/LOAD AND NULL BKPT FLAG
|
|
_PTM EQU 52 ; PTM ADDRESS
|
|
NUMVTR EQU 52/2+1 ; NUMBER OF VECTORS
|
|
HIVTR EQU 52 ; HIGHEST VECTOR OFFSET
|
|
|
|
******************************************
|
|
* WORK AREA
|
|
* THIS WORK AREA IS ASSIGNED TO THE PAGE ADDRESSED BY
|
|
* -$1800,PCR FROM THE BASE ADDRESS OF THE ASSIST09
|
|
* ROM. THE DIRECT PAGE REGISTER DURING MOST ROUTINE
|
|
* OPERATIONS WILL POINT TO THIS WORK AREA. THE STACK
|
|
* INITIALLY STARTS UNDER THE RESERVED WORK AREAS AS
|
|
* DEFINED HEREIN.
|
|
******************************************
|
|
WORKPG EQU ROMBEG+RAMOFS ; SETUP DIRECT PAGE ADDRESS
|
|
SETDP WORKPG!>8 ; NOTIFY ASSEMBLER
|
|
ORG WORKPG+256 ; READY PAGE DEFINITIONS
|
|
|
|
* THE FOLLOWING THRU BKPTOP MUST RESIDE IN THIS ORDER
|
|
* FOR PROPER INITIALIZATION
|
|
ORG *-4
|
|
PAUSER EQU * ; PAUSE ROUTINE
|
|
ORG *-1
|
|
SWIBFL EQU * ; BYPASS SWI AS BREAKPOINT FLAG
|
|
ORG *-1
|
|
BKPTCT EQU * ; BREAKPOINT COUNT
|
|
ORG *-2 ; SLEVEL EQU
|
|
SLEVEL EQU * ; STACK TRACE LEVEL
|
|
ORG -NUMVTR*2+*
|
|
VECTAB EQU * ; VECTOR TABLE
|
|
ORG -2*NUMBKP+*
|
|
BKPTBL EQU * ; BREAKPOINT TABLE
|
|
ORG -2*NUMBKP+*
|
|
BKPTOP EQU * ; BREAKPOINT OPCODE TABLE
|
|
ORG *-2
|
|
WINDOW EQU * ; WINDOW
|
|
ORG *-2
|
|
ADDR EQU * ; ADDRESS POINTER VALUE
|
|
ORG *-1
|
|
BASEPG EQU * ; BASE PAGE VALUE
|
|
ORG *-2
|
|
NUMBER EQU * ; BINARY BUILD AREA
|
|
ORG *-2
|
|
LASTOP EQU * ; LAST OPCODE TRACED
|
|
ORG *-2
|
|
RSTACK EQU * ; RESET STACK POINTER
|
|
ORG *-2
|
|
PSTACK EQU * ; COMMAND RECOVERY STACK
|
|
ORG *-2
|
|
PCNTER EQU * ; LAST PROGRAM COUNTER
|
|
ORG *-2
|
|
TRACEC EQU * ; TRACE COUNT
|
|
ORG *-1
|
|
SWICNT EQU * ; TRACE "SWI" NEST LEVEL COUNT
|
|
ORG *-1 ; (MISFLG MUST FOLLOW SWICNT)
|
|
MISFLG EQU * ; LOAD CMD/THRU BREAKPOINT FLAG
|
|
ORG *-1
|
|
DELIM EQU * ; EXPRESSION DELIMITER/WORK BYTE
|
|
ORG *-40
|
|
ROM2WK EQU * ; EXTENSION ROM RESERVED AREA
|
|
ORG *-21
|
|
TSTACK EQU * ; TEMPORARY STACK HOLD
|
|
STACK EQU * ; START OF INITIAL STACK
|
|
|
|
******************************************
|
|
* DEFAULT THE ROM BEGINNING ADDRESS TO 'ROMBEG'
|
|
* ASSIST09 IS POSITION ADDRESS INDEPENDENT, HOWEVER
|
|
* WE ASSEMBLE ASSUMING CONTROL OF THE HARDWARE VECTORS.
|
|
* NOTE THAT THE WORK RAM PAGE MUST BE 'RAMOFS'
|
|
* FROM THE ROM BEGINNING ADDRESS.
|
|
********************************************
|
|
ORG ROMBEG ; ROM ASSEMBLY/DEFAULT ADDRESS
|
|
|
|
*****************************************************
|
|
* BLDVTR - BUILD ASSIST09 VECTOR TABLE
|
|
* HARDWARE RESET CALLS THIS SUBROUTINE TO BUILD THE
|
|
* ASSIST09 VECTOR TABLE. THIS SUBROUTINE RESIDES AT
|
|
* THE FIRST BYTE OF THE ASSIST09 ROM, AND CAN BE
|
|
* CALLED VIA EXTERNAL CONTROL CODE FOR REMOTE
|
|
* ASSIST09 EXECUTION.
|
|
* INPUT: S->VALID STACK RAM
|
|
* OUTPUT: U->VECTOR TABLE ADDRESS
|
|
* DPR->ASSIST09 WORK AREA PAGE
|
|
* THE VECTOR TABLE AND DEFAULTS ARE INITIALIZED
|
|
* ALL REGISTERS VOLATILE
|
|
*************************************************
|
|
BLDVTR LEAX VECTAB,PCR ; ADDRESS VECTOR TABLE
|
|
TFR X,D ; OBTAIN BASE PAGE ADDRESS
|
|
TFR A,DP ; SETUP DPR
|
|
STA <BASEPG ; STORE FOR QUICK REFERENCE
|
|
LEAU ,X ; RETURN TABLE TO CALLER
|
|
LEAY <INITVT,PCR ; LOAD FROM ADDR
|
|
STU ,X++ ; INIT VECTOR TABLE ADDRESS
|
|
LDB #NUMVTR-5 ; NUMBER RELOCATABLE VECTORS
|
|
PSHS B ; STORE INDEX ON STACK
|
|
BLD2 TFR Y,D ; PREPARE ADDRESS RESOLVE
|
|
ADDD ,Y++ ; TO ABSOLUTE ADDRESS
|
|
STD ,X++ ; INTO VECTOR TABLE
|
|
DEC ,S ; COUNT DOWN
|
|
BNE BLD2 ; BRANCH IF MORE TO INSERT
|
|
LDB #INTVE-INTVS ; STATIC VALUE INIT LENGTH
|
|
BLD3 LDA ,Y+ ; LOAD NEXT BYTE
|
|
STA ,X+ ; STORE INTO POSITION
|
|
DECB ; COUNT DOWN
|
|
BNE BLD3 ; LOOP UNTIL DONE
|
|
LEAY ROM2OF,PCR ; TEST POSSIBLE EXTENSION ROM
|
|
LDX #$20FE ; LOAD "BRA *" FLAG PATTERN
|
|
CMPX ,Y++ ; ? EXTENDED ROM HERE
|
|
BNE BLDRTN ; BRANCH NOT OUR ROM TO RETURN
|
|
JSR ,Y ; CALL EXTENDED ROM INITIALIZE
|
|
BLDRTN PULS PC,B ; RETURN TO INITIALIZER
|
|
|
|
*****************************************************
|
|
* RESET ENTRY POINT
|
|
* HARDWARE RESET ENTERS HERE IF ASSIST09 IS ENABLED
|
|
* TO RECEIVE THE MC6809 HARDWARE VECTORS. WE CALL
|
|
* THE BLDVTR SUBROUTINE TO INITIALIZE THE VECTOR
|
|
* TABLE, STACK, AND THEN FIREUP THE MONITOR VIA SWI
|
|
* CALL.
|
|
*******************************************************
|
|
RESET LEAS STACK,PCR ; SETUP INITIAL STACK
|
|
BSR BLDVTR ; BUILD VECTOR TABLE
|
|
RESET2 CLRA ; ISSUE STARTUP MESSAGE
|
|
TFR A,DP ; DEFAULT TO PAGE ZERO
|
|
SWI ; PERFORM MONITOR FIREUP
|
|
FCB MONITR ; TO ENTER COMMAND PROCESSING
|
|
BRA RESET2 ; REENTER MONITOR IF 'CONTINUE'
|
|
|
|
******************************************************
|
|
* INITVT - INITIAL VECTOR TABLE
|
|
* THIS TABLE IS RELOCATED TO RAM AND REPRESENTS THE
|
|
* INITIAL STATE OF THE VECTOR TABLE. ALL ADDRESSES
|
|
* ARE CONVERTED TO ABSOLUTE FORM. THIS TABLE STARTS
|
|
* WITH THE SECOND ENTRY, ENDS WITH STATIC CONSTANT
|
|
* INITIALIZATION DATA WHICH CARRIES BEYOND THE TABLE.
|
|
************************************************
|
|
INITVT FDB CMDTBL-* ; DEFAULT FIRST COMMAND TABLE
|
|
FDB RSRVDR-* ; DEFAULT UNDEFINED HARDWARE VECTOR
|
|
FDB SWI3R-* ; DEFAULT SWI3
|
|
FDB SWI2R-* ; DEFAULT SWI2
|
|
FDB FIRQR-* ; DEFAULT FIRQ
|
|
FDB IRQR-* ; DEFAULT IRQ ROUTINE
|
|
FDB SWIR-* ; DEFAULT SWI ROUTINE
|
|
FDB NMIR-* ; DEFAULT NMI ROUTINE
|
|
FDB RESET-* ; RESTART VECTOR
|
|
FDB CION-* ; DEFAULT CION
|
|
FDB CIDTA-* ; DEFAULT CIDTA
|
|
FDB CIOFF-* ; DEFAULT CIOFF
|
|
FDB COON-* ; DEFAULT COON
|
|
FDB CODTA-* ; DEFAULT CODTA
|
|
FDB COOFF-* ; DEFAULT COOFF
|
|
FDB HSDTA-* ; DEFAULT HSDTA
|
|
FDB BSON-* ; DEFAULT BSON
|
|
FDB BSDTA-* ; DEFAULT BSDTA
|
|
FDB BSOFF-* ; DEFAULT BSOFF
|
|
FDB PAUSER-* ; DEFAULT PAUSE ROUTINE
|
|
FDB EXP1-* ; DEFAULT EXPRESSION ANALYZER
|
|
FDB CMDTB2-* ; DEFAULT SECOND COMMAND TABLE
|
|
* CONSTANTS
|
|
INTVS FDB ACIA ; DEFAULT ACIA
|
|
FCB DFTCHP,DFTNLP ; DEFAULT NULL PADDS
|
|
FDB 0 ; DEFAULT ECHO
|
|
FDB PTM ; DEFAULT PTM
|
|
FDB 0 ; INITIAL STACK TRACE LEVEL
|
|
FCB 0 ; INITIAL BREAKPOINT COUNT
|
|
FCB 0 ; SWI BREAKPOINT LEVEL
|
|
FCB $39 ; DEFAULT PAUSE ROUTINE (RTS)
|
|
INTVE EQU *
|
|
*B
|
|
***********************************************
|
|
* ASSIST09 SWI HANDLER
|
|
* THE SWI HANDLER PROVIDES ALL INTERFACING NECESSARY
|
|
* FOR A USER PROGRAM. A FUNCTION BYTE IS ASSUMED TO
|
|
* FOLLOW THE SWI INSTRUCTION. IT IS BOUND CHECKED
|
|
* AND THE PROPER ROUTINE IS GIVEN CONTROL. THIS
|
|
* INVOCATION MAY ALSO BE A BREAKPOINT INTERRUPT.
|
|
* IF SO, THE BREAKPOINT HANDLER IS ENTERED.
|
|
* INPUT: MACHINE STATE DEFINED FOR SWI
|
|
* OUTPUT: VARIES ACCORDING TO FUNCTION CALLED. PC ON
|
|
* CALLERS STACK INCREMENTED BY ONE IF VALID CALL.
|
|
* VOLATILE REGISTERS: SEE FUNCTIONS CALLED
|
|
* STATE: RUNS DISABLED UNLESS FUNCTION CLEARS I FLAG.
|
|
************************************************
|
|
* SWI FUNCTION VECTOR TABLE
|
|
SWIVTB FDB ZINCH-SWIVTB ; INCHNP
|
|
FDB ZOTCH1-SWIVTB ; OUTCH
|
|
FDB ZPDTA1-SWIVTB ; PDATA1
|
|
FDB ZPDATA-SWIVTB ; PDATA
|
|
FDB ZOT2HS-SWIVTB ; OUT2HS
|
|
FDB ZOT4HS-SWIVTB ; OUT4HS
|
|
FDB ZPCRLF-SWIVTB ; PCRLF
|
|
FDB ZSPACE-SWIVTB ; SPACE
|
|
FDB ZMONTR-SWIVTB ; MONITR
|
|
FDB ZVSWTH-SWIVTB ; VCTRSW
|
|
FDB ZBKPNT-SWIVTB ; BREAKPOINT
|
|
FDB ZPAUSE-SWIVTB ; TASK PAUSE
|
|
|
|
SWIR DEC SWICNT,PCR ; UP "SWI" LEVEL FOR TRACE
|
|
LBSR LDDP ; SETUP PAGE AND VERIFY STACK
|
|
* CHECK FOR BREAKPOINT TRAP
|
|
LDU 10,S ; LOAD PROGRAM COUNTER
|
|
LEAU -1,U ; BACK TO SWI ADDRESS
|
|
TST <SWIBFL ; ? THIS "SWI" BREAKPOINT
|
|
BNE SWIDNE ; BRANCH IF SO TO LET THROUGH
|
|
LBSR CBKLDR ; OBTAIN BREAKPOINT POINTERS
|
|
NEGB ; OBTAIN POSITIVE COUNT
|
|
SWILP DECB ; COUNT DOWN
|
|
BMI SWIDNE ; BRANCH WHEN DONE
|
|
CMPU ,Y++ ; ? WAS THIS A BREAKPOINT
|
|
BNE SWILP ; BRANCH IF NOT
|
|
STU 10,S ; SET PROGRAM COUNTER BACK
|
|
LBRA ZBKPNT ; GO DO BREAKPOINT
|
|
SWIDNE CLR <SWIBFL ; CLEAR IN CASE SET
|
|
PULU D ; OBTAIN FUNCTION BYTE, UP PC
|
|
CMPB #NUMFUN ; ? TOO HIGH
|
|
LBHI ERROR ; YES, DO BREAKPOINT
|
|
STU 10,S ; BUMP PROGRAM COUNTER PAST SWI
|
|
ASLB ; FUNCTION CODE TIMES TWO
|
|
LEAU SWIVTB,PCR ; OBTAIN VECTOR BRANCH ADDRESS
|
|
LDD B,U ; LOAD OFFSET
|
|
JMP D,U ; JUMP TO ROUTINE
|
|
|
|
**********************************************
|
|
* REGISTERS TO FUNCTION ROUTINES:
|
|
* DP-> WORK AREA PAGE
|
|
* D,Y,U=UNRELIABLE X=AS CALLED FROM USER
|
|
* S=AS FROM SWI INTERRUPT
|
|
*********************************************
|
|
|
|
**************************************************
|
|
* [SWI FUNCTION 8]
|
|
* MONITOR ENTRY
|
|
* FIREUP THE ASSIST09 MONITOR.
|
|
* THE STACK WITH ITS VALUES FOR THE DIRECT PAGE
|
|
* REGISTER AND CONDITION CODE FLAGS ARE USED AS IS.
|
|
* 1) INITIALIZE CONSOLE I/O
|
|
* 2) OPTIONALLY PRINT SIGNON
|
|
* 3) INITIALIZE PTM FOR SINGLE STEPPING
|
|
* 4) ENTER COMMAND PROCESSOR
|
|
* INPUT: A=0 INIT CONSOLE AND PRINT STARTUP MESSAGE
|
|
* A#0 OMIT CONSOLE INIT AND STARTUP MESSAGE
|
|
*************************************************
|
|
|
|
SIGNON FCC /ASSIST09/ ; SIGNON EYE-CATCHER
|
|
FCB EOT
|
|
ZMONTR STS <RSTACK ; SAVE FOR BAD STACK RECOVERY
|
|
TST 1,S ; ? INIT CONSOLE AND SEND MSG
|
|
BNE ZMONT2 ; BRANCH IF NOT
|
|
JSR [VECTAB+_CION,PCR] ; READY CONSOLE INPUT
|
|
JSR [VECTAB+_COON,PCR] ; READY CONSOLE OUTPUT
|
|
LEAX SIGNON,PCR ; READY SIGNON EYE-CATCHER
|
|
SWI ; PERFORM
|
|
FCB PDATA ; PRINT STRING
|
|
ZMONT2 LDX <VECTAB+_PTM ; LOAD PTM ADDRESS
|
|
BEQ CMD ; BRANCH IF NOT TO USE A PTM
|
|
CLR PTMTM1-PTM,X ; SET LATCH TO CLEAR RESET
|
|
CLR PTMTM1+1-PTM,X ; AND SET GATE HIGH
|
|
LDD #$01A6 ; SETUP TIMER 1 MODE
|
|
STA PTMC2-PTM,X ; SETUP FOR CONTROL REGISTER1
|
|
STB PTMC13-PTM,X ; SET OUTPUT ENABLED/
|
|
* SINGLE SHOT/ DUAL 8 BIT/INTERNAL MODE/OPERATE
|
|
CLR PTMC2-PTM,X ; SET CR2 BACK TO RESET FORM
|
|
* FALL INTO COMMAND PROCESSOR
|
|
|
|
***************************************************
|
|
* COMMAND HANDLER
|
|
* BREAKPOINTS ARE REMOVED AT THIS TIME.
|
|
* PROMPT FOR A COMMAND, AND STORE ALL CHARACTERS
|
|
* UNTIL A SEPARATOR ON THE STACK.
|
|
* SEARCH FOR FIRST MATCHING COMMAND SUBSET,
|
|
* CALL IT OR GIVE '?' RESPONSE.
|
|
* DURING COMMAND SEARCH:
|
|
* B=OFFSET TO NEXT ENTRY ON X
|
|
* U=SAVED S
|
|
* U-1=ENTRY SIZE+2
|
|
* U-2=VALID NUMBER FLAG (>=0 VALID)/COMPARE CNT
|
|
* U-3=CARRIAGE RETURN FLAG (0=CR HAS BEEN DONE)
|
|
* U-4=START OF COMMAND STORE
|
|
* S+0=END OF COMMAND STORE
|
|
***********************************************
|
|
|
|
CMD SWI ; TO NEW LINE
|
|
FCB PCRLF ; FUNCTION
|
|
* DISARM THE BREAKPOINTS
|
|
CMDNEP LBSR CBKLDR ; OBTAIN BREAKPOINT POINTERS
|
|
BPL CMDNOL ; BRANCH IF NOT ARMED OR NONE
|
|
NEGB ; MAKE POSITIVE
|
|
STB <BKPTCT ; FLAG AS DISARMED
|
|
CMDDDL DECB ; ? FINISHED
|
|
BMI CMDNOL ; BRANCH IF SO
|
|
LDA -NUMBKP*2,Y ; LOAD OPCODE STORED
|
|
STA [,Y++] ; STORE BACK OVER "SWI"
|
|
BRA CMDDDL ; LOOP UNTIL DONE
|
|
CMDNOL LDX 10,S ; LOAD USERS PROGRAM COUNTER
|
|
STX <PCNTER ; SAVE FOR EXPRESSION ANALYZER
|
|
LDA #PROMPT ; LOAD PROMPT CHARACTER
|
|
SWI ; SEND TO OUTPUT HANDLER
|
|
FCB OUTCH ; FUNCTION
|
|
LEAU ,S ; REMEMBER STACK RESTORE ADDRESS
|
|
STU <PSTACK ; REMEMBER STACK FOR ERROR USE
|
|
CLRA ; PREPARE ZERO
|
|
CLRB ; PREPARE ZERO
|
|
STD <NUMBER ; CLEAR NUMBER BUILD AREA
|
|
STD <MISFLG ; CLEAR MISCEL. AND SWICNT FLAGS
|
|
STD <TRACEC ; CLEAR TRACE COUNT
|
|
LDB #2 ; SET D TO TWO
|
|
PSHS D,CC ; PLACE DEFAULTS ONTO STACK
|
|
* CHECK FOR "QUICK" COMMANDS.
|
|
LBSR READ ; OBTAIN FIRST CHARACTER
|
|
LEAX CDOT+2,PCR ; PRESET FOR SINGLE TRACE
|
|
CMPA #'. ; ? QUICK TRACE
|
|
BEQ CMDXQT ; BRANCH EQUAL FOR TRACE ONE
|
|
LEAX CMPADP+2,PCR ; READY MEMORY ENTRY POINT
|
|
CMPA #'/ ; ? OPEN LAST USED MEMORY
|
|
BEQ CMDXQT ; BRANCH TO DO IT IF SO
|
|
* PROCESS NEXT CHARACTER
|
|
CMD2 CMPA #' ; ? BLANK OR DELIMITER
|
|
BLS CMDGOT ; BRANCH YES, WE HAVE IT
|
|
PSHS A ; BUILD ONTO STACK
|
|
INC -1,U ; COUNT THIS CHARACTER
|
|
CMPA #'/ ; ? MEMORY COMMAND
|
|
BEQ CMDMEM ; BRANCH IF SO
|
|
LBSR BLDHXC ; TREAT AS HEX VALUE
|
|
BEQ CMD3 ; BRANCH IF STILL VALID NUMBER
|
|
DEC -2,U ; FLAG AS INVALID NUMBER
|
|
CMD3 LBSR READ ; OBTAIN NEXT CHARACTER
|
|
BRA CMD2 ; TEST NEXT CHARACTER
|
|
* GOT COMMAND, NOW SEARCH TABLES
|
|
CMDGOT SUBA #CR ; SET ZERO IF CARRIAGE RETURN
|
|
STA -3,U ; SETUP FLAG
|
|
LDX <VECTAB+_CMDL1 ; START WITH FIRST CMD LIST
|
|
CMDSCH LDB ,X+ ; LOAD ENTRY LENGTH
|
|
BPL CMDSME ; BRANCH IF NOT LIST END
|
|
LDX <VECTAB+_CMDL2 ; NOW TO SECOND CMD LITS
|
|
INCB ; ? TO CONTINUE TO DEFAULT LIST
|
|
BEQ CMDSCH ; BRANCH IF SO
|
|
CMDBAD LDS <PSTACK ; RESTORE STACK
|
|
LEAX ERRMSG,PCR ; POINT TO ERROR STRING
|
|
SWI ; SEND OUT
|
|
FCB PDATA1 ; TO CONSOLE
|
|
BRA CMD ; AND TRY AGAIN
|
|
* SEARCH NEXT ENTRY
|
|
CMDSME DECB ; TAKE ACCOUNT OF LENGTH BYTE
|
|
CMPB -1,U ; ? ENTERED LONGER THAN ENTRY
|
|
BHS CMDSIZ ; BRANCH IF NOT TOO LONG
|
|
CMDFLS ABX ; SKIP TO NEXT ENTRY
|
|
BRA CMDSCH ; AND TRY NEXT
|
|
CMDSIZ LEAY -3,U ; PREPARE TO COMPARE
|
|
LDA -1,U ; LOAD SIZE+2
|
|
SUBA #2 ; TO ACTUAL SIZE ENTERED
|
|
STA -2,U ; SAVE SIZE FOR COUNTDOWN
|
|
CMDCMP DECB ; DOWN ONE BYTE
|
|
LDA ,X+ ; NEXT COMMAND CHARACTER
|
|
CMPA ,-Y ; ? SAME AS THAT ENTERED
|
|
BNE CMDFLS ; BRANCH TO FLUSH IF NOT
|
|
DEC -2,U ; COUNT DOWN LENGTH OF ENTRY
|
|
BNE CMDCMP ; BRANCH IF MORE TO TEST
|
|
ABX ; TO NEXT ENTRY
|
|
LDD -2,X ; LOAD OFFSET
|
|
LEAX D,X ; COMPUTE ROUTINE ADDRESS+2
|
|
CMDXQT TST -3,U ; SET CC FOR CARRIAGE RETURN TEST
|
|
LEAS ,U ; DELETE STACK WORK AREA
|
|
JSR -2,X ; CALL COMMAND
|
|
LBRA CMDNOL ; GO GET NEXT COMMAND
|
|
CMDMEM TST -2,U ; ? VALID HEX NUMBER ENTERED
|
|
BMI CMDBAD ; BRANCH ERROR IF NOT
|
|
LEAX <CMEMN-CMPADP,X ; TO DIFFERENT ENTRY
|
|
LDD <NUMBER ; LOAD NUMBER ENTERED
|
|
BRA CMDXQT ; AND ENTER MEMORY COMMAND
|
|
|
|
** COMMANDS ARE ENTERED AS A SUBROUTINE WITH:
|
|
** DPR->ASSIST09 DIRECT PAGE WORK AREA
|
|
** Z=1 CARRIAGE RETURN ENTERED
|
|
** Z=0 NON CARRIAGE RETURN DELIMITER
|
|
** S=NORMAL RETURN ADDRESS
|
|
** THE LABEL "CMDBAD" MAY BE ENTERED TO ISSUE AN
|
|
** AN ERROR FLAG (*).
|
|
**************************************************
|
|
* ASSIST09 COMMAND TABLES
|
|
* THESE ARE THE DEFAULT COMMAND TABLES. EXTERNAL
|
|
* TABLES OF THE SAME FORMAT MAY EXTEND/REPLACE
|
|
* THESE BY USING THE VECTOR SWAP FUNCTION.
|
|
*
|
|
* ENTRY FORMAT:
|
|
* +0...TOTAL SIZE OF ENTRY (INCLUDING THIS BYTE)
|
|
* +1...COMMAND STRING
|
|
* +N...TWO BYTE OFFSET TO COMMAND (ENTRYADDR-*)
|
|
*
|
|
* THE TABLES TERMINATE WITH A ONE BYTE -1 OR -2.
|
|
* THE -1 CONTINUES THE COMMAND SEARCH WITH THE
|
|
* SECOND COMMAND TABLE.
|
|
* THE -2 TERMINATES COMMAND SEARCHES.
|
|
*****************************************************
|
|
|
|
* THIS IS THE DEFAULT LIST FOR THE SECOND COMMAND
|
|
* LIST ENTRY.
|
|
|
|
CMDTB2 FCB -2 ; STOP COMMAND SEARCHES
|
|
|
|
* THIS IS THE DEFAULT LIST FOR THE FIRST COMMAND
|
|
* LIST ENTRY.
|
|
|
|
CMDTBL EQU * ; MONITOR COMMAND TABLE
|
|
FCB 4
|
|
FCC /B/ ; 'BREAKPOINT' COMMAND
|
|
FDB CBKPT-*
|
|
FCB 4
|
|
FCC /C/ ; 'CALL' COMMAND
|
|
FDB CCALL-*
|
|
FCB 4
|
|
FCC /D/ ; 'DISPLAY' COMMAND
|
|
FDB CDISP-*
|
|
FCB 4
|
|
FCC /E/ ; 'ENCODE' COMMAND
|
|
FDB CENCDE-*
|
|
FCB 4
|
|
FCC /G/ ; 'GO' COMMAND
|
|
FDB CGO-*
|
|
FCB 4
|
|
FCC /L/ ; 'LOAD' COMMAND
|
|
FDB CLOAD-*
|
|
FCB 4
|
|
FCC /M/ ; 'MEMORY' COMMAND
|
|
FDB CMEM-*
|
|
FCB 4
|
|
FCC /N/ ; 'NULLS' COMMAND
|
|
FDB CNULLS-*
|
|
FCB 4
|
|
FCC /O/ ; 'OFFSET' COMMAND
|
|
FDB COFFS-*
|
|
FCB 4
|
|
FCC /P/ ; 'PUNCH' COMMAND
|
|
FDB CPUNCH-*
|
|
FCB 4
|
|
FCC /R/ ; 'REGISTERS' COMMAND
|
|
FDB CREG-*
|
|
FCB 4
|
|
FCC /S/ ; 'STLEVEL' COMMAND
|
|
FDB CSTLEV-*
|
|
FCB 4
|
|
FCC /T/ ; 'TRACE' COMMAND
|
|
FDB CTRACE-*
|
|
FCB 4
|
|
FCC /V/ ; 'VERIFY' COMMAND
|
|
FDB CVER-*
|
|
FCB 4
|
|
FCC /W/ ; 'WINDOW' COMMAND
|
|
FDB CWINDO-*
|
|
FCB -1 ; END, CONTINUE WITH THE SECOND
|
|
|
|
*************************************************
|
|
* [SWI FUNCTIONS 4 AND 5]
|
|
* 4 - OUT2HS - DECODE BYTE TO HEX AND ADD SPACE
|
|
* 5 - OUT4HS - DECODE WORD TO HEX AND ADD SPACE
|
|
* INPUT: X->BYTE OR WORD TO DECODE
|
|
* OUTPUT: CHARACTERS SENT TO OUTPUT HANDLER
|
|
* X->NEXT BYTE OR WORD
|
|
*************************************************
|
|
ZOUT2H LDA ,X+ ; LOAD NEXT BYTE
|
|
PSHS D ; SAVE - DO NOT REREAD
|
|
LDB #16 ; SHIFT BY 4 BITS
|
|
MUL ; WITH MULTIPLY
|
|
BSR ZOUTHX ; SEND OUT AS HEX
|
|
PULS D ; RESTORE BYTES
|
|
ANDA #$0F ; ISOLATE RIGHT HEX
|
|
ZOUTHX ADDA #$90 ; PREPARE A-F ADJUST
|
|
DAA ; ADJUST
|
|
ADCA #$40 ; PREPARE CHARACTER BITS
|
|
DAA ; ADJUST
|
|
SEND JMP [VECTAB+_CODTA,PCR] ; SEND TO OUT HANDLER
|
|
|
|
ZOT4HS BSR ZOUT2H ; CONVERT FIRST BYTE
|
|
ZOT2HS BSR ZOUT2H ; CONVERT BYTE TO HEX
|
|
STX 4,S ; UPDATE USERS X REGISTER
|
|
* FALL INTO SPACE ROUTINE
|
|
|
|
*************************************************
|
|
* [SWI FUNCTION 7]
|
|
* SPACE - SEND BLANK TO OUTPUT HANDLER
|
|
* INPUT: NONE
|
|
* OUTPUT: BLANK SEND TO CONSOLE HANDLER
|
|
*************************************************
|
|
ZSPACE LDA #' ; LOAD BLANK
|
|
BRA ZOTCH2 ; SEND AND RETURN
|
|
|
|
***********************************************
|
|
* [SWI FUNCTION 9]
|
|
* SWAP VECTOR TABLE ENTRY
|
|
* INPUT: A=VECTOR TABLE CODE (OFFSET)
|
|
* X=0 OR REPLACEMENT VALUE
|
|
* OUTPUT: X=PREVIOUS VALUE
|
|
***********************************************
|
|
ZVSWTH LDA 1,S ; LOAD REQUESTERS A
|
|
CMPA #HIVTR ; ? SUB-CODE TOO HIGH
|
|
BHI ZOTCH3 ; IGNORE CALL IF SO
|
|
LDY <VECTAB+_AVTBL ; LOAD VECTOR TABLE ADDRESS
|
|
LDU A,Y ; U=OLD ENTRY
|
|
STU 4,S ; RETURN OLD VALUE TO CALLERS X
|
|
STX -2,S ; ? X=0
|
|
BEQ ZOTCH3 ; YES, DO NOT CHANGE ENTRY
|
|
STX A,Y ; REPLACE ENTRY
|
|
BRA ZOTCH3 ; RETURN FROM SWI
|
|
*D
|
|
|
|
************************************************
|
|
* [SWI FUNCTION 0]
|
|
* INCHNP - OBTAIN INPUT CHAR IN A (NO PARITY)
|
|
* NULLS AND RUBOUTS ARE IGNORED.
|
|
* AUTOMATIC LINE FEED IS SENT UPON RECEIVING A
|
|
* CARRIAGE RETURN.
|
|
* UNLESS WE ARE LOADING FROM TAPE.
|
|
************************************************
|
|
ZINCHP BSR XQPAUS ; RELEASE PROCESSOR
|
|
ZINCH BSR XQCIDT ; CALL INPUT DATA APPENDAGE
|
|
BCC ZINCHP ; LOOP IF NONE AVAILABLE
|
|
TSTA ; ? TEST FOR NULL
|
|
BEQ ZINCH ; IGNORE NULL
|
|
CMPA #$7F ; ? RUBOUT
|
|
BEQ ZINCH ; BRANCH YES TO IGNORE
|
|
STA 1,S ; STORE INTO CALLERS A
|
|
TST <MISFLG ; ? LOAD IN PROGRESS
|
|
BNE ZOTCH3 ; BRANCH IF SO TO NOT ECHO
|
|
CMPA #CR ; ? CARRIAGE RETURN
|
|
BNE ZIN2 ; NO, TEST ECHO BYTE
|
|
LDA #LF ; LOAD LINE FEED
|
|
BSR SEND ; ALWAYS ECHO LINE FEED
|
|
ZIN2 TST <VECTAB+_ECHO ; ? ECHO DESIRED
|
|
BNE ZOTCH3 ; NO, RETURN
|
|
* FALL THROUGH TO OUTCH
|
|
************************************************
|
|
* [SWI FUNCTION 1]
|
|
* OUTCH - OUTPUT CHARACTER FROM A
|
|
* INPUT: NONE
|
|
* OUTPUT: IF LINEFEED IS THE OUTPUT CHARACTER THEN
|
|
* C=0 NO CTL-X RECEIVED, C=1 CTL-X RECEIVED
|
|
************************************************
|
|
ZOTCH1 LDA 1,S ; LOAD CHARACTER TO SEND
|
|
LEAX <ZPCRLS,PCR ; DEFAULT FOR LINE FEED
|
|
CMPA #LF ; ? LINE FEED
|
|
BEQ ZPDTLP ; BRANCH TO CHECK PAUSE IF SO
|
|
ZOTCH2 BSR SEND ; SEND TO OUTPUT ROUTINE
|
|
ZOTCH3 INC <SWICNT ; BUMP UP "SWI" TRACE NEST LEVEL
|
|
RTI ; RETURN FROM "SWI" FUNCTION
|
|
|
|
**************************************************
|
|
* [SWI FUNCTION 6]
|
|
* PCRLF - SEND CR/LF TO CONSOLE HANDLER
|
|
* INPUT: NONE
|
|
* OUTPUT: CR AND LF SENT TO HANDLER
|
|
* C=0 NO CTL-X, C=1 CTL-X RECEIVED
|
|
**************************************************
|
|
ZPCRLS FCB EOT ; NULL STRING
|
|
ZPCRLF LEAX ZPCRLS,PCR ; READY CR,LF STRING
|
|
* FALL INTO CR/LF CODE
|
|
|
|
**************************************************
|
|
* [SWI FUNCTION 3]
|
|
* PDATA - OUTPUT CR/LF AND STRING
|
|
* INPUT: X->STRING
|
|
* OUTPUT: CR/LF AND STRING SENT TO OUTPUT CONSOLE
|
|
* HANDLER.
|
|
* C=0 NO CTL-X, C=1 CTL-X RECEIVED
|
|
* NOTE: LINE FEED MUST FOLLOW CARRIAGE RETURN FOR
|
|
* PROPER PUNCH DATA.
|
|
**************************************************
|
|
|
|
ZPDATA LDA #CR ; LOAD CARRIAGE RETURN
|
|
BSR SEND ; SEND IT
|
|
LDA #LF ; LOAD LINE FEED
|
|
* FALL INTO PDATA1
|
|
|
|
*************************************************
|
|
* [SWI FUNCTION 2]
|
|
* PDATA1 - OUTPUT STRING TILL EOT ($04)
|
|
* THIS ROUTINE PAUSES IF AN INPUT BYTE BECOMES
|
|
* AVAILABLE DURING OUTPUT TRANSMISSION UNTIL A
|
|
* SECOND IS RECEIVED.
|
|
* INPUT: X->STRING
|
|
* OUTPUT: STRING SENT TO OUTPUT CONSOLE DRIVER
|
|
* C=0 NO CTL-X, C=1 CTL-X RECEIVED
|
|
*************************************************
|
|
|
|
ZPDTLP BSR SEND ; SEND CHARACTER TO DRIVER
|
|
ZPDTA1 LDA ,X+ ; LOAD NEXT CHARACTER
|
|
CMPA #EOT ; ? EOT
|
|
BNE ZPDTLP ; LOOP IF NOT
|
|
* FALL INTO PAUSE CHECK FUNCTION
|
|
|
|
********************************************
|
|
* [SWI FUNCTION 12]
|
|
* PAUSE - RETURN TO TASK DISPATCHING AND CHECK
|
|
* FOR FREEZE CONDITION OR CTL-X BREAK
|
|
* THIS FUNCTION ENTERS THE TASK PAUSE HANDLER SO
|
|
* OPTIONALLY OTHER 6809 PROCESSES MAY GAIN CONTROL.
|
|
* UPON RETURN, CHECK FOR A 'FREEZE' CONDITION
|
|
* WITH A RESULTING WAIT LOOP, OR CONDITION CODE
|
|
* RETURN IF A CONTROL-X IS ENTERED FROM THE INPUT
|
|
* HANDLER.
|
|
* OUTPUT: C=1 IF CTL-X HAS ENTERED, C=0 OTHERWISE
|
|
******************************************
|
|
|
|
ZPAUSE BSR XQPAUS ; RELEASE CONTROL AT EVERY LINE
|
|
BSR CHKABT ; CHECK FOR FREEZE OR ABORT
|
|
TFR CC,B ; PREPARE TO REPLACE CC
|
|
STB ,S ; OVERLAY OLD ONE ON STACK
|
|
BRA ZOTCH3 ; RETURN FROM "SWI"
|
|
|
|
* CHKABT - SCAN FOR INPUT PAUSE/ABORT DURING OUTPUT
|
|
* OUTPUT: C=0 OK, C=1 ABORT (CTL-X ISSUED)
|
|
* VOLATILE: U,X,D
|
|
CHKABT BSR XQCIDT ; ATTEMPT INPUT
|
|
BCC CHKRTN ; BRANCH NO TO RETURN
|
|
CMPA #CAN ; ? CTL-X FOR ABORT
|
|
BNE CHKWT ; BRANCH NO TO PAUSE
|
|
CHKSEC COMB ; SET CARRY
|
|
CHKRTN RTS ; RETURN TO CALLER WITH CC SET
|
|
CHKWT BSR XQPAUS ; PAUSE FOR A MOMENT
|
|
BSR XQCIDT ; ? KEY FOR START
|
|
BCC CHKWT ; LOOP UNTIL RECEIVED
|
|
CMPA #CAN ; ? ABORT SIGNALED FROM WAIT
|
|
BEQ CHKSEC ; BRANCH YES
|
|
CLRA ; SET C=0 FOR NO ABORT
|
|
RTS ; AND RETURN
|
|
|
|
* SAVE MEMORY WITH JUMPS
|
|
XQPAUS JMP [VECTAB+_PAUSE,PCR] ; TO PAUSE ROUTINE
|
|
XQCIDT JSR [VECTAB+_CIDTA,PCR] ; TO INPUT ROUTINE
|
|
ANDA #$7F ; STRIP PARITY
|
|
RTS ; RETURN TO CALLER
|
|
|
|
********************************************
|
|
* NMI DEFAULT INTERRUPT HANDLER
|
|
* THE NMI HANDLER IS USED FOR TRACING INSTRUCTIONS.
|
|
* TRACE PRINTOUTS OCCUR ONLY AS LONG AS THE STACK
|
|
* TRACE LEVEL IS NOT BREACHED BY FALLING BELOW IT.
|
|
* TRACING CONTINUES UNTIL THE COUNT TURNS ZERO OR
|
|
* A CTL-X IS ENTERED FROM THE INPUT CONSOLE DEVICE.
|
|
*********************************************
|
|
|
|
MSHOWP FCB 'O,'P,'-,EOT ; OPCODE PREP
|
|
|
|
NMIR BSR LDDP ; LOAD PAGE AND VERIFY STACK
|
|
TST <MISFLG ; ? THRU A BREAKPOINT
|
|
BNE NMICON ; BRANCH IF SO TO CONTINUE
|
|
TST <SWICNT ; ? INHIBIT "SWI" DURING TRACE
|
|
BMI NMITRC ; BRANCH YES
|
|
LEAX 12,S ; OBTAIN USERS STACK POINTER
|
|
CMPX <SLEVEL ; ? TO TRACE HERE
|
|
BLO NMITRC ; BRANCH IF TOO LOW TO DISPLAY
|
|
LEAX MSHOWP,PCR ; LOAD OP PREP
|
|
SWI ; SEND TO CONSOLE
|
|
FCB PDATA1 ; FUNCTION
|
|
ROL <DELIM ; SAVE CARRY BIT
|
|
LEAX LASTOP,PCR ; POINT TO LAST OP
|
|
SWI ; SEND OUT AS HEX
|
|
FCB OUT4HS ; FUNCTION
|
|
BSR REGPRS ; FOLLOW MEMORY WITH REGISTERS
|
|
BCS ZBKCMD ; BRANCH IF "CANCEL"
|
|
ROR <DELIM ; RESTORE CARRY BIT
|
|
BCS ZBKCMD ; BRANCH IF "CANCEL"
|
|
LDX <TRACEC ; LOAD TRACE COUNT
|
|
BEQ ZBKCMD ; IF ZERO TO COMMAND HANDLER
|
|
LEAX -1,X ; MINUS ONE
|
|
STX <TRACEC ; REFRESH
|
|
BEQ ZBKCMD ; STOP TRACE WHEN ZERO
|
|
BSR CHKABT ; ? ABORT THE TRACE
|
|
BCS ZBKCMD ; BRANCH YES TO COMMAND HANDLER
|
|
NMITRC LBRA CTRCE3 ; NO, TRACE ANOTHER INSTRUCTION
|
|
|
|
REGPRS LBSR REGPRT ; PRINT REGISTERS AS FROM COMMAND
|
|
RTS ; RETURN TO CALLER
|
|
|
|
* JUST EXECUTED THRU A BRKPNT. NOW CONTINUE NORMALLY
|
|
|
|
NMICON CLR <MISFLG ; CLEAR THRU FLAG
|
|
LBSR ARMBK2 ; ARM BREAKPOINTS
|
|
RTI RTI ; AND CONTINUE USERS PROGRAM
|
|
|
|
* LDDP - SETUP DIRECT PAGE REGISTER, VERIFY STACK.
|
|
* AN INVALID STACK CAUSES A RETURN TO THE COMMAND
|
|
* HANDLER.
|
|
* INPUT: FULLY STACKED REGISTERS FROM AN INTERRUPT
|
|
* OUTPUT: DPR LOADED TO WORK PAGE
|
|
|
|
ERRMSG FCB '?,BELL,$20,EOT ; ERROR RESPONSE
|
|
|
|
LDDP LDB BASEPG,PCR ; LOAD DIRECT PAGE HIGH BYTE
|
|
TFR B,DP ; SETUP DIRECT PAGE REGISTER
|
|
CMPA 3,S ; ? IS STACK VALID
|
|
BEQ RTS ; YES, RETURN
|
|
LDS <RSTACK ; RESET TO INITIAL STACK POINTER
|
|
ERROR LEAX ERRMSG,PCR ; LOAD ERROR REPORT
|
|
SWI ; SEND OUT BEFORE REGISTERS
|
|
FCB PDATA ; ON NEXT LINE
|
|
* FALL INTO BREAKPOINT HANDLER
|
|
|
|
**********************************************
|
|
* [SWI FUNCTION 10]
|
|
* BREAKPOINT PROGRAM FUNCTION
|
|
* PRINT REGISTERS AND GO TO COMMAND HANLER
|
|
***********************************************
|
|
|
|
ZBKPNT BSR REGPRS ; PRINT OUT REGISTERS
|
|
ZBKCMD LBRA CMDNEP ; NOW ENTER COMMAND HANDLER
|
|
|
|
********************************************
|
|
* IRQ, RESERVED, SWI2 AND SWI3 INTERRUPT HANDLERS
|
|
* THE DEFAULT HANDLING IS TO CAUSE A BREAKPOINT.
|
|
********************************************
|
|
SWI2R EQU * ; SWI2 ENTRY
|
|
SWI3R EQU * ; SWI3 ENTRY
|
|
IRQR EQU * ; IRQ ENTRY
|
|
RSRVDR BSR LDDP ; SET BASE PAGE, VALIDATE STACK
|
|
BRA ZBKPNT ; FORCE A BREAKPOINT
|
|
|
|
******************************************
|
|
* FIRQ HANDLER
|
|
* JUST RETURN FOR THE FIRQ INTERRUPT
|
|
******************************************
|
|
FIRQR EQU RTI ; IMMEDIATE RETURN
|
|
|
|
**************************************************
|
|
* DEFAULT I/O DRIVERS
|
|
**************************************************
|
|
* CIDTA - RETURN CONSOLE INPUT CHARACTER
|
|
* OUTPUT: C=0 IF NO DATA READY, C=1 A=CHARACTER
|
|
* U VOLATILE
|
|
|
|
CIDTA LDU <VECTAB+_ACIA ; LOAD ACIA ADDRESS
|
|
LDA ,U ; LOAD STATUS REGISTER
|
|
LSRA ; TEST RECEIVER REGISTER FLAG
|
|
BCC CIRTN ; RETURN IF NOTHING
|
|
LDA 1,U ; LOAD DATA BYTE
|
|
CIRTN RTS ; RETURN TO CALLER
|
|
|
|
* CION - INPUT CONSOLE INITIALIZATION
|
|
* COON - OUTPUT CONSOLE INITIALIZATION
|
|
* A,X VOLATILE
|
|
CION EQU *
|
|
COON LDA #3 ; RESET ACIA CODE
|
|
LDX <VECTAB+_ACIA ; LOAD ACIA ADDRESS
|
|
STA ,X ; STORE INTO STATUS REGISTER
|
|
LDA #$51 ; SET CONTROL
|
|
STA ,X ; REGISTER UP
|
|
RTS RTS ; RETURN TO CALLER
|
|
|
|
* THE FOLLOWING HAVE NO DUTIES TO PERFORM
|
|
CIOFF EQU RTS ; CONSOLE INPUT OFF
|
|
COOFF EQU RTS ; CONSOLE OUTPUT OFF
|
|
|
|
* CODTA - OUTPUT CHARACTER TO CONSOLE DEVICE
|
|
* INPUT: A=CHARACTER TO SEND
|
|
* OUTPUT: CHAR SENT TO TERMINAL WITH PROPER PADDING
|
|
* ALL REGISTERS TRANSPARENT
|
|
|
|
CODTA PSHS U,D,CC ; SAVE REGISTERS,WORK BYTE
|
|
LDU <VECTAB+_ACIA ; ADDRESS ACIA
|
|
BSR CODTAO ; CALL OUTPUT CHAR SUBROUTINE
|
|
CMPA #DLE ; ? DATA LINE ESCAPE
|
|
BEQ CODTRT ; YES, RETURN
|
|
LDB <VECTAB+_PAD ; DEFAULT TO CHAR PAD COUNT
|
|
CMPA #CR ; ? CR
|
|
BNE CODTPD ; BRANCH NO
|
|
LDB <VECTAB+_PAD+1 ; LOAD NEW LINE PAD COUNT
|
|
CODTPD CLRA ; CREATE NULL
|
|
STB ,S ; SAVE COUNT
|
|
FCB SKIP2 ; ENTER LOOP
|
|
CODTLP BSR CODTAO ; SEND NULL
|
|
DEC ,S ; ? FINISHED
|
|
BPL CODTLP ; NO, CONTINUE WITH MORE
|
|
CODTRT PULS PC,U,D,CC ; RESTORE REGISTERS AND RETURN
|
|
|
|
CODTAD LBSR XQPAUS ; TEMPORARY GIVE UP CONTROL
|
|
CODTAO LDB ,U ; LOAD ACIA CONTROL REGISTER
|
|
BITB #$02 ; ? TX REGISTER CLEAR
|
|
BEQ CODTAD ; RELEASE CONTROL IF NOT
|
|
STA 1,U ; STORE INTO DATA REGISTER
|
|
RTS ; RETURN TO CALLER
|
|
*E
|
|
|
|
* BSON - TURN ON READ/VERIFY/PUNCH MECHANISM
|
|
* A IS VOLATILE
|
|
|
|
BSON LDA #$11 ; SET READ CODE
|
|
TST 6,S ; ? READ OR VERIFY
|
|
BNE BSON2 ; BRANCH YES
|
|
INCA ; SET TO WRITE
|
|
BSON2 SWI ; PERFORM OUTPUT
|
|
FCB OUTCH ; FUNCTION
|
|
INC <MISFLG ; SET LOAD IN PROGRESS FLAG
|
|
RTS ; RETURN TO CALLER
|
|
|
|
* BSOFF - TURN OFF READ/VERIFY/PUNCH MECHANISM
|
|
* A,X VOLATILE
|
|
|
|
BSOFF LDA #$14 ; TO DC4 - STOP
|
|
SWI ; SEND OUT
|
|
FCB OUTCH ; FUNCTION
|
|
DECA ; CHANGE TO DC3 (X-OFF)
|
|
SWI ; SEND OUT
|
|
FCB OUTCH ; FUNCTION
|
|
DEC <MISFLG ; CLEAR LOAD IN PROGRESS FLAG
|
|
LDX #25000 ; DELAY 1 SECOND (2MHZ CLOCK)
|
|
BSOFLP LEAX -1,X ; COUNT DOWN
|
|
BNE BSOFLP ; LOOP TILL DONE
|
|
RTS ; RETURN TO CALLER
|
|
|
|
* BSDTA - READ/VERIFY/PUNCH HANDLER
|
|
* INPUT: S+6=CODE BYTE, VERIFY(-1),PUNCH(0),LOAD(1)
|
|
* S+4=START ADDRESS
|
|
* S+2=STOP ADDRESS
|
|
* S+0=RETURN ADDRESS
|
|
* OUTPUT: Z=1 NORMAL COMPLETION, Z=0 INVALID LOAD/VER
|
|
* REGISTERS ARE VOLATILE
|
|
BSDTA LDU 2,S ; U=TO ADDRESS OR OFFSET
|
|
TST 6,S ; ? PUNCH
|
|
BEQ BSDPUN ; BRANCH YES
|
|
|
|
* DURING READ/VERIFY: S+2=MSB ADDRESS SAVE BYTE
|
|
* S+1=BYTE COUNTER
|
|
* S+0=CHECKSUM
|
|
* U HOLDS OFFSET
|
|
LEAS -3,S ; ROOM FOR WORK/COUNTER/CHECKSUM
|
|
BSDLD1 SWI ; GET NEXT CHARACTER
|
|
FCB INCHNP ; FUNCTION
|
|
BSDLD2 CMPA #'S ; ? START OF S1/S9
|
|
BNE BSDLD1 ; BRANCH NOT
|
|
SWI ; GET NEXT CHARACTER
|
|
FCB INCHNP ; FUNCTION
|
|
CMPA #'9 ; ? HAVE S9
|
|
BEQ BSDSRT ; YES, RETURN GOOD CODE
|
|
CMPA #'1 ; ? HAVE NEW RECORD
|
|
BNE BSDLD2 ; BRANCH IF NOT
|
|
CLR ,S ; CLEAR CHECKSUM
|
|
BSR BYTE ; OBTAIN BYTE COUNT
|
|
STB 1,S ; SAVE FOR DECREMENT
|
|
|
|
* READ ADDRESS
|
|
BSR BYTE ; OBTAIN HIGH VALUE
|
|
STB 2,S ; SAVE IT
|
|
BSR BYTE ; OBTAIN LOW VALUE
|
|
LDA 2,S ; MAKE D=VALUE
|
|
LEAY D,U ; Y=ADDRESS+OFFSET
|
|
* STORE TEXT
|
|
BSDNXT BSR BYTE ; NEXT BYTE
|
|
BEQ BSDEOL ; BRANCH IF CHECKSUM
|
|
TST 9,S ; ? VERIFY ONLY
|
|
BMI BSDCMP ; YES, ONLY COMPARE
|
|
STB ,Y ; STORE INTO MEMORY
|
|
BSDCMP CMPB ,Y+ ; ? VALID RAM
|
|
BEQ BSDNXT ; YES, CONTINUE READING
|
|
BSDSRT PULS PC,X,A ; RETURN WITH Z SET PROPER
|
|
BSDEOL INCA ; ? VALID CHECKSUM
|
|
BEQ BSDLD1 ; BRANCH YES
|
|
BRA BSDSRT ; RETURN Z=0 INVALID
|
|
|
|
* BYTE BUILDS 8 BIT VALUE FROM TWO HEX DIGITS IN
|
|
BYTE BSR BYTHEX ; OBTAIN FIRST HEX
|
|
LDB #16 ; PREPARE SHIFT
|
|
MUL ; OVER TO A
|
|
BSR BYTHEX ; OBTAIN SECOND HEX
|
|
PSHS B ; SAVE HIGH HEX
|
|
ADDA ,S+ ; COMBINE BOTH SIDES
|
|
TFR A,B ; SEND BACK IN B
|
|
ADDA 2,S ; COMPUTE NEW CHECKSUM
|
|
STA 2,S ; STORE BACK
|
|
DEC 3,S ; DECREMENT BYTE COUNT
|
|
BYTRTS RTS ; RETURN TO CALLER
|
|
|
|
BYTHEX SWI ; GET NEXT HEX
|
|
FCB INCHNP ; CHARACTER
|
|
LBSR CNVHEX ; CONVERT TO HEX
|
|
BEQ BYTRTS ; RETURN IF VALID HEX
|
|
PULS PC,U,Y,X,A ; RETURN TO CALLER WITH Z=0
|
|
|
|
* PUNCH STACK USE: S+8=TO ADDRESS
|
|
* S+6=RETURN ADDRESS
|
|
* S+4=SAVED PADDING VALUES
|
|
* S+2 FROM ADDRESS
|
|
* S+1=FRAME COUNT/CHECKSUM
|
|
* S+0=BYTE COUNT
|
|
|
|
BSDPUN LDU <VECTAB+_PAD ; LOAD PADDING VALUES
|
|
LDX 4,S ; X=FROM ADDRESS
|
|
PSHS U,X,D ; CREATE STACK WORK AREA
|
|
LDD #24 ; SET A=0, B=24
|
|
STB <VECTAB+_PAD ; SETUP 24 CHARACTER PADS
|
|
SWI ; SEND NULLS OUT
|
|
FCB OUTCH ; FUNCTION
|
|
LDB #4 ; SETUP NEW LINE PAD TO 4
|
|
STD <VECTAB+_PAD ; SETUP PUNCH PADDING
|
|
* CALCULATE SIZE
|
|
BSPGO LDD 8,S ; LOAD TO
|
|
SUBD 2,S ; MINUS FROM=LENGTH
|
|
CMPD #24 ; ? MORE THAN 23
|
|
BLO BSPOK ; NO, OK
|
|
LDB #23 ; FORCE TO 23 MAX
|
|
BSPOK INCB ; PREPARE COUNTER
|
|
STB ,S ; STORE BYTE COUNT
|
|
ADDB #3 ; ADJUST TO FRAME COUNT
|
|
STB 1,S ; SAVE
|
|
|
|
*PUNCH CR,LF,NULS,S,1
|
|
LEAX <BSPSTR,PCR ; LOAD START RECORD HEADER
|
|
SWI ; SEND OUT
|
|
FCB PDATA ; FUNCTION
|
|
* SEND FRAME COUNT
|
|
CLRB ; INITIALIZE CHECKSUM
|
|
LEAX 1,S ; POINT TO FRAME COUNT AND ADDR
|
|
BSR BSPUN2 ; SEND FRAME COUNT
|
|
*DATA ADDRESS
|
|
BSR BSPUN2 ; SEND ADDRESS HI
|
|
BSR BSPUN2 ; SEND ADDRESS LOW
|
|
*PUNCH DATA
|
|
LDX 2,S ; LOAD START DATA ADDRESS
|
|
BSPMRE BSR BSPUN2 ; SEND OUT NEXT BYTE
|
|
DEC ,S ; ? FINAL BYTE
|
|
BNE BSPMRE ; LOOP IF NOT DONE
|
|
STX 2,S ; UPDATE FROM ADDRESS VALUE
|
|
*PUNCH CHECKSUM
|
|
COMB ; COMPLEMENT
|
|
STB 1,S ; STORE FOR SENDOUT
|
|
LEAX 1,S ; POINT TO IT
|
|
BSR BSPUNC ; SEND OUT AS HEX
|
|
LDX 8,S ; LOAD TOP ADDRESS
|
|
CMPX 2,S ; ? DONE
|
|
BHS BSPGO ; BRANCH NOT
|
|
LEAX <BSPEOF,PCR ; PREPARE END OF FILE
|
|
SWI ; SEND OUT STRING
|
|
FCB PDATA ; FUNCTION
|
|
LDD 4,S ; RECOVER PAD COUNTS
|
|
STD <VECTAB+_PAD ; RESTORE
|
|
CLRA ; SET Z=1 FOR OK RETURN
|
|
PULS PC,U,X,D ; RETURN WITH OK CODE
|
|
BSPUN2 ADDB ,X ; ADD TO CHECKSUM
|
|
BSPUNC LBRA ZOUT2H ; SEND OUT AS HEX AND RETURN
|
|
|
|
BSPSTR FCB 'S,'1,EOT ; CR,LF,NULLS,S,1
|
|
BSPEOF FCC /S9030000FC/ ; EOF STRING
|
|
FCB CR,LF,EOT
|
|
|
|
* HSDTA - HIGH SPEED PRINT MEMORY
|
|
* INPUT: S+4=START ADDRESS
|
|
* S+2=STOP ADDRESS
|
|
* S+0=RETURN ADDRESS
|
|
* X,D VOLATILE
|
|
|
|
* SEND TITLE
|
|
|
|
HSDTA SWI ; SEND NEW LINE
|
|
FCB PCRLF ; FUNCTION
|
|
LDB #6 ; PREPARE 6 SPACES
|
|
HSBLNK SWI ; SEND BLANK
|
|
FCB SPACE ; FUNCTION
|
|
DECB ; COUNT DOWN
|
|
BNE HSBLNK ; LOOP IF MORE
|
|
CLRB ; SETUP BYTE COUNT
|
|
HSHTTL TFR B,A ; PREPARE FOR CONVERT
|
|
LBSR ZOUTHX ; CONVERT TO A HEX DIGIT
|
|
SWI ; SEND BLANK
|
|
FCB SPACE ; FUNCTION
|
|
SWI ; SEND ANOTHER
|
|
FCB SPACE ; BLANK
|
|
INCB ; UP ANOTHER
|
|
CMPB #$10 ; ? PAST 'F'
|
|
BLO HSHTTL ; LOOP UNTIL SO
|
|
HSHLNE SWI ; TO NEXT LINE
|
|
FCB PCRLF ; FUNCTION
|
|
BCS HSDRTN ; RETURN IF USER ENTERED CTL-X
|
|
LEAX 4,S ; POINT AT ADDRESS TO CONVERT
|
|
SWI ; PRINT OUT ADDRESS
|
|
FCB OUT4HS ; FUNCTION
|
|
LDX 4,S ; LOAD ADDRESS PROPER
|
|
LDB #16 ; NEXT SIXTEEN
|
|
HSHNXT SWI ; CONVERT BYTE TO HEX AND SEND
|
|
FCB OUT2HS ; FUNCTION
|
|
DECB ; COUNT DOWN
|
|
BNE HSHNXT ; LOOP IF NOT SIXTEENTH
|
|
SWI ; SEND BLANK
|
|
FCB SPACE ; FUNCTION
|
|
LDX 4,S ; RELOAD FROM ADDRESS
|
|
LDB #16 ; COUNT
|
|
HSHCHR LDA ,X+ ; NEXT BYTE
|
|
BMI HSHDOT ; TOO LARGE, TO A DOT
|
|
CMPA #' ; ? LOWER THAN A BLANK
|
|
BHS HSHCOK ; NO, BRANCH OK
|
|
HSHDOT LDA #'. ; CONVERT INVALID TO A BLANK
|
|
HSHCOK SWI ; SEND CHARACTER
|
|
FCB OUTCH ; FUNCTION
|
|
DECB ; ? DONE
|
|
BNE HSHCHR ; BRANCH NO
|
|
CMPX 2,S ; ? PAST LAST ADDRESS
|
|
BHS HSDRTN ; QUIT IF SO
|
|
STX 4,S ; UPDATE FROM ADDRESS
|
|
LDA 5,S ; LOAD LOW BYTE ADDRESS
|
|
ASLA ; ? TO SECTION BOUNDARY
|
|
BNE HSHLNE ; BRANCH IF NOT
|
|
BRA HSDTA ; BRANCH IF SO
|
|
HSDRTN SWI ; SEND NEW LINE
|
|
FCB PCRLF ; FUNCTION
|
|
RTS ; RETURN TO CALLER
|
|
*F
|
|
|
|
***********************************************
|
|
* A S S I S T 0 9 C O M M A N D S
|
|
***********************************************
|
|
|
|
*************REGISTERS - DISPLAY AND CHANGE REGISTERS
|
|
CREG BSR REGPRT ; PRINT REGISTERS
|
|
INCA ; SET FOR CHANGE FUNCTION
|
|
BSR REGCHG ; GO CHANGE, DISPLAY REGISTERS
|
|
RTS ; RETURN TO COMMAND PROCESSOR
|
|
|
|
********************************************
|
|
* REGPRT - PRINT/CHANGE REGISTERS SUBROUTINE
|
|
* WILL ABORT TO 'CMDBAD' IF OVERFLOW DETECTED DURING
|
|
* A CHANGE OPERATION. CHANGE DISPLAYS REGISTERS WHEN
|
|
* DONE.
|
|
|
|
* REGISTER MASK LIST CONSISTS OF:
|
|
* A) CHARACTERS DENOTING REGISTER
|
|
* B) ZERO FOR ONE BYTE, -1 FOR TWO
|
|
* C) OFFSET ON STACK TO REGISTER POSITION
|
|
* INPUT: SP+4=STACKED REGISTERS
|
|
* A=0 PRINT, A#0 PRINT AND CHANGE
|
|
* OUTPUT: (ONLY FOR REGISTER DISPLAY)
|
|
* C=1 CONTROL-X ENTERED, C=0 OTHERWISE
|
|
* VOLATILE: D,X (CHANGE)
|
|
* B,X (DISPLAY)
|
|
*******************************************
|
|
|
|
REGMSK FCB 'P,'C,-1,19 ; PC REG
|
|
FCB 'A,0,10 ; A REG
|
|
FCB 'B,0,11 ; B REG
|
|
FCB 'X,-1,13 ; X REG
|
|
FCB 'Y,-1,15 ; Y REG
|
|
FCB 'U,-1,17 ; U REG
|
|
FCB 'S,-1,1 ; S REG
|
|
FCB 'C,'C,0,9 ; CC REG
|
|
FCB 'D,'P,0,12 ; DP REG
|
|
FCB 0 ; END OF LIST
|
|
|
|
REGPRT CLRA ; SETUP PRINT ONLY FLAG
|
|
REGCHG LEAX 4+12,S ; READY STACK VALUE
|
|
PSHS Y,X,A ; SAVE ON STACK WITH OPTION
|
|
LEAY REGMSK,PCR ; LOAD REGISTER MASK
|
|
REGP1 LDD ,Y+ ; LOAD NEXT CHAR OR <=0
|
|
TSTA ; ? END OF CHARACTERS
|
|
BLE REGP2 ; BRANCH NOT CHARACTER
|
|
SWI ; SEND TO CONSOLE
|
|
FCB OUTCH ; FUNCTION BYTE
|
|
BRA REGP1 ; CHECK NEXT
|
|
REGP2 LDA #'- ; READY '-'
|
|
SWI ; SEND OUT
|
|
FCB OUTCH ; WITH OUTCH
|
|
LEAX B,S ; X->REGISTER TO PRINT
|
|
TST ,S ; ? CHANGE OPTION
|
|
BNE REGCNG ; BRANCH YES
|
|
TST -1,Y ; ? ONE OR TWO BYTES
|
|
BEQ REGP3 ; BRANCH ZERO MEANS ONE
|
|
SWI ; PERFORM WORD HEX
|
|
FCB OUT4HS ; FUNCTION
|
|
FCB SKIP2 ; SKIP BYTE PRINT
|
|
REGP3 SWI ; PERFORM BYTE HEX
|
|
FCB OUT2HS ; FUNCTION
|
|
REG4 LDD ,Y+ ; TO FRONT OF NEXT ENTRY
|
|
TSTB ; ? END OF ENTRIES
|
|
BNE REGP1 ; LOOP IF MORE
|
|
SWI ; FORCE NEW LINE
|
|
FCB PCRLF ; FUNCTION
|
|
REGRTN PULS PC,Y,X,A ; RESTORE STACK AND RETURN
|
|
|
|
REGCNG BSR BLDNNB ; INPUT BINARY NUMBER
|
|
BEQ REGNXC ; IF CHANGE THEN JUMP
|
|
CMPA #CR ; ? NO MORE DESIRED
|
|
BEQ REGAGN ; BRANCH NOPE
|
|
LDB -1,Y ; LOAD SIZE FLAG
|
|
DECB ; MINUS ONE
|
|
NEGB ; MAKE POSITIVE
|
|
ASLB ; TIMES TWO (=2 OR =4)
|
|
REGSKP SWI ; PERFORM SPACES
|
|
FCB SPACE ; FUNCTION
|
|
DECB
|
|
BNE REGSKP ; LOOP IF MORE
|
|
BRA REG4 ; CONTINUE WITH NEXT REGISTER
|
|
REGNXC STA ,S ; SAVE DELIMITER IN OPTION
|
|
* ; (ALWAYS > 0)
|
|
LDD <NUMBER ; OBTAIN BINARY RESULT
|
|
TST -1,Y ; ? TWO BYTES WORTH
|
|
BNE REGTWO ; BRANCH YES
|
|
LDA ,-X ; SETUP FOR TWO
|
|
REGTWO STD ,X ; STORE IN NEW VALUE
|
|
LDA ,S ; RECOVER DELIMITER
|
|
CMPA #CR ; ? END OF CHANGES
|
|
BNE REG4 ; NO, KEEP ON TRUCK'N
|
|
* MOVE STACKED DATA TO NEW STACK IN CASE STACK
|
|
* POINTER HAS CHANGED
|
|
REGAGN LEAX TSTACK,PCR ; LOAD TEMP AREA
|
|
LDB #21 ; LOAD COUNT
|
|
REGTF1 PULS A ; NEXT BYTE
|
|
STA ,X+ ; STORE INTO TEMP
|
|
DECB ; COUNT DOWN
|
|
BNE REGTF1 ; LOOP IF MORE
|
|
LDS -20,X ; LOAD NEW STACK POINTER
|
|
LDB #21 ; LOAD COUNT AGAIN
|
|
REGTF2 LDA ,-X ; NEXT TO STORE
|
|
PSHS A ; BACK ONTO NEW STACK
|
|
DECB ; COUNT DOWN
|
|
BNE REGTF2 ; LOOP IF MORE
|
|
BRA REGRTN ; GO RESTART COMMAND
|
|
|
|
*********************************************
|
|
* BLDNUM - BUILDS BINARY VALUE FROM INPUT HEX
|
|
* THE ACTIVE EXPRESSION HANDLER IS USED.
|
|
* INPUT: S=RETURN ADDRESS
|
|
* OUTPUT: A=DELIMITER WHICH TERMINATED VALUE
|
|
* (IF DELM NOT ZERO)
|
|
* "NUMBER"=WORD BINARY RESULT
|
|
* Z=1 IF INPUT RECEIVED, Z=0 IF NO HEX RECEIVED
|
|
* REGISTERS ARE TRANSPARENT
|
|
**********************************************
|
|
* EXECUTE SINGLE OR EXTENDED ROM EXPRESSION HANDLER
|
|
*
|
|
* THE FLAG "DELIM" IS USED AS FOLLOWS:
|
|
* DELIM=0 NO LEADING BLANKS, NO FORCED TERMINATOR
|
|
* DELIM=CHR ACCEPT LEADING 'CHR'S, FORCED TERMINATOR
|
|
BLDNNB CLRA ; NO DYNAMIC DELIMITER
|
|
FCB SKIP2 ; SKIP NEXT INSTRUCTION
|
|
* BUILD WITH LEADING BLANKS
|
|
BLDNUM LDA #' ; ALLOW LEADING BLANKS
|
|
STA <DELIM ; STORE AS DELIMITER
|
|
JMP [VECTAB+_EXPAN,PCR] ; TO EXP ANALYZER
|
|
* THIS IS THE DEFAULT SINGLE ROM ANALYZER. WE ACCEPT:
|
|
* 1) HEX INPUT
|
|
* 2) 'M' FOR LAST MEMORY EXAMINE ADDRESS
|
|
* 3) 'P' FOR PROGRAM COUNTER ADDRESS
|
|
* 4) 'W' FOR WINDOW VALUE
|
|
* 5) '@' FOR INDIRECT VALUE
|
|
|
|
EXP1 PSHS X,B ; SAVE REGISTERS
|
|
EXPDLM BSR BLDHXI ; CLEAR NUMBER, CHECK FIRST CHAR
|
|
BEQ EXP2 ; IF HEX DIGIT CONTINUE BUILDING
|
|
* SKIP BLANKS IF DESIRED
|
|
CMPA <DELIM ; ? CORRECT DELIMITER
|
|
BEQ EXPDLM ; YES, IGNORE IT
|
|
* TEST FOR M OR P
|
|
LDX <ADDR ; DEFAULT FOR 'M'
|
|
CMPA #'M ; ? MEMORY EXAMINE ADDR WANTED
|
|
BEQ EXPTDL ; BRANCH IF SO
|
|
LDX <PCNTER ; DEFAULT FOR 'P'
|
|
CMPA #'P ; ? LAST PROGRAM COUNTER WANTED
|
|
BEQ EXPTDL ; BRANCH IF SO
|
|
LDX <WINDOW ; DEFAULT TO WINDOW
|
|
CMPA #'W ; ? WINDOW WANTED
|
|
BEQ EXPTDL
|
|
|
|
EXPRTN PULS PC,X,B ; RETURN AND RESTORE REGISTERS
|
|
* GOT HEX, NOW CONTINUE BUILDING
|
|
EXP2 BSR BLDHEX ; COMPUTE NEXT DIGIT
|
|
BEQ EXP2 ; CONTINUE IF MORE
|
|
BRA EXPCDL ; SEARCH FOR +/-
|
|
* STORE VALUE AND CHECK IF NEED DELIMITER
|
|
EXPTDI LDX ,X ; INDIRECTION DESIRED
|
|
EXPTDL STX <NUMBER ; STORE RESULT
|
|
TST <DELIM ; ? TO FORCE A DELIMITER
|
|
BEQ EXPRTN ; RETURN IF NOT WITH VALUE
|
|
BSR READ ; OBTAIN NEXT CHARACTER
|
|
* TEST FOR + OR -
|
|
EXPCDL LDX <NUMBER ; LOAD LAST VALUE
|
|
CMPA #'+ ; ? ADD OPERATOR
|
|
BNE EXPCHM ; BRANCH NOT
|
|
BSR EXPTRM ; COMPUTE NEXT TERM
|
|
PSHS A ; SAVE DELIMITER
|
|
LDD <NUMBER ; LOAD NEW TERM
|
|
EXPADD LEAX D,X ; ADD TO X
|
|
STX <NUMBER ; STORE AS NEW RESULT
|
|
PULS A ; RESTORE DELIMITER
|
|
BRA EXPCDL ; NOW TEST IT
|
|
EXPCHM CMPA #'- ; ? SUBTRACT OPERATOR
|
|
BEQ EXPSUB ; BRANCH IF SO
|
|
CMPA #'@ ; ? INDIRECTION DESIRED
|
|
BEQ EXPTDI ; BRANCH IF SO
|
|
CLRB ; SET DELIMITER RETURN
|
|
BRA EXPRTN ; AND RETURN TO CALLER
|
|
EXPSUB BSR EXPTRM ; OBTAIN NEXT TERM
|
|
PSHS A ; SAVE DELIMITER
|
|
LDD <NUMBER ; LOAD UP NEXT TERM
|
|
NEGA ; NEGATE A
|
|
NEGB ; NEGATE B
|
|
SBCA #0 ; CORRECT FOR A
|
|
BRA EXPADD ; GO ADD TO EXPRESSION
|
|
* COMPUTE NEXT EXPRESSION TERM
|
|
* OUTPUT: X=OLD VALUE
|
|
* 'NUMBER'=NEXT TERM
|
|
EXPTRM BSR BLDNUM ; OBTAIN NEXT VALUE
|
|
BEQ CNVRTS ; RETURN IF VALID NUMBER
|
|
BLDBAD LBRA CMDBAD ; ABORT COMMAND IF INVALID
|
|
|
|
*********************************************
|
|
* BUILD BINARY VALUE USING INPUT CHARACTERS.
|
|
* INPUT: A=ASCII HEX VALUE OR DELIMITER
|
|
* SP+0=RETURN ADDRESS
|
|
* SP+2=16 BIT RESULT AREA
|
|
* OUTPUT: Z=1 A=BINARY VALUE
|
|
* Z=0 IF INVALID HEX CHARACTER (A UNCHANGED)
|
|
* VOLATILE: D
|
|
****************************************
|
|
BLDHXI CLR <NUMBER ; CLEAR NUMBER
|
|
CLR <NUMBER+1 ; CLEAR NUMBER
|
|
BLDHEX BSR READ ; GET INPUT CHARACTER
|
|
BLDHXC BSR CNVHEX ; CONVERT AND TEST CHARACTER
|
|
BNE CNVRTS ; RETURN IF NOT A NUMBER
|
|
LDB #16 ; PREPARE SHIFT
|
|
MUL ; BY FOUR PLACES
|
|
LDA #4 ; ROTATE BINARY INTO VALUE
|
|
BLDSHF ASLB ; OBTAIN NEXT BIT
|
|
ROL <NUMBER+1 ; INTO LOW BYTE
|
|
ROL <NUMBER ; INTO HI BYTE
|
|
DECA ; COUNT DOWN
|
|
BNE BLDSHF ; BRANCH IF MORE TO DO
|
|
BRA CNVOK ; SET GOOD RETURN CODE
|
|
|
|
****************************************
|
|
* CONVERT ASCII CHARACTER TO BINARY BYTE
|
|
* INPUT: A=ASCII
|
|
* OUTPUT: Z=1 A=BINARY VALUE
|
|
* Z=0 IF INVALID
|
|
* ALL REGISTERS TRANSPARENT
|
|
* (A UNALTERED IF INVALID HEX)
|
|
**************************************
|
|
CNVHEX CMPA #'0 ; ? LOWER THAN A ZERO
|
|
BLO CNVRTS ; BRANCH NOT VALUE
|
|
CMPA #'9 ; ? POSSIBLE A-F
|
|
BLE CNVGOT ; BRANCH NO TO ACCEPT
|
|
CMPA #'A ; ? LESS THEN TEN
|
|
BLO CNVRTS ; RETURN IF MINUS (INVALID)
|
|
CMPA #'F ; ? NOT TOO LARGE
|
|
BHI CNVRTS ; NO, RETURN TOO LARGE
|
|
SUBA #7 ; DOWN TO BINARY
|
|
CNVGOT ANDA #$0F ; CLEAR HIGH HEX
|
|
CNVOK ORCC #4 ; FORCE ZERO ON FOR VALID HEX
|
|
CNVRTS RTS ; RETURN TO CALLER
|
|
|
|
* GET INPUT CHAR, ABORT COMMAND IF CONTROL-X (CANCEL)
|
|
READ SWI ; GET NEXT CHARACTER
|
|
FCB INCHNP ; FUNCTION
|
|
CMPA #CAN ; ? ABORT COMMAND
|
|
BEQ BLDBAD ; BRANCH TO ABORT IF SO
|
|
RTS ; RETURN TO CALLER
|
|
*G
|
|
|
|
***************GO - START PROGRAM EXECUTION
|
|
CGO BSR GOADDR ; BUILD ADDRESS IF NEEDED
|
|
RTI ; START EXECUTING
|
|
|
|
* FIND OPTIONAL NEW PROGRAM COUNTER. ALSO ARM THE
|
|
* BREAKPOINTS.
|
|
GOADDR PULS Y,X ; RECOVER RETURN ADDRESS
|
|
PSHS X ; STORE RETURN BACK
|
|
BNE GONDFT ; IF NO CARRIAGE RETURN THEN NEW PC
|
|
|
|
* DEFAULT PROGRAM COUNTER, SO FALL THROUGH IF
|
|
* IMMEDIATE BREAKPOINT.
|
|
LBSR CBKLDR ; SEARCH BREAKPOINTS
|
|
LDX 12,S ; LOAD PROGRAM COUNTER
|
|
ARMBLP DECB ; COUNT DOWN
|
|
BMI ARMBK2 ; DONE, NONE TO SINGLE TRACE
|
|
LDA -NUMBKP*2,Y ; PRE-FETCH OPCODE
|
|
CMPX ,Y++ ; ? IS THIS A BREAKPOINT
|
|
BNE ARMBLP ; LOOP IF NOT
|
|
CMPA #$3F ; ? SWI BREAKPOINTED
|
|
BNE ARMNSW ; NO, SKIP SETTING OF PASS FLAG
|
|
STA <SWIBFL ; SHOW UPCOMING SWI NOT BRKPNT
|
|
ARMNSW INC <MISFLG ; FLAG THRU A BREAKPOINT
|
|
LBRA CDOT ; DO SINGLE TRACE W/O BREAKPOINTS
|
|
|
|
* OBTAIN NEW PROGRAM COUNTER
|
|
GONDFT LBSR CDNUM ; OBTAIN NEW PROGRAM COUNTER
|
|
STD 12,S ; STORE INTO STACK
|
|
ARMBK2 LBSR CBKLDR ; OBTAIN TABLE
|
|
NEG <BKPTCT ; COMPLEMENT TO SHOW ARMED
|
|
ARMLOP DECB ; ? DONE
|
|
BMI CNVRTS ; RETURN WHEN DONE
|
|
LDA [,Y] ; LOAD OPCODE
|
|
STA -NUMBKP*2,Y ; STORE INTO OPCODE TABLE
|
|
LDA #$3F ; READY "SWI" OPCODE
|
|
STA [,Y++] ; STORE AND MOVE UP TABLE
|
|
BRA ARMLOP ; AND CONTINUE
|
|
|
|
*******************CALL - CALL ADDRESS AS SUBROUTINE
|
|
CCALL BSR GOADDR ; FETCH ADDRESS IF NEEDED
|
|
PULS U,Y,X,DP,D,CC ; RESTORE USERS REGISTERS
|
|
JSR [,S++] ; CALL USER SUBROUTINE
|
|
CGOBRK SWI ; PERFORM BREAKPOINT
|
|
FCB BRKPT ; FUNCTION
|
|
BRA CGOBRK ; LOOP UNTIL USER CHANGES PC
|
|
|
|
****************MEMORY - DISPLAY/CHANGE MEMORY
|
|
* CMEMN AND CMPADP ARE DIRECT ENTRY POINTS FROM
|
|
* THE COMMAND HANDLER FOR QUICK COMMANDS
|
|
CMEM LBSR CDNUM ; OBTAIN ADDRESS
|
|
CMEMN STD <ADDR ; STORE DEFAULT
|
|
CMEM2 LDX <ADDR ; LOAD POINTER
|
|
LBSR ZOUT2H ; SEND OUT HEX VALUE OF BYTE
|
|
LDA #'- ; LOAD DELIMITER
|
|
SWI ; SEND OUT
|
|
FCB OUTCH ; FUNCTION
|
|
CMEM4 LBSR BLDNNB ; OBTAIN NEW BYTE VALUE
|
|
BEQ CMENUM ; BRANCH IF NUMBER
|
|
* COMA - SKIP BYTE
|
|
CMPA #', ; ? COMMA
|
|
BNE CMNOTC ; BRANCH NOT
|
|
STX <ADDR ; UPDATE POINTER
|
|
LEAX 1,X ; TO NEXT BYTE
|
|
BRA CMEM4 ; AND INPUT IT
|
|
CMENUM LDB <NUMBER+1 ; LOAD LOW BYTE VALUE
|
|
BSR MUPDAT ; GO OVERLAY MEMORY BYTE
|
|
CMPA #', ; ? CONTINUE WITH NO DISPLAY
|
|
BEQ CMEM4 ; BRANCH YES
|
|
* QUOTED STRING
|
|
CMNOTC CMPA #$27 ; ? QUOTED STRING
|
|
BNE CMNOTQ ; BRANCH NO
|
|
CMESTR BSR READ ; OBTAIN NEXT CHARACTER
|
|
CMPA #$27 ; ? END OF QUOTED STRING
|
|
BEQ CMSPCE ; YES, QUIT STRING MODE
|
|
TFR A,B ; TO B FOR SUBROUTINE
|
|
BSR MUPDAT ; GO UPDATE BYTE
|
|
BRA CMESTR ; GET NEXT CHARACTER
|
|
* BLANK - NEXT BYTE
|
|
CMNOTQ CMPA #$20 ; ? BLANK FOR NEXT BYTE
|
|
BNE CMNOTB ; BRANCH NOT
|
|
STX <ADDR ; UPDATE POINTER
|
|
CMSPCE SWI ; GIVE SPACE
|
|
FCB SPACE ; FUNCTION
|
|
BRA CMEM2 ; NOW PROMPT FOR NEXT
|
|
|
|
* LINE FEED - NEXT BYTE WITH ADDRESS
|
|
CMNOTB CMPA #LF ; ? LINE FEED FOR NEXT BYTE
|
|
BNE CMNOTL ; BRANCH NO
|
|
LDA #CR ; GIVE CARRIAGE RETURN
|
|
SWI ; TO CONSOLE
|
|
FCB OUTCH ; HANDLER
|
|
STX <ADDR ; STORE NEXT ADDRESS
|
|
BRA CMPADP ; BRANCH TO SHOW
|
|
|
|
* UP ARROW - PREVIOUS BYTE AND ADDRESS
|
|
CMNOTL CMPA #'^ ; ? UP ARROW FOR PREVIOUS BYTE
|
|
BNE CMNOTU ; BRANCH NOT
|
|
LEAX -2,X ; DOWN TO PREVIOUS BYTE
|
|
STX <ADDR ; STORE NEW POINTER
|
|
CMPADS SWI ; FORCE NEW LINE
|
|
FCB PCRLF ; FUNCTION
|
|
CMPADP BSR PRTADR ; GO PRINT ITS VALUE
|
|
BRA CMEM2 ; THEN PROMPT FOR INPUT
|
|
|
|
* SLASH - NEXT BYTE WITH ADDRESS
|
|
CMNOTU CMPA #'/ ; ? SLASH FOR CURRENT DISPLAY
|
|
BEQ CMPADS ; YES, SEND ADDRESS
|
|
RTS ; RETURN FROM COMMAND
|
|
|
|
* PRINT CURRENT ADDRESS
|
|
PRTADR LDX <ADDR ; LOAD POINTER VALUE
|
|
PSHS X ; SAVE X ON STACK
|
|
LEAX ,S ; POINT TO IT FOR DISPLAY
|
|
SWI ; DISPLAY POINTER IN HEX
|
|
FCB OUT4HS ; FUNCTION
|
|
PULS PC,X ; RECOVER POINTER AND RETURN
|
|
|
|
* UPDATE BYTE
|
|
MUPDAT LDX <ADDR ; LOAD NEXT BYTE POINTER
|
|
STB ,X+ ; STORE AND INCREMENT X
|
|
CMPB -1,X ; ? SUCCESFULL STORE
|
|
BNE MUPBAD ; BRANCH FOR '?' IF NOT
|
|
STX <ADDR ; STORE NEW POINTER VALUE
|
|
RTS ; BACK TO CALLER
|
|
MUPBAD PSHS A ; SAVE A REGISTER
|
|
LDA #'? ; SHOW INVALID
|
|
SWI ; SEND OUT
|
|
FCB OUTCH ; FUNCTION
|
|
PULS PC,A ; RETURN TO CALLER
|
|
|
|
********************WINDOW - SET WINDOW VALUE
|
|
CWINDO BSR CDNUM ; OBTAIN WINDOW VALUE
|
|
STD <WINDOW ; STORE IT IN
|
|
RTS ; END COMMAND
|
|
|
|
******************DISPLAY - HIGH SPEED DISPLAY MEMORY
|
|
CDISP BSR CDNUM ; FETCH ADDRESS
|
|
ANDB #$F0 ; FORCE TO 16 BOUNDARY
|
|
TFR D,Y ; SAVE IN Y
|
|
LEAX 15,Y ; DEFAULT LENGTH
|
|
BCS CDISPS ; BRANCH IF END OF INPUT
|
|
BSR CDNUM ; OBTAIN COUNT
|
|
LEAX D,Y ; ASSUME COUNT, COMPUTE END ADDR
|
|
CDISPS PSHS Y,X ; SETUP PARAMETERS FOR HSDATA
|
|
CMPD 2,S ; ? WAS IT COUNT
|
|
BLS CDCNT ; BRANCH YES
|
|
STD ,S ; STORE HIGH ADDRESS
|
|
CDCNT JSR [VECTAB+_HSDTA,PCR] ; CALL PRINT ROUTINE
|
|
PULS PC,U,Y ; CLEAN STACK AND END COMMAND
|
|
|
|
* OBTAIN NUMBER - ABORT IF NONE
|
|
* ONLY DELIMITERS OF CR, BLANK, OR '/' ARE ACCEPTED
|
|
* OUTPUT: D=VALUE, C=1 IF CARRIAGE RETURN DELMITER,
|
|
* ELSE C=0
|
|
CDNUM LBSR BLDNUM ; OBTAIN NUMBER
|
|
BNE CDBADN ; BRANCH IF INVALID
|
|
CMPA #'/ ; ? VALID DELIMITER
|
|
BHI CDBADN ; BRANCH IF NOT FOR ERROR
|
|
CMPA #CR+1 ; LEAVE COMPARE FOR CARRIAGE RET
|
|
LDD <NUMBER ; LOAD NUMBER
|
|
RTS ; RETURN WITH COMPARE
|
|
CDBADN LBRA CMDBAD ; RETURN TO ERROR MECHANISM
|
|
|
|
*****************PUNCH - PUNCH MEMORY IN S1-S9 FORMAT
|
|
CPUNCH BSR CDNUM ; OBTAIN START ADDRESS
|
|
TFR D,Y ; SAVE IN Y
|
|
BSR CDNUM ; OBTAIN END ADDRESS
|
|
CLR ,-S ; SETUP PUNCH FUNCTION CODE
|
|
PSHS Y,D ; STORE VALUES ON STACK
|
|
CCALBS JSR [VECTAB+_BSON,PCR] ; INITIALIZE HANDLER
|
|
JSR [VECTAB+_BSDTA,PCR] ; PERFORM FUNCTION
|
|
PSHS CC ; SAVE RETURN CODE
|
|
JSR [VECTAB+_BSOFF,PCR] ; TURN OFF HANDLER
|
|
PULS CC ; OBTAIN CONDITION CODE SAVED
|
|
BNE CDBADN ; BRANCH IF ERROR
|
|
PULS PC,Y,X,A ; RETURN FROM COMMAND
|
|
|
|
*****************LOAD - LOAD MEMORY FROM S1-S9 FORMAT
|
|
CLOAD BSR CLVOFS ; CALL SETUP AND PASS CODE
|
|
FCB 1 ; LOAD FUNCTION CODE FOR PACKET
|
|
|
|
CLVOFS LEAU [,S++] ; LOAD CODE IN HIGH BYTE OF U
|
|
LEAU [,U] ; NOT CHANGING CC AND RESTORE S
|
|
BEQ CLVDFT ; BRANCH IF CARRIAGE RETURN NEXT
|
|
BSR CDNUM ; OBTAIN OFFSET
|
|
FCB SKIP2 ; SKIP DEFAULT OFFSET
|
|
CLVDFT CLRA ; CREATE ZERO OFFSET
|
|
CLRB ; AS DEFAULT
|
|
PSHS U,DP,D ; SETUP CODE, NULL WORD, OFFSET
|
|
BRA CCALBS ; ENTER CALL TO BS ROUTINES
|
|
|
|
******************VERIFY - COMPARE MEMORY WITH FILES
|
|
CVER BSR CLVOFS ; COMPUTE OFFSET IF ANY
|
|
FCB -1 ; VERIFY FNCTN CODE FOR PACKET
|
|
|
|
*******************TRACE - TRACE INSTRUCTIONS
|
|
******************* . - SINGLE STEP TRACE
|
|
CTRACE BSR CDNUM ; OBTAIN TRACE COUNT
|
|
STD <TRACEC ; STORE COUNT
|
|
CDOT LEAS 2,S ; RID COMMAND RETURN FROM STACK
|
|
CTRCE3 LDU [10,S] ; LOAD OPCODE TO EXECUTE
|
|
STU <LASTOP ; STORE FOR TRACE INTERRUPT
|
|
LDU <VECTAB+_PTM ; LOAD PTM ADDRESS
|
|
LDD #$0701 ; 7,1 CYCLES DOWN+CYCLES UP
|
|
STD PTMTM1-PTM,U ; START NMI TIMEOUT
|
|
RTI ; RETURN FOR ONE INSTRUCTION
|
|
|
|
*************NULLS - SET NEW LINE AND CHAR PADDING
|
|
CNULLS BSR CDNUM ; OBTAIN NEW LINE PAD
|
|
STD <VECTAB+_PAD ; RESET VALUES
|
|
RTS ; END COMMAND
|
|
|
|
******************STLEVEL - SET STACK TRACE LEVEL
|
|
CSTLEV BEQ STLDFT ; TAKE DEFAULT
|
|
BSR CDNUM ; OBTAIN NEW STACK LEVEL
|
|
STD <SLEVEL ; STORE NEW ENTRY
|
|
RTS ; TO COMMAND HANDLER
|
|
STLDFT LEAX 14,S ; COMPUTE NMI COMPARE
|
|
STX <SLEVEL ; AND STORE IT
|
|
RTS ; END COMMAND
|
|
|
|
******************OFFSET - COMPUTE SHORT AND LONG
|
|
****************** BRANCH OFFSETS
|
|
COFFS BSR CDNUM ; OBTAIN INSTRUCTION ADDRESS
|
|
TFR D,X ; USE AS FROM ADDRESS
|
|
BSR CDNUM ; OBTAIN TO ADDRESS
|
|
* D=TO INSTRUCTION, X=FROM INSTRUCTION OFFSET BYTE(S)
|
|
LEAX 1,X ; ADJUST FOR *+2 SHORT BRANCH
|
|
PSHS Y,X ; STORE WORK WORD AND VALUE ON S
|
|
SUBD ,S ; FIND OFFSET
|
|
STD ,S ; SAVE OVER STACK
|
|
LEAX 1,S ; POINT FOR ONE BYTE DISPLAY
|
|
SEX ; SIGN EXTEND LOW BYTE
|
|
CMPA ,S ; ? VALID ONE BYTE OFFSET
|
|
BNE COFNO1 ; BRANCH IF NOT
|
|
SWI ; SHOW ONE BYTE OFFSET
|
|
FCB OUT2HS ; FUNCTION
|
|
COFNO1 LDU ,S ; RELOAD OFFSET
|
|
LEAU -1,U ; CONVERT TO LONG BRANCH OFFSET
|
|
STU ,X ; STORE BACK WHERE X POINTS NOW
|
|
SWI ; SHOW TWO BYTE OFFSET
|
|
FCB OUT4HS ; FUNCTION
|
|
SWI ; FORCE NEW LINE
|
|
FCB PCRLF ; FUNCTION
|
|
PULS PC,X,D ; RESTORE STACK AND END COMMAND
|
|
*H
|
|
|
|
*************BREAKPOINT - DISPLAY/ENTER/DELETE/CLEAR
|
|
************* BREAKPOINTS
|
|
CBKPT BEQ CBKDSP ; BRANCH DISPLAY OF JUST 'B'
|
|
LBSR BLDNUM ; ATTEMPT VALUE ENTRY
|
|
BEQ CBKADD ; BRANCH TO ADD IF SO
|
|
CMPA #'- ; ? CORRECT DELIMITER
|
|
BNE CBKERR ; NO, BRANCH FOR ERROR
|
|
LBSR BLDNUM ; ATTEMPT DELETE VALUE
|
|
BEQ CBKDLE ; GOT ONE, GO DELETE IT
|
|
CLR <BKPTCT ; WAS 'B -', SO ZERO COUNT
|
|
CBKRTS RTS ; END COMMAND
|
|
* DELETE THE ENTRY
|
|
CBKDLE BSR CBKSET ; SETUP REGISTERS AND VALUE
|
|
CBKDLP DECB ; ? ANY ENTRIES IN TABLE
|
|
BMI CBKERR ; BRANCH NO, ERROR
|
|
CMPX ,Y++ ; ? IS THIS THE ENTRY
|
|
BNE CBKDLP ; NO, TRY NEXT
|
|
* FOUND, NOW MOVE OTHERS UP IN ITS PLACE
|
|
CBKDLM LDX ,Y++ ; LOAD NEXT ONE UP
|
|
STX -4,Y ; MOVE DOWN BY ONE
|
|
DECB ; ? DONE
|
|
BPL CBKDLM ; NO, CONTINUE MOVE
|
|
DEC <BKPTCT ; DECREMENT BREAKPOINT COUNT
|
|
CBKDSP BSR CBKSET ; SETUP REGISTERS AND LOAD VALUE
|
|
BEQ CBKRTS ; RETURN IF NONE TO DISPLY
|
|
CBKDSL LEAX ,Y++ ; POINT TO NEXT ENTRY
|
|
SWI ; DISPLAY IN HEX
|
|
FCB OUT4HS ; FUNCTION
|
|
DECB ; COUNT DOWN
|
|
BNE CBKDSL ; LOOP IF NGABLE RAM
|
|
SWI ; SKIP TO NEW LINK
|
|
FCB PCRLF ; FUNCTIONRTS
|
|
RTS
|
|
|
|
* ADD NEW ENTRY
|
|
CBKADD BSR CBKSET ; SETUP REGISTERS
|
|
CMPB #NUMBKP ; ? ALREADY FULL
|
|
BEQ CBKERR ; BRANCH ERROR IF SO
|
|
LDA ,X ; LOAD BYTE TO TRAP
|
|
STB ,X ; TRY TO CHANGE
|
|
CMPB ,X ; ? CHANGEABLE RAM
|
|
BNE CBKERR ; BRANCH ERROR IF NOT
|
|
STA ,X ; RESTORE BYTE
|
|
CBKADL DECB ; COUNT DOWN
|
|
BMI CBKADT ; BRANCH IF DONE TO ADD IT
|
|
CMPX ,Y++ ; ? ENTRY ALREADY HERE
|
|
BNE CBKADL ; LOOP IF NOT
|
|
CBKERR LBRA CMDBAD ; RETURN TO ERROR PRODUCE
|
|
CBKADT STX ,Y ; ADD THIS ENTRY
|
|
CLR -NUMBKP*2+1,Y ; CLEAR OPTIONAL BYTE
|
|
INC <BKPTCT ; ADD ONE TO COUNT
|
|
BRA CBKDSP ; AND NOW DISPLAY ALL OF 'EM
|
|
* SETUP REGISTERS FOR SCAN
|
|
CBKSET LDX <NUMBER ; LOAD VALUE DESIRED
|
|
CBKLDR LEAY BKPTBL,PCR ; LOAD START OF TABLE
|
|
LDB <BKPTCT ; LOAD ENTRY COUNT
|
|
RTS ; RETURN
|
|
|
|
*****************ENCODE - ENCODE A POSTBYTE
|
|
CENCDE CLR ,-S ; DEFAULT TO NOT INDIRECT
|
|
CLRB ; ZERO POSTBYTE VALUE
|
|
LEAX <CONV1,PCR ; START TABLE SEARCH
|
|
SWI ; OBTAIN FIRST CHARACTER
|
|
FCB INCHNP ; FUNCTION
|
|
CMPA #'[ ; ? INDIRECT HERE
|
|
BNE CEN2 ; BRANCH IF NOT
|
|
LDA #$10 ; SET INDIRECT BIT ON
|
|
STA ,S ; SAVE FOR LATER
|
|
CENGET SWI ; OBTAIN NEXT CHARACTER
|
|
FCB INCHNP ; FUNCTION
|
|
CEN2 CMPA #CR ; ? END OF ENTRY
|
|
BEQ CEND1 ; BRANCH YES
|
|
CENLP1 TST ,X ; ? END OF TABLE
|
|
BMI CBKERR ; BRANCH ERROR IF SO
|
|
CMPA ,X++ ; ? THIS THE CHARACTER
|
|
BNE CENLP1 ; BRANCH IF NOT
|
|
ADDB -1,X ; ADD THIS VALUE
|
|
BRA CENGET ; GET NEXT INPUT
|
|
CEND1 LEAX <CONV2,PCR ; POINT AT TABLE 2
|
|
TFR B,A ; SAVE COPY IN A
|
|
ANDA #$60 ; ISOLATE REGISTER MASK
|
|
ORA ,S ; ADD IN INDIRECTION BIT
|
|
STA ,S ; SAVE BACK AS POSTBYTE SKELETON
|
|
ANDB #$9F ; CLEAR REGISTER BITS
|
|
CENLP2 TST ,X ; ? END OF TABLE
|
|
BEQ CBKERR ; BRANCH ERROR IF SO
|
|
CMPB ,X++ ; ? SAME VALUE
|
|
BNE CENLP2 ; LOOP IF NOT
|
|
LDB -1,X ; LOAD RESULT VALUE
|
|
ORB ,S ; ADD TO BASE SKELETON
|
|
STB ,S ; SAVE POSTBYTE ON STACK
|
|
LEAX ,S ; POINT TO IT
|
|
SWI ; SEND OUT AS HEX
|
|
FCB OUT2HS ; FUNCTION
|
|
SWI ; TO NEXT LINE
|
|
FCB PCRLF ; FUNCTION
|
|
PULS PC,B ; END OF COMMAND
|
|
|
|
* TABLE ONE DEFINES VALID INPUT IN SEQUENCE
|
|
CONV1
|
|
FCB 'A,$04,'B,$05,'D,$06,'H,$01
|
|
FCB 'H,$01,'H,$01,'H,$00,',,$00
|
|
FCB '-,$09,'-,$01,'S,$70,'Y,$30
|
|
FCB 'U,$50,'X,$10,'+,$07,'+,$01
|
|
FCB 'P,$80,'C,$00,'R,$00,'],$00
|
|
FCB $FF ; END OF TABLE
|
|
|
|
* CONV2 USES ABOVE CONVERSION TO SET POSTBYTE
|
|
* BIT SKELETON.
|
|
CONV2
|
|
FDB $1084,$1100 ; R, H,R
|
|
FDB $1288,$1389 ; HH,R HHHH,R
|
|
FDB $1486,$1585 ; A,R B,R
|
|
FDB $168B,$1780 ; D,R ,R+
|
|
FDB $1881,$1982 ; ,R++ ,-R
|
|
FDB $1A83,$828C ; ,--R HH,PCR
|
|
FDB $838D,$039F ; HHHH,PCR [HHHH]
|
|
FCB 0 ; END OF TABLE
|
|
|
|
****************************************************
|
|
* DEFAULT INTERRUPT TRANSFERS *
|
|
****************************************************
|
|
RSRVD JMP [VECTAB+_RSVD,PCR] ; RESERVED VECTOR
|
|
SWI3 JMP [VECTAB+_SWI3,PCR] ; SWI3 VECTOR
|
|
SWI2 JMP [VECTAB+_SWI2,PCR] ; SWI2 VECTOR
|
|
FIRQ JMP [VECTAB+_FIRQ,PCR] ; FIRQ VECTOR
|
|
IRQ JMP [VECTAB+_IRQ,PCR] ; IRQ VECTOR
|
|
SWI JMP [VECTAB+_SWI,PCR] ; SWI VECTOR
|
|
NMI JMP [VECTAB+_NMI,PCR] ; NMI VECTOR
|
|
|
|
******************************************************
|
|
* ASSIST09 HARDWARE VECTOR TABLE
|
|
* THIS TABLE IS USED IF THE ASSIST09 ROM ADDRESSES
|
|
* THE MC6809 HARDWARE VECTORS.
|
|
******************************************************
|
|
ORG ROMBEG+ROMSIZ-16 ; SETUP HARDWARE VECTORS
|
|
FDB RSRVD ; RESERVED SLOT
|
|
FDB SWI3 ; SOFTWARE INTERRUPT 3
|
|
FDB SWI2 ; SOFTWARE INTERRUPT 2
|
|
FDB FIRQ ; FAST INTERRUPT REQUEST
|
|
FDB IRQ ; INTERRUPT REQUEST
|
|
FDB SWI ; SOFTWARE INTERRUPT
|
|
FDB NMI ; NON-MASKABLE INTERRUPT
|
|
FDB RESET ; RESTART
|