topicchi/SyncHome
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c79ed8aef46f9453b56144d4b797bae44ddeee4e
SyncHome/trunk/workspace/AVR-Computer/AVR65C02/SBC2OS/SbcOS.asm

1898 lines
84 KiB
NASM
Raw Normal View History

daily_automated
2023-03-13 08:36:51 +00:00
;---------------------------------------------------------------------
; SBC Firmware V5.2, 6-30-13, by Daryl Rictor
;
; ----------------- assembly instructions ----------------------------
; *= $E800 ; start of operating system
Start_OS jmp MonitorBoot ; easy access to monitor program
Jmp_CR jmp Print_CR
Jmp_1sp jmp Print1SP ; jump table for usable monitor
Jmp_2sp jmp Print2SP ; routines
Jmp_xsp jmp PrintXSP ; This will not change in future
Jmp_nib jmp PrintDig ; releases, only be added to
Jmp_byte jmp Print1Byte
jmp_wrd jmp Print2Byte
jmp_bell jmp Bell
jmp_delay jmp Delay
jmp_scan jmp Scan_input
jmp_inp jmp Input_chr
jmp_out jmp Output
jmp_input jmp Input
jmp_input1 jmp Input1
;
;
;*********************************************************************
; local Zero-page variables
;
Prompt = $32 ; 1 byte
linecnt = $33 ; 1 byte
Modejmp = $34 ; 1 byte
Hexdigcnt = $35 ; 1 byte
OPCtxtptr = $36 ; 1 byte
Memchr = $37 ; 1 byte
Startaddr = $38 ; 2 bytes
Startaddr_H = $39
Addrptr = $3a ; 2 bytes
Addrptr_H = $3b
Hexdigits = $3c ; 2 bytes
Hexdigits_H = $3d
Memptr = $3e ; 2 bytes
Memptr_H = $3f
;
; Local Non-Zero Page Variables
;
buffer = $0300 ; keybd input buffer (127 chrs max)
PCH = $03e0 ; hold program counter (need PCH next to PCL for Printreg routine)
PCL = $03e1 ; ""
ACC = $03e2 ; hold Accumulator (A)
XREG = $03e3 ; hold X register
YREG = $03e4 ; hold Y register
SPTR = $03e5 ; hold stack pointer
PREG = $03e6 ; hold status register (P)
ChrInVect = $03eb ; holds Character Input Address
ScanInVect = $03ee ; holds Character Scan Input address
ChrOutVect = $03f1 ; holds Character Output Address
BRKvector = $03f4 ; holds application break vector
RESvector = $03f7 ; 2F7,8,9 holds application reset vector & checksum
INTvector = $03fa ; 2FA,B,C holds application interrupt vector & checksum
NMIvector = $03fd ; 2FD,E,F holds application NMI vector & checksum
;
; *************************************************************************
; kernal commands
; *************************************************************************
; PrintRegCR - subroutine prints a CR, the register contents, CR, then returns
; PrintReg - same as PrintRegCR without leading CR
; Print2Byte - prints AAXX hex digits
; Print1Byte - prints AA hex digits
; PrintDig - prints A hex nibble (low 4 bits)
; Print_CR - prints a CR (ASCII 13)and LF (ASCII 10)
; PrintXSP - prints # of spaces in X Reg
; Print2SP - prints 2 spaces
; Print1SP - prints 1 space
; Input_assem - Alternate input prompt for Assember
; Input - print <CR> and prompt then get a line of input, store at buffer
; Input_Chr - get one byte from input port, waits for input
; Scan_Input - Checks for an input character (no waiting)
; Output - send one byte to the output port
; Bell - send ctrl-g (bell) to output port
; Delay - delay loop
; *************************************************************************
;
RegData .byte" PC= A= X= Y= S= P= (NVRBDIZC)="
;
PrintReg Jsr Print_CR ; Lead with a CR
ldx #$ff ;
ldy #$ff ;
Printreg1 iny ;
lda Regdata,y ;
jsr Output ;
cmp #$3D ; "="
bne Printreg1 ;
Printreg2 inx ;
cpx #$07 ;
beq Printreg3 ; done with first 6
lda PCH,x ;
jsr Print1Byte ;
cpx #$00 ;
bne Printreg1 ;
bra Printreg2 ;
Printreg3 dex ;
lda PCH,x ; get Preg
ldx #$08 ;
Printreg4 rol ;
tay ;
lda #$31 ;
bcs Printreg5 ;
dec ;
Printreg5 jsr Output ;
tya ;
dex ;
bne Printreg4 ;
; fall into the print CR routine
Print_CR PHA ; Save Acc
LDA #$0D ; "cr"
JSR OUTPUT ; send it
LDA #$0A ; "lf"
JSR OUTPUT ; send it
PLA ; Restore Acc
RTS ;
Print2Byte JSR Print1Byte ; prints AAXX hex digits
TXA ;
Print1Byte PHA ; prints AA hex digits
LSR ; MOVE UPPER NIBBLE TO LOWER
LSR ;
LSR ;
LSR ;
JSR PrintDig ;
PLA ;
PrintDig PHY ; prints A hex nibble (low 4 bits)
AND #$0F ;
TAY ;
LDA Hexdigdata,Y ;
PLY ;
jmp output ;
PrintXSP1 JSR Print1SP ;
dex ;
PrintXSP cpx #$00 ;
bne PrintXSP1 ;
rts ;
Print2SP jsr Print1SP ; print 2 SPACES
Print1SP LDA #$20 ; print 1 SPACE
JMP OUTPUT ;
;
Input_Assem lda #$21 ; Assembler Prompt "!"
.byte $2c ; mask out next line to bypass
Input lda #$3E ; Monitor Prompt ">"
sta Prompt ; save prompt chr
Input1 jsr Print_CR ; New Line
lda Prompt ; get prompt
jsr Output ; Print Prompt
ldy #$ff ; pointer
InputWait jsr Input_Chr ; get a character
cmp #$20 ; is ctrl char?
BCS InputSave ; no, echo chr
cmp #$0d ; cr
Beq InputDone ; done
cmp #$1B ; esc
beq Input1 ; cancel and new line
cmp #$08 ; bs
beq backspace ;
cmp #$09 ; TAB key
beq tabkey ;
cmp #$02 ; Ctrl-B
bne InputWait ; Ignore other codes
brk ; Force a keyboard Break cmd
backspace cpy #$ff ;
beq InputWait ; nothing to do
dey ; remove last char
Lda #$08 ; backup one space
jsr Output ;
Lda #$20 ; Print space (destructive BS)
jsr Output ;
Lda #$08 ; backup one space
jsr Output ;
BRA InputWait ; ready for next key
tabkey lda #$20 ; convert tab to space
iny ; move cursor
bmi InputTooLong ; line too long?
sta Buffer,y ; no, save space in buffer
jsr output ; print the space too
tya ; test to see if tab is on multiple of 8
and #$07 ; mask remainder of cursor/8
bne tabkey ; not done, add another space
bra InputWait ; done.
InputSave CMP #$61 ; ucase
BCC InputSave1 ;
SBC #$20 ;
InputSave1 INY ;
BMI InputTooLong ; get next char (up to 127)
STA Buffer,y ;
JSR Output ; OutputCharacter
BRA InputWait ;
InputDone INY ;
InputTooLong LDA #$0d ; force CR at end of 128 characters
sta Buffer,y ;
JSR Output ;
; lda #$0a ; lf Char
; JSR Output ;
RTS ;
;
Input_chr jmp (ChrInVect) ;
Scan_input jmp (ScanInVect) ;
Output jmp (ChrOutVect) ;
;
bell LDA #$07 ; Ctrl G Bell
jmp Output ;
;
Delay PHA ; use A to execute a delay loop
delay1 DEC ;
BNE delay1 ;
PLA ;
DEC ;
BNE Delay ;
GRTS RTS ;
;
;
BRKroutine sta ACC ; save A Monitor"s break handler
stx Xreg ; save X
sty Yreg ; save Y
pla ;
sta Preg ; save P
pla ; PCL
plx ; PCH
sec ;
sbc #$02 ;
sta PCL ; backup to BRK cmd
bcs Brk2 ;
dex ;
Brk2 stx PCH ; save PC
TSX ; get stack pointer
stx SPtr ; save stack pointer
jsr Bell ; Beep speaker
jsr PrintReg ; dump register contents
ldx #$FF ;
txs ; clear stack
cli ; enable interrupts again
jmp Monitor ; start the monitor
;*************************************************************************
;
; Monitor Program
;
;**************************************************************************
MonitorBoot
jsr bell ; beep ready
JSR Version ;
SYSjmp ; Added for EhBASIC
Monitor LDX #$FF ;
TXS ; Init the stack
JSR input ; line input
LDA #$00 ;
TAY ; set to 1st character in line
sta LineCnt ; normal list vs range list
Mon01 STA Memchr ;
Mon02 STZ Hexdigits ; holds parsed hex
STZ Hexdigits+1 ;
JSR ParseHexDig ; Get any Hex chars
LDX #CmdCount ; get # of cmds currently used
Mon08 CMP CmdAscii,X ; is non hex cmd chr?
BEQ Mon09 ; yes x= cmd number
DEX ;
BPL Mon08 ;
BRA Monitor ; no
Mon09 PHX ; save command
PHY ; Save input line pointer
TXA ;
ASL ; ptr * 2
TAX ;
JSR Mon10 ; Execute cmd
PLY ;
PLX ;
BEQ Monitor ; done
LDA Cmdseccode,X ;
BMI Mon02 ;
BRA Mon01 ;
Mon10 JMP (Cmdjmptbl,X) ;
;--------------- Routines used by the Monitor commands ----------------------
ParseHexDig STZ Hexdigcnt ; cntr
BRA ParseHex05 ;
ParseHex03 TXA ; parse hex dig
LDX #$04 ;
ParseHex04 ASL Hexdigits ;
ROL Hexdigits+1 ;
DEX ;
BNE ParseHex04 ;
TSB Hexdigits ;
DEC Hexdigcnt ;
ParseHex05 LDA buffer,Y ;
LDX #$0F ; is hex chr?
INY ;
ParseHex07 CMP Hexdigdata,X ;
BEQ ParseHex03 ; yes
DEX ;
BPL ParseHex07 ;
RTS ; Stored in HexDigits if HexDigCnt <> 0
;
Help_cmd lda #<Helptxt ; lower byte - Menu of Commands
sta addrptr ;
lda #>Helptxt ; upper byte
sta addrptr+1 ;
bra Help_cmd3 ;
Help_Cmd4 cmp #$7e ; "~"
beq Help_Cmd1 ;
jsr Output ;
bra Help_cmd2 ;
Help_cmd1 jsr Print_CR ;
Help_cmd2 jsr Inc_addrptr ;
Help_cmd3 lda (addrptr) ;
bne Help_cmd4 ;
rts ;
Version jsr Print_CR ;
ldx #$FF ; set txt pointer
lda #$0d ;
PortReadyMsg inx ;
JSR Output ; put character to Port
lda porttxt,x ; get message text
bne PortReadyMsg ;
rts ;
;
Excute_cmd jsr exe1 ;
ldx #$FF ; reset stack
txs ;
jmp Monitor ;
exe1 JMP (Hexdigits) ;
;
DOT_cmd LDX Hexdigits ; move address to addrptr
LDA Hexdigits+1 ;
STX Addrptr ;
STA Addrptr+1 ;
inc LineCnt ; range list command
RTS ;
;
CR_cmd CPY #$01 ;
BNE SP_cmd ;
LDA Addrptr ; CR alone - move addrptr to hexdigits
ORA #$0F ; to simulate entering an address
STA Hexdigits ; *** change 07 to 0f for 16 byte/line
LDA Addrptr+1 ;
STA Hexdigits+1 ;
BRA SP_cmd2 ;
SP_cmd LDA Hexdigcnt ; Space command entry
BEQ SP_cmd5 ; any digits to process? no - done
LDX Memchr ; yes - is sec cmd code 0 ? yes -
BEQ SP_cmd1 ; yes -
DEX ; Is sec cmd = 1?
BEQ SP_cmd3 ; yes - is sec cmd code 1 ?
LDA Hexdigits ; no - ":" cmd processed
STA (Addrptr) ;
JMP Inc_addrptr ; set to next address and return
SP_cmd1 JSR DOT_cmd ; sec dig = 0 move address to addrptr
BRA SP_cmd3 ;
SP_cmd2 LDA Addrptr ; CR cmd entry
BIT #$0F ; *** changed 07 to 0F for 16 bytes/line
BEQ SP_cmd3 ; if 16, print new line
cpy #$00 ; if TXT cmd, don"t print the - or spaces between chrs
beq TXT_cmd1 ;
BIT #$07 ; if 8, print -
BEQ SP_cmd33 ;
BRA SP_cmd4 ; else print next byte
SP_cmd3 JSR Print_CR ; "." cmd - display address and data
jsr Scan_Input ; see if brk requested
bcs SP_brk ; if so, stop
LDA Addrptr+1 ; print address
LDX Addrptr ;
JSR Print2Byte ;
SP_cmd33 LDA #$20 ; " " print 1 - 16 bytes of data
JSR OUTPUT ;
LDA #$2D ; "-"
JSR OUTPUT ;
SP_cmd4 LDA #$20 ; " "
JSR OUTPUT ;
cpy #$00 ;
beq TXT_Cmd1 ;
LDA (Addrptr) ;
JSR Print1Byte ;
SP_cmd44 SEC ; checks if range done
LDA Addrptr ;
SBC Hexdigits ;
LDA Addrptr+1 ;
SBC Hexdigits+1 ;
jsr Inc_addrptr ;
BCC SP_cmd2 ; loop until range done
SP_brk STZ Memchr ; reset sec cmd code
SP_cmd5 RTS ; done or no digits to process
;
TXT_Cmd PHY ;
ldy #$00 ;
jsr SP_cmd ;
PLY ;
RTS ;
TXT_cmd1 LDA (Addrptr) ;
AND #$7F ;
CMP #$7F ;
BEQ TXT_Cmd2 ;
CMP #$20 ; " "
BCS TXT_Cmd3 ;
TXT_Cmd2 LDA #$2E ; "." use "." if not printable char
TXT_Cmd3 JSR OUTPUT ;
BRA SP_cmd44 ;
;
Inc_addrptr INC Addrptr ; increments addrptr
BNE Inc_addr1 ;
INC Addrptr+1 ;
Inc_addr1 RTS ;
;
Insert_cmd lda Linecnt ; "I" cmd code
beq Insert_3 ; abort if no . cmd entered
sec ;
lda Hexdigits ;
sbc addrptr ;
tax ;
lda Hexdigits+1 ;
sbc addrptr+1 ;
tay ;
bcc Insert_3 ;
clc ;
txa ;
adc memptr ;
sta hexdigits ;
tya ;
adc memptr+1 ;
sta hexdigits+1 ;
Insert_0 LDA (memptr) ;
STA (Hexdigits) ;
lda #$FF ;
DEC Hexdigits ;
cmp Hexdigits ;
BNE Insert_1 ;
DEC Hexdigits+1 ;
Insert_1 dec Memptr ;
cmp Memptr ;
bne Insert_2 ;
dec Memptr+1 ;
Insert_2 SEC ;
LDA memptr ;
SBC Addrptr ;
LDA memptr+1 ;
SBC Addrptr+1 ;
bcc Insert_3 ;
jsr Scan_Input ; see if brk requested
bcc Insert_0 ; if so, stop List
Insert_3 RTS ;
;
Move_cmd lda Linecnt ; *** any changes to this routine affect EEPROM_WR too!!!
bne Move_cmd3 ; abort if no . cmd was used
Move_brk RTS ;
Move_cmd1 INC Addrptr ; increments addrptr
BNE Move_cmd2 ;
INC Addrptr+1 ;
Move_cmd2 inc Hexdigits ; "M" cmd code
bne Move_cmd3 ;
inc Hexdigits+1 ;
Move_cmd3 SEC ; checks if range done
LDA Memptr ;
SBC Addrptr ;
LDA Memptr+1 ;
SBC Addrptr+1 ;
BCC Move_brk ; exit if range done
jsr Scan_Input ; see if brk requested
bcs Move_brk ;
LDA (Addrptr) ; Moves one byte
STA (Hexdigits) ;
BRA Move_cmd1 ; (zapped after move from eeprom_wr)
EEPROM_TEST lda (Addrptr) ; moved along with Move_cmd for EEPROM_WR
eor (Hexdigits) ; ""
bmi EEPROM_TEST ; ""
bra Move_cmd1 ; ""
EEPROM_WR lda Addrptr ; move the Move_cmd sub to $0280 (kybrd buffer)
pha ; adding EEPROM test routine
lda Addrptr+1 ; then run the burn program from RAM
pha ;
lda #<Move_cmd ;
sta Addrptr ;
lda #>Move_cmd ;
sta Addrptr+1 ;
ldy #$2E ; 47 instructions
EEPROM_WR1 lda (Addrptr),y ;
sta $0280,y ;
dey ;
bpl EEPROM_WR1 ;
lda #$EA ; NOP instruction
sta $02A5 ; *
sta $02A6 ; * affected by changes to Move_cmd routine
sta $029C ; * affected by changes to Move_cmd routine
sta $029D ; * affected by changes to Move_cmd routine
sta $029E ; * affected by changes to Move_cmd routine
sta $029F ; * affected by changes to Move_cmd routine
sta $02A0 ; * affected by changes to Move_cmd routine
pla ;
sta Addrptr+1 ;
pla ;
sta Addrptr ;
jmp $0280 ;
;
Dest_cmd LDX Hexdigits ; ">" cmd code
LDA Hexdigits+1 ;
STX Memptr ; move address to memptr
STA Memptr+1 ;
RTS ;
;
LIST_cmd lda LineCnt ; Check for normal/range
beq List_cmd_1 ; 0 = normal 1=range
LDA Addrptr ; Dissassemble range of code
LDX Addrptr+1 ; move addrptr to startaddr
STA Startaddr ;
STX Startaddr+1 ;
List_range sec ;
lda Startaddr ;
sbc Addrptr ;
lda Startaddr+1 ;
sbc Addrptr+1 ;
bcc List_done ;
jsr List_Line ; list one line
jsr Scan_Input ; see if brk requested
bcs List_done ; if so, stop List
SEC ; checks if range done
LDA Hexdigits ;
SBC Startaddr ;
LDA Hexdigits+1 ;
SBC Startaddr+1 ;
BCS List_range ; if not, loop until done
stz LineCnt ;
List_done RTS ;
List_cmd_1 LDA Hexdigcnt ; Dissassemble one page of cmds
BEQ List1 ; followed with more pages
LDX Hexdigits ;
LDA Hexdigits+1 ;
STX Startaddr ;
STA Startaddr+1 ;
List1 LDA #$14 ; one page of dissassembly
STA Linecnt ;
List2 JSR List_line ;
DEC Linecnt ;
BNE List2 ;
RTS ;
List_line JSR Print_CR ;
JSR List_one ; one line of dissassembly
CLC ;
LDA Startaddr ; inc address pointer to next cmd
ADC Hexdigcnt ;
STA Startaddr ;
BCC List3 ;
INC Startaddr+1 ;
List3 RTS ;
List_one LDA (Startaddr) ; Dissassemble one CMD from Startaddr
TAX ; Initialize List Cmd pointers
LDA OPCtxtidx,X ;
STA OPCtxtptr ;
LDA OPCaddmode,X ;
AND #$0F ; mask out psuedo-modes
STA Modejmp ;
TAX ;
LDA ModeByteCnt,X ;
STA Hexdigcnt ;
LDA Startaddr+1 ;
LDX Startaddr ;
JSR Print2Byte ; print address
LDA #$2D ; "-"
JSR OUTPUT ;
JSR Print2SP ; print " "
LDX #$01 ;---------
List4 LDY #$00 ;print up to 3 ascii chars...
List5 CPY Hexdigcnt ; two spaces...
BCS List6 ; up to three hex chars...
LDA (Startaddr),Y ; two spaces
CPX #$00 ;
BNE List8 ;
JSR Print1Byte ;
BRA List7 ;
List6 CPX #$00 ;
BNE List7 ;
JSR Print2SP ;
List7 LDA #$20 ; " "
List8 AND #$7F ;
CMP #$7F ;
BEQ List9 ;
CMP #$20 ; " "
BCS List10 ;
List9 LDA #$2E ; "." use "." if not printable char
List10 JSR OUTPUT ;
INY ;
CPY #$03 ;
BCC List5 ;
JSR Print2SP ;
DEX ;
BEQ List4 ;---------
LDA OPCtxtptr ; get opcode text
ASL ;
ADC OPCtxtptr ;
TAX ;
LDY #$FD ;
List11 LDA OPCtxtData,X ;
JSR OUTPUT ; print opcode text
INX ;
INY ;
BNE List11 ;
LDA OPCtxtptr ;
CMP #$42 ; 4chr opcodes start
BMI List12 ;
CMP #$46 ; the .xx cmds
BPL List12 ;
lda (startaddr) ; get opcode of 4byte code
lsr
lsr
lsr
lsr
AND #$07 ; strip last 3 bits
ora #$30 ; add CHR '0'
jsr Output ; print it
lda #$20 ; " "
jsr Output ;
jmp List13 ;
List12 JSR Print2SP ;
List13 LDA Modejmp ; setup to print operand
ASL ;
TAX ;
JMP (ModeJmpTbl,X) ; goto operand printing command
IMM_mode LDA #$23 ; print #$HH
JSR output ;
ZP_mode LDA #$24 ; print $HH
JSR output ;
LDY #$01 ;
Byte_mode LDA (Startaddr),Y ;
JMP Print1Byte ;
ZP_X_mode JSR ZP_mode ; print $HH,X
X_mode LDA #$2C ; print ,X
JSR output ;
LDA #$58 ;
JMP output ;
ZP_Y_mode JSR ZP_mode ; print $HH,Y
Y_mode LDA #$2C ; Print ,Y
JSR output ;
LDA #$59 ;
JMP output ;
INDZP_mode JSR IND0_mode ; Print ($HH)
JSR ZP_mode ;
IND1_mode LDA #$29 ; Print )
JMP output ;
INDZP_X_mode JSR IND0_mode ; Print ($HH,X)
JSR ZP_mode ;
JSR X_mode ;
BRA IND1_mode ;
INDZP_Y_mode JSR INDZP_mode ; Print ($HH),Y
BRA Y_mode ;
ABS_mode LDA #$24 ; Print $HHHH
JSR output ;
LDY #$02 ;
JSR Byte_mode ;
DEY ;
BRA Byte_mode ;
ABS_X_mode JSR ABS_mode ; Print $HHHH,X
BRA X_mode ;
ABS_Y_mode JSR ABS_mode ; Print $HHHH,Y
BRA Y_mode ;
INDABS_mode JSR IND0_mode ; Print ($HHHH)
JSR ABS_mode ;
BRA IND1_mode ;
INDABSX_mode JSR IND0_mode ; Print ($HHHH,X)
JSR ABS_mode ;
JSR X_mode ;
BRA IND1_mode ;
IMPLIED_mode RTS ; Implied/Accumulator mode
IND0_mode LDA #$28 ; Print (
JMP output ;
BBREL_mode JSR ZP_mode ;
LDA #$2C ; Print ,
JSR output ;
LDA #$24 ; Print $
JSR output ;
LDY #$02 ;
LDA (Startaddr),Y ;
STA Memchr ;
CLC ;
LDA Startaddr ;
ADC #$03 ;
JMP REL_mode0 ;
REL_mode LDA #$24 ; Print $HHHH as Relative Branch
JSR output ;
LDY #$01 ;
LDA (Startaddr),Y ;
STA Memchr ;
CLC ;
LDA Startaddr ;
ADC #$02 ;
REL_mode0 TAX ;
LDA Startaddr+1 ;
ADC #$00 ;
TAY ;
CLC ;
TXA ;
ADC Memchr ;
TAX ;
TYA ;
LDY Memchr ;
BPL Rel_mode1 ;
DEC ;
Rel_mode1 ADC #$00 ;
JMP Print2Byte ;
;
;mini assembler code
;
Assem_Init tsx ;
inx ;
inx ;
inx ;
inx ;
stz $0100,x ;
jsr version ; show version and ? prompt
jmp Assembler ;
Asm_Help lda #<AsmHelptxt ; lower byte - Menu of Commands
sta addrptr ;
lda #>AsmHelptxt ; upper byte
sta addrptr+1 ;
bra AsmHelp3 ;
ASmHelp4 cmp #$7e ; "~"
beq AsmHelp1 ;
jsr Output ;
bra AsmHelp2 ;
AsmHelp1 jsr Print_CR ;
AsmHelp2 jsr Inc_addrptr ;
AsmHelp3 lda (addrptr) ;
bne AsmHelp4 ;
jsr Opcode_List ;
Assembler LDX #$FF ;
TXS ; init stack
stz HexDigCnt ;
jsr Input_assem ;
ldy #$00 ; beginning of input line
lda buffer ;
cmp #$0d ; Enter = done
bne Asm01 ;
JMP Monitor ; exit assembler
Asm01 cmp #$3f ; "?" Print Help
beq Asm_Help ;
cmp #$20 ; space
beq Asm_opfetch ;
cmp #$3b ; ";" ignore line
beq Assembler ;
cmp #$4C ; "L" list
beq Asm_List ;
cmp #$24 ; "$" ignore this
bne Asm02 ;
iny ;
Asm02 STZ Hexdigits ; holds parsed hex
STZ Hexdigits+1 ;
JSR ParseHexDig ; get Hex Chars
LDX Hexdigcnt ;
Beq Asm_Err ;
cmp #$4C ; "L" do list ???
Beq Asm_List1 ;
cmp #$20 ; Space
Beq Asm_opfetch ;
Asm_Err tya ; get line pointer
tax ;
lda #$0a ; LF move down one line
jsr output ;
jsr PrintXSP ; move to where error occured
lda #$5E ; "^" ???
jsr Output ; mark it
jsr bell ;
bra Assembler ;
Asm_list stz HexDigcnt ;
Asm_List1 jsr List_Cmd_1 ;
Asm_hop bra Assembler ;
Asm_opfetch lda HexDigCnt ;
beq Asm_op01 ; no address change
LDX Hexdigits ;
LDA Hexdigits+1 ;
STX AddrPtr ;
STA AddrPtr+1 ;
dey ;
Asm_stripSP iny ;
Asm_op01 lda buffer,y ;
cmp #$20 ; strip spaces
beq Asm_stripSP ;
cmp #$0d ; done
beq Asm_hop ;
cmp #$3b ; ";" comment char done
beq Asm_hop ;
ldx #$00 ;
stx OpcTxtPtr ;
sty LineCnt ;
Asm_opclp ldy LineCnt ;
lda OpcTxtPtr ;
ASL ;
adc OpcTxtPtr ;
tax ;
lda buffer,y ;
iny ;
cmp OpcTxtData,x ;
bne Asm_getnext ;
lda buffer,y ;
inx ;
iny ;
cmp OpcTxtData,x ;
bne Asm_getnext ;
lda buffer,y ;
inx ;
iny ;
cmp OpcTxtData,x ;
beq Asm_goodop ;
Asm_getnext ldx OpcTxtPtr ;
inx ;
stx OpcTxtPtr ;
cpx #$4A ; last one? then err
bne Asm_opclp
Asm_err2 jmp Asm_err
Asm_goodop lda #$00
sta ModeJmp ;
dec ModeJmp ; init to FF for () check
sta HexDigits ; and Byte holder
sta HexDigits+1 ;
sta HexDigCnt ;
ldx OpcTxtPtr ;
cpx #$42 ;
bmi Asm_goodSP ; not a 4 chr opcode
cpx #$46
bpl Asm_goodSP ; not a 4 chr opcode
lda buffer,y ; get next chr
iny ; advance pointer
cmp #$38 ;
bpl Asm_err2 ; not chr "0"-"7"
cmp #$30
bmi Asm_err2 ; not chr "0"-"7"
ASL
ASL
ASL
ASL
sta startaddr_H ; temp holder for 4th chr opcode
LDA #$80 ; flag for
Asm_goodSP ldx buffer,y ; get next operand char
iny ; point to next operand chr
cpx #$20 ; sp
bne Asm_GoodSP2
cmp #$80
bmi Asm_goodSP
Asm_goodSP1 ldx OpcTxtPtr ; check if its a BBRx or BBSx opcode
cpx #$44 ;
bpl Asm_GoodSP ;
ldx HexDigCnt ;
beq Asm_goodSP ;
cmp #$D0 ; already have zp & rel?
bpl Asm_GoodSP ; we don't care then
cmp #$C0 ; already got a zp address?
bpl Asm_Err2 ; then error
ldx HexDigits+1
bne Asm_err2 ; not zero page
ldx HexDigits
stx startaddr ; temp zp value for BBRx & BBSx cmds
ora #$40 ; mark zp address fetched
and #$F7 ; mask out zp address found
bra Asm_goodSP ; get next chr
Asm_goodSp2 cpx #$0d ; CR
bne Asm_eol
Asm_jmp1 jmp Asm_modeSrch
Asm_eol cpx #$3b ; ";"
beq Asm_jmp1
pha
lda OpcTxtPtr
cmp #$46 ; normal opcode if <=45h
bmi Asm_opnd1
bne Asm_xtra1
cpx #$24 ; $ .db pseudo-opcode
beq Asm_db1
dey
Asm_db1 jsr ParseHexDig
plx
ldx HexDigCnt
beq Asm_err2 ; no digits retrieved
ldy #$00
lda #$01
PHA
lda HexDigits
sta (AddrPtr),y
jmp Asm_save
Asm_xtra1 cmp #$47 ; .dw pseudo-opcode
bne Asm_xtra2
cpx #$24 ; $
beq Asm_dw1
dey
Asm_dw1 jsr ParseHexDig
plx
ldx HexDigCnt
beq Asm_err1 ; no digits retrieved
ldy #$00
lda #$02
PHA
lda HexDigits
sta (AddrPtr),y
lda HexDigits+1
iny
sta (AddrPtr),y
jmp Asm_save
Asm_xtra2 cmp #$48 ; .ds pseudo-opcode
bne Asm_err1
jmp Asm_txt
Asm_opnd1 pla
cpx #$23 ; # 20
bne Asm_parse01
ora #$20
jmp Asm_goodSP
Asm_parse01 cpx #$28 ; ( 04
bne Asm_parse02
ora #$04
ldx modeJmp
bpl Asm_err1 ; more than one (
inc ModeJmp
jmp Asm_goodSP
Asm_parse02 cpx #$29 ; )
bne Asm_parse03
ldx ModeJmp
bne Asm_err1 ; ) without (
inc ModeJmp
jmp Asm_goodSP
Asm_parse03 cpx #$2C ; ,
bne Asm_parse04
ldx buffer,y
cpx #$58 ; X 02
bne Asm_parse31
ora #$02
iny
jmp Asm_goodSP
Asm_parse31 cpx #$59 ; Y 01
beq Asm_parse32
cmp #$80 ; is BBRx or BBSx cmd active?
bmi Asm_err1 ; , without X or Y or 4byte opcode
jmp Asm_goodSP1 ; save zp address
Asm_parse32 ora #$01
iny
jmp Asm_goodSP
Asm_parse04 cpx #$24 ; $
beq Asm_parse42 ;
dey ; not #$(),X,Y so try Hexdig, if not err
Asm_parse42 pha
jsr ParseHexDig
dey ; adjust input line pointer
pla
ldx HexDigCnt
beq Asm_err1 ; no digits retrieved
ldx HexDigits+1
bne Asm_parse41
ora #$08 ; <256 08
jmp Asm_goodSP
Asm_parse41 ora #$10 ; 2 bytes 10
jmp Asm_goodSP
Asm_err1 jmp Asm_Err
Asm_ModeSrch ldx #$0F ; # of modes
Asm_ModeS1 cmp Asm_ModeLst,x
beq Asm_ModeFnd
dex
bpl Asm_ModeS1
bra Asm_Err1 ; invalid Mode
Asm_ModeFnd stx Memchr ; save mode
cmp #$80 ; is it 4 chr opcode?
bmi Asm_opcSrch ;no
txa
ora startaddr_H ; adjust the psuedo mode
sta Memchr ; set proper mode
Asm_opcSrch ldx #$00
Asm_opcSrch1 lda OpcTxtidx,x
cmp OpcTxtPtr
bne Asm_srchNxt
lda OPCaddmode,x
cmp Memchr
beq Asm_OpcFnd
Asm_srchNxt inx
bne Asm_opcSrch1
lda Memchr ;
cmp #$02 ; ZP
bne Asm_srchAlt
LDA #$01 ; ABS
sta Memchr
bra Asm_opcSrch
Asm_srchAlt cmp #$01 ; ABS
bne Asm_srchA0
LDA #$0A ; REL
sta Memchr
bra Asm_opcSrch
Asm_srchA0 cmp #$0d ; ind zp
bne Asm_srchA1
LDA #$0b ; ind Abs
sta Memchr
bra Asm_opcSrch
Asm_SrchA1 cmp #$07 ; zp,y
bne Asm_Err1 ; no more modes to try, bad mode err
LDA #$09 ; ABS,y
sta Memchr
bra Asm_opcSrch
Asm_OpcFnd lda Memchr
and #$0F ; mask out psuedo modes
sta Memchr ;
CMP #$0E ; BBR mode?
bne Asm_opcFnd0 ;
jsr Asm_BRelCalc ;
sta HexDigits_H ;
lda Startaddr ;
sta Hexdigits ;
bra Asm_OpcFnd1 ;
Asm_OpcFnd0 cmp #$0A ; is Rel Mode?
bne Asm_OpcFnd1
jsr Asm_RelCalc ; adjust rel address
Asm_OpcFnd1 ldy #$00
txa
sta (AddrPtr),y
iny
ldx Memchr ;
lda ModeByteCnt,x
PHA ; Save # of bytes
cmp #$01
beq Asm_EchoL
lda HexDigits
sta (AddrPtr),y
iny
lda ModeByteCnt,x
cmp #$02
beq Asm_EchoL
lda HexDigits+1
sta (AddrPtr),y
Asm_EchoL lda AddrPtr
sta StartAddr
lda AddrPtr+1
sta StartAddr+1
jsr List_One
Asm_Save clc
PLA
adc AddrPtr
sta AddrPtr
bcc Asm_done
inc AddrPtr+1
Asm_done jmp Assembler
Asm_BRelCalc jsr Asm_relsub
sbc #$03
bra Asm_RelC1
Asm_RelSub sec
lda Hexdigits
sbc AddrPtr
sta Memptr
lda Hexdigits+1
sbc AddrPtr+1
sta Memptr+1
sec
lda Memptr
rts
Asm_RelCalc jsr Asm_relsub
sbc #$02
Asm_Relc1 sta Memptr
bcs Asm_relC2
dec Memptr+1
Asm_relC2 lda Memptr+1
beq Asm_relC4 ; positive
cmp #$FF ; negative
bne Asm_txtErr
lda Memptr
bpl Asm_txtErr
Asm_relC3 sta HexDigits
rts
Asm_relC4 lda Memptr
bpl Asm_relC3
Asm_txtErr jmp Asm_Err
Asm_txt plx ; process the .ds pseudo-opcode
dey
tya
tax
ldy #$fe
Asm_txt1 iny
Asm_txt2 lda buffer,x ; get next operand char
inx ; point to next operand chr
cmp #$0d ; CR
beq Asm_txt9
cmp #$27 ; "
bne Asm_txt3
cpy #$ff ; opening " found?
bne Asm_txt9 ; no, closing, so done
bra Asm_txt1 ; yes, get first text chr
Asm_txt3 cpy #$ff ; already found opening "?
beq Asm_txt4 ;
sta (AddrPtr),y ; yes, save chr
bra Asm_txt1
Asm_txt4 cmp #$20 ; no, if not a space, then err
beq Asm_txt2
txa
tay
bra Asm_txtErr
Asm_txt9 tya
pha
jmp Asm_save
;
Opcode_List ldy #$49 ; Number of Opcodes (64)
ldx #$00 ; pointer to characters
Opcode_List1 txa ;
and #$0F ; Print CR after each 16 opcodes
bne Opcode_List2 ; not divisible by 16
jsr Print_CR ;
Opcode_List2 lda OPCtxtData,x ; get opcode chr data
jsr Output ; print 1st char
inx ;
lda OPCtxtData,x ;
jsr Output ; print 2nd char
inx ;
lda OPCtxtData,x ;
jsr Output ; print 3rd char
inx ;
cpy #$08 ;
bpl Opcode_List3 ; not 4 byte code
cpy #$04 ;
bmi Opcode_list3 ;
lda #$78 ; add 'x'
jsr output ; for RMBx, SMBx,BBRx, & BBSx
Opcode_List3 lda #$20 ; print space
jsr Output ;
dey ;
bne Opcode_List1 ;
jsr Print_CR ; one last CR-LF
rts ;
;
;-----------DATA TABLES ------------------------------------------------
;
Hexdigdata .byte "0123456789ABCDEF";hex char table
;
CmdCount =$13 ; number of commands to scan for
CmdAscii .byte $0D ; 0 enter cmd codes
.byte $20 ; 1 SPACE
.byte $2E ; 2 .
.byte $3A ; 3 :
.byte $3E ; 4 >
.byte $3f ; 5 ? - Help
.byte $21 ; 6 ! - Assembler
.byte $47 ; 7 g - Go
.byte $49 ; 8 i - Insert
.byte $4C ; 9 l - List
.byte $4D ; A m - Move
.byte $51 ; B q - Query memory (text dump)
.byte $52 ; C r - Registers
.byte $40 ; D @ - Cold Start Basic
.byte $23 ; E # - Warm Start Basic
.byte $55 ; F U - Uploader
.byte $56 ;10 v - Version
.byte $57 ;11 w - "(W)rite" eeprom
.byte $24 ;12 $ - fig forth
.byte $25 ;13 % - uChess
;
Cmdjmptbl .word CR_cmd ; 0 enter cmd jmp table
.word SP_cmd ; 1 space
.word DOT_cmd ; 2 .
.word DOT_cmd ; 3 :
.word Dest_cmd ; 4 >
.word Help_Cmd ; 5 ?
.word Assem_init ; 6 !
.word Excute_cmd ; 7 g
.word Insert_Cmd ; 8 i
.word LIST_cmd ; 9 l
.word Move_cmd ; A m
.word TXT_cmd ; B q
.word Printreg ; C r
.word bsetup ; D @
.word $0000 ; E #
.word xmodem ; F u
.word Version ;10 v
.word EEPROM_WR ;11 w
.word TOPROM ;12 $
.word _CSTART ;13 % - uChess
;
Cmdseccode .byte $00 ; 0 enter secondary command table
.byte $FF ; 1 sp
.byte $01 ; 2 .
.byte $02 ; 3 :
.byte $00 ; 4 >
.byte $00 ; 5 ?
.byte $00 ; 6 !
.byte $00 ; 7 g
.byte $00 ; 8 i
.byte $00 ; 9 l
.byte $00 ; A m
.byte $00 ; B q
.byte $00 ; C r
.byte $00 ; D @
.byte $00 ; E #
.byte $00 ; F u
.byte $00 ;10 v
.byte $00 ;11 w
.byte $00 ;12 $
.byte $00 ;13 % - uChess
;
;
OPCtxtidx .byte $0B ;0 operand text index
.byte $23 ;1
.byte $49 ;2
.byte $49 ;3
.byte $3B ;4
.byte $23 ;5
.byte $02 ;6
.byte $44 ;7
.byte $25 ;8
.byte $23 ;9
.byte $02 ;A
.byte $49 ;B
.byte $3B ;C
.byte $23 ;D
.byte $02 ;E
.byte $42 ;F
.byte $09 ;10
.byte $23 ;11
.byte $23 ;12
.byte $49 ;13
.byte $3A ;14
.byte $23 ;15
.byte $02 ;16
.byte $44 ;17
.byte $0E ;18
.byte $23 ;19
.byte $19 ;1A
.byte $49 ;1B
.byte $3A ;1C
.byte $23 ;1D
.byte $02 ;1E
.byte $42 ;1F
.byte $1D ;20
.byte $01 ;21
.byte $49 ;22
.byte $49 ;23
.byte $06 ;24
.byte $01 ;25
.byte $2C ;26
.byte $44 ;27
.byte $29 ;28
.byte $01 ;29
.byte $2C ;2A
.byte $49 ;2B
.byte $06 ;2C
.byte $01 ;2D
.byte $2C ;2E
.byte $42 ;2F
.byte $07 ;30
.byte $01 ;31
.byte $01 ;32
.byte $49 ;33
.byte $06 ;34
.byte $01 ;35
.byte $2C ;36
.byte $44 ;37
.byte $31 ;38
.byte $01 ;39
.byte $15 ;3A
.byte $49 ;3B
.byte $06 ;3C
.byte $01 ;3D
.byte $2C ;3E
.byte $42 ;3F
.byte $2E ;40
.byte $18 ;41
.byte $49 ;42
.byte $49 ;43
.byte $49 ;44
.byte $18 ;45
.byte $21 ;46
.byte $44 ;47
.byte $24 ;48
.byte $18 ;49
.byte $21 ;4A
.byte $49 ;4B
.byte $1C ;4C
.byte $18 ;4D
.byte $21 ;4E
.byte $42 ;4F
.byte $0C ;50
.byte $18 ;51
.byte $18 ;52
.byte $49 ;53
.byte $49 ;54
.byte $18 ;55
.byte $21 ;56
.byte $44 ;57
.byte $10 ;58
.byte $18 ;59
.byte $27 ;5A
.byte $49 ;5B
.byte $49 ;5C
.byte $18 ;5D
.byte $21 ;5E
.byte $42 ;5F
.byte $2F ;60
.byte $00 ;61
.byte $49 ;62
.byte $49 ;63
.byte $37 ;64
.byte $00 ;65
.byte $2D ;66
.byte $44 ;67
.byte $28 ;68
.byte $00 ;69
.byte $2D ;6A
.byte $49 ;6B
.byte $1C ;6C
.byte $00 ;6D
.byte $2D ;6E
.byte $42 ;6F
.byte $0D ;70
.byte $00 ;71
.byte $00 ;72
.byte $49 ;73
.byte $37 ;74
.byte $00 ;75
.byte $2D ;76
.byte $44 ;77
.byte $33 ;78
.byte $00 ;79
.byte $2B ;7A
.byte $49 ;7B
.byte $1C ;7C
.byte $00 ;7D
.byte $2D ;7E
.byte $42 ;7F
.byte $0A ;80
.byte $34 ;81
.byte $49 ;82
.byte $49 ;83
.byte $36 ;84
.byte $34 ;85
.byte $35 ;86
.byte $45 ;87
.byte $17 ;88
.byte $06 ;89
.byte $3D ;8A
.byte $49 ;8B
.byte $36 ;8C
.byte $34 ;8D
.byte $35 ;8E
.byte $43 ;8F
.byte $03 ;90
.byte $34 ;91
.byte $34 ;92
.byte $49 ;93
.byte $36 ;94
.byte $34 ;95
.byte $35 ;96
.byte $45 ;97
.byte $3F ;98
.byte $34 ;99
.byte $3E ;9A
.byte $49 ;9B
.byte $37 ;9C
.byte $34 ;9D
.byte $37 ;9E
.byte $43 ;9F
.byte $20 ;A0
.byte $1E ;A1
.byte $1F ;A2
.byte $49 ;A3
.byte $20 ;A4
.byte $1E ;A5
.byte $1F ;A6
.byte $45 ;A7
.byte $39 ;A8
.byte $1E ;A9
.byte $38 ;AA
.byte $49 ;AB
.byte $20 ;AC
.byte $1E ;AD
.byte $1F ;AE
.byte $43 ;AF
.byte $04 ;B0
.byte $1E ;B1
.byte $1E ;B2
.byte $49 ;B3
.byte $20 ;B4
.byte $1E ;B5
.byte $1F ;B6
.byte $45 ;B7
.byte $11 ;B8
.byte $1E ;B9
.byte $3C ;BA
.byte $49 ;BB
.byte $20 ;BC
.byte $1E ;BD
.byte $1F ;BE
.byte $43 ;BF
.byte $14 ;C0
.byte $12 ;C1
.byte $49 ;C2
.byte $49 ;C3
.byte $14 ;C4
.byte $12 ;C5
.byte $15 ;C6
.byte $45 ;C7
.byte $1B ;C8
.byte $12 ;C9
.byte $16 ;CA
.byte $40 ;CB
.byte $14 ;CC
.byte $12 ;CD
.byte $15 ;CE
.byte $43 ;CF
.byte $08 ;D0
.byte $12 ;D1
.byte $12 ;D2
.byte $49 ;D3
.byte $49 ;D4
.byte $12 ;D5
.byte $15 ;D6
.byte $45 ;D7
.byte $0F ;D8
.byte $12 ;D9
.byte $26 ;DA
.byte $41 ;DB
.byte $49 ;DC
.byte $12 ;DD
.byte $15 ;DE
.byte $43 ;DF
.byte $13 ;E0
.byte $30 ;E1
.byte $49 ;E2
.byte $49 ;E3
.byte $13 ;E4
.byte $30 ;E5
.byte $19 ;E6
.byte $45 ;E7
.byte $1A ;E8
.byte $30 ;E9
.byte $22 ;EA
.byte $49 ;EB
.byte $13 ;EC
.byte $30 ;ED
.byte $19 ;EE
.byte $43 ;EF
.byte $05 ;F0
.byte $30 ;F1
.byte $30 ;F2
.byte $49 ;F3
.byte $49 ;F4
.byte $30 ;F5
.byte $19 ;F6
.byte $45 ;F7
.byte $32 ;F8
.byte $30 ;F9
.byte $2A ;FA
.byte $49 ;FB
.byte $49 ;FC
.byte $30 ;FD
.byte $19 ;FE
.byte $43 ;FF
;
OPCaddmode .byte $03 ;0 opcode address mode
.byte $04 ;1
.byte $03 ;2
.byte $03 ;3
.byte $02 ;4
.byte $02 ;5
.byte $02 ;6
.byte $0F ;7
.byte $03 ;8
.byte $00 ;9
.byte $03 ;A
.byte $03 ;B
.byte $01 ;C
.byte $01 ;D
.byte $01 ;E
.byte $0E ;F
.byte $0A ;10
.byte $05 ;11
.byte $0D ;12
.byte $03 ;13
.byte $02 ;14
.byte $06 ;15
.byte $06 ;16
.byte $1F ;17
.byte $03 ;18
.byte $09 ;19
.byte $03 ;1A
.byte $03 ;1B
.byte $01 ;1C
.byte $08 ;1D
.byte $08 ;1E
.byte $1E ;1F
.byte $01 ;20
.byte $04 ;21
.byte $03 ;22
.byte $03 ;23
.byte $02 ;24
.byte $02 ;25
.byte $02 ;26
.byte $2F ;27
.byte $03 ;28
.byte $00 ;29
.byte $03 ;2A
.byte $03 ;2B
.byte $01 ;2C
.byte $01 ;2D
.byte $01 ;2E
.byte $2E ;2F
.byte $0A ;30
.byte $05 ;31
.byte $0D ;32
.byte $03 ;33
.byte $06 ;34
.byte $06 ;35
.byte $06 ;36
.byte $3F ;37
.byte $03 ;38
.byte $09 ;39
.byte $03 ;3A
.byte $03 ;3B
.byte $08 ;3C
.byte $08 ;3D
.byte $08 ;3E
.byte $3E ;3F
.byte $03 ;40
.byte $04 ;41
.byte $03 ;42
.byte $03 ;43
.byte $03 ;44
.byte $02 ;45
.byte $02 ;46
.byte $4F ;47
.byte $03 ;48
.byte $00 ;49
.byte $03 ;4A
.byte $03 ;4B
.byte $01 ;4C
.byte $01 ;4D
.byte $01 ;4E
.byte $4E ;4F
.byte $0A ;50
.byte $05 ;51
.byte $0D ;52
.byte $03 ;53
.byte $03 ;54
.byte $06 ;55
.byte $06 ;56
.byte $5F ;57
.byte $03 ;58
.byte $09 ;59
.byte $03 ;5A
.byte $03 ;5B
.byte $03 ;5C
.byte $08 ;5D
.byte $08 ;5E
.byte $5E ;5F
.byte $03 ;60
.byte $04 ;61
.byte $03 ;62
.byte $03 ;63
.byte $02 ;64
.byte $02 ;65
.byte $02 ;66
.byte $6F ;67
.byte $03 ;68
.byte $00 ;69
.byte $03 ;6A
.byte $03 ;6B
.byte $0B ;6C
.byte $01 ;6D
.byte $01 ;6E
.byte $6E ;6F
.byte $0A ;70
.byte $05 ;71
.byte $0D ;72
.byte $03 ;73
.byte $06 ;74
.byte $06 ;75
.byte $06 ;76
.byte $7F ;77
.byte $03 ;78
.byte $09 ;79
.byte $03 ;7A
.byte $03 ;7B
.byte $0C ;7C
.byte $08 ;7D
.byte $08 ;7E
.byte $7E ;7F
.byte $0A ;80
.byte $04 ;81
.byte $03 ;82
.byte $03 ;83
.byte $02 ;84
.byte $02 ;85
.byte $02 ;86
.byte $0F ;87
.byte $03 ;88
.byte $00 ;89
.byte $03 ;8A
.byte $03 ;8B
.byte $01 ;8C
.byte $01 ;8D
.byte $01 ;8E
.byte $0E ;8F
.byte $0A ;90
.byte $05 ;91
.byte $0D ;92
.byte $03 ;93
.byte $06 ;94
.byte $06 ;95
.byte $07 ;96
.byte $1F ;97
.byte $03 ;98
.byte $09 ;99
.byte $03 ;9A
.byte $03 ;9B
.byte $01 ;9C
.byte $08 ;9D
.byte $08 ;9E
.byte $1E ;9F
.byte $00 ;A0
.byte $04 ;A1 changed from 0d to 04
.byte $00 ;A2
.byte $03 ;A3
.byte $02 ;A4
.byte $02 ;A5
.byte $02 ;A6
.byte $2F ;A7
.byte $03 ;A8
.byte $00 ;A9
.byte $03 ;AA
.byte $03 ;AB
.byte $01 ;AC
.byte $01 ;AD
.byte $01 ;AE
.byte $2E ;AF
.byte $0A ;B0
.byte $05 ;B1
.byte $0D ;B2
.byte $03 ;B3
.byte $06 ;B4
.byte $06 ;B5
.byte $07 ;B6
.byte $3F ;B7
.byte $03 ;B8
.byte $09 ;B9
.byte $03 ;BA
.byte $03 ;BB
.byte $08 ;BC
.byte $08 ;BD
.byte $09 ;BE
.byte $3E ;BF
.byte $00 ;C0
.byte $04 ;C1
.byte $03 ;C2
.byte $03 ;C3
.byte $02 ;C4
.byte $02 ;C5
.byte $02 ;C6
.byte $4F ;C7
.byte $03 ;C8
.byte $00 ;C9
.byte $03 ;CA
.byte $03 ;CB
.byte $01 ;CC
.byte $01 ;CD
.byte $01 ;CE
.byte $4E ;CF
.byte $0A ;D0
.byte $05 ;D1
.byte $0D ;D2
.byte $03 ;D3
.byte $03 ;D4
.byte $06 ;D5
.byte $06 ;D6
.byte $5F ;D7
.byte $03 ;D8
.byte $09 ;D9
.byte $03 ;DA
.byte $03 ;DB
.byte $03 ;DC
.byte $08 ;DD
.byte $08 ;DE
.byte $5E ;DF
.byte $00 ;E0
.byte $04 ;E1
.byte $03 ;E2
.byte $03 ;E3
.byte $02 ;E4
.byte $02 ;E5
.byte $02 ;E6
.byte $6F ;E7
.byte $03 ;E8
.byte $00 ;E9
.byte $03 ;EA
.byte $03 ;EB
.byte $01 ;EC
.byte $01 ;ED
.byte $01 ;EE
.byte $6E ;EF
.byte $0A ;F0
.byte $05 ;F1
.byte $0D ;F2
.byte $03 ;F3
.byte $03 ;F4
.byte $06 ;F5
.byte $06 ;F6
.byte $7F ;F7
.byte $03 ;F8
.byte $09 ;F9
.byte $03 ;FA
.byte $03 ;FB
.byte $03 ;FC
.byte $08 ;FD
.byte $08 ;FE
.byte $7E ;FF
;
;
ModeByteCnt .byte $02 ;0 opcode mode byte count
.byte $03 ;1
.byte $02 ;2
.byte $01 ;3
.byte $02 ;4
.byte $02 ;5
.byte $02 ;6
.byte $02 ;7
.byte $03 ;8
.byte $03 ;9
.byte $02 ;A
.byte $03 ;B
.byte $03 ;C
.byte $02 ;D
.byte $03 ;E
.byte $02 ;F
;
;
ModeJmpTbl .word IMM_mode ;0 Operand print table
.word ABS_mode ;1
.word ZP_mode ;2
.word IMPLIED_mode ;3
.word INDZP_X_mode ;4
.word INDZP_Y_mode ;5
.word ZP_X_mode ;6
.word ZP_Y_mode ;7
.word ABS_X_mode ;8
.word ABS_Y_mode ;9
.word REL_mode ;a
.word INDABS_mode ;b
.word INDABSX_mode ;c
.word INDZP_mode ;d
.word BBREL_mode ;e
.word ZP_mode ;f dup of ZP for RMB,SMB cmds
;
;
Asm_ModeLst .byte $28 ;0 IMM_mode
.byte $10 ;1 ABS_mode
.byte $08 ;2 ZP_mode
.byte $00 ;3 IMPLIED_mode
.byte $0E ;4 INDZP_X_mode
.byte $0D ;5 INDZP_Y_mode
.byte $0A ;6 ZP_X_mode
.byte $09 ;7 ZP_Y_mode
.byte $12 ;8 ABS_X_mode
.byte $11 ;9 ABS_Y_mode
.byte $40 ;A REL_mode Never set!!!
.byte $14 ;B INDABS_mode
.byte $16 ;C INDABSX_mode
.byte $0C ;D INDZP_mode
.byte $D0 ;E BBREL_mode
.byte $88 ;F used for RMBx & SMBx
;
;
OPCtxtData .byte "ADC" ;0
.byte "AND" ;1
.byte "ASL" ;2
.byte "BCC" ;3
.byte "BCS" ;4
.byte "BEQ" ;5
.byte "BIT" ;6
.byte "BMI" ;7
.byte "BNE" ;8
.byte "BPL" ;9
.byte "BRA" ;A
.byte "BRK" ;B
.byte "BVC" ;C
.byte "BVS" ;D
.byte "CLC" ;E
.byte "CLD" ;F
.byte "CLI" ;10
.byte "CLV" ;11
.byte "CMP" ;12
.byte "CPX" ;13
.byte "CPY" ;14
.byte "DEC" ;15
.byte "DEX" ;16
.byte "DEY" ;17
.byte "EOR" ;18
.byte "INC" ;19
.byte "INX" ;1A
.byte "INY" ;1B
.byte "JMP" ;1C
.byte "JSR" ;1D
.byte "LDA" ;1E
.byte "LDX" ;1F
.byte "LDY" ;20
.byte "LSR" ;21
.byte "NOP" ;22
.byte "ORA" ;23
.byte "PHA" ;24
.byte "PHP" ;25
.byte "PHX" ;26
.byte "PHY" ;27
.byte "PLA" ;28
.byte "PLP" ;29
.byte "PLX" ;2A
.byte "PLY" ;2B
.byte "ROL" ;2C
.byte "ROR" ;2D
.byte "RTI" ;2E
.byte "RTS" ;2F
.byte "SBC" ;30
.byte "SEC" ;31
.byte "SED" ;32
.byte "SEI" ;33
.byte "STA" ;34
.byte "STX" ;35
.byte "STY" ;36
.byte "STZ" ;37
.byte "TAX" ;38
.byte "TAY" ;39
.byte "TRB" ;3A
.byte "TSB" ;3B
.byte "TSX" ;3C
.byte "TXA" ;3D
.byte "TXS" ;3E
.byte "TYA" ;3F
.byte "WAI" ;40
.byte "STP" ;41
.byte "BBR" ;42 4Byte Opcodes
.byte "BBS" ;43
.byte "RMB" ;44
.byte "SMB" ;45
.byte ".DB" ;46 define 1 byte for assembler
.byte ".DW" ;47 define 1 word for assembler
.byte ".DS" ;48 define a string block for assembler
.byte "???" ;49 for invalid opcode
;
;
HelpTxt .byte "~Current commands are :~"
.byte "Syntax = {} required, [] optional, HHHH hex address, DD hex data~"
.byte "~"
.byte "[HHHH][ HHHH]{Return} - Hex dump address(s)(up to 16 if no address entered)~"
.byte "[HHHH]{.HHHH}{Return} - Hex dump range of addresses (16 per line)~"
.byte "[HHHH]{:DD}[ DD]{Return} - Change data bytes~"
.byte "[HHHH]{G}{Return} - Execute a program (use RTS to return to monitor)~"
.byte "{HHHH.HHHH>HHHH{I}{Return} - move range at 2nd HHHH down to 1st to 3rd HHHH~"
.byte "[HHHH]{L}{Return} - List (disassemble) 20 lines of program~"
.byte "[HHHH]{.HHHH}{L}{Return} - Dissassemble a range~"
.byte "{HHHH.HHHH>HHHH{M}{Return} - Move range at 1st HHHH thru 2nd to 3rd HHHH~"
.byte "[HHHH][ HHHH]{Q}{Return} - Text dump address(s)~"
.byte "[HHHH]{.HHHH}{Q}{Return} - Text dump range of addresses (16 per line)~"
.byte "{R}{Return} - Print register contents from memory locations~"
.byte "{U}{Return} - Upload File (Xmodem/CRC or Intel Hex)~"
.byte "{V}{Return} - Monitor Version~"
.byte "{HHHH.HHHH>HHHH{W}{Return} - Write data in RAM to EEPROM~"
.byte "{!}{Return} - Enter Assembler~"
.byte "{@}{Return} - Cold-Start Enhanced Basic~"
.byte "{#}{Return} - Warm_Start Enhanced Basic~"
.byte "{$}{Return} - Start FIGForth~"
.byte "{%}{Return} - Start MicroChess~"
.byte "{?}{Return} - Print menu of commands~~"
.byte $00
AsmHelpTxt .byte "~Current commands are :~"
.byte "Syntax = {} required, [] optional~"
.byte "HHHH=hex address, OPC=Opcode, DD=hex data, '_'=Space Bar or Tab~"
.byte "'$' Symbols are optional, all values are HEX.~"
.byte "Any input after a 'semi-colon' is ignored.~"
.byte "~"
.byte "{HHHH}{Return} - Set input address~"
.byte "[HHHH][_]{OPC}[_][#($DD_HHHH,X),Y]{Return} - Assemble line~"
.byte "[HHHH]{L}{Return} - List (disassemble) 20 lines of program~"
.byte "{Return} - Exit Assembler back to Monitor~"
.byte "{?}{Return} - Print menu of commands~~"
.byte $00
;
Porttxt .byte "65C02 Monitor v5.2 (6-28-13) Ready"
.byte $0d, $0a
.byte "with Enhanced Basic Interpreter (c) Lee Davison,"
.byte $0d, $0a
.byte "FIGForth, and MicroChess (c) Peter Jennings"
.byte $0d, $0a
.byte "(Press ? for help)"
.byte $00
;
; *** VERSION Notes ***
; 3.5 added the text dump command, "q"
; 4.0 reorganized structure, added RAM vectors for chrin, scan_in, and chrout
; 4.1 fixed set time routine so 20-23 is correct
; 4.2 RST, IRQ, NMI, BRK all jmp ind to 02xx page to allow user prog to control
; 4.3 added status register bits to printreg routine
; 4.4 refined set time to reduce unneeded sec"s and branches, disp time added CR,
; and added zeromem to the reset routine, ensuring a reset starts fresh every time!
; continued to re-organize - moved monitor"s brk handler into mon area.
; 4.5 nop out the jsr scan_input in the eeprom write routine to prevent BRK"s
; 4.6 added version printout when entering assember to show ? prompt
; 4.7 added Lee Davison's Enhanced Basic to ROM Image
; 4.9 Added all of the WDC opcodes to the disassembler and mini-assembler
; 5.0 Added TAB key support to the input routine, expands tabs to spaces
; 5.1 Added jump table at the start of the monitor to commonly used routines
; 5.2 Added FIGForth and MicroChess
;
;end of file
Reference in New Issue Copy Permalink