;--------------------------------------------------------------------- ; 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 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 ; 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+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 ; 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