From 215b5758f513cc8970060dbecd433d5c0d544994 Mon Sep 17 00:00:00 2001 From: Simon Owen Date: Thu, 4 Feb 2010 19:15:30 +0000 Subject: [PATCH] Changes for the switch from SubVersion to git - Fixed line endings of all text files - Set executable bit on m.bat - Added basic .gitignore --- .gitignore | 3 + ReadMe.txt | 54 +- apple1emu.asm | 1328 ++++----- font.pl | 128 +- m.bat | 4 +- opdefs.inc | 516 ++-- opdefs.pl | 170 +- opimpl.inc | 7088 ++++++++++++++++++++++++------------------------- 8 files changed, 4647 insertions(+), 4644 deletions(-) create mode 100644 .gitignore mode change 100644 => 100755 m.bat diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..cea93ba --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +.* +!.gitignore +apple1emu.dsk diff --git a/ReadMe.txt b/ReadMe.txt index 0a7a595..b17b5bf 100644 --- a/ReadMe.txt +++ b/ReadMe.txt @@ -1,27 +1,27 @@ -Apple 1 Emulator for SAM Coupe (v1.2) -------------------------------------- - -See website for usage: http://simonowen.com/sam/apple1emu/ - ---- - -Version 1.2 (5/9/2008) -- Fixed BRK flags (clear D, set I, N/Z set from wrong EXX set) -- Fixed Esc repeat, broken in previous version -- Added Applesoft BASIC [Lite] and Lee Davidson's Enhanced BASIC -- Updated Ken Wessen's Krusader assembler to v1.3 -- First byte of emulator at &c000 appears to be ROM (for Applesoft BASIC ROM) -- Terminal output now supports lower-case characters (for Enhanced BASIC) - -Version 1.1 (27/8/2008) -- Improved 65C02 core for ~20% speed boost -- Fixed broken TRB, which was masking the wrong value -- BIT #imm no longer considers setting N flag - -Version 1.0 (19/3/2007) -- Initial release - ---- - -Simon Owen -simon@simonowen.com +Apple 1 Emulator for SAM Coupe (v1.2) +------------------------------------- + +See website for usage: http://simonowen.com/sam/apple1emu/ + +--- + +Version 1.2 (5/9/2008) +- Fixed BRK flags (clear D, set I, N/Z set from wrong EXX set) +- Fixed Esc repeat, broken in previous version +- Added Applesoft BASIC [Lite] and Lee Davidson's Enhanced BASIC +- Updated Ken Wessen's Krusader assembler to v1.3 +- First byte of emulator at &c000 appears to be ROM (for Applesoft BASIC ROM) +- Terminal output now supports lower-case characters (for Enhanced BASIC) + +Version 1.1 (27/8/2008) +- Improved 65C02 core for ~20% speed boost +- Fixed broken TRB, which was masking the wrong value +- BIT #imm no longer considers setting N flag + +Version 1.0 (19/3/2007) +- Initial release + +--- + +Simon Owen +simon@simonowen.com diff --git a/apple1emu.asm b/apple1emu.asm index c7ff29e..f645d4f 100644 --- a/apple1emu.asm +++ b/apple1emu.asm @@ -1,664 +1,664 @@ -; Apple 1 emulator for SAM Coupe, by Simon Owen -; -; Version 1.2 (5/9/2008) -; -; WWW: http://simonowen.com/sam/apple1emu/ - -base: equ &d000 ; Emulator code shares Apple 1 I/O area - -status: equ &f9 ; Status and extended keyboard port -lmpr: equ &fa ; Low Memory Page Register -hmpr: equ &fb ; High Memory Page Register -vmpr: equ &fc ; Video Memory Page Register -keyboard: equ &fe ; Keyboard port -border: equ &fe ; Border port - -rom0_off: equ %00100000 ; LMPR bit to disable ROM0 -rom1_on: equ %01000000 ; LMPR bit to enable ROM1 -vmpr_mode2: equ %00100000 ; Mode 2 select for VMPR - -low_page: equ 3 ; LMPR during emulation -screen_page: equ 5 ; SAM display -file_page: equ 6 ; File import text page - -m6502_nmi: equ &fffa ; nmi vector address -m6502_reset: equ &fffc ; reset vector address -m6502_int: equ &fffe ; int vector address (also for BRK) - -r1onclbc: equ &01ea ; ROM 1 on, call BC -getkey: equ &1cab ; SAM ROM key reading (NZ=got key in A, A=0 for no key) - - -; PIA registers for keyboard and display I/O - -kbd_data: equ &d010 ; keyboard data -kbd_ctrl: equ &d011 ; keyboard control -dsp_data: equ &d012 ; display data -dsp_ctrl: equ &d013 ; display control - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - org base - dump $ - autoexec - - di - jr start - - defs kbd_data-$ - ; This gap contains the PIA locations from above - defs dsp_ctrl-kbd_data+1 - -start: ld a,low_page+rom0_off - out (lmpr),a - ld a,vmpr_mode2+screen_page - out (vmpr),a - ld (basic_stack),sp - ld sp,stack_top - - call set_sam_attrs ; set the mode 2 attrs so the screen is visible - call setup_im2 ; enable IM 2 - - ld a,(op_00) ; lowest address used by emulator - ld (rom_write+1),a ; save byte to restore to simulate ROM - -reset_loop: ld hl,0 - ld (dsp_data),hl ; display ready - ld (kbd_data),hl ; no key available - - ld hl,(m6502_reset) ; start from reset vector - ld (reg_pc),hl - ld a,&04 ; interrupts disabled - ld (reg_p),a - - ei - call load_state - call execute ; GO! - call save_state - jr reset_loop - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -; Utility functions - -; Fill SAM mode 2 display attributes to make the screen visible -set_sam_attrs: ld a,screen_page+rom0_off - out (lmpr),a - - ld hl,&2000 - ld bc,&1844 ; 24 blocks of bright green on black -clear_lp: ld (hl),c - inc l - jr nz,clear_lp - inc h - djnz clear_lp - - ld a,low_page+rom0_off - out (lmpr),a - ret - -; Scroll the screen up 1 row and clear the bottom line -scroll_screen: ld hl,0 - ld d,h - ld e,l - inc h - ld bc,&1700 -scroll_lp: FOR 32, ldi ; 32 * LDI - jp pe,scroll_lp - dec h -scroll_clr: ld (hl),0 - inc l - jp nz,scroll_clr - ret - -; Advance the cursor 1 character, wrapping and scrolling if necessary -advance_chr: ld hl,(cursor_xy) - cp &5f - jr z,back_chr - cp &0a - jr z,advance_line - cp &0d - jr z,advance_line - ld a,l - add a,6 - ld l,a - cp &f0 - jr c,no_wrap -advance_line: ld l,0 - inc h - ld a,h - cp &18 - jr nz,no_wrap - dec h - exx - call scroll_screen - exx -no_wrap: ld (cursor_xy),hl - ret -back_chr: ld a,l - sub 6 - ld l,a - jr nc,no_wrap - ld l,39*6 - ld a,h - sub 1 - adc a,0 - ld h,a - jr no_wrap - -; Map display character from SAM to Apple 1 -map_chr: sub &20 - ret nc - xor a - ret - -; Display character in A at current cursor position -display_chr: add a,a ; * 2 - ld l,a - ld h,0 - add hl,hl ; * 4 - add hl,hl ; * 8 - ld de,font_data - add hl,de - ld d,mask_data/256 - exx - ld hl,(cursor_xy) - ld a,l - and %00000111 - srl l - srl l - srl l - inc l - exx - ld e,a - exx - ld de,&0020 - ld b,8 -draw_lp: exx - ld c,(hl) - inc l - xor a - cp e - jr z,no_rot - ld b,e -rot_lp: srl c - rra - djnz rot_lp -no_rot: ld b,a - ld a,(de) - inc e - exx - and (hl) - inc l - exx - or c - ex af,af' - ld a,(de) - dec e - exx - and (hl) - exx - or b - exx - ld (hl),a - dec l - ex af,af' - ld (hl),a - add hl,de - djnz draw_lp - ret - -; LSB=pixel position (0-240), MSB=display row (0-23) -cursor_xy: defw 0 - -; Map key symbols from SAM to Apple 1 -map_key: cp &0c - jr z,del_key - cp &fc - jr z,tab_key - cp &80 - jr nc,ignore_key - cp &61 ; 'a' - ret c - cp &7b ; 'z'+1 - ret nc - and %11011111 - ret -del_key: ld a,&5f ; Delete -> _ - ret -tab_key: ld a,&09 ; standard tab - ret -invalid_key: ld a,&20 ; space for invalid - ret -ignore_key: xor a ; ignore - ret - -; Get a type-in key from the imported file -get_filekey: ld a,file_page+rom0_off - out (lmpr),a - - ld hl,(filepos) - ld a,h - or l - or (hl) - jr z,file_done ; jump if no file - -file_skip: ld a,(hl) ; fetch next file character - inc hl - and a - jr z,clear_file2 ; clear file at end - cp &0d ; CR? - jr z,file_skip ; ignore CR in file - cp &0a ; LF? - jr nz,file_done - ld a,&0d ; convert LF to CR -file_done: ld (filepos),hl - and a - ret -filepos: defw 0 - -; Clear the file area to disable type-in -clear_file: ld a,file_page+rom0_off - out (lmpr),a -clear_file2: ld hl,0 - ld c,l -clr_file_lp: ld (hl),c - inc l - jr nz,clr_file_lp - inc h - bit 7,h - jr nz,clr_file_lp - ld h,l - xor a ; no file character - jr file_done - -update_io: - ld a,&f7 - in a,(status) - and %00100000 - jr nz,not_esc ; jump if Esc not pressed - - call clear_file ; Esc cancels type-in mode - - ld a,&fe - in a,(keyboard) - rra - jr c,not_reset ; unshifted gives chr - - ld a,&c9 ; RET opcode - ld (main_loop),a ; return to reset on next instruction -not_reset: - -still_esc: ld a,&f7 - in a,(status) - and %00100000 - jr z,still_esc ; wait until Esc released - - ld a,&1b ; Esc character - jr got_key -not_esc: - ld a,&7f - in a,(keyboard) - bit 1,a - jr nz,not_sym - - ld a,&f7 - in a,(keyboard) - rra - ld c,&ff ; line interrupt disable - jr nc,got_line - rra - ld c,88 ; centre of display (312/2-68=88) - jr c,not_sym -got_line: ld a,c - out (status),a ; set or disable line interrupt -not_sym: - ld hl,kbd_ctrl - bit 7,(hl) ; key available? - jr nz,no_key ; no need to read more yet - - call get_filekey ; got a type-in key from file? - jr nz,got_key ; jump if we have - -skip_key: ld a,&1f ; LMPR page for BASIC, with ROM 0 enabled - out (lmpr),a - ld (save_stack),sp - ld sp,(basic_stack) - ld bc,getkey ; return key code in A, zero for none - call r1onclbc - ld sp,(save_stack) - jr z,no_key - call map_key - and a - jr z,skip_key -got_key: - ld hl,kbd_data - ld (hl),a - set 7,(hl) ; bit 7 always set - inc l - set 7,(hl) ; key available -no_key: - ld hl,dsp_data - bit 7,(hl) ; display char available? - jr z,no_char - res 7,(hl) ; display ready - ld a,(hl) ; fetch character to display - and a - jr z,done_draw - cp &7f - jr z,done_draw - push af - ld a,screen_page+rom0_off - out (lmpr),a ; page in screen - ld a,&00 ; space - call display_chr ; erase cursor - pop af - cp &5f ; backspace? (underscore) - jr z,done_draw2 ; if so, no need to process further - - push af - call map_chr ; map output from SAM->Apple 1 - call display_chr ; show it - pop af -done_draw2: call advance_chr ; advance the cursor position - ld a,&5f ; cursor block - call display_chr ; show cursor -done_draw: -no_char: - ret - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -; Interrupt handling - -setup_im2: ld hl,im2_table - ld a,im2_jp/256 -im2_fill: ld (hl),a - inc l - jr nz,im2_fill - inc h - ld (hl),a ; complete the final entry - ld a,im2_table/256 - ld i,a - im 2 ; set interrupt mode 2 - ret - -im2_handler: push af - push bc - push de - push hl - ex af,af' - exx - push af - push bc - push de - push hl - push ix - push iy - - in a,(lmpr) - push af - call update_io - pop af - out (lmpr),a - - pop iy - pop ix - pop hl - pop de - pop bc - pop af - exx - ex af,af' - pop hl - pop de - pop bc - pop af - ei - reti - - -; IM 2 table must be aligned to 256-byte boundary - defs -$\256 -im2_table: defs 257 - -; IM 2 vector must have LSB==MSB - defs $/256-1 -stack_top: ; stack fits nicely in the slack space -im2_jp: jp im2_handler - -basic_stack: defw 0 -save_stack: defw 0 - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -; 65C02 emulation - -execute: ld a,&1a ; LD A,(DE) - ld (ix),a - jp (ix) - - -i_undoc_3: inc de ; 3-byte NOP -i_undoc_2: inc de ; 2-byte NOP -i_undoc_1: jp (ix) ; NOP - - -read_write_loop: -write_loop: ld a,h - cp op_00/256 ; MSB of lowest emulator byte - jr nc,write_trap - -zwrite_loop: -main_loop: ld a,(de) ; 7/7/15 - fetch opcode - inc de ; 6/7/11 - PC++ - ld l,a ; 4/6/6 - LSB is opcode - ld h,msb_table/256 ; 7/7/15 - look-up table - ld h,(hl) ; 7/8/16 - opcode MSB - jp (hl) ; 4/5/9 - execute! - ; = 35T (official) / 40T (off-screen) / 72T (on-screen) - -write_trap: cp &d0 ; I/O page? - jr nz,rom_write - ld a,l - cp &12 ; display char? - jr z,chr_write - jp (ix) -chr_write: set 7,(hl) ; display busy - jp (ix) - -rom_write: ld a,&00 ; patched by starting code - ld (op_00),a ; emulator appears read-only to be ROM for RAM tests - jp (ix) - -read_loop: ld a,h - cp &d0 - jr z,read_trap - - ld a,(de) ; fetch opcode - inc de ; PC++ - ld l,a ; LSB is opcode - ld h,msb_table/256 ; look-up table - ld h,(hl) ; opcode MSB - jp (hl) ; execute! - -read_trap: ld a,l - cp &10 ; key read? - jr z,key_read - jp (ix) -key_read: inc l - res 7,(hl) ; key not available - jp (ix) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -load_state: ld a,(reg_a) - ld b,a ; set A - ld a,(reg_x) - ld iyh,a ; set X to IYh - ld a,(reg_y) - ld iyl,a ; set Y to IYl - exx - ld a,(reg_s) - ld l,a ; set S - ld h,&01 ; MSB for stack pointer - ld a,(reg_p) - ld c,a ; keep safe - and %00001100 ; keep D and I - or %00110000 ; force T and B - ld d,a ; set P - ld a,c - and %01000000 ; keep V - ld e,a ; set V - ld a,c - rra ; carry from C - ex af,af' ; set carry - ld a,c - and %10000010 ; keep N Z - xor %00000010 ; zero for Z - exx - ld c,a ; set N Z - ld de,(reg_pc) ; set PC - ld ix,main_loop ; decode loop - ret - -save_state: ld a,b ; get A - ld (reg_a),a - ld a,iyh ; get X from IYh - ld (reg_x),a - ld a,iyl ; get Y from IYl - ld (reg_y),a - ex af,af' ; carry - inc c - dec c ; set N Z - push af ; save flags - ex af,af' ; protect carry - exx - pop bc - ld a,c - and %10000001 ; keep Z80 N and C - bit 6,c ; check Z80 Z - jr z,save_nz - or %00000010 ; set Z -save_nz: or e ; merge V - or d ; merge T B D I - ld (reg_p),a - ld a,l ; get S - ld (reg_s),a - exx - ld (reg_pc),de - ret - - -; During running we keep the 65xx registers in Z80 registers -; These are used only to hold the state before/after running -reg_a: defb 0 -reg_p: defb 0 -reg_x: defb 0 -reg_y: defb 0 -reg_s: defb 0 -reg_pc: defw 0 - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - defs -$\256 - -msb_table: defb op_00>>8, op_01>>8, op_02>>8, op_03>>8, op_04>>8, op_05>>8, op_06>>8, op_07>>8 - defb op_08>>8, op_09>>8, op_0a>>8, op_0b>>8, op_0c>>8, op_0d>>8, op_0e>>8, op_0f>>8 - defb op_10>>8, op_11>>8, op_12>>8, op_13>>8, op_14>>8, op_15>>8, op_16>>8, op_17>>8 - defb op_18>>8, op_19>>8, op_1a>>8, op_1b>>8, op_1c>>8, op_1d>>8, op_1e>>8, op_1f>>8 - defb op_20>>8, op_21>>8, op_22>>8, op_23>>8, op_24>>8, op_25>>8, op_26>>8, op_27>>8 - defb op_28>>8, op_29>>8, op_2a>>8, op_2b>>8, op_2c>>8, op_2d>>8, op_2e>>8, op_2f>>8 - defb op_30>>8, op_31>>8, op_32>>8, op_33>>8, op_34>>8, op_35>>8, op_36>>8, op_37>>8 - defb op_38>>8, op_39>>8, op_3a>>8, op_3b>>8, op_3c>>8, op_3d>>8, op_3e>>8, op_3f>>8 - defb op_40>>8, op_41>>8, op_42>>8, op_43>>8, op_44>>8, op_45>>8, op_46>>8, op_47>>8 - defb op_48>>8, op_49>>8, op_4a>>8, op_4b>>8, op_4c>>8, op_4d>>8, op_4e>>8, op_4f>>8 - defb op_50>>8, op_51>>8, op_52>>8, op_53>>8, op_54>>8, op_55>>8, op_56>>8, op_57>>8 - defb op_58>>8, op_59>>8, op_5a>>8, op_5b>>8, op_5c>>8, op_5d>>8, op_5e>>8, op_5f>>8 - defb op_60>>8, op_61>>8, op_62>>8, op_63>>8, op_64>>8, op_65>>8, op_66>>8, op_67>>8 - defb op_68>>8, op_69>>8, op_6a>>8, op_6b>>8, op_6c>>8, op_6d>>8, op_6e>>8, op_6f>>8 - defb op_70>>8, op_71>>8, op_72>>8, op_73>>8, op_74>>8, op_75>>8, op_76>>8, op_77>>8 - defb op_78>>8, op_79>>8, op_7a>>8, op_7b>>8, op_7c>>8, op_7d>>8, op_7e>>8, op_7f>>8 - defb op_80>>8, op_81>>8, op_82>>8, op_83>>8, op_84>>8, op_85>>8, op_86>>8, op_87>>8 - defb op_88>>8, op_89>>8, op_8a>>8, op_8b>>8, op_8c>>8, op_8d>>8, op_8e>>8, op_8f>>8 - defb op_90>>8, op_91>>8, op_92>>8, op_93>>8, op_94>>8, op_95>>8, op_96>>8, op_97>>8 - defb op_98>>8, op_99>>8, op_9a>>8, op_9b>>8, op_9c>>8, op_9d>>8, op_9e>>8, op_9f>>8 - defb op_a0>>8, op_a1>>8, op_a2>>8, op_a3>>8, op_a4>>8, op_a5>>8, op_a6>>8, op_a7>>8 - defb op_a8>>8, op_a9>>8, op_aa>>8, op_ab>>8, op_ac>>8, op_ad>>8, op_ae>>8, op_af>>8 - defb op_b0>>8, op_b1>>8, op_b2>>8, op_b3>>8, op_b4>>8, op_b5>>8, op_b6>>8, op_b7>>8 - defb op_b8>>8, op_b9>>8, op_ba>>8, op_bb>>8, op_bc>>8, op_bd>>8, op_be>>8, op_bf>>8 - defb op_c0>>8, op_c1>>8, op_c2>>8, op_c3>>8, op_c4>>8, op_c5>>8, op_c6>>8, op_c7>>8 - defb op_c8>>8, op_c9>>8, op_ca>>8, op_cb>>8, op_cc>>8, op_cd>>8, op_ce>>8, op_cf>>8 - defb op_d0>>8, op_d1>>8, op_d2>>8, op_d3>>8, op_d4>>8, op_d5>>8, op_d6>>8, op_d7>>8 - defb op_d8>>8, op_d9>>8, op_da>>8, op_db>>8, op_dc>>8, op_dd>>8, op_de>>8, op_df>>8 - defb op_e0>>8, op_e1>>8, op_e2>>8, op_e3>>8, op_e4>>8, op_e5>>8, op_e6>>8, op_e7>>8 - defb op_e8>>8, op_e9>>8, op_ea>>8, op_eb>>8, op_ec>>8, op_ed>>8, op_ee>>8, op_ef>>8 - defb op_f0>>8, op_f1>>8, op_f2>>8, op_f3>>8, op_f4>>8, op_f5>>8, op_f6>>8, op_f7>>8 - defb op_f8>>8, op_f9>>8, op_fa>>8, op_fb>>8, op_fc>>8, op_fd>>8, op_fe>>8, op_ff>>8 - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - defs -$\256 ; align to 256-byte boundary - -; !"#$%&1()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]`abcdefghijklmnopqrstuvwxyz{|}~ -font_data: - MDAT "font.bin" - -mask_data: defb %00000011,%11111111 - defb %11000000,%11111111 - defb %11110000,%00111111 - defb %11111100,%00001111 - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -end: equ $ -length: equ end-start - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - ; Instruction implementations - INC "opimpl.inc" - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - ; Woz Monitor ROM (&ff00-&ffff) - ; May be overwritten by includes below - dump &ff00 - MDAT "apple1.rom" - - -; Use RAM-based Applesoft BASIC by default -IF 1 - ; Applesoft BASIC [Lite] (6000-7FFF) - ; http://cowgod.org/replica1/applesoft/ - dump low_page,&6000 - MDAT "applesoft-lite-0.4-ram.bin" -ELSE - ; Lee Davidson's Enhanced BASIC (5800-77CE) - ; http://members.lycos.co.uk/leeedavison/6502/ehbasic/ - dump low_page,&5800 - MDAT "ehbasic.bin" -ENDIF - - -; Use Ken Wessen's BASIC+assembler by default -IF 1 - ; Ken Wessen's custom BASIC + Krusader assembler + enhanced monitor (E000-FFFF) - ; BRK handler points to mini-monitor in this version - ; http://school.anhb.uwa.edu.au/personalpages/kwessen/apple1/Krusader.htm - dump &e000 - MDAT "65C02.rom.bin" -ELSE - ; Applesoft BASIC [Lite] + Woz monitor (E000-FFFF) - ; http://cowgod.org/replica1/applesoft/ - dump &e000 - MDAT "applesoft-lite-0.4.bin" -ENDIF - - - ; Test program to output the character set (5000-500B) - ; LDX $00 ; loop: TXA ; JSR echo ; INX ; BRA loop - dump low_page,&5000 - defb &a2, &00, &8a, &20, &ef, &ff, &e8, &80, &f9 +; Apple 1 emulator for SAM Coupe, by Simon Owen +; +; Version 1.2 (5/9/2008) +; +; WWW: http://simonowen.com/sam/apple1emu/ + +base: equ &d000 ; Emulator code shares Apple 1 I/O area + +status: equ &f9 ; Status and extended keyboard port +lmpr: equ &fa ; Low Memory Page Register +hmpr: equ &fb ; High Memory Page Register +vmpr: equ &fc ; Video Memory Page Register +keyboard: equ &fe ; Keyboard port +border: equ &fe ; Border port + +rom0_off: equ %00100000 ; LMPR bit to disable ROM0 +rom1_on: equ %01000000 ; LMPR bit to enable ROM1 +vmpr_mode2: equ %00100000 ; Mode 2 select for VMPR + +low_page: equ 3 ; LMPR during emulation +screen_page: equ 5 ; SAM display +file_page: equ 6 ; File import text page + +m6502_nmi: equ &fffa ; nmi vector address +m6502_reset: equ &fffc ; reset vector address +m6502_int: equ &fffe ; int vector address (also for BRK) + +r1onclbc: equ &01ea ; ROM 1 on, call BC +getkey: equ &1cab ; SAM ROM key reading (NZ=got key in A, A=0 for no key) + + +; PIA registers for keyboard and display I/O + +kbd_data: equ &d010 ; keyboard data +kbd_ctrl: equ &d011 ; keyboard control +dsp_data: equ &d012 ; display data +dsp_ctrl: equ &d013 ; display control + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + org base + dump $ + autoexec + + di + jr start + + defs kbd_data-$ + ; This gap contains the PIA locations from above + defs dsp_ctrl-kbd_data+1 + +start: ld a,low_page+rom0_off + out (lmpr),a + ld a,vmpr_mode2+screen_page + out (vmpr),a + ld (basic_stack),sp + ld sp,stack_top + + call set_sam_attrs ; set the mode 2 attrs so the screen is visible + call setup_im2 ; enable IM 2 + + ld a,(op_00) ; lowest address used by emulator + ld (rom_write+1),a ; save byte to restore to simulate ROM + +reset_loop: ld hl,0 + ld (dsp_data),hl ; display ready + ld (kbd_data),hl ; no key available + + ld hl,(m6502_reset) ; start from reset vector + ld (reg_pc),hl + ld a,&04 ; interrupts disabled + ld (reg_p),a + + ei + call load_state + call execute ; GO! + call save_state + jr reset_loop + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; Utility functions + +; Fill SAM mode 2 display attributes to make the screen visible +set_sam_attrs: ld a,screen_page+rom0_off + out (lmpr),a + + ld hl,&2000 + ld bc,&1844 ; 24 blocks of bright green on black +clear_lp: ld (hl),c + inc l + jr nz,clear_lp + inc h + djnz clear_lp + + ld a,low_page+rom0_off + out (lmpr),a + ret + +; Scroll the screen up 1 row and clear the bottom line +scroll_screen: ld hl,0 + ld d,h + ld e,l + inc h + ld bc,&1700 +scroll_lp: FOR 32, ldi ; 32 * LDI + jp pe,scroll_lp + dec h +scroll_clr: ld (hl),0 + inc l + jp nz,scroll_clr + ret + +; Advance the cursor 1 character, wrapping and scrolling if necessary +advance_chr: ld hl,(cursor_xy) + cp &5f + jr z,back_chr + cp &0a + jr z,advance_line + cp &0d + jr z,advance_line + ld a,l + add a,6 + ld l,a + cp &f0 + jr c,no_wrap +advance_line: ld l,0 + inc h + ld a,h + cp &18 + jr nz,no_wrap + dec h + exx + call scroll_screen + exx +no_wrap: ld (cursor_xy),hl + ret +back_chr: ld a,l + sub 6 + ld l,a + jr nc,no_wrap + ld l,39*6 + ld a,h + sub 1 + adc a,0 + ld h,a + jr no_wrap + +; Map display character from SAM to Apple 1 +map_chr: sub &20 + ret nc + xor a + ret + +; Display character in A at current cursor position +display_chr: add a,a ; * 2 + ld l,a + ld h,0 + add hl,hl ; * 4 + add hl,hl ; * 8 + ld de,font_data + add hl,de + ld d,mask_data/256 + exx + ld hl,(cursor_xy) + ld a,l + and %00000111 + srl l + srl l + srl l + inc l + exx + ld e,a + exx + ld de,&0020 + ld b,8 +draw_lp: exx + ld c,(hl) + inc l + xor a + cp e + jr z,no_rot + ld b,e +rot_lp: srl c + rra + djnz rot_lp +no_rot: ld b,a + ld a,(de) + inc e + exx + and (hl) + inc l + exx + or c + ex af,af' + ld a,(de) + dec e + exx + and (hl) + exx + or b + exx + ld (hl),a + dec l + ex af,af' + ld (hl),a + add hl,de + djnz draw_lp + ret + +; LSB=pixel position (0-240), MSB=display row (0-23) +cursor_xy: defw 0 + +; Map key symbols from SAM to Apple 1 +map_key: cp &0c + jr z,del_key + cp &fc + jr z,tab_key + cp &80 + jr nc,ignore_key + cp &61 ; 'a' + ret c + cp &7b ; 'z'+1 + ret nc + and %11011111 + ret +del_key: ld a,&5f ; Delete -> _ + ret +tab_key: ld a,&09 ; standard tab + ret +invalid_key: ld a,&20 ; space for invalid + ret +ignore_key: xor a ; ignore + ret + +; Get a type-in key from the imported file +get_filekey: ld a,file_page+rom0_off + out (lmpr),a + + ld hl,(filepos) + ld a,h + or l + or (hl) + jr z,file_done ; jump if no file + +file_skip: ld a,(hl) ; fetch next file character + inc hl + and a + jr z,clear_file2 ; clear file at end + cp &0d ; CR? + jr z,file_skip ; ignore CR in file + cp &0a ; LF? + jr nz,file_done + ld a,&0d ; convert LF to CR +file_done: ld (filepos),hl + and a + ret +filepos: defw 0 + +; Clear the file area to disable type-in +clear_file: ld a,file_page+rom0_off + out (lmpr),a +clear_file2: ld hl,0 + ld c,l +clr_file_lp: ld (hl),c + inc l + jr nz,clr_file_lp + inc h + bit 7,h + jr nz,clr_file_lp + ld h,l + xor a ; no file character + jr file_done + +update_io: + ld a,&f7 + in a,(status) + and %00100000 + jr nz,not_esc ; jump if Esc not pressed + + call clear_file ; Esc cancels type-in mode + + ld a,&fe + in a,(keyboard) + rra + jr c,not_reset ; unshifted gives chr + + ld a,&c9 ; RET opcode + ld (main_loop),a ; return to reset on next instruction +not_reset: + +still_esc: ld a,&f7 + in a,(status) + and %00100000 + jr z,still_esc ; wait until Esc released + + ld a,&1b ; Esc character + jr got_key +not_esc: + ld a,&7f + in a,(keyboard) + bit 1,a + jr nz,not_sym + + ld a,&f7 + in a,(keyboard) + rra + ld c,&ff ; line interrupt disable + jr nc,got_line + rra + ld c,88 ; centre of display (312/2-68=88) + jr c,not_sym +got_line: ld a,c + out (status),a ; set or disable line interrupt +not_sym: + ld hl,kbd_ctrl + bit 7,(hl) ; key available? + jr nz,no_key ; no need to read more yet + + call get_filekey ; got a type-in key from file? + jr nz,got_key ; jump if we have + +skip_key: ld a,&1f ; LMPR page for BASIC, with ROM 0 enabled + out (lmpr),a + ld (save_stack),sp + ld sp,(basic_stack) + ld bc,getkey ; return key code in A, zero for none + call r1onclbc + ld sp,(save_stack) + jr z,no_key + call map_key + and a + jr z,skip_key +got_key: + ld hl,kbd_data + ld (hl),a + set 7,(hl) ; bit 7 always set + inc l + set 7,(hl) ; key available +no_key: + ld hl,dsp_data + bit 7,(hl) ; display char available? + jr z,no_char + res 7,(hl) ; display ready + ld a,(hl) ; fetch character to display + and a + jr z,done_draw + cp &7f + jr z,done_draw + push af + ld a,screen_page+rom0_off + out (lmpr),a ; page in screen + ld a,&00 ; space + call display_chr ; erase cursor + pop af + cp &5f ; backspace? (underscore) + jr z,done_draw2 ; if so, no need to process further + + push af + call map_chr ; map output from SAM->Apple 1 + call display_chr ; show it + pop af +done_draw2: call advance_chr ; advance the cursor position + ld a,&5f ; cursor block + call display_chr ; show cursor +done_draw: +no_char: + ret + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; Interrupt handling + +setup_im2: ld hl,im2_table + ld a,im2_jp/256 +im2_fill: ld (hl),a + inc l + jr nz,im2_fill + inc h + ld (hl),a ; complete the final entry + ld a,im2_table/256 + ld i,a + im 2 ; set interrupt mode 2 + ret + +im2_handler: push af + push bc + push de + push hl + ex af,af' + exx + push af + push bc + push de + push hl + push ix + push iy + + in a,(lmpr) + push af + call update_io + pop af + out (lmpr),a + + pop iy + pop ix + pop hl + pop de + pop bc + pop af + exx + ex af,af' + pop hl + pop de + pop bc + pop af + ei + reti + + +; IM 2 table must be aligned to 256-byte boundary + defs -$\256 +im2_table: defs 257 + +; IM 2 vector must have LSB==MSB + defs $/256-1 +stack_top: ; stack fits nicely in the slack space +im2_jp: jp im2_handler + +basic_stack: defw 0 +save_stack: defw 0 + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; 65C02 emulation + +execute: ld a,&1a ; LD A,(DE) + ld (ix),a + jp (ix) + + +i_undoc_3: inc de ; 3-byte NOP +i_undoc_2: inc de ; 2-byte NOP +i_undoc_1: jp (ix) ; NOP + + +read_write_loop: +write_loop: ld a,h + cp op_00/256 ; MSB of lowest emulator byte + jr nc,write_trap + +zwrite_loop: +main_loop: ld a,(de) ; 7/7/15 - fetch opcode + inc de ; 6/7/11 - PC++ + ld l,a ; 4/6/6 - LSB is opcode + ld h,msb_table/256 ; 7/7/15 - look-up table + ld h,(hl) ; 7/8/16 - opcode MSB + jp (hl) ; 4/5/9 - execute! + ; = 35T (official) / 40T (off-screen) / 72T (on-screen) + +write_trap: cp &d0 ; I/O page? + jr nz,rom_write + ld a,l + cp &12 ; display char? + jr z,chr_write + jp (ix) +chr_write: set 7,(hl) ; display busy + jp (ix) + +rom_write: ld a,&00 ; patched by starting code + ld (op_00),a ; emulator appears read-only to be ROM for RAM tests + jp (ix) + +read_loop: ld a,h + cp &d0 + jr z,read_trap + + ld a,(de) ; fetch opcode + inc de ; PC++ + ld l,a ; LSB is opcode + ld h,msb_table/256 ; look-up table + ld h,(hl) ; opcode MSB + jp (hl) ; execute! + +read_trap: ld a,l + cp &10 ; key read? + jr z,key_read + jp (ix) +key_read: inc l + res 7,(hl) ; key not available + jp (ix) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +load_state: ld a,(reg_a) + ld b,a ; set A + ld a,(reg_x) + ld iyh,a ; set X to IYh + ld a,(reg_y) + ld iyl,a ; set Y to IYl + exx + ld a,(reg_s) + ld l,a ; set S + ld h,&01 ; MSB for stack pointer + ld a,(reg_p) + ld c,a ; keep safe + and %00001100 ; keep D and I + or %00110000 ; force T and B + ld d,a ; set P + ld a,c + and %01000000 ; keep V + ld e,a ; set V + ld a,c + rra ; carry from C + ex af,af' ; set carry + ld a,c + and %10000010 ; keep N Z + xor %00000010 ; zero for Z + exx + ld c,a ; set N Z + ld de,(reg_pc) ; set PC + ld ix,main_loop ; decode loop + ret + +save_state: ld a,b ; get A + ld (reg_a),a + ld a,iyh ; get X from IYh + ld (reg_x),a + ld a,iyl ; get Y from IYl + ld (reg_y),a + ex af,af' ; carry + inc c + dec c ; set N Z + push af ; save flags + ex af,af' ; protect carry + exx + pop bc + ld a,c + and %10000001 ; keep Z80 N and C + bit 6,c ; check Z80 Z + jr z,save_nz + or %00000010 ; set Z +save_nz: or e ; merge V + or d ; merge T B D I + ld (reg_p),a + ld a,l ; get S + ld (reg_s),a + exx + ld (reg_pc),de + ret + + +; During running we keep the 65xx registers in Z80 registers +; These are used only to hold the state before/after running +reg_a: defb 0 +reg_p: defb 0 +reg_x: defb 0 +reg_y: defb 0 +reg_s: defb 0 +reg_pc: defw 0 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + defs -$\256 + +msb_table: defb op_00>>8, op_01>>8, op_02>>8, op_03>>8, op_04>>8, op_05>>8, op_06>>8, op_07>>8 + defb op_08>>8, op_09>>8, op_0a>>8, op_0b>>8, op_0c>>8, op_0d>>8, op_0e>>8, op_0f>>8 + defb op_10>>8, op_11>>8, op_12>>8, op_13>>8, op_14>>8, op_15>>8, op_16>>8, op_17>>8 + defb op_18>>8, op_19>>8, op_1a>>8, op_1b>>8, op_1c>>8, op_1d>>8, op_1e>>8, op_1f>>8 + defb op_20>>8, op_21>>8, op_22>>8, op_23>>8, op_24>>8, op_25>>8, op_26>>8, op_27>>8 + defb op_28>>8, op_29>>8, op_2a>>8, op_2b>>8, op_2c>>8, op_2d>>8, op_2e>>8, op_2f>>8 + defb op_30>>8, op_31>>8, op_32>>8, op_33>>8, op_34>>8, op_35>>8, op_36>>8, op_37>>8 + defb op_38>>8, op_39>>8, op_3a>>8, op_3b>>8, op_3c>>8, op_3d>>8, op_3e>>8, op_3f>>8 + defb op_40>>8, op_41>>8, op_42>>8, op_43>>8, op_44>>8, op_45>>8, op_46>>8, op_47>>8 + defb op_48>>8, op_49>>8, op_4a>>8, op_4b>>8, op_4c>>8, op_4d>>8, op_4e>>8, op_4f>>8 + defb op_50>>8, op_51>>8, op_52>>8, op_53>>8, op_54>>8, op_55>>8, op_56>>8, op_57>>8 + defb op_58>>8, op_59>>8, op_5a>>8, op_5b>>8, op_5c>>8, op_5d>>8, op_5e>>8, op_5f>>8 + defb op_60>>8, op_61>>8, op_62>>8, op_63>>8, op_64>>8, op_65>>8, op_66>>8, op_67>>8 + defb op_68>>8, op_69>>8, op_6a>>8, op_6b>>8, op_6c>>8, op_6d>>8, op_6e>>8, op_6f>>8 + defb op_70>>8, op_71>>8, op_72>>8, op_73>>8, op_74>>8, op_75>>8, op_76>>8, op_77>>8 + defb op_78>>8, op_79>>8, op_7a>>8, op_7b>>8, op_7c>>8, op_7d>>8, op_7e>>8, op_7f>>8 + defb op_80>>8, op_81>>8, op_82>>8, op_83>>8, op_84>>8, op_85>>8, op_86>>8, op_87>>8 + defb op_88>>8, op_89>>8, op_8a>>8, op_8b>>8, op_8c>>8, op_8d>>8, op_8e>>8, op_8f>>8 + defb op_90>>8, op_91>>8, op_92>>8, op_93>>8, op_94>>8, op_95>>8, op_96>>8, op_97>>8 + defb op_98>>8, op_99>>8, op_9a>>8, op_9b>>8, op_9c>>8, op_9d>>8, op_9e>>8, op_9f>>8 + defb op_a0>>8, op_a1>>8, op_a2>>8, op_a3>>8, op_a4>>8, op_a5>>8, op_a6>>8, op_a7>>8 + defb op_a8>>8, op_a9>>8, op_aa>>8, op_ab>>8, op_ac>>8, op_ad>>8, op_ae>>8, op_af>>8 + defb op_b0>>8, op_b1>>8, op_b2>>8, op_b3>>8, op_b4>>8, op_b5>>8, op_b6>>8, op_b7>>8 + defb op_b8>>8, op_b9>>8, op_ba>>8, op_bb>>8, op_bc>>8, op_bd>>8, op_be>>8, op_bf>>8 + defb op_c0>>8, op_c1>>8, op_c2>>8, op_c3>>8, op_c4>>8, op_c5>>8, op_c6>>8, op_c7>>8 + defb op_c8>>8, op_c9>>8, op_ca>>8, op_cb>>8, op_cc>>8, op_cd>>8, op_ce>>8, op_cf>>8 + defb op_d0>>8, op_d1>>8, op_d2>>8, op_d3>>8, op_d4>>8, op_d5>>8, op_d6>>8, op_d7>>8 + defb op_d8>>8, op_d9>>8, op_da>>8, op_db>>8, op_dc>>8, op_dd>>8, op_de>>8, op_df>>8 + defb op_e0>>8, op_e1>>8, op_e2>>8, op_e3>>8, op_e4>>8, op_e5>>8, op_e6>>8, op_e7>>8 + defb op_e8>>8, op_e9>>8, op_ea>>8, op_eb>>8, op_ec>>8, op_ed>>8, op_ee>>8, op_ef>>8 + defb op_f0>>8, op_f1>>8, op_f2>>8, op_f3>>8, op_f4>>8, op_f5>>8, op_f6>>8, op_f7>>8 + defb op_f8>>8, op_f9>>8, op_fa>>8, op_fb>>8, op_fc>>8, op_fd>>8, op_fe>>8, op_ff>>8 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + defs -$\256 ; align to 256-byte boundary + +; !"#$%&1()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]`abcdefghijklmnopqrstuvwxyz{|}~ +font_data: + MDAT "font.bin" + +mask_data: defb %00000011,%11111111 + defb %11000000,%11111111 + defb %11110000,%00111111 + defb %11111100,%00001111 + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +end: equ $ +length: equ end-start + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + ; Instruction implementations + INC "opimpl.inc" + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + ; Woz Monitor ROM (&ff00-&ffff) + ; May be overwritten by includes below + dump &ff00 + MDAT "apple1.rom" + + +; Use RAM-based Applesoft BASIC by default +IF 1 + ; Applesoft BASIC [Lite] (6000-7FFF) + ; http://cowgod.org/replica1/applesoft/ + dump low_page,&6000 + MDAT "applesoft-lite-0.4-ram.bin" +ELSE + ; Lee Davidson's Enhanced BASIC (5800-77CE) + ; http://members.lycos.co.uk/leeedavison/6502/ehbasic/ + dump low_page,&5800 + MDAT "ehbasic.bin" +ENDIF + + +; Use Ken Wessen's BASIC+assembler by default +IF 1 + ; Ken Wessen's custom BASIC + Krusader assembler + enhanced monitor (E000-FFFF) + ; BRK handler points to mini-monitor in this version + ; http://school.anhb.uwa.edu.au/personalpages/kwessen/apple1/Krusader.htm + dump &e000 + MDAT "65C02.rom.bin" +ELSE + ; Applesoft BASIC [Lite] + Woz monitor (E000-FFFF) + ; http://cowgod.org/replica1/applesoft/ + dump &e000 + MDAT "applesoft-lite-0.4.bin" +ENDIF + + + ; Test program to output the character set (5000-500B) + ; LDX $00 ; loop: TXA ; JSR echo ; INX ; BRA loop + dump low_page,&5000 + defb &a2, &00, &8a, &20, &ef, &ff, &e8, &80, &f9 diff --git a/font.pl b/font.pl index 8ab1a90..276cbd0 100644 --- a/font.pl +++ b/font.pl @@ -1,64 +1,64 @@ -#!/usr/bin/perl -w -# -# Convert PNG image to raw font binary for Apple 1 emulator -# -# Makes lots of assumptions about the input image! - -use Compress::Zlib; - -# Input image and output data file -my $input = 'font.png'; -my $output = 'font.bin'; - -# Our characters are 6 pixels wide -$chrw = 6; - - -# Slurp the entire PNG image -open INPUT, "<$input" and binmode INPUT or die "$input: $!\n"; -read INPUT, $data='', -s $input; -close INPUT; - -# Find and extract the image dimensions -$data =~ /IHDR(.{8})/s; -($w,$h) = unpack "N2", $1; - -# Extract and expand the compressed image data -($data) = $data =~ /IDAT(.*).{8}IEND/s; -$data = Compress::Zlib::uncompress($data); - -# Remove the type byte from the start of each line -$w_2 = $w/2; -$data =~ s/.(.{$w_2})/$1/sg; - -@data = (); - -# Unpack the pixel nibbles -foreach (unpack "C*", $data) { - push @data, $_>>4, $_&1; -} - - -open OUTPUT, ">$output" and binmode OUTPUT or die "$output: $!\n"; - -# Process all characters -foreach $chr (0..$w/$chrw-1) -{ - # Process the image line by line - foreach $y (0..$h-1) - { - # Locate the pixel data for the current character - my $x = $chr*$chrw + $w*$y; - my $b = 0; - - # Pack the 1bpp data into a single byte - foreach (@data[$x..$x+$chrw-1]) { - $b = ($b << 1) | $_; - } - - # Left-align within the byte and output it - print OUTPUT chr($b << (8-$chrw)); - } -} - -close OUTPUT; +#!/usr/bin/perl -w +# +# Convert PNG image to raw font binary for Apple 1 emulator +# +# Makes lots of assumptions about the input image! + +use Compress::Zlib; + +# Input image and output data file +my $input = 'font.png'; +my $output = 'font.bin'; + +# Our characters are 6 pixels wide +$chrw = 6; + + +# Slurp the entire PNG image +open INPUT, "<$input" and binmode INPUT or die "$input: $!\n"; +read INPUT, $data='', -s $input; +close INPUT; + +# Find and extract the image dimensions +$data =~ /IHDR(.{8})/s; +($w,$h) = unpack "N2", $1; + +# Extract and expand the compressed image data +($data) = $data =~ /IDAT(.*).{8}IEND/s; +$data = Compress::Zlib::uncompress($data); + +# Remove the type byte from the start of each line +$w_2 = $w/2; +$data =~ s/.(.{$w_2})/$1/sg; + +@data = (); + +# Unpack the pixel nibbles +foreach (unpack "C*", $data) { + push @data, $_>>4, $_&1; +} + + +open OUTPUT, ">$output" and binmode OUTPUT or die "$output: $!\n"; + +# Process all characters +foreach $chr (0..$w/$chrw-1) +{ + # Process the image line by line + foreach $y (0..$h-1) + { + # Locate the pixel data for the current character + my $x = $chr*$chrw + $w*$y; + my $b = 0; + + # Pack the 1bpp data into a single byte + foreach (@data[$x..$x+$chrw-1]) { + $b = ($b << 1) | $_; + } + + # Left-align within the byte and output it + print OUTPUT chr($b << (8-$chrw)); + } +} + +close OUTPUT; diff --git a/m.bat b/m.bat old mode 100644 new mode 100755 index 45a5fdc..946c21b --- a/m.bat +++ b/m.bat @@ -1,2 +1,2 @@ -pyz80.py -I samdos2 -s length apple1emu.asm -@if %errorlevel%==0 start apple1emu.dsk +pyz80.py -I samdos2 -s length apple1emu.asm +@if %errorlevel%==0 start apple1emu.dsk diff --git a/opdefs.inc b/opdefs.inc index 4194599..6642683 100644 --- a/opdefs.inc +++ b/opdefs.inc @@ -1,258 +1,258 @@ -; Opcode table positions (auto-generated by opdefs.pl) - -op_00: equ &c000 ; +42 -op_01: equ &c401 ; +18 -op_02: equ &ca02 ; +3 -op_03: equ &c103 ; +3 -op_04: equ &c304 ; +14 -op_05: equ &c205 ; +12 -op_06: equ &c706 ; +13 -op_07: equ &cb07 ; +9 -op_08: equ &c108 ; +23 -op_09: equ &ca09 ; +10 -op_0a: equ &cc0a ; +7 -op_0b: equ &c90b ; +3 -op_0c: equ &c50c ; +16 -op_0d: equ &c80d ; +13 -op_0e: equ &c60e ; +14 -op_0f: equ &c90f ; +13 -op_10: equ &cd10 ; +8 -op_11: equ &c211 ; +22 -op_12: equ &c312 ; +20 -op_13: equ &c413 ; +3 -op_14: equ &ca14 ; +15 -op_15: equ &cc15 ; +14 -op_16: equ &cb16 ; +15 -op_17: equ &ce17 ; +9 -op_18: equ &cd18 ; +4 -op_19: equ &c719 ; +17 -op_1a: equ &c41a ; +4 -op_1b: equ &cf1b ; +3 -op_1c: equ &c61c ; +17 -op_1d: equ &c81d ; +17 -op_1e: equ &c41e ; +18 -op_1f: equ &cd1f ; +13 -op_20: equ &c920 ; +16 -op_21: equ &c521 ; +18 -op_22: equ &ce22 ; +3 -op_23: equ &ca23 ; +3 -op_24: equ &c124 ; +27 -op_25: equ &cb25 ; +12 -op_26: equ &ca26 ; +13 -op_27: equ &c327 ; +9 -op_28: equ &c228 ; +25 -op_29: equ &cc29 ; +10 -op_2a: equ &ce2a ; +7 -op_2b: equ &c02b ; +3 -op_2c: equ &cd2c ; +9 -op_2d: equ &c62d ; +13 -op_2e: equ &c02e ; +14 -op_2f: equ &c72f ; +13 -op_30: equ &c830 ; +8 -op_31: equ &c331 ; +22 -op_32: equ &c432 ; +20 -op_33: equ &c933 ; +3 -op_34: equ &c534 ; +10 -op_35: equ &ca35 ; +14 -op_36: equ &c936 ; +15 -op_37: equ &cc37 ; +9 -op_38: equ &cb38 ; +4 -op_39: equ &c839 ; +17 -op_3a: equ &c63a ; +4 -op_3b: equ &cd3b ; +3 -op_3c: equ &cb3c ; +13 -op_3d: equ &c73d ; +17 -op_3e: equ &c63e ; +18 -op_3f: equ &c13f ; +13 -op_40: equ &c040 ; +35 -op_41: equ &c541 ; +18 -op_42: equ &c242 ; +3 -op_43: equ &cc43 ; +3 -op_44: equ &ca44 ; +3 -op_45: equ &c245 ; +12 -op_46: equ &c446 ; +13 -op_47: equ &ca47 ; +9 -op_48: equ &cc48 ; +7 -op_49: equ &cb49 ; +10 -op_4a: equ &cd4a ; +7 -op_4b: equ &c34b ; +3 -op_4c: equ &ce4c ; +6 -op_4d: equ &c94d ; +13 -op_4e: equ &c34e ; +14 -op_4f: equ &c84f ; +13 -op_50: equ &ca50 ; +10 -op_51: equ &c151 ; +22 -op_52: equ &c252 ; +20 -op_53: equ &c453 ; +3 -op_54: equ &c554 ; +3 -op_55: equ &c755 ; +14 -op_56: equ &c656 ; +15 -op_57: equ &cb57 ; +9 -op_58: equ &cd58 ; +6 -op_59: equ &c559 ; +17 -op_5a: equ &cc5a ; +8 -op_5b: equ &c95b ; +3 -op_5c: equ &c85c ; +3 -op_5d: equ &c45d ; +17 -op_5e: equ &c35e ; +18 -op_5f: equ &c95f ; +13 -op_60: equ &ca60 ; +13 -op_61: equ &c861 ; +14 -op_62: equ &cc62 ; +3 -op_63: equ &c063 ; +3 -op_64: equ &cb64 ; +8 -op_65: equ &cd65 ; +8 -op_66: equ &c666 ; +13 -op_67: equ &c767 ; +9 -op_68: equ &cc68 ; +8 -op_69: equ &c069 ; +27 -op_6a: equ &ce6a ; +7 -op_6b: equ &c16b ; +3 -op_6c: equ &c56c ; +10 -op_6d: equ &cb6d ; +9 -op_6e: equ &c16e ; +14 -op_6f: equ &c26f ; +13 -op_70: equ &c970 ; +10 -op_71: equ &c371 ; +18 -op_72: equ &c472 ; +16 -op_73: equ &c673 ; +3 -op_74: equ &ca74 ; +10 -op_75: equ &c775 ; +10 -op_76: equ &c676 ; +15 -op_77: equ &cc77 ; +9 -op_78: equ &cd78 ; +6 -op_79: equ &c879 ; +13 -op_7a: equ &cb7a ; +9 -op_7b: equ &ce7b ; +3 -op_7c: equ &c57c ; +15 -op_7d: equ &c97d ; +13 -op_7e: equ &c27e ; +18 -op_7f: equ &ca7f ; +13 -op_80: equ &c180 ; +21 -op_81: equ &c781 ; +14 -op_82: equ &c482 ; +3 -op_83: equ &cb83 ; +3 -op_84: equ &c384 ; +10 -op_85: equ &c485 ; +8 -op_86: equ &c086 ; +10 -op_87: equ &c887 ; +9 -op_88: equ &cc88 ; +6 -op_89: equ &cb89 ; +7 -op_8a: equ &c98a ; +5 -op_8b: equ &cd8b ; +3 -op_8c: equ &c58c ; +12 -op_8d: equ &c68d ; +10 -op_8e: equ &c48e ; +12 -op_8f: equ &c38f ; +13 -op_90: equ &c990 ; +8 -op_91: equ &c091 ; +19 -op_92: equ &c292 ; +17 -op_93: equ &c793 ; +3 -op_94: equ &c894 ; +12 -op_95: equ &c195 ; +10 -op_96: equ &c796 ; +12 -op_97: equ &ca97 ; +9 -op_98: equ &c698 ; +5 -op_99: equ &c599 ; +14 -op_9a: equ &cb9a ; +7 -op_9b: equ &cc9b ; +3 -op_9c: equ &c99c ; +11 -op_9d: equ &c49d ; +14 -op_9e: equ &c39e ; +15 -op_9f: equ &c69f ; +13 -op_a0: equ &caa0 ; +7 -op_a1: equ &c1a1 ; +15 -op_a2: equ &c8a2 ; +7 -op_a3: equ &c7a3 ; +3 -op_a4: equ &c0a4 ; +10 -op_a5: equ &c2a5 ; +9 -op_a6: equ &c7a6 ; +10 -op_a7: equ &c5a7 ; +9 -op_a8: equ &caa8 ; +5 -op_a9: equ &c8a9 ; +6 -op_aa: equ &c9aa ; +5 -op_ab: equ &cbab ; +3 -op_ac: equ &c4ac ; +12 -op_ad: equ &c6ad ; +11 -op_ae: equ &c3ae ; +12 -op_af: equ &c2af ; +13 -op_b0: equ &c7b0 ; +8 -op_b1: equ &c0b1 ; +20 -op_b2: equ &c1b2 ; +18 -op_b3: equ &c5b3 ; +3 -op_b4: equ &c8b4 ; +12 -op_b5: equ &c9b5 ; +11 -op_b6: equ &c5b6 ; +12 -op_b7: equ &cbb7 ; +9 -op_b8: equ &c4b8 ; +6 -op_b9: equ &c6b9 ; +15 -op_ba: equ &ccba ; +8 -op_bb: equ &cabb ; +3 -op_bc: equ &c3bc ; +16 -op_bd: equ &c7bd ; +15 -op_be: equ &c4be ; +16 -op_bf: equ &cabf ; +13 -op_c0: equ &c9c0 ; +13 -op_c1: equ &c2c1 ; +20 -op_c2: equ &c8c2 ; +3 -op_c3: equ &cbc3 ; +3 -op_c4: equ &c5c4 ; +15 -op_c5: equ &c8c5 ; +14 -op_c6: equ &c0c6 ; +9 -op_c7: equ &c1c7 ; +9 -op_c8: equ &ccc8 ; +6 -op_c9: equ &cbc9 ; +12 -op_ca: equ &cdca ; +6 -op_cb: equ &cecb ; +3 -op_cc: equ &c3cc ; +16 -op_cd: equ &c6cd ; +15 -op_ce: equ &c9ce ; +11 -op_cf: equ &c7cf ; +13 -op_d0: equ &ccd0 ; +8 -op_d1: equ &c0d1 ; +24 -op_d2: equ &c1d2 ; +22 -op_d3: equ &c5d3 ; +3 -op_d4: equ &c8d4 ; +3 -op_d5: equ &c4d5 ; +16 -op_d6: equ &c5d6 ; +11 -op_d7: equ &cad7 ; +9 -op_d8: equ &c8d8 ; +13 -op_d9: equ &c2d9 ; +19 -op_da: equ &cbda ; +8 -op_db: equ &c9db ; +4 -op_dc: equ &c7dc ; +3 -op_dd: equ &c3dd ; +19 -op_de: equ &c6de ; +15 -op_df: equ &c9df ; +13 -op_e0: equ &cae0 ; +13 -op_e1: equ &c7e1 ; +14 -op_e2: equ &cce2 ; +3 -op_e3: equ &cbe3 ; +3 -op_e4: equ &c5e4 ; +15 -op_e5: equ &c8e5 ; +8 -op_e6: equ &cce6 ; +9 -op_e7: equ &cbe7 ; +9 -op_e8: equ &c1e8 ; +6 -op_e9: equ &c0e9 ; +22 -op_ea: equ &c4ea ; +2 -op_eb: equ &cdeb ; +3 -op_ec: equ &c4ec ; +16 -op_ed: equ &c6ed ; +9 -op_ee: equ &c8ee ; +11 -op_ef: equ &c7ef ; +13 -op_f0: equ &caf0 ; +8 -op_f1: equ &c1f1 ; +18 -op_f2: equ &c2f2 ; +16 -op_f3: equ &c3f3 ; +3 -op_f4: equ &c5f4 ; +3 -op_f5: equ &c9f5 ; +10 -op_f6: equ &c3f6 ; +11 -op_f7: equ &cbf7 ; +9 -op_f8: equ &c6f8 ; +14 -op_f9: equ &c8f9 ; +13 -op_fa: equ &cafa ; +9 -op_fb: equ &c5fb ; +3 -op_fc: equ &c4fc ; +3 -op_fd: equ &c7fd ; +13 -op_fe: equ &c5fe ; +15 -op_ff: equ &c4ff ; +13 +; Opcode table positions (auto-generated by opdefs.pl) + +op_00: equ &c000 ; +42 +op_01: equ &c401 ; +18 +op_02: equ &ca02 ; +3 +op_03: equ &c103 ; +3 +op_04: equ &c304 ; +14 +op_05: equ &c205 ; +12 +op_06: equ &c706 ; +13 +op_07: equ &cb07 ; +9 +op_08: equ &c108 ; +23 +op_09: equ &ca09 ; +10 +op_0a: equ &cc0a ; +7 +op_0b: equ &c90b ; +3 +op_0c: equ &c50c ; +16 +op_0d: equ &c80d ; +13 +op_0e: equ &c60e ; +14 +op_0f: equ &c90f ; +13 +op_10: equ &cd10 ; +8 +op_11: equ &c211 ; +22 +op_12: equ &c312 ; +20 +op_13: equ &c413 ; +3 +op_14: equ &ca14 ; +15 +op_15: equ &cc15 ; +14 +op_16: equ &cb16 ; +15 +op_17: equ &ce17 ; +9 +op_18: equ &cd18 ; +4 +op_19: equ &c719 ; +17 +op_1a: equ &c41a ; +4 +op_1b: equ &cf1b ; +3 +op_1c: equ &c61c ; +17 +op_1d: equ &c81d ; +17 +op_1e: equ &c41e ; +18 +op_1f: equ &cd1f ; +13 +op_20: equ &c920 ; +16 +op_21: equ &c521 ; +18 +op_22: equ &ce22 ; +3 +op_23: equ &ca23 ; +3 +op_24: equ &c124 ; +27 +op_25: equ &cb25 ; +12 +op_26: equ &ca26 ; +13 +op_27: equ &c327 ; +9 +op_28: equ &c228 ; +25 +op_29: equ &cc29 ; +10 +op_2a: equ &ce2a ; +7 +op_2b: equ &c02b ; +3 +op_2c: equ &cd2c ; +9 +op_2d: equ &c62d ; +13 +op_2e: equ &c02e ; +14 +op_2f: equ &c72f ; +13 +op_30: equ &c830 ; +8 +op_31: equ &c331 ; +22 +op_32: equ &c432 ; +20 +op_33: equ &c933 ; +3 +op_34: equ &c534 ; +10 +op_35: equ &ca35 ; +14 +op_36: equ &c936 ; +15 +op_37: equ &cc37 ; +9 +op_38: equ &cb38 ; +4 +op_39: equ &c839 ; +17 +op_3a: equ &c63a ; +4 +op_3b: equ &cd3b ; +3 +op_3c: equ &cb3c ; +13 +op_3d: equ &c73d ; +17 +op_3e: equ &c63e ; +18 +op_3f: equ &c13f ; +13 +op_40: equ &c040 ; +35 +op_41: equ &c541 ; +18 +op_42: equ &c242 ; +3 +op_43: equ &cc43 ; +3 +op_44: equ &ca44 ; +3 +op_45: equ &c245 ; +12 +op_46: equ &c446 ; +13 +op_47: equ &ca47 ; +9 +op_48: equ &cc48 ; +7 +op_49: equ &cb49 ; +10 +op_4a: equ &cd4a ; +7 +op_4b: equ &c34b ; +3 +op_4c: equ &ce4c ; +6 +op_4d: equ &c94d ; +13 +op_4e: equ &c34e ; +14 +op_4f: equ &c84f ; +13 +op_50: equ &ca50 ; +10 +op_51: equ &c151 ; +22 +op_52: equ &c252 ; +20 +op_53: equ &c453 ; +3 +op_54: equ &c554 ; +3 +op_55: equ &c755 ; +14 +op_56: equ &c656 ; +15 +op_57: equ &cb57 ; +9 +op_58: equ &cd58 ; +6 +op_59: equ &c559 ; +17 +op_5a: equ &cc5a ; +8 +op_5b: equ &c95b ; +3 +op_5c: equ &c85c ; +3 +op_5d: equ &c45d ; +17 +op_5e: equ &c35e ; +18 +op_5f: equ &c95f ; +13 +op_60: equ &ca60 ; +13 +op_61: equ &c861 ; +14 +op_62: equ &cc62 ; +3 +op_63: equ &c063 ; +3 +op_64: equ &cb64 ; +8 +op_65: equ &cd65 ; +8 +op_66: equ &c666 ; +13 +op_67: equ &c767 ; +9 +op_68: equ &cc68 ; +8 +op_69: equ &c069 ; +27 +op_6a: equ &ce6a ; +7 +op_6b: equ &c16b ; +3 +op_6c: equ &c56c ; +10 +op_6d: equ &cb6d ; +9 +op_6e: equ &c16e ; +14 +op_6f: equ &c26f ; +13 +op_70: equ &c970 ; +10 +op_71: equ &c371 ; +18 +op_72: equ &c472 ; +16 +op_73: equ &c673 ; +3 +op_74: equ &ca74 ; +10 +op_75: equ &c775 ; +10 +op_76: equ &c676 ; +15 +op_77: equ &cc77 ; +9 +op_78: equ &cd78 ; +6 +op_79: equ &c879 ; +13 +op_7a: equ &cb7a ; +9 +op_7b: equ &ce7b ; +3 +op_7c: equ &c57c ; +15 +op_7d: equ &c97d ; +13 +op_7e: equ &c27e ; +18 +op_7f: equ &ca7f ; +13 +op_80: equ &c180 ; +21 +op_81: equ &c781 ; +14 +op_82: equ &c482 ; +3 +op_83: equ &cb83 ; +3 +op_84: equ &c384 ; +10 +op_85: equ &c485 ; +8 +op_86: equ &c086 ; +10 +op_87: equ &c887 ; +9 +op_88: equ &cc88 ; +6 +op_89: equ &cb89 ; +7 +op_8a: equ &c98a ; +5 +op_8b: equ &cd8b ; +3 +op_8c: equ &c58c ; +12 +op_8d: equ &c68d ; +10 +op_8e: equ &c48e ; +12 +op_8f: equ &c38f ; +13 +op_90: equ &c990 ; +8 +op_91: equ &c091 ; +19 +op_92: equ &c292 ; +17 +op_93: equ &c793 ; +3 +op_94: equ &c894 ; +12 +op_95: equ &c195 ; +10 +op_96: equ &c796 ; +12 +op_97: equ &ca97 ; +9 +op_98: equ &c698 ; +5 +op_99: equ &c599 ; +14 +op_9a: equ &cb9a ; +7 +op_9b: equ &cc9b ; +3 +op_9c: equ &c99c ; +11 +op_9d: equ &c49d ; +14 +op_9e: equ &c39e ; +15 +op_9f: equ &c69f ; +13 +op_a0: equ &caa0 ; +7 +op_a1: equ &c1a1 ; +15 +op_a2: equ &c8a2 ; +7 +op_a3: equ &c7a3 ; +3 +op_a4: equ &c0a4 ; +10 +op_a5: equ &c2a5 ; +9 +op_a6: equ &c7a6 ; +10 +op_a7: equ &c5a7 ; +9 +op_a8: equ &caa8 ; +5 +op_a9: equ &c8a9 ; +6 +op_aa: equ &c9aa ; +5 +op_ab: equ &cbab ; +3 +op_ac: equ &c4ac ; +12 +op_ad: equ &c6ad ; +11 +op_ae: equ &c3ae ; +12 +op_af: equ &c2af ; +13 +op_b0: equ &c7b0 ; +8 +op_b1: equ &c0b1 ; +20 +op_b2: equ &c1b2 ; +18 +op_b3: equ &c5b3 ; +3 +op_b4: equ &c8b4 ; +12 +op_b5: equ &c9b5 ; +11 +op_b6: equ &c5b6 ; +12 +op_b7: equ &cbb7 ; +9 +op_b8: equ &c4b8 ; +6 +op_b9: equ &c6b9 ; +15 +op_ba: equ &ccba ; +8 +op_bb: equ &cabb ; +3 +op_bc: equ &c3bc ; +16 +op_bd: equ &c7bd ; +15 +op_be: equ &c4be ; +16 +op_bf: equ &cabf ; +13 +op_c0: equ &c9c0 ; +13 +op_c1: equ &c2c1 ; +20 +op_c2: equ &c8c2 ; +3 +op_c3: equ &cbc3 ; +3 +op_c4: equ &c5c4 ; +15 +op_c5: equ &c8c5 ; +14 +op_c6: equ &c0c6 ; +9 +op_c7: equ &c1c7 ; +9 +op_c8: equ &ccc8 ; +6 +op_c9: equ &cbc9 ; +12 +op_ca: equ &cdca ; +6 +op_cb: equ &cecb ; +3 +op_cc: equ &c3cc ; +16 +op_cd: equ &c6cd ; +15 +op_ce: equ &c9ce ; +11 +op_cf: equ &c7cf ; +13 +op_d0: equ &ccd0 ; +8 +op_d1: equ &c0d1 ; +24 +op_d2: equ &c1d2 ; +22 +op_d3: equ &c5d3 ; +3 +op_d4: equ &c8d4 ; +3 +op_d5: equ &c4d5 ; +16 +op_d6: equ &c5d6 ; +11 +op_d7: equ &cad7 ; +9 +op_d8: equ &c8d8 ; +13 +op_d9: equ &c2d9 ; +19 +op_da: equ &cbda ; +8 +op_db: equ &c9db ; +4 +op_dc: equ &c7dc ; +3 +op_dd: equ &c3dd ; +19 +op_de: equ &c6de ; +15 +op_df: equ &c9df ; +13 +op_e0: equ &cae0 ; +13 +op_e1: equ &c7e1 ; +14 +op_e2: equ &cce2 ; +3 +op_e3: equ &cbe3 ; +3 +op_e4: equ &c5e4 ; +15 +op_e5: equ &c8e5 ; +8 +op_e6: equ &cce6 ; +9 +op_e7: equ &cbe7 ; +9 +op_e8: equ &c1e8 ; +6 +op_e9: equ &c0e9 ; +22 +op_ea: equ &c4ea ; +2 +op_eb: equ &cdeb ; +3 +op_ec: equ &c4ec ; +16 +op_ed: equ &c6ed ; +9 +op_ee: equ &c8ee ; +11 +op_ef: equ &c7ef ; +13 +op_f0: equ &caf0 ; +8 +op_f1: equ &c1f1 ; +18 +op_f2: equ &c2f2 ; +16 +op_f3: equ &c3f3 ; +3 +op_f4: equ &c5f4 ; +3 +op_f5: equ &c9f5 ; +10 +op_f6: equ &c3f6 ; +11 +op_f7: equ &cbf7 ; +9 +op_f8: equ &c6f8 ; +14 +op_f9: equ &c8f9 ; +13 +op_fa: equ &cafa ; +9 +op_fb: equ &c5fb ; +3 +op_fc: equ &c4fc ; +3 +op_fd: equ &c7fd ; +13 +op_fe: equ &c5fe ; +15 +op_ff: equ &c4ff ; +13 diff --git a/opdefs.pl b/opdefs.pl index 047b4e7..703194c 100644 --- a/opdefs.pl +++ b/opdefs.pl @@ -1,85 +1,85 @@ -#!/usr/bin/perl -w -# -# Calculates opcode addresses for the inline instruction decoding table -# -# Used by the Apple 1 emulator, available from: -# -# http://simonowen.com/sam/apple1emu/ - -$source = 'apple1emu.asm'; -$codeend = 0xd000; - -# Assemble, outputting the symbols containing opcode implementation lengths -$_ = `pyz80.py -s op_.*_len $source`; - -# Create include file for definitions -my $outfile = 'opdefs.inc'; -open(FILE, ">$outfile") or die "$!"; -print FILE "; Opcode table positions (auto-generated by opdefs.pl)\n\n"; - -# Assembly failed? -if ($?) -{ - # Create dummy offset list to allow lengths to be calculated - for (0..255) { - printf FILE "op_%02x: equ &%04x\n", $_, $codeend-0x1000; - } - - print "Assembly error, creating dummy definitions!\n"; - exit; -} - -# Create hash from opcode to length -while (/OP_(..)_LEN': (\d+)/g) { - $len{hex $1} = $2; -} - -# Position in order of size, largest first -@todo = reverse sort { $len{$a} <=> $len{$b} } keys %len; - -my($size,$used) = (0,0); - -OPCODE: -foreach $op (@todo) -{ -MSB: - # Work up through MSB values until we find a space - for ($msb = 0 ; ; $msb++) - { - # Determine the extent of the opcode in the current MSB - my $start = ($msb << 8) | $op; - my $end = $start + $len{$op}-1; - - # Check against what we've already positioned - foreach (keys %off) - { - # Determine extent of existing item - my $start2 = $off{$_}; - my $end2 = $start2 + $len{$_}-1; - - # Reject MSB if new position would overlap - next MSB unless ($start > $end2 || $end < $start2); - } - - # Assign to the free spot we've found - $off{$op} = $start; - - # Update size stats - $used += $len{$op}; - if ($end > $size) { $size = $end; } - - next OPCODE; - } -} - -# Position base so code finishes at the required point -$base = $codeend - (($size + 0xff) & ~0xff); - -print "Size = $size, used = $used, slack = ", $size-$used, "\n"; - -# Output sorted list of calculated positions -foreach (sort { $a <=> $b } @todo) { - printf FILE "op_%02x: equ &%04x ; +$len{$_}\n", $_, $base+$off{$_}; -} - -close FILE; +#!/usr/bin/perl -w +# +# Calculates opcode addresses for the inline instruction decoding table +# +# Used by the Apple 1 emulator, available from: +# +# http://simonowen.com/sam/apple1emu/ + +$source = 'apple1emu.asm'; +$codeend = 0xd000; + +# Assemble, outputting the symbols containing opcode implementation lengths +$_ = `pyz80.py -s op_.*_len $source`; + +# Create include file for definitions +my $outfile = 'opdefs.inc'; +open(FILE, ">$outfile") or die "$!"; +print FILE "; Opcode table positions (auto-generated by opdefs.pl)\n\n"; + +# Assembly failed? +if ($?) +{ + # Create dummy offset list to allow lengths to be calculated + for (0..255) { + printf FILE "op_%02x: equ &%04x\n", $_, $codeend-0x1000; + } + + print "Assembly error, creating dummy definitions!\n"; + exit; +} + +# Create hash from opcode to length +while (/OP_(..)_LEN': (\d+)/g) { + $len{hex $1} = $2; +} + +# Position in order of size, largest first +@todo = reverse sort { $len{$a} <=> $len{$b} } keys %len; + +my($size,$used) = (0,0); + +OPCODE: +foreach $op (@todo) +{ +MSB: + # Work up through MSB values until we find a space + for ($msb = 0 ; ; $msb++) + { + # Determine the extent of the opcode in the current MSB + my $start = ($msb << 8) | $op; + my $end = $start + $len{$op}-1; + + # Check against what we've already positioned + foreach (keys %off) + { + # Determine extent of existing item + my $start2 = $off{$_}; + my $end2 = $start2 + $len{$_}-1; + + # Reject MSB if new position would overlap + next MSB unless ($start > $end2 || $end < $start2); + } + + # Assign to the free spot we've found + $off{$op} = $start; + + # Update size stats + $used += $len{$op}; + if ($end > $size) { $size = $end; } + + next OPCODE; + } +} + +# Position base so code finishes at the required point +$base = $codeend - (($size + 0xff) & ~0xff); + +print "Size = $size, used = $used, slack = ", $size-$used, "\n"; + +# Output sorted list of calculated positions +foreach (sort { $a <=> $b } @todo) { + printf FILE "op_%02x: equ &%04x ; +$len{$_}\n", $_, $base+$off{$_}; +} + +close FILE; diff --git a/opimpl.inc b/opimpl.inc index 041e592..9edfafa 100644 --- a/opimpl.inc +++ b/opimpl.inc @@ -1,3544 +1,3544 @@ -; 65C02 instruction implementations -; -; NOTE: If you change this file, opdefs.inc must be rebuilt by running -; opdefs.pl (requires the pyz80 assembler) - -INC "opdefs.inc" - - org op_00 - dump $ -i_brk: inc de ; return to BRK+2 - - ex af,af' ; get C - inc c - dec c ; set N Z - push af ; save flags for below - ex af,af' ; save C - - ld a,d ; PCH - exx - ld (hl),a ; push return PCH - dec l ; S-- - exx - ld a,e ; PCL - exx - ld (hl),a ; push return PCL - dec l ; S-- - - pop bc ; Z80 flags in C - ld a,c - and %10000001 ; keep Z80 N and C - bit 6,c ; check Z80 Z - jr z,brk_nz - or %00000010 ; set Z -brk_nz: or e ; merge V - or d ; merge T B D I - or %00010000 ; set B (stack value only) - ld (hl),a ; push P - dec l ; S-- - - res 3,d ; clear D [65C02] - set 2,d ; set I (disable interrupts) - exx - ld de,(m6502_int) ; fetch interrupt handler - jp (ix) ; main_loop -op_00_len: equ $-op_00 - - - - org op_01 - dump $ -i_ora_ix: ld a,(de) ; ORA ($xx,X) - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - ld a,b ; A - or (hl) ; A|x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_01_len: equ $-op_01 - - - org op_02 - dump $ - jp i_undoc_1 -op_02_len: equ $-op_02 - - - org op_03 - dump $ - jp i_undoc_2 -op_03_len: equ $-op_03 - - - org op_04 - dump $ -i_tsb_z: ld a,(de) ; TSB $nn [65C02] - inc de - ld l,a - ld h,0 - ld c,(hl) ; x - ld a,c - or b ; x|A - ld (hl),a ; set mem - ld a,c - and b ; x&A - ld c,a ; set Z - jp (ix) ; zwrite_loop -op_04_len: equ $-op_04 - - - - org op_05 - dump $ -i_ora_z: ld a,(de) ; ORA $nn - inc de - ld l,a - ld h,0 - ld a,b ; A - or (hl) ; A|x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_05_len: equ $-op_05 - - - - org op_06 - dump $ -i_asl_z: ld a,(de) ; ASL $nn - inc de - ld l,a - ld h,0 - ex af,af' - sla (hl) ; x << 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_06_len: equ $-op_06 - - - - org op_07 - dump $ -i_rmb_0: ld a,(de) ; RMB0 [65C02] - inc de - ld l,a - ld h,0 - res 0,(hl) - jp (ix) ; zwrite_loop -op_07_len: equ $-op_07 - - - - org op_08 - dump $ -i_php: ex af,af' ; carry - inc c - dec c ; set N Z - push af ; save flags - ex af,af' ; protect carry - exx - pop bc - ld a,c - and %10000001 ; keep Z80 N and C - bit 6,c ; check Z80 Z - jr z,php_nz - or %00000010 ; set Z -php_nz: or e ; merge V - or d ; merge T D I - ld (hl),a - dec l ; S-- - exx - jp (ix) ; main_loop -op_08_len: equ $-op_08 - - - - org op_09 - dump $ -i_ora_i: ld h,d - ld l,e - inc de - ld a,b ; A - or (hl) ; A|x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_09_len: equ $-op_09 - - - - org op_0a - dump $ -i_asl_acc: ex af,af' - sla b ; A << 1 - ld c,b ; set N Z - ex af,af' ; set carry - jp (ix) ; main_loop -op_0a_len: equ $-op_0a - - - - org op_0b - dump $ - jp i_undoc_2 -op_0b_len: equ $-op_0b - - - - org op_0c - dump $ -i_tsb_a: ex de,hl ; TSB $nnnn [65C02] - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ld c,(hl) ; x - ld a,c - or b ; x|A - ld (hl),a ; set mem - ld a,c - and b ; x&A - ld c,a ; set Z - jp write_loop -op_0c_len: equ $-op_0c - - - - org op_0d - dump $ -i_ora_a: ex de,hl ; ORA $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ld a,b ; A - or (hl) ; A|x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_0d_len: equ $-op_0d - - - - org op_0e - dump $ -i_asl_a: ex de,hl ; ASL $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ex af,af' - sla (hl) ; x << 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_0e_len: equ $-op_0e - - - - org op_0f - dump $ -i_bbr_0: ld a,(de) ; BBR0 [65C02] - inc de - ld l,a - ld h,0 - bit 0,(hl) - jp z,i_bra ; ToDo: read after branch - inc de - jp (ix) ; zread_loop -op_0f_len: equ $-op_0f - - - - org op_10 - dump $ -i_bpl: inc c - dec c - jp p,i_bra ; branch if plus - inc de - jp (ix) ; main_loop -op_10_len: equ $-op_10 - - - - org op_11 - dump $ -i_ora_iy: ld a,(de) ; ORA ($nn),Y - inc de - ld l,a - ld h,0 - ld a,iyl ; Y - add a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,0 - adc a,h - ld h,a - ld a,b ; A - or (hl) ; A|x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_11_len: equ $-op_11 - - - - org op_12 - dump $ -i_ora_iz: ld a,(de) ; indirect zero-page [65C02] - inc de - ld l,a - ld h,0 - ld a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - ld a,b ; A - or (hl) ; A|x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_12_len: equ $-op_12 - - - - org op_13 - dump $ - jp i_undoc_2 -op_13_len: equ $-op_13 - - - - org op_14 - dump $ -i_trb_z: ld a,(de) ; TRB $nn [65C02] - inc de - ld l,a - ld h,0 - ld c,(hl) ; x - ld a,b ; A - cpl ; ~A - and c ; x&~A - ld (hl),a ; set mem - ld a,c - and b ; x&A - ld c,a ; set Z (N lost) - jp (ix) ; zwrite_loop -op_14_len: equ $-op_14 - - - - org op_15 - dump $ -i_ora_zx: ld a,(de) ; ORA $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld a,b ; A - or (hl) ; A|x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_15_len: equ $-op_15 - - - - org op_16 - dump $ -i_asl_zx: ld a,(de) ; ASL $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ex af,af' - sla (hl) ; x << 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_16_len: equ $-op_16 - - - - org op_17 - dump $ -i_rmb_1: ld a,(de) ; RMB1 [65C02] - inc de - ld l,a - ld h,0 - res 1,(hl) - jp (ix) ; zwrite_loop -op_17_len: equ $-op_17 - - - - org op_18 - dump $ -i_clc: and a ; clear C - ex af,af' ; save carry - jp (ix) ; main_loop -op_18_len: equ $-op_18 - - - - org op_19 - dump $ -i_ora_ay: ld a,(de) ; ORA $nnnn,Y - inc de - add a,iyl ; add Y - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ld a,b ; A - or (hl) ; A|x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_19_len: equ $-op_19 - - - - org op_1a - dump $ -i_inc_acc: inc b ; A++ [65C02] - ld c,b ; set N Z - jp (ix) ; main_loop -op_1a_len: equ $-op_1a - - - - org op_1b - dump $ - jp i_undoc_3 -op_1b_len: equ $-op_1b - - - - org op_1c - dump $ -i_trb_a: ex de,hl ; TRB $nnnn [65C02] - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ld c,(hl) ; x - ld a,b ; A - cpl ; ~A - and c ; x&~A - ld (hl),a ; set mem - ld a,c - and b ; x&A - ld c,a ; set Z (N lost) - jp write_loop -op_1c_len: equ $-op_1c - - - - org op_1d - dump $ -i_ora_ax: ld a,(de) ; ORA $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ld a,b ; A - or (hl) ; A|x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_1d_len: equ $-op_1d - - - - org op_1e - dump $ -i_asl_ax: ld a,(de) ; ASL $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ex af,af' - sla (hl) ; x << 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_1e_len: equ $-op_1e - - - - org op_1f - dump $ -i_bbr_1: ld a,(de) ; BBR1 [65C02] - inc de - ld l,a - ld h,0 - bit 1,(hl) - jp z,i_bra - inc de - jp (ix) ; main_loop -op_1f_len: equ $-op_1f - - - - org op_20 - dump $ -i_jsr: ex de,hl ; JSR nn - ld e,(hl) ; subroutine low - inc hl ; only 1 inc - we push ret-1 - ld d,(hl) ; subroutine high - ld a,h ; PCh - exx - ld (hl),a ; push ret-1 high byte - dec l ; S-- - exx - ld a,l ; PCl - exx - ld (hl),a ; push ret-1 low byte - dec l ; S-- - exx - jp (ix) ; main_loop -op_20_len: equ $-op_20 - - - - org op_21 - dump $ -i_and_ix: ld a,(de) ; AND ($xx,X) - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - ld a,b ; A - and (hl) ; A&x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_21_len: equ $-op_21 - - - - org op_22 - dump $ - jp i_undoc_1 -op_22_len: equ $-op_22 - - - org op_23 - dump $ - jp i_undoc_2 -op_23_len: equ $-op_23 - - - - org op_24 - dump $ -i_bit_z: ld a,(de) ; BIT $nn - inc de - ld l,a - ld h,0 -i_bit: ld c,(hl) ; set N - ld a,c - and %01000000 ; V flag from bit 6 of x - exx - ld e,a ; set V - exx - ld a,(de) ; next instruction - and %11011111 - cp &d0 ; BNE or BEQ next? - jr z,bit_z - jp (ix) ; main_loop ; use N flag -bit_z: ld a,b ; A - and c ; perform BIT test - ld c,a ; set Z - jp read_loop -op_24_len: equ $-op_24 - - - - org op_25 - dump $ -i_and_z: ld a,(de) ; AND $nn - inc de - ld l,a - ld h,0 - ld a,b ; A - and (hl) ; A&x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_25_len: equ $-op_25 - - - - org op_26 - dump $ -i_rol_z: ld a,(de) ; ROL $nn - inc de - ld l,a - ld h,0 - ex af,af' - rl (hl) ; x << 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_26_len: equ $-op_26 - - - - org op_27 - dump $ -i_rmb_2: ld a,(de) ; RMB2 [65C02] - inc de - ld l,a - ld h,0 - res 2,(hl) - jp (ix) ; zwrite_loop -op_27_len: equ $-op_27 - - - - org op_28 - dump $ -i_plp: exx - inc l ; S++ - ld a,(hl) ; pop P - ld c,a ; keep safe - and %00001100 ; keep D and I - or %00110000 ; force T and B - ld d,a ; set P - ld a,c - and %01000000 ; keep V - ld e,a ; set V - ld a,c - rra ; carry from C - ex af,af' ; set carry - ld a,c - and %10000010 ; keep N Z - xor %00000010 ; zero for Z - exx - ld c,a ; set N Z - jp (ix) ; main_loop -op_28_len: equ $-op_28 - - - - org op_29 - dump $ -i_and_i: ld h,d - ld l,e - inc de - ld a,b ; A - and (hl) ; A&x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_29_len: equ $-op_29 - - - - org op_2a - dump $ -i_rol_acc: ex af,af' - rl b - ld c,b ; set N Z - ex af,af' ; set carry - jp (ix) ; main_loop -op_2a_len: equ $-op_2a - - - org op_2b - dump $ - jp i_undoc_2 -op_2b_len: equ $-op_2b - - - - org op_2c - dump $ -i_bit_a: ex de,hl ; BIT $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - jp i_bit -op_2c_len: equ $-op_2c - - - - org op_2d - dump $ -i_and_a: ex de,hl ; AND $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ld a,b ; A - and (hl) ; A&x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_2d_len: equ $-op_2d - - - - org op_2e - dump $ -i_rol_a: ex de,hl ; ROL $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ex af,af' - rl (hl) ; x << 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_2e_len: equ $-op_2e - - - - org op_2f - dump $ -i_bbr_2: ld a,(de) ; BBR2 [65C02] - inc de - ld l,a - ld h,0 - bit 2,(hl) - jp z,i_bra - inc de - jp (ix) ; zread_loop -op_2f_len: equ $-op_2f - - - - org op_30 - dump $ -i_bmi: inc c - dec c - jp m,i_bra ; branch if minus - inc de - jp (ix) ; main_loop -op_30_len: equ $-op_30 - - - - org op_31 - dump $ -i_and_iy: ld a,(de) ; AND ($nn),Y - inc de - ld l,a - ld h,0 - ld a,iyl ; Y - add a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,0 - adc a,h - ld h,a - ld a,b ; A - and (hl) ; A&x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_31_len: equ $-op_31 - - - - org op_32 - dump $ -i_and_iz: ld a,(de) ; indirect zero-page [65C02] - inc de - ld l,a - ld h,0 - ld a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - ld a,b ; A - and (hl) ; A&x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_32_len: equ $-op_32 - - - - org op_33 - dump $ - jp i_undoc_2 -op_33_len: equ $-op_33 - - - - org op_34 - dump $ -i_bit_zx: ld a,(de) ; BIT $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - jp i_bit -op_34_len: equ $-op_34 - - - - org op_35 - dump $ -i_and_zx: ld a,(de) ; AND $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld a,b ; A - and (hl) ; A&x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_35_len: equ $-op_35 - - - - org op_36 - dump $ -i_rol_zx: ld a,(de) ; ROL $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ex af,af' - rl (hl) ; x << 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_36_len: equ $-op_36 - - - - org op_37 - dump $ -i_rmb_3: ld a,(de) ; RMB3 [65C02] - inc de - ld l,a - ld h,0 - res 3,(hl) - jp (ix) ; zwrite_loop -op_37_len: equ $-op_37 - - - - org op_38 - dump $ -i_sec: scf ; set C - ex af,af' ; save carry - jp (ix) ; main_loop -op_38_len: equ $-op_38 - - - - org op_39 - dump $ -i_and_ay: ld a,(de) ; AND $nnnn,Y - inc de - add a,iyl ; add Y - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ld a,b ; A - and (hl) ; A&x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_39_len: equ $-op_39 - - - - org op_3a - dump $ -i_dec_acc: dec b ; A-- [65C02] - ld c,b ; set N Z - jp (ix) ; main_loop -op_3a_len: equ $-op_3a - - - - org op_3b - dump $ - jp i_undoc_3 -op_3b_len: equ $-op_3b - - - - org op_3c - dump $ -i_bit_ax: ld a,(de) ; BIT $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - jp i_bit -op_3c_len: equ $-op_3c - - - - org op_3d - dump $ -i_and_ax: ld a,(de) ; AND $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ld a,b ; A - and (hl) ; A&x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_3d_len: equ $-op_3d - - - - org op_3e - dump $ -i_rol_ax: ld a,(de) ; ROL $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ex af,af' - rl (hl) ; x << 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_3e_len: equ $-op_3e - - - - org op_3f - dump $ -i_bbr_3: ld a,(de) ; BBR3 [65C02] - inc de - ld l,a - ld h,0 - bit 3,(hl) - jp z,i_bra - inc de - jp (ix) ; zread_loop -op_3f_len: equ $-op_3f - - - - org op_40 - dump $ -i_rti: exx - inc l ; S++ - ld a,(hl) ; pop P - ld c,a ; keep safe - and %00001100 ; keep D and I - or %00110000 ; force T and B - ld d,a ; set P - ld a,c - and %01000000 ; keep V - ld e,a ; set V - ld a,c - rra ; carry from C - ex af,af' ; set carry - ld a,c - and %10000010 ; keep N Z - xor %00000010 ; zero for Z - exx - ld c,a ; set N Z - exx - inc l ; S++ - ld a,(hl) ; pop return LSB - exx - ld e,a ; PCL - exx - inc l ; S++ - ld a,(hl) ; pop return MSB - exx - ld d,a ; PCH - jp (ix) ; main_loop -op_40_len: equ $-op_40 - - - - org op_41 - dump $ -i_eor_ix: ld a,(de) ; EOR ($xx,X) - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - ld a,b ; A - xor (hl) ; A^x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_41_len: equ $-op_41 - - - - org op_42 - dump $ - jp i_undoc_1 -op_42_len: equ $-op_42 - - - - org op_43 - dump $ - jp i_undoc_2 -op_43_len: equ $-op_43 - - - - org op_44 - dump $ - jp i_undoc_2 -op_44_len: equ $-op_44 - - - - org op_45 - dump $ -i_eor_z: ld a,(de) ; EOR $nn - inc de - ld l,a - ld h,0 - ld a,b ; A - xor (hl) ; A^x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_45_len: equ $-op_45 - - - - org op_46 - dump $ -i_lsr_z: ld a,(de) ; LSR $nn - inc de - ld l,a - ld h,0 - ex af,af' - srl (hl) ; x >> 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_46_len: equ $-op_46 - - - - org op_47 - dump $ -i_rmb_4: ld a,(de) ; RMB4 [65C02] - inc de - ld l,a - ld h,0 - res 4,(hl) - jp (ix) ; zwrite_loop -op_47_len: equ $-op_47 - - - - org op_48 - dump $ -i_pha: ld a,b ; A - exx - ld (hl),a ; push A - dec l ; S-- - exx - jp (ix) ; main_loop -op_48_len: equ $-op_48 - - - - org op_49 - dump $ -i_eor_i: ld h,d - ld l,e - inc de - ld a,b ; A - xor (hl) ; A^x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_49_len: equ $-op_49 - - - - org op_4a - dump $ -i_lsr_acc: ex af,af' - srl b ; A >> 1 - ld c,b ; set N Z - ex af,af' ; set carry - jp (ix) ; main_loop -op_4a_len: equ $-op_4a - - - - org op_4b - dump $ - jp i_undoc_2 -op_4b_len: equ $-op_4b - - - - org op_4c - dump $ -i_jmp_a: ex de,hl ; JMP nn - ld e,(hl) - inc hl - ld d,(hl) - jp (ix) ; main_loop -op_4c_len: equ $-op_4c - - - - org op_4d - dump $ -i_eor_a: ex de,hl ; EOR $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ld a,b ; A - xor (hl) ; A^x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_4d_len: equ $-op_4d - - - - org op_4e - dump $ -i_lsr_a: ex de,hl ; LSR $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ex af,af' - srl (hl) ; x >> 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_4e_len: equ $-op_4e - - - - org op_4f - dump $ -i_bbr_4: ld a,(de) ; BBR4 [65C02] - inc de - ld l,a - ld h,0 - bit 4,(hl) - jp z,i_bra - inc de - jp (ix) ; zread_loop -op_4f_len: equ $-op_4f - - - - org op_50 - dump $ -i_bvc: exx - bit 6,e - exx - jp z,i_bra ; branch if V clear - inc de - jp (ix) ; main_loop -op_50_len: equ $-op_50 - - - - org op_51 - dump $ -i_eor_iy: ld a,(de) ; EOR ($nn),Y - inc de - ld l,a - ld h,0 - ld a,iyl ; Y - add a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,0 - adc a,h - ld h,a - ld a,b ; A - xor (hl) ; A^x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_51_len: equ $-op_51 - - - - org op_52 - dump $ -i_eor_iz: ld a,(de) ; indirect zero-page [65C02] - inc de - ld l,a - ld h,0 - ld a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - ld a,b ; A - xor (hl) ; A^x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_52_len: equ $-op_52 - - - - org op_53 - dump $ - jp i_undoc_2 -op_53_len: equ $-op_53 - - - - org op_54 - dump $ - jp i_undoc_2 -op_54_len: equ $-op_54 - - - - org op_55 - dump $ -i_eor_zx: ld a,(de) ; EOR $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld a,b ; A - xor (hl) ; A^x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_55_len: equ $-op_55 - - - - org op_56 - dump $ -i_lsr_zx: ld a,(de) ; LSR $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ex af,af' - srl (hl) ; x >> 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_56_len: equ $-op_56 - - - - org op_57 - dump $ -i_rmb_5: ld a,(de) ; RMB5 [65C02] - inc de - ld l,a - ld h,0 - res 5,(hl) - jp (ix) ; zwrite_loop -op_57_len: equ $-op_57 - - - - org op_58 - dump $ -i_cli: exx - res 2,d ; clear I (enable interrupts) - exx - jp (ix) ; main_loop -op_58_len: equ $-op_58 - - - - org op_59 - dump $ -i_eor_ay: ld a,(de) ; EOR $nnnn,Y - inc de - add a,iyl ; add Y - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ld a,b ; A - xor (hl) ; A^x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_59_len: equ $-op_59 - - - - org op_5a - dump $ -i_phy: ld a,iyl ; PHY [65C02] - exx - ld (hl),a ; push Y - dec l ; S-- - exx - jp (ix) ; main_loop -op_5a_len: equ $-op_5a - - - - org op_5b - dump $ - jp i_undoc_3 -op_5b_len: equ $-op_5b - - - - org op_5c - dump $ - jp i_undoc_3 -op_5c_len: equ $-op_5c - - - - org op_5d - dump $ -i_eor_ax: ld a,(de) ; EOR $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ld a,b ; A - xor (hl) ; A^x - ld b,a ; set A - ld c,a ; set N Z - jp read_loop -op_5d_len: equ $-op_5d - - - - org op_5e - dump $ -i_lsr_ax: ld a,(de) ; LSR $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ex af,af' - srl (hl) ; x >> 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_5e_len: equ $-op_5e - - - - org op_5f - dump $ -i_bbr_5: ld a,(de) ; BBR5 [65C02] - inc de - ld l,a - ld h,0 - bit 5,(hl) - jp z,i_bra - inc de - jp (ix) ; zread_loop -op_5f_len: equ $-op_5f - - - - org op_60 - dump $ -i_rts: exx ; RTS - inc l ; S++ - ld a,(hl) ; PC LSB - exx - ld e,a - exx - inc l ; S++ - ld a,(hl) ; PC MSB - exx - ld d,a - inc de ; PC++ (strange but true) - jp (ix) ; main_loop -op_60_len: equ $-op_60 - - - - org op_61 - dump $ -i_adc_ix: ld a,(de) ; ADX ($xx,X) - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - jp i_adc -op_61_len: equ $-op_61 - - - - org op_62 - dump $ - jp i_undoc_1 -op_62_len: equ $-op_62 - - - - org op_63 - dump $ - jp i_undoc_2 -op_63_len: equ $-op_63 - - - - org op_64 - dump $ -i_stz_z: ld a,(de) ; STZ $nn [65C02] - inc de - ld l,a - ld h,0 - ld (hl),h - jp (ix) ; zwrite_loop -op_64_len: equ $-op_64 - - - - org op_65 - dump $ -i_adc_z: ld a,(de) ; ADC $nn - inc de - ld l,a - ld h,0 - jp i_adc -op_65_len: equ $-op_65 - - - - org op_66 - dump $ -i_ror_z: ld a,(de) ; ROR $nn - inc de - ld l,a - ld h,0 - ex af,af' - rr (hl) ; x >> 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_66_len: equ $-op_66 - - - - org op_67 - dump $ -i_rmb_6: ld a,(de) ; RMB6 [65C02] - inc de - ld l,a - ld h,0 - res 6,(hl) - jp (ix) ; zwrite_loop -op_67_len: equ $-op_67 - - - - org op_68 - dump $ -i_pla: exx - inc l ; S++ - ld a,(hl) ; pop A - exx - ld b,a ; set A - ld c,a ; set N Z - jp (ix) ; main_loop -op_68_len: equ $-op_68 - - - - org op_69 - dump $ -i_adc_i: ld h,d - ld l,e - inc de -i_adc: ex af,af' ; carry - ld a,b ; A - adc a,(hl) ; A+M+C -adc_daa: nop - ld b,a ; set A - ld c,a ; set N Z - exx - jp pe,adcsbc_v - ld e,%00000000 - exx - ex af,af' ; set carry - jp read_loop -adcsbc_v: ld e,%01000000 - exx - ex af,af' ; set carry - jp read_loop -op_69_len: equ $-op_69 - - - - org op_6a - dump $ -i_ror_acc: ex af,af' - rr b - ld c,b ; set N Z - ex af,af' ; set carry - jp (ix) ; main_loop -op_6a_len: equ $-op_6a - - - - org op_6b - dump $ - jp i_undoc_2 -op_6b_len: equ $-op_6b - - - - org op_6c - dump $ -i_jmp_i: ex de,hl ; JMP (nn) - ld e,(hl) - inc hl - ld d,(hl) - ex de,hl - ld e,(hl) -; inc l ; 6502 bug wraps within page, *OR* - inc hl ; 65C02 spans pages correctly - ld d,(hl) - jp (ix) ; main_loop -op_6c_len: equ $-op_6c - - - - org op_6d - dump $ -i_adc_a: ex de,hl ; ADC $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - jp i_adc -op_6d_len: equ $-op_6d - - - - org op_6e - dump $ -i_ror_a: ex de,hl ; ROR $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ex af,af' - rr (hl) ; x >> 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_6e_len: equ $-op_6e - - - - org op_6f - dump $ -i_bbr_6: ld a,(de) ; BBR6 [65C02] - inc de - ld l,a - ld h,0 - bit 6,(hl) - jp z,i_bra - inc de - jp (ix) ; zread_loop -op_6f_len: equ $-op_6f - - - - org op_70 - dump $ -i_bvs: exx - bit 6,e - exx - jp nz,i_bra ; branch if V set - inc de - jp (ix) ; main_loop -op_70_len: equ $-op_70 - - - - org op_71 - dump $ -i_adc_iy: ld a,(de) ; ADC ($nn),Y - inc de - ld l,a - ld h,0 - ld a,iyl ; Y - add a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,0 - adc a,h - ld h,a - jp i_adc -op_71_len: equ $-op_71 - - - - org op_72 - dump $ -i_adc_iz: ld a,(de) ; indirect zero-page [65C02] - inc de - ld l,a - ld h,0 - ld a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - jp i_adc -op_72_len: equ $-op_72 - - - - org op_73 - dump $ - jp i_undoc_2 -op_73_len: equ $-op_73 - - - - org op_74 - dump $ -i_stz_zx: ld a,(de) ; STZ $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld (hl),h - jp (ix) ; zwrite_loop -op_74_len: equ $-op_74 - - - - org op_75 - dump $ -i_adc_zx: ld a,(de) ; ADC $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - jp i_adc -op_75_len: equ $-op_75 - - - - org op_76 - dump $ -i_ror_zx: ld a,(de) ; ROR $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ex af,af' - rr (hl) ; x >> 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_76_len: equ $-op_76 - - - - org op_77 - dump $ -i_rmb_7: ld a,(de) ; RMB7 [65C02] - inc de - ld l,a - ld h,0 - res 7,(hl) - jp (ix) ; zwrite_loop -op_77_len: equ $-op_77 - - - - org op_78 - dump $ -i_sei: exx - set 2,d ; set I (disable interrupts) - exx - jp (ix) ; main_loop -op_78_len: equ $-op_78 - - - - org op_79 - dump $ -i_adc_ay: ld a,(de) ; ADC $nnnn,Y - inc de - add a,iyl ; add Y - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - jp i_adc -op_79_len: equ $-op_79 - - - - org op_7a - dump $ -i_ply: exx ; PLY [65C02] - inc l ; S++ - ld a,(hl) ; pop - exx - ld iyl,a ; set Y - ld c,a ; set N Z - jp (ix) ; main_loop -op_7a_len: equ $-op_7a - - - - org op_7b - dump $ - jp i_undoc_3 -op_7b_len: equ $-op_7b - - - - org op_7c - dump $ -i_jmp_ax: ld a,(de) ; JMP (nn,X) [65C02] - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 ; carry spans page - ld h,a - ld e,(hl) - inc hl - ld d,(hl) - jp (ix) ; main_loop -op_7c_len: equ $-op_7c - - - - org op_7d - dump $ -i_adc_ax: ld a,(de) ; ADC $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - jp i_adc -op_7d_len: equ $-op_7d - - - - org op_7e - dump $ -i_ror_ax: ld a,(de) ; ROR $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ex af,af' - rr (hl) ; x >> 1 - ld c,(hl) ; set N Z - ex af,af' ; set carry - jp write_loop -op_7e_len: equ $-op_7e - - - - org op_7f - dump $ -i_bbr_7: ld a,(de) ; BBR7 [65C02] - inc de - ld l,a - ld h,0 - bit 7,(hl) - jp z,i_bra - inc de - jp (ix) ; zread_loop -op_7f_len: equ $-op_7f - - - - org op_80 - dump $ -i_bra: ld a,(de) ; BRA [65C02] - inc de - ld l,a ; offset low - rla ; set carry with sign - sbc a,a ; form high byte for offset - ld h,a - add hl,de ; PC=PC+e - ex de,hl - jp (ix) ; main_loop -i_bra_ex: ex af,af' ; preseve C before branch - ld a,(de) - inc de - ld l,a ; offset low - rla ; set carry with sign - sbc a,a ; form high byte for offset - ld h,a - add hl,de ; PC=PC+e - ex de,hl - jp (ix) ; main_loop -op_80_len: equ $-op_80 - - - - org op_81 - dump $ -i_sta_ix: ld a,(de) ; STA ($xx,X) - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - ld (hl),b ; store A - jp (ix) ; zwrite_loop -op_81_len: equ $-op_81 - - - - org op_82 - dump $ - jp i_undoc_2 -op_82_len: equ $-op_82 - - - - org op_83 - dump $ - jp i_undoc_2 -op_83_len: equ $-op_83 - - - - org op_84 - dump $ -i_sty_z: ld a,(de) ; STY $nn - inc de - ld l,a - ld h,0 - ld a,iyl ; Y - ld (hl),a - jp (ix) ; zwrite_loop -op_84_len: equ $-op_84 - - - - org op_85 - dump $ -i_sta_z: ld a,(de) ; STA $nn - inc de - ld l,a - ld h,0 - ld (hl),b ; store A - jp (ix) ; zwrite_loop -op_85_len: equ $-op_85 - - - - org op_86 - dump $ -i_stx_z: ld a,(de) ; STX $nn - inc de - ld l,a - ld h,0 - ld a,iyh ; X - ld (hl),a - jp (ix) ; zwrite_loop -op_86_len: equ $-op_86 - - - - org op_87 - dump $ -i_smb_0: ld a,(de) ; SMB0 [65C02] - inc de - ld l,a - ld h,0 - set 0,(hl) - jp (ix) ; zwrite_loop -op_87_len: equ $-op_87 - - - - org op_88 - dump $ -i_dey: dec iyl ; Y-- - ld c,iyl ; set N Z - jp (ix) ; main_loop -op_88_len: equ $-op_88 - - - - org op_89 - dump $ -i_bit_i: ld a,(de) ; BIT #$nn - inc de - and b ; BIT test against A - ld c,a ; set Z - jp read_loop -op_89_len: equ $-op_89 - - - - org op_8a - dump $ -i_txa: ld b,iyh ; A=X - ld c,b ; set N Z - jp (ix) ; main_loop -op_8a_len: equ $-op_8a - - - - org op_8b - dump $ - jp i_undoc_2 -op_8b_len: equ $-op_8b - - - - org op_8c - dump $ -i_sty_a: ex de,hl ; STY $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ld a,iyl ; Y - ld (hl),a - jp write_loop -op_8c_len: equ $-op_8c - - - - org op_8d - dump $ -i_sta_a: ex de,hl ; STA $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ld (hl),b ; store A - jp write_loop -op_8d_len: equ $-op_8d - - - - org op_8e - dump $ -i_stx_a: ex de,hl ; STX $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ld a,iyh ; X - ld (hl),a - jp write_loop -op_8e_len: equ $-op_8e - - - - org op_8f - dump $ -i_bbs_0: ld a,(de) ; BBS0 [65C02] - inc de - ld l,a - ld h,0 - bit 0,(hl) - jp nz,i_bra ; ToDo: read after branch - inc de - jp (ix) ; zread_loop -op_8f_len: equ $-op_8f - - - - org op_90 - dump $ -i_bcc: ex af,af' - jp nc,i_bra_ex ; branch if C clear - ex af,af' - inc de - jp (ix) ; main_loop -op_90_len: equ $-op_90 - - - - org op_91 - dump $ -i_sta_iy: ld a,(de) ; STA ($nn),Y - inc de - ld l,a - ld h,0 - ld a,iyl ; Y - add a,(hl) - inc l - ld h,(hl) - ld l,a - ld a,0 - adc a,h - ld h,a - ld (hl),b ; store A - jp write_loop -op_91_len: equ $-op_91 - - - - org op_92 - dump $ -i_sta_iz: ld a,(de) ; STA ($nn) [65C02] - inc de - ld l,a - ld h,0 - ld a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - ld (hl),b ; store A - jp write_loop -op_92_len: equ $-op_92 - - - - org op_93 - dump $ - jp i_undoc_2 -op_93_len: equ $-op_93 - - - - org op_94 - dump $ -i_sty_zx: ld a,(de) ; STY $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld a,iyl ; Y - ld (hl),a - jp (ix) ; zwrite_loop -op_94_len: equ $-op_94 - - - - org op_95 - dump $ -i_sta_zx: ld a,(de) ; STA $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld (hl),b ; store A - jp (ix) ; zwrite_loop -op_95_len: equ $-op_95 - - - - org op_96 - dump $ -i_stx_zy: ld a,(de) ; STX $nn,Y - inc de - add a,iyl ; add Y (may wrap in zero page) - ld l,a - ld h,0 - ld a,iyh ; X - ld (hl),a - jp (ix) ; zwrite_loop -op_96_len: equ $-op_96 - - - - org op_97 - dump $ -i_smb_1: ld a,(de) ; SMB1 [65C02] - inc de - ld l,a - ld h,0 - set 1,(hl) - jp (ix) ; zwrite_loop -op_97_len: equ $-op_97 - - - - org op_98 - dump $ -i_tya: ld b,iyl ; A=Y - ld c,b ; set N Z - jp (ix) ; main_loop -op_98_len: equ $-op_98 - - - - org op_99 - dump $ -i_sta_ay: ld a,(de) ; STA $nnnn,Y - inc de - add a,iyl ; add Y - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ld (hl),b ; store A - jp write_loop -op_99_len: equ $-op_99 - - - - org op_9a - dump $ -i_txs: ld a,iyh ; X - exx - ld l,a ; set S (no flags set) - exx - jp (ix) ; main_loop -op_9a_len: equ $-op_9a - - - - org op_9b - dump $ - jp i_undoc_2 -op_9b_len: equ $-op_9b - - - - org op_9c - dump $ -i_stz_a: ex de,hl ; STZ $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ld (hl),0 - jp write_loop -op_9c_len: equ $-op_9c - - - - org op_9d - dump $ -i_sta_ax: ld a,(de) ; STA $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ld (hl),b ; store A - jp write_loop -op_9d_len: equ $-op_9d - - - - org op_9e - dump $ -i_stz_ax: ld a,(de) ; STZ $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ld (hl),0 - jp write_loop -op_9e_len: equ $-op_9e - - - - org op_9f - dump $ -i_bbs_1: ld a,(de) ; BBS1 [65C02] - inc de - ld l,a - ld h,0 - bit 1,(hl) - jp nz,i_bra - inc de - jp (ix) ; zread_loop -op_9f_len: equ $-op_9f - - - - org op_a0 - dump $ -i_ldy_i: ld a,(de) ; LDY #$nn - inc de - ld c,a ; set N Z - ld iyl,c ; set Y - jp (ix) ; main_loop -op_a0_len: equ $-op_a0 - - - - org op_a1 - dump $ -i_lda_ix: ld a,(de) ; LDA ($nn,X) - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - ld b,(hl) ; set A - ld c,b ; set N Z - jp (ix) ; zread_loop -op_a1_len: equ $-op_a1 - - - - org op_a2 - dump $ -i_ldx_i: ld a,(de) ; LDX #$nn - inc de - ld iyh,a ; set X - ld c,a ; set N Z - jp (ix) ; main_loop -op_a2_len: equ $-op_a2 - - - - org op_a3 - dump $ - jp i_undoc_2 -op_a3_len: equ $-op_a3 - - - - org op_a4 - dump $ -i_ldy_z: ld a,(de) ; LDY $nn - inc de - ld l,a - ld h,0 - ld c,(hl) ; set N Z - ld iyl,c ; set Y - jp (ix) ; zread_loop -op_a4_len: equ $-op_a4 - - - - org op_a5 - dump $ -i_lda_z: ld a,(de) ; LDA $nn - inc de - ld l,a - ld h,0 - ld b,(hl) ; set A - ld c,b ; set N Z - jp (ix) ; zread_loop -op_a5_len: equ $-op_a5 - - - - org op_a6 - dump $ -i_ldx_z: ld a,(de) ; LDX $nn - inc de - ld l,a - ld h,0 - ld c,(hl) ; set N Z - ld iyh,c ; set X - jp (ix) ; zread_loop -op_a6_len: equ $-op_a6 - - - - org op_a7 - dump $ -i_smb_2: ld a,(de) ; SMB2 [65C02] - inc de - ld l,a - ld h,0 - set 2,(hl) - jp (ix) ; zwrite_loop -op_a7_len: equ $-op_a7 - - - - org op_a8 - dump $ -i_tay: ld iyl,b ; Y=A - ld c,b ; set N Z - jp (ix) ; main_loop -op_a8_len: equ $-op_a8 - - - - org op_a9 - dump $ -i_lda_i: ld a,(de) ; LDA #$nn - inc de - ld b,a ; set A - ld c,b ; set N Z - jp (ix) ; main_loop -op_a9_len: equ $-op_a9 - - - - org op_aa - dump $ -i_tax: ld iyh,b ; X=A - ld c,b ; set N Z - jp (ix) ; main_loop -op_aa_len: equ $-op_aa - - - - org op_ab - dump $ - jp i_undoc_2 -op_ab_len: equ $-op_ab - - - - org op_ac - dump $ -i_ldy_a: ex de,hl ; LDY $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ld c,(hl) ; set N Z - ld iyl,c ; set Y - jp read_loop -op_ac_len: equ $-op_ac - - - - org op_ad - dump $ -i_lda_a: ex de,hl ; LDA $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ld b,(hl) ; set A - ld c,b ; set N Z - jp read_loop -op_ad_len: equ $-op_ad - - - - org op_ae - dump $ -i_ldx_a: ex de,hl ; LDX $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ld c,(hl) ; set N Z - ld iyh,c ; set X - jp read_loop -op_ae_len: equ $-op_ae - - - - org op_af - dump $ -i_bbs_2: ld a,(de) ; BBS2 [65C02] - inc de - ld l,a - ld h,0 - bit 2,(hl) - jp nz,i_bra - inc de - jp (ix) ; zread_loop -op_af_len: equ $-op_af - - - - org op_b0 - dump $ -i_bcs: ex af,af' - jp c,i_bra_ex ; branch if C set - ex af,af' - inc de - jp (ix) ; main_loop -op_b0_len: equ $-op_b0 - - - - org op_b1 - dump $ -i_lda_iy: ld a,(de) ; LDA ($nn),Y - inc de - ld l,a - ld h,0 - ld a,iyl ; Y - add a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,0 - adc a,h - ld h,a - ld b,(hl) ; set A - ld c,b ; set N Z - jp read_loop -op_b1_len: equ $-op_b1 - - - - org op_b2 - dump $ -i_lda_iz: ld a,(de) ; LDA ($nn) [65C02] - inc de - ld l,a - ld h,0 - ld a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - ld b,(hl) ; set A - ld c,b ; set N Z - jp read_loop -op_b2_len: equ $-op_b2 - - - - org op_b3 - dump $ - jp i_undoc_2 -op_b3_len: equ $-op_b3 - - - - org op_b4 - dump $ -i_ldy_zx: ld a,(de) ; LDY $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld c,(hl) ; set N Z - ld iyl,c ; set Y - jp (ix) ; zread_loop -op_b4_len: equ $-op_b4 - - - - org op_b5 - dump $ -i_lda_zx: ld a,(de) ; LDA $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld b,(hl) ; set A - ld c,b ; set N Z - jp (ix) ; zread_loop -op_b5_len: equ $-op_b5 - - - - org op_b6 - dump $ -i_ldx_zy: ld a,(de) ; LDX $nn,Y - inc de - add a,iyl ; add Y (may wrap in zero page) - ld l,a - ld h,0 - ld c,(hl) ; set N Z - ld iyh,c ; set X - jp (ix) ; zread_loop -op_b6_len: equ $-op_b6 - - - - org op_b7 - dump $ -i_smb_3: ld a,(de) ; SMB3 [65C02] - inc de - ld l,a - ld h,0 - set 3,(hl) - jp (ix) ; zwrite_loop -op_b7_len: equ $-op_b7 - - - - org op_b8 - dump $ -i_clv: exx ; clear overflow - ld e,0 - exx - jp (ix) ; main_loop -op_b8_len: equ $-op_b8 - - - - org op_b9 - dump $ -i_lda_ay: ld a,(de) ; LDA $nnnn,Y - inc de - add a,iyl ; add Y - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ld b,(hl) ; set A - ld c,b ; set N Z - jp read_loop -op_b9_len: equ $-op_b9 - - - - org op_ba - dump $ -i_tsx: exx - ld a,l ; S - exx - ld iyh,a ; X=S - ld c,a ; set N Z - jp (ix) ; main_loop -op_ba_len: equ $-op_ba - - - - org op_bb - dump $ - jp i_undoc_3 -op_bb_len: equ $-op_bb - - - - org op_bc - dump $ -i_ldy_ax: ld a,(de) ; LDY $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ld c,(hl) ; set N Z - ld iyl,c ; set Y - jp read_loop -op_bc_len: equ $-op_bc - - - - org op_bd - dump $ -i_lda_ax: ld a,(de) ; LDA $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ld b,(hl) ; set A - ld c,b ; set N Z - jp read_loop -op_bd_len: equ $-op_bd - - - - org op_be - dump $ -i_ldx_ay: ld a,(de) ; LDX $nnnn,Y - inc de - add a,iyl ; add Y - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ld c,(hl) ; set N Z - ld iyh,c ; set X - jp read_loop -op_be_len: equ $-op_be - - - - org op_bf - dump $ -i_bbs_3: ld a,(de) ; BBS3 [65C02] - inc de - ld l,a - ld h,0 - bit 3,(hl) - jp nz,i_bra - inc de - jp (ix) ; zread_loop -op_bf_len: equ $-op_bf - - - - org op_c0 - dump $ -i_cpy_i: ld h,d - ld l,e - inc de - ex af,af' ; carry - ld a,iyl ; Y - sub (hl) ; Y-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_c0_len: equ $-op_c0 - - - - org op_c1 - dump $ -i_cmp_ix: ld a,(de) ; CMP ($xx,X) - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - ex af,af' ; carry - ld a,b ; A - sub (hl) ; A-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_c1_len: equ $-op_c1 - - - - org op_c2 - dump $ - jp i_undoc_2 -op_c2_len: equ $-op_c2 - - - - org op_c3 - dump $ - jp i_undoc_2 -op_c3_len: equ $-op_c3 - - - - org op_c4 - dump $ -i_cpy_z: ld a,(de) ; CPY $nn - inc de - ld l,a - ld h,0 - ex af,af' ; carry - ld a,iyl ; Y - sub (hl) ; Y-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_c4_len: equ $-op_c4 - - - - org op_c5 - dump $ -i_cmp_z: ld a,(de) ; CMP $nn - inc de - ld l,a - ld h,0 - ex af,af' ; carry - ld a,b ; A - sub (hl) ; A-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_c5_len: equ $-op_c5 - - - - org op_c6 - dump $ -i_dec_z: ld a,(de) ; DEC $nn - inc de - ld l,a - ld h,0 - dec (hl) ; zero-page-- - ld c,(hl) ; set N Z - jp (ix) ; zread_write_loop -op_c6_len: equ $-op_c6 - - - - org op_c7 - dump $ -i_smb_4: ld a,(de) ; SMB4 [65C02] - inc de - ld l,a - ld h,0 - set 4,(hl) - jp (ix) ; zwrite_loop -op_c7_len: equ $-op_c7 - - - - org op_c8 - dump $ -i_iny: inc iyl ; Y++ - ld c,iyl ; set N Z - jp (ix) ; main_loop -op_c8_len: equ $-op_c8 - - - - org op_c9 - dump $ -i_cmp_i: ld h,d - ld l,e - inc de - ex af,af' ; carry - ld a,b ; A - sub (hl) ; A-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_c9_len: equ $-op_c9 - - - - org op_ca - dump $ -i_dex: dec iyh ; X-- - ld c,iyh ; set N Z - jp (ix) ; main_loop -op_ca_len: equ $-op_ca - - - - org op_cb - dump $ -i_wai: dec de ; WAI [65C02] - jp (ix) ; main_loop -op_cb_len: equ $-op_cb - - - - org op_cc - dump $ -i_cpy_a: ex de,hl ; CPY $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ex af,af' ; carry - ld a,iyl ; Y - sub (hl) ; Y-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_cc_len: equ $-op_cc - - - - org op_cd - dump $ -i_cmp_a: ex de,hl ; CMP $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ex af,af' ; carry - ld a,b ; A - sub (hl) ; A-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_cd_len: equ $-op_cd - - - - org op_ce - dump $ -i_dec_a: ex de,hl ; DEC $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - dec (hl) ; mem-- - ld c,(hl) ; set N Z - jp read_write_loop -op_ce_len: equ $-op_ce - - - - org op_cf - dump $ -i_bbs_4: ld a,(de) ; BBS4 [65C02] - inc de - ld l,a - ld h,0 - bit 4,(hl) - jp nz,i_bra - inc de - jp (ix) ; zread_loop -op_cf_len: equ $-op_cf - - - - org op_d0 - dump $ -i_bne: inc c - dec c - jp nz,i_bra ; branch if not zero - inc de - jp (ix) ; main_loop -op_d0_len: equ $-op_d0 - - - - org op_d1 - dump $ -i_cmp_iy: ld a,(de) ; CMP ($nn),Y - inc de - ld l,a - ld h,0 - ld a,iyl ; Y - add a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,0 - adc a,h - ld h,a - ex af,af' ; carry - ld a,b ; A - sub (hl) ; A-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_d1_len: equ $-op_d1 - - - - org op_d2 - dump $ -i_cmp_iz: ld a,(de) ; indirect zero-page [65C02] - inc de - ld l,a - ld h,0 - ld a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - ex af,af' ; carry - ld a,b ; A - sub (hl) ; A-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_d2_len: equ $-op_d2 - - - - org op_d3 - dump $ - jp i_undoc_2 -op_d3_len: equ $-op_d3 - - - - org op_d4 - dump $ - jp i_undoc_2 -op_d4_len: equ $-op_d4 - - - - org op_d5 - dump $ -i_cmp_zx: ld a,(de) ; CMP $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ex af,af' ; carry - ld a,b ; A - sub (hl) ; A-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_d5_len: equ $-op_d5 - - - - org op_d6 - dump $ -i_dec_zx: ld a,(de) ; DEC $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - dec (hl) ; zero-page-- - ld c,(hl) ; set N Z - jp (ix) ; zread_write_loop -op_d6_len: equ $-op_d6 - - - - org op_d7 - dump $ -i_smb_5: ld a,(de) ; SMB5 [65C02] - inc de - ld l,a - ld h,0 - set 5,(hl) - jp (ix) ; zwrite_loop -op_d7_len: equ $-op_d7 - - - - org op_d8 - dump $ -i_cld: exx - res 3,d ; clear D - exx - xor a ; NOP - ld (adc_daa),a ; use binary mode for adc - ld (sbc_daa),a ; use binary mode for sbc - jp (ix) ; main_loop -op_d8_len: equ $-op_d8 - - - - org op_d9 - dump $ -i_cmp_ay: ld a,(de) ; CMP $nnnn,Y - inc de - add a,iyl ; add Y - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ex af,af' ; carry - ld a,b ; A - sub (hl) ; A-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_d9_len: equ $-op_d9 - - - - org op_da - dump $ -i_phx: ld a,iyh ; PHX [65C02] - exx - ld (hl),a ; push X - dec l ; S-- - exx - jp (ix) ; main_loop -op_da_len: equ $-op_da - - - - org op_db - dump $ -i_stp: dec de ; STP [65C02] - jp i_sei ; disable interrupts -op_db_len: equ $-op_db - - - - org op_dc - dump $ - jp i_undoc_3 -op_dc_len: equ $-op_dc - - - - org op_dd - dump $ -i_cmp_ax: ld a,(de) ; CMP $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - ex af,af' ; carry - ld a,b ; A - sub (hl) ; A-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_dd_len: equ $-op_dd - - - - org op_de - dump $ -i_dec_ax: ld a,(de) ; DEC $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - dec (hl) ; mem-- - ld c,(hl) ; set N Z - jp read_write_loop -op_de_len: equ $-op_de - - - - org op_df - dump $ -i_bbs_5: ld a,(de) ; BBS5 [65C02] - inc de - ld l,a - ld h,0 - bit 5,(hl) - jp nz,i_bra - inc de - jp (ix) ; zread_loop -op_df_len: equ $-op_df - - - - org op_e0 - dump $ -i_cpx_i: ld h,d - ld l,e - inc de - ex af,af' ; carry - ld a,iyh ; X - sub (hl) ; X-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_e0_len: equ $-op_e0 - - - - org op_e1 - dump $ -i_sbc_ix: ld a,(de) ; SBC ($xx,X) - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - jp i_sbc -op_e1_len: equ $-op_e1 - - - - org op_e2 - dump $ - jp i_undoc_2 -op_e2_len: equ $-op_e2 - - - - org op_e3 - dump $ - jp i_undoc_2 -op_e3_len: equ $-op_e3 - - - - org op_e4 - dump $ -i_cpx_z: ld a,(de) ; CPX $nn - inc de - ld l,a - ld h,0 - ex af,af' ; carry - ld a,iyh ; X - sub (hl) ; X-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_e4_len: equ $-op_e4 - - - - org op_e5 - dump $ -i_sbc_z: ld a,(de) ; SBC $nn - inc de - ld l,a - ld h,0 - jp i_sbc -op_e5_len: equ $-op_e5 - - - - org op_e6 - dump $ -i_inc_z: ld a,(de) ; INC $nn - inc de - ld l,a - ld h,0 - inc (hl) ; zero-page++ - ld c,(hl) ; set N Z - jp (ix) ; zread_write_loop -op_e6_len: equ $-op_e6 - - - - org op_e7 - dump $ -i_smb_6: ld a,(de) ; SMB6 [65C02] - inc de - ld l,a - ld h,0 - set 6,(hl) - jp (ix) ; zwrite_loop -op_e7_len: equ $-op_e7 - - - - org op_e8 - dump $ -i_inx: inc iyh ; X++ - ld c,iyh ; set N Z - jp (ix) ; main_loop -op_e8_len: equ $-op_e8 - - - - org op_e9 - dump $ -i_sbc_i: ld h,d - ld l,e - inc de -i_sbc: ex af,af' ; carry - ccf ; uses inverted carry - ld a,b - sbc a,(hl) ; A-M-(1-C) -sbc_daa: nop - ld b,a ; set A - ld c,a ; set N Z - ccf ; no carry for overflow - exx - jp pe,adcsbc_v - ld e,%00000000 - exx - ex af,af' ; set carry - jp read_loop -op_e9_len: equ $-op_e9 - - - - org op_ea - dump $ -i_nop: jp (ix) ; main_loop -op_ea_len: equ $-op_ea - - - - org op_eb - dump $ - jp i_undoc_2 -op_eb_len: equ $-op_eb - - - - org op_ec - dump $ -i_cpx_a: ex de,hl ; CPX $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - ex af,af' ; carry - ld a,iyh ; X - sub (hl) ; X-x (result discarded) - ld c,a ; set N Z - ccf - ex af,af' ; set carry - jp read_loop -op_ec_len: equ $-op_ec - - - - org op_ed - dump $ -i_sbc_a: ex de,hl ; SBC $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - jp i_sbc -op_ed_len: equ $-op_ed - - - - org op_ee - dump $ -i_inc_a: ex de,hl ; INC $nnnn - ld e,(hl) - inc hl - ld d,(hl) - inc hl - ex de,hl - inc (hl) ; mem++ - ld c,(hl) ; set N Z - jp read_write_loop -op_ee_len: equ $-op_ee - - - - org op_ef - dump $ -i_bbs_6: ld a,(de) ; BBS6 [65C02] - inc de - ld l,a - ld h,0 - bit 6,(hl) - jp nz,i_bra - inc de - jp (ix) ; zread_loop -op_ef_len: equ $-op_ef - - - - org op_f0 - dump $ -i_beq: inc c - dec c - jp z,i_bra ; branch if zero - inc de - jp (ix) ; main_loop -op_f0_len: equ $-op_f0 - - - - org op_f1 - dump $ -i_sbc_iy: ld a,(de) ; SBC ($nn),Y - inc de - ld l,a - ld h,0 - ld a,iyl ; Y - add a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,0 - adc a,h - ld h,a - jp i_sbc -op_f1_len: equ $-op_f1 - - - - org op_f2 - dump $ -i_sbc_iz: ld a,(de) ; indirect zero-page [65C02] - inc de - ld l,a - ld h,0 - ld a,(hl) - inc l ; (may wrap in zero page) - ld h,(hl) - ld l,a - ld a,(hl) - inc hl - ld h,(hl) - ld l,a - jp i_sbc -op_f2_len: equ $-op_f2 - - - - org op_f3 - dump $ - jp i_undoc_2 -op_f3_len: equ $-op_f3 - - - - org op_f4 - dump $ - jp i_undoc_2 -op_f4_len: equ $-op_f4 - - - - org op_f5 - dump $ -i_sbc_zx: ld a,(de) ; SBC $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - jp i_sbc -op_f5_len: equ $-op_f5 - - - - org op_f6 - dump $ -i_inc_zx: ld a,(de) ; INC $nn,X - inc de - add a,iyh ; add X (may wrap in zero page) - ld l,a - ld h,0 - inc (hl) ; zero-page++ - ld c,(hl) ; set N Z - jp (ix) ; zread_write_loop -op_f6_len: equ $-op_f6 - - - - org op_f7 - dump $ -i_smb_7: ld a,(de) ; SMB7 [65C02] - inc de - ld l,a - ld h,0 - set 7,(hl) - jp (ix) ; zwrite_loop -op_f7_len: equ $-op_f7 - - - - org op_f8 - dump $ -i_sed: exx - set 3,d ; set D - exx - ld a,&27 ; DAA - ld (adc_daa),a ; use decimal mode for adc - ld (sbc_daa),a ; use decimal mode for sbc - jp (ix) ; main_loop -op_f8_len: equ $-op_f8 - - - - org op_f9 - dump $ -i_sbc_ay: ld a,(de) ; SBC $nnnn,Y - inc de - add a,iyl ; add Y - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - jp i_sbc -op_f9_len: equ $-op_f9 - - - - org op_fa - dump $ -i_plx: exx ; PLX [65C02] - inc l ; S++ - ld a,(hl) ; pop - exx - ld iyh,a ; set X - ld c,a ; set N Z - jp (ix) ; main_loop -op_fa_len: equ $-op_fa - - - - org op_fb - dump $ - jp i_undoc_3 -op_fb_len: equ $-op_fb - - - - org op_fc - dump $ - jp i_undoc_3 -op_fc_len: equ $-op_fc - - - - org op_fd - dump $ -i_sbc_ax: ld a,(de) ; SBC $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - jp i_sbc -op_fd_len: equ $-op_fd - - - - org op_fe - dump $ -i_inc_ax: ld a,(de) ; INC $nnnn,X - inc de - add a,iyh ; add X - ld l,a - ld a,(de) - inc de - adc a,0 - ld h,a - inc (hl) ; mem++ - ld c,(hl) ; set N Z - jp read_write_loop -op_fe_len: equ $-op_fe - - - - org op_ff - dump $ -i_bbs_7: ld a,(de) ; BBS7 [65C02] - inc de - ld l,a - ld h,0 - bit 7,(hl) - jp nz,i_bra - inc de - jp (ix) ; zread_loop -op_ff_len: equ $-op_ff +; 65C02 instruction implementations +; +; NOTE: If you change this file, opdefs.inc must be rebuilt by running +; opdefs.pl (requires the pyz80 assembler) + +INC "opdefs.inc" + + org op_00 + dump $ +i_brk: inc de ; return to BRK+2 + + ex af,af' ; get C + inc c + dec c ; set N Z + push af ; save flags for below + ex af,af' ; save C + + ld a,d ; PCH + exx + ld (hl),a ; push return PCH + dec l ; S-- + exx + ld a,e ; PCL + exx + ld (hl),a ; push return PCL + dec l ; S-- + + pop bc ; Z80 flags in C + ld a,c + and %10000001 ; keep Z80 N and C + bit 6,c ; check Z80 Z + jr z,brk_nz + or %00000010 ; set Z +brk_nz: or e ; merge V + or d ; merge T B D I + or %00010000 ; set B (stack value only) + ld (hl),a ; push P + dec l ; S-- + + res 3,d ; clear D [65C02] + set 2,d ; set I (disable interrupts) + exx + ld de,(m6502_int) ; fetch interrupt handler + jp (ix) ; main_loop +op_00_len: equ $-op_00 + + + + org op_01 + dump $ +i_ora_ix: ld a,(de) ; ORA ($xx,X) + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + ld a,b ; A + or (hl) ; A|x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_01_len: equ $-op_01 + + + org op_02 + dump $ + jp i_undoc_1 +op_02_len: equ $-op_02 + + + org op_03 + dump $ + jp i_undoc_2 +op_03_len: equ $-op_03 + + + org op_04 + dump $ +i_tsb_z: ld a,(de) ; TSB $nn [65C02] + inc de + ld l,a + ld h,0 + ld c,(hl) ; x + ld a,c + or b ; x|A + ld (hl),a ; set mem + ld a,c + and b ; x&A + ld c,a ; set Z + jp (ix) ; zwrite_loop +op_04_len: equ $-op_04 + + + + org op_05 + dump $ +i_ora_z: ld a,(de) ; ORA $nn + inc de + ld l,a + ld h,0 + ld a,b ; A + or (hl) ; A|x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_05_len: equ $-op_05 + + + + org op_06 + dump $ +i_asl_z: ld a,(de) ; ASL $nn + inc de + ld l,a + ld h,0 + ex af,af' + sla (hl) ; x << 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_06_len: equ $-op_06 + + + + org op_07 + dump $ +i_rmb_0: ld a,(de) ; RMB0 [65C02] + inc de + ld l,a + ld h,0 + res 0,(hl) + jp (ix) ; zwrite_loop +op_07_len: equ $-op_07 + + + + org op_08 + dump $ +i_php: ex af,af' ; carry + inc c + dec c ; set N Z + push af ; save flags + ex af,af' ; protect carry + exx + pop bc + ld a,c + and %10000001 ; keep Z80 N and C + bit 6,c ; check Z80 Z + jr z,php_nz + or %00000010 ; set Z +php_nz: or e ; merge V + or d ; merge T D I + ld (hl),a + dec l ; S-- + exx + jp (ix) ; main_loop +op_08_len: equ $-op_08 + + + + org op_09 + dump $ +i_ora_i: ld h,d + ld l,e + inc de + ld a,b ; A + or (hl) ; A|x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_09_len: equ $-op_09 + + + + org op_0a + dump $ +i_asl_acc: ex af,af' + sla b ; A << 1 + ld c,b ; set N Z + ex af,af' ; set carry + jp (ix) ; main_loop +op_0a_len: equ $-op_0a + + + + org op_0b + dump $ + jp i_undoc_2 +op_0b_len: equ $-op_0b + + + + org op_0c + dump $ +i_tsb_a: ex de,hl ; TSB $nnnn [65C02] + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ld c,(hl) ; x + ld a,c + or b ; x|A + ld (hl),a ; set mem + ld a,c + and b ; x&A + ld c,a ; set Z + jp write_loop +op_0c_len: equ $-op_0c + + + + org op_0d + dump $ +i_ora_a: ex de,hl ; ORA $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ld a,b ; A + or (hl) ; A|x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_0d_len: equ $-op_0d + + + + org op_0e + dump $ +i_asl_a: ex de,hl ; ASL $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ex af,af' + sla (hl) ; x << 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_0e_len: equ $-op_0e + + + + org op_0f + dump $ +i_bbr_0: ld a,(de) ; BBR0 [65C02] + inc de + ld l,a + ld h,0 + bit 0,(hl) + jp z,i_bra ; ToDo: read after branch + inc de + jp (ix) ; zread_loop +op_0f_len: equ $-op_0f + + + + org op_10 + dump $ +i_bpl: inc c + dec c + jp p,i_bra ; branch if plus + inc de + jp (ix) ; main_loop +op_10_len: equ $-op_10 + + + + org op_11 + dump $ +i_ora_iy: ld a,(de) ; ORA ($nn),Y + inc de + ld l,a + ld h,0 + ld a,iyl ; Y + add a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,0 + adc a,h + ld h,a + ld a,b ; A + or (hl) ; A|x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_11_len: equ $-op_11 + + + + org op_12 + dump $ +i_ora_iz: ld a,(de) ; indirect zero-page [65C02] + inc de + ld l,a + ld h,0 + ld a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + ld a,b ; A + or (hl) ; A|x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_12_len: equ $-op_12 + + + + org op_13 + dump $ + jp i_undoc_2 +op_13_len: equ $-op_13 + + + + org op_14 + dump $ +i_trb_z: ld a,(de) ; TRB $nn [65C02] + inc de + ld l,a + ld h,0 + ld c,(hl) ; x + ld a,b ; A + cpl ; ~A + and c ; x&~A + ld (hl),a ; set mem + ld a,c + and b ; x&A + ld c,a ; set Z (N lost) + jp (ix) ; zwrite_loop +op_14_len: equ $-op_14 + + + + org op_15 + dump $ +i_ora_zx: ld a,(de) ; ORA $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld a,b ; A + or (hl) ; A|x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_15_len: equ $-op_15 + + + + org op_16 + dump $ +i_asl_zx: ld a,(de) ; ASL $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ex af,af' + sla (hl) ; x << 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_16_len: equ $-op_16 + + + + org op_17 + dump $ +i_rmb_1: ld a,(de) ; RMB1 [65C02] + inc de + ld l,a + ld h,0 + res 1,(hl) + jp (ix) ; zwrite_loop +op_17_len: equ $-op_17 + + + + org op_18 + dump $ +i_clc: and a ; clear C + ex af,af' ; save carry + jp (ix) ; main_loop +op_18_len: equ $-op_18 + + + + org op_19 + dump $ +i_ora_ay: ld a,(de) ; ORA $nnnn,Y + inc de + add a,iyl ; add Y + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ld a,b ; A + or (hl) ; A|x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_19_len: equ $-op_19 + + + + org op_1a + dump $ +i_inc_acc: inc b ; A++ [65C02] + ld c,b ; set N Z + jp (ix) ; main_loop +op_1a_len: equ $-op_1a + + + + org op_1b + dump $ + jp i_undoc_3 +op_1b_len: equ $-op_1b + + + + org op_1c + dump $ +i_trb_a: ex de,hl ; TRB $nnnn [65C02] + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ld c,(hl) ; x + ld a,b ; A + cpl ; ~A + and c ; x&~A + ld (hl),a ; set mem + ld a,c + and b ; x&A + ld c,a ; set Z (N lost) + jp write_loop +op_1c_len: equ $-op_1c + + + + org op_1d + dump $ +i_ora_ax: ld a,(de) ; ORA $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ld a,b ; A + or (hl) ; A|x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_1d_len: equ $-op_1d + + + + org op_1e + dump $ +i_asl_ax: ld a,(de) ; ASL $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ex af,af' + sla (hl) ; x << 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_1e_len: equ $-op_1e + + + + org op_1f + dump $ +i_bbr_1: ld a,(de) ; BBR1 [65C02] + inc de + ld l,a + ld h,0 + bit 1,(hl) + jp z,i_bra + inc de + jp (ix) ; main_loop +op_1f_len: equ $-op_1f + + + + org op_20 + dump $ +i_jsr: ex de,hl ; JSR nn + ld e,(hl) ; subroutine low + inc hl ; only 1 inc - we push ret-1 + ld d,(hl) ; subroutine high + ld a,h ; PCh + exx + ld (hl),a ; push ret-1 high byte + dec l ; S-- + exx + ld a,l ; PCl + exx + ld (hl),a ; push ret-1 low byte + dec l ; S-- + exx + jp (ix) ; main_loop +op_20_len: equ $-op_20 + + + + org op_21 + dump $ +i_and_ix: ld a,(de) ; AND ($xx,X) + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + ld a,b ; A + and (hl) ; A&x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_21_len: equ $-op_21 + + + + org op_22 + dump $ + jp i_undoc_1 +op_22_len: equ $-op_22 + + + org op_23 + dump $ + jp i_undoc_2 +op_23_len: equ $-op_23 + + + + org op_24 + dump $ +i_bit_z: ld a,(de) ; BIT $nn + inc de + ld l,a + ld h,0 +i_bit: ld c,(hl) ; set N + ld a,c + and %01000000 ; V flag from bit 6 of x + exx + ld e,a ; set V + exx + ld a,(de) ; next instruction + and %11011111 + cp &d0 ; BNE or BEQ next? + jr z,bit_z + jp (ix) ; main_loop ; use N flag +bit_z: ld a,b ; A + and c ; perform BIT test + ld c,a ; set Z + jp read_loop +op_24_len: equ $-op_24 + + + + org op_25 + dump $ +i_and_z: ld a,(de) ; AND $nn + inc de + ld l,a + ld h,0 + ld a,b ; A + and (hl) ; A&x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_25_len: equ $-op_25 + + + + org op_26 + dump $ +i_rol_z: ld a,(de) ; ROL $nn + inc de + ld l,a + ld h,0 + ex af,af' + rl (hl) ; x << 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_26_len: equ $-op_26 + + + + org op_27 + dump $ +i_rmb_2: ld a,(de) ; RMB2 [65C02] + inc de + ld l,a + ld h,0 + res 2,(hl) + jp (ix) ; zwrite_loop +op_27_len: equ $-op_27 + + + + org op_28 + dump $ +i_plp: exx + inc l ; S++ + ld a,(hl) ; pop P + ld c,a ; keep safe + and %00001100 ; keep D and I + or %00110000 ; force T and B + ld d,a ; set P + ld a,c + and %01000000 ; keep V + ld e,a ; set V + ld a,c + rra ; carry from C + ex af,af' ; set carry + ld a,c + and %10000010 ; keep N Z + xor %00000010 ; zero for Z + exx + ld c,a ; set N Z + jp (ix) ; main_loop +op_28_len: equ $-op_28 + + + + org op_29 + dump $ +i_and_i: ld h,d + ld l,e + inc de + ld a,b ; A + and (hl) ; A&x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_29_len: equ $-op_29 + + + + org op_2a + dump $ +i_rol_acc: ex af,af' + rl b + ld c,b ; set N Z + ex af,af' ; set carry + jp (ix) ; main_loop +op_2a_len: equ $-op_2a + + + org op_2b + dump $ + jp i_undoc_2 +op_2b_len: equ $-op_2b + + + + org op_2c + dump $ +i_bit_a: ex de,hl ; BIT $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + jp i_bit +op_2c_len: equ $-op_2c + + + + org op_2d + dump $ +i_and_a: ex de,hl ; AND $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ld a,b ; A + and (hl) ; A&x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_2d_len: equ $-op_2d + + + + org op_2e + dump $ +i_rol_a: ex de,hl ; ROL $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ex af,af' + rl (hl) ; x << 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_2e_len: equ $-op_2e + + + + org op_2f + dump $ +i_bbr_2: ld a,(de) ; BBR2 [65C02] + inc de + ld l,a + ld h,0 + bit 2,(hl) + jp z,i_bra + inc de + jp (ix) ; zread_loop +op_2f_len: equ $-op_2f + + + + org op_30 + dump $ +i_bmi: inc c + dec c + jp m,i_bra ; branch if minus + inc de + jp (ix) ; main_loop +op_30_len: equ $-op_30 + + + + org op_31 + dump $ +i_and_iy: ld a,(de) ; AND ($nn),Y + inc de + ld l,a + ld h,0 + ld a,iyl ; Y + add a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,0 + adc a,h + ld h,a + ld a,b ; A + and (hl) ; A&x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_31_len: equ $-op_31 + + + + org op_32 + dump $ +i_and_iz: ld a,(de) ; indirect zero-page [65C02] + inc de + ld l,a + ld h,0 + ld a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + ld a,b ; A + and (hl) ; A&x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_32_len: equ $-op_32 + + + + org op_33 + dump $ + jp i_undoc_2 +op_33_len: equ $-op_33 + + + + org op_34 + dump $ +i_bit_zx: ld a,(de) ; BIT $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + jp i_bit +op_34_len: equ $-op_34 + + + + org op_35 + dump $ +i_and_zx: ld a,(de) ; AND $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld a,b ; A + and (hl) ; A&x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_35_len: equ $-op_35 + + + + org op_36 + dump $ +i_rol_zx: ld a,(de) ; ROL $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ex af,af' + rl (hl) ; x << 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_36_len: equ $-op_36 + + + + org op_37 + dump $ +i_rmb_3: ld a,(de) ; RMB3 [65C02] + inc de + ld l,a + ld h,0 + res 3,(hl) + jp (ix) ; zwrite_loop +op_37_len: equ $-op_37 + + + + org op_38 + dump $ +i_sec: scf ; set C + ex af,af' ; save carry + jp (ix) ; main_loop +op_38_len: equ $-op_38 + + + + org op_39 + dump $ +i_and_ay: ld a,(de) ; AND $nnnn,Y + inc de + add a,iyl ; add Y + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ld a,b ; A + and (hl) ; A&x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_39_len: equ $-op_39 + + + + org op_3a + dump $ +i_dec_acc: dec b ; A-- [65C02] + ld c,b ; set N Z + jp (ix) ; main_loop +op_3a_len: equ $-op_3a + + + + org op_3b + dump $ + jp i_undoc_3 +op_3b_len: equ $-op_3b + + + + org op_3c + dump $ +i_bit_ax: ld a,(de) ; BIT $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + jp i_bit +op_3c_len: equ $-op_3c + + + + org op_3d + dump $ +i_and_ax: ld a,(de) ; AND $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ld a,b ; A + and (hl) ; A&x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_3d_len: equ $-op_3d + + + + org op_3e + dump $ +i_rol_ax: ld a,(de) ; ROL $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ex af,af' + rl (hl) ; x << 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_3e_len: equ $-op_3e + + + + org op_3f + dump $ +i_bbr_3: ld a,(de) ; BBR3 [65C02] + inc de + ld l,a + ld h,0 + bit 3,(hl) + jp z,i_bra + inc de + jp (ix) ; zread_loop +op_3f_len: equ $-op_3f + + + + org op_40 + dump $ +i_rti: exx + inc l ; S++ + ld a,(hl) ; pop P + ld c,a ; keep safe + and %00001100 ; keep D and I + or %00110000 ; force T and B + ld d,a ; set P + ld a,c + and %01000000 ; keep V + ld e,a ; set V + ld a,c + rra ; carry from C + ex af,af' ; set carry + ld a,c + and %10000010 ; keep N Z + xor %00000010 ; zero for Z + exx + ld c,a ; set N Z + exx + inc l ; S++ + ld a,(hl) ; pop return LSB + exx + ld e,a ; PCL + exx + inc l ; S++ + ld a,(hl) ; pop return MSB + exx + ld d,a ; PCH + jp (ix) ; main_loop +op_40_len: equ $-op_40 + + + + org op_41 + dump $ +i_eor_ix: ld a,(de) ; EOR ($xx,X) + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + ld a,b ; A + xor (hl) ; A^x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_41_len: equ $-op_41 + + + + org op_42 + dump $ + jp i_undoc_1 +op_42_len: equ $-op_42 + + + + org op_43 + dump $ + jp i_undoc_2 +op_43_len: equ $-op_43 + + + + org op_44 + dump $ + jp i_undoc_2 +op_44_len: equ $-op_44 + + + + org op_45 + dump $ +i_eor_z: ld a,(de) ; EOR $nn + inc de + ld l,a + ld h,0 + ld a,b ; A + xor (hl) ; A^x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_45_len: equ $-op_45 + + + + org op_46 + dump $ +i_lsr_z: ld a,(de) ; LSR $nn + inc de + ld l,a + ld h,0 + ex af,af' + srl (hl) ; x >> 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_46_len: equ $-op_46 + + + + org op_47 + dump $ +i_rmb_4: ld a,(de) ; RMB4 [65C02] + inc de + ld l,a + ld h,0 + res 4,(hl) + jp (ix) ; zwrite_loop +op_47_len: equ $-op_47 + + + + org op_48 + dump $ +i_pha: ld a,b ; A + exx + ld (hl),a ; push A + dec l ; S-- + exx + jp (ix) ; main_loop +op_48_len: equ $-op_48 + + + + org op_49 + dump $ +i_eor_i: ld h,d + ld l,e + inc de + ld a,b ; A + xor (hl) ; A^x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_49_len: equ $-op_49 + + + + org op_4a + dump $ +i_lsr_acc: ex af,af' + srl b ; A >> 1 + ld c,b ; set N Z + ex af,af' ; set carry + jp (ix) ; main_loop +op_4a_len: equ $-op_4a + + + + org op_4b + dump $ + jp i_undoc_2 +op_4b_len: equ $-op_4b + + + + org op_4c + dump $ +i_jmp_a: ex de,hl ; JMP nn + ld e,(hl) + inc hl + ld d,(hl) + jp (ix) ; main_loop +op_4c_len: equ $-op_4c + + + + org op_4d + dump $ +i_eor_a: ex de,hl ; EOR $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ld a,b ; A + xor (hl) ; A^x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_4d_len: equ $-op_4d + + + + org op_4e + dump $ +i_lsr_a: ex de,hl ; LSR $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ex af,af' + srl (hl) ; x >> 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_4e_len: equ $-op_4e + + + + org op_4f + dump $ +i_bbr_4: ld a,(de) ; BBR4 [65C02] + inc de + ld l,a + ld h,0 + bit 4,(hl) + jp z,i_bra + inc de + jp (ix) ; zread_loop +op_4f_len: equ $-op_4f + + + + org op_50 + dump $ +i_bvc: exx + bit 6,e + exx + jp z,i_bra ; branch if V clear + inc de + jp (ix) ; main_loop +op_50_len: equ $-op_50 + + + + org op_51 + dump $ +i_eor_iy: ld a,(de) ; EOR ($nn),Y + inc de + ld l,a + ld h,0 + ld a,iyl ; Y + add a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,0 + adc a,h + ld h,a + ld a,b ; A + xor (hl) ; A^x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_51_len: equ $-op_51 + + + + org op_52 + dump $ +i_eor_iz: ld a,(de) ; indirect zero-page [65C02] + inc de + ld l,a + ld h,0 + ld a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + ld a,b ; A + xor (hl) ; A^x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_52_len: equ $-op_52 + + + + org op_53 + dump $ + jp i_undoc_2 +op_53_len: equ $-op_53 + + + + org op_54 + dump $ + jp i_undoc_2 +op_54_len: equ $-op_54 + + + + org op_55 + dump $ +i_eor_zx: ld a,(de) ; EOR $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld a,b ; A + xor (hl) ; A^x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_55_len: equ $-op_55 + + + + org op_56 + dump $ +i_lsr_zx: ld a,(de) ; LSR $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ex af,af' + srl (hl) ; x >> 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_56_len: equ $-op_56 + + + + org op_57 + dump $ +i_rmb_5: ld a,(de) ; RMB5 [65C02] + inc de + ld l,a + ld h,0 + res 5,(hl) + jp (ix) ; zwrite_loop +op_57_len: equ $-op_57 + + + + org op_58 + dump $ +i_cli: exx + res 2,d ; clear I (enable interrupts) + exx + jp (ix) ; main_loop +op_58_len: equ $-op_58 + + + + org op_59 + dump $ +i_eor_ay: ld a,(de) ; EOR $nnnn,Y + inc de + add a,iyl ; add Y + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ld a,b ; A + xor (hl) ; A^x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_59_len: equ $-op_59 + + + + org op_5a + dump $ +i_phy: ld a,iyl ; PHY [65C02] + exx + ld (hl),a ; push Y + dec l ; S-- + exx + jp (ix) ; main_loop +op_5a_len: equ $-op_5a + + + + org op_5b + dump $ + jp i_undoc_3 +op_5b_len: equ $-op_5b + + + + org op_5c + dump $ + jp i_undoc_3 +op_5c_len: equ $-op_5c + + + + org op_5d + dump $ +i_eor_ax: ld a,(de) ; EOR $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ld a,b ; A + xor (hl) ; A^x + ld b,a ; set A + ld c,a ; set N Z + jp read_loop +op_5d_len: equ $-op_5d + + + + org op_5e + dump $ +i_lsr_ax: ld a,(de) ; LSR $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ex af,af' + srl (hl) ; x >> 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_5e_len: equ $-op_5e + + + + org op_5f + dump $ +i_bbr_5: ld a,(de) ; BBR5 [65C02] + inc de + ld l,a + ld h,0 + bit 5,(hl) + jp z,i_bra + inc de + jp (ix) ; zread_loop +op_5f_len: equ $-op_5f + + + + org op_60 + dump $ +i_rts: exx ; RTS + inc l ; S++ + ld a,(hl) ; PC LSB + exx + ld e,a + exx + inc l ; S++ + ld a,(hl) ; PC MSB + exx + ld d,a + inc de ; PC++ (strange but true) + jp (ix) ; main_loop +op_60_len: equ $-op_60 + + + + org op_61 + dump $ +i_adc_ix: ld a,(de) ; ADX ($xx,X) + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + jp i_adc +op_61_len: equ $-op_61 + + + + org op_62 + dump $ + jp i_undoc_1 +op_62_len: equ $-op_62 + + + + org op_63 + dump $ + jp i_undoc_2 +op_63_len: equ $-op_63 + + + + org op_64 + dump $ +i_stz_z: ld a,(de) ; STZ $nn [65C02] + inc de + ld l,a + ld h,0 + ld (hl),h + jp (ix) ; zwrite_loop +op_64_len: equ $-op_64 + + + + org op_65 + dump $ +i_adc_z: ld a,(de) ; ADC $nn + inc de + ld l,a + ld h,0 + jp i_adc +op_65_len: equ $-op_65 + + + + org op_66 + dump $ +i_ror_z: ld a,(de) ; ROR $nn + inc de + ld l,a + ld h,0 + ex af,af' + rr (hl) ; x >> 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_66_len: equ $-op_66 + + + + org op_67 + dump $ +i_rmb_6: ld a,(de) ; RMB6 [65C02] + inc de + ld l,a + ld h,0 + res 6,(hl) + jp (ix) ; zwrite_loop +op_67_len: equ $-op_67 + + + + org op_68 + dump $ +i_pla: exx + inc l ; S++ + ld a,(hl) ; pop A + exx + ld b,a ; set A + ld c,a ; set N Z + jp (ix) ; main_loop +op_68_len: equ $-op_68 + + + + org op_69 + dump $ +i_adc_i: ld h,d + ld l,e + inc de +i_adc: ex af,af' ; carry + ld a,b ; A + adc a,(hl) ; A+M+C +adc_daa: nop + ld b,a ; set A + ld c,a ; set N Z + exx + jp pe,adcsbc_v + ld e,%00000000 + exx + ex af,af' ; set carry + jp read_loop +adcsbc_v: ld e,%01000000 + exx + ex af,af' ; set carry + jp read_loop +op_69_len: equ $-op_69 + + + + org op_6a + dump $ +i_ror_acc: ex af,af' + rr b + ld c,b ; set N Z + ex af,af' ; set carry + jp (ix) ; main_loop +op_6a_len: equ $-op_6a + + + + org op_6b + dump $ + jp i_undoc_2 +op_6b_len: equ $-op_6b + + + + org op_6c + dump $ +i_jmp_i: ex de,hl ; JMP (nn) + ld e,(hl) + inc hl + ld d,(hl) + ex de,hl + ld e,(hl) +; inc l ; 6502 bug wraps within page, *OR* + inc hl ; 65C02 spans pages correctly + ld d,(hl) + jp (ix) ; main_loop +op_6c_len: equ $-op_6c + + + + org op_6d + dump $ +i_adc_a: ex de,hl ; ADC $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + jp i_adc +op_6d_len: equ $-op_6d + + + + org op_6e + dump $ +i_ror_a: ex de,hl ; ROR $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ex af,af' + rr (hl) ; x >> 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_6e_len: equ $-op_6e + + + + org op_6f + dump $ +i_bbr_6: ld a,(de) ; BBR6 [65C02] + inc de + ld l,a + ld h,0 + bit 6,(hl) + jp z,i_bra + inc de + jp (ix) ; zread_loop +op_6f_len: equ $-op_6f + + + + org op_70 + dump $ +i_bvs: exx + bit 6,e + exx + jp nz,i_bra ; branch if V set + inc de + jp (ix) ; main_loop +op_70_len: equ $-op_70 + + + + org op_71 + dump $ +i_adc_iy: ld a,(de) ; ADC ($nn),Y + inc de + ld l,a + ld h,0 + ld a,iyl ; Y + add a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,0 + adc a,h + ld h,a + jp i_adc +op_71_len: equ $-op_71 + + + + org op_72 + dump $ +i_adc_iz: ld a,(de) ; indirect zero-page [65C02] + inc de + ld l,a + ld h,0 + ld a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + jp i_adc +op_72_len: equ $-op_72 + + + + org op_73 + dump $ + jp i_undoc_2 +op_73_len: equ $-op_73 + + + + org op_74 + dump $ +i_stz_zx: ld a,(de) ; STZ $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld (hl),h + jp (ix) ; zwrite_loop +op_74_len: equ $-op_74 + + + + org op_75 + dump $ +i_adc_zx: ld a,(de) ; ADC $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + jp i_adc +op_75_len: equ $-op_75 + + + + org op_76 + dump $ +i_ror_zx: ld a,(de) ; ROR $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ex af,af' + rr (hl) ; x >> 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_76_len: equ $-op_76 + + + + org op_77 + dump $ +i_rmb_7: ld a,(de) ; RMB7 [65C02] + inc de + ld l,a + ld h,0 + res 7,(hl) + jp (ix) ; zwrite_loop +op_77_len: equ $-op_77 + + + + org op_78 + dump $ +i_sei: exx + set 2,d ; set I (disable interrupts) + exx + jp (ix) ; main_loop +op_78_len: equ $-op_78 + + + + org op_79 + dump $ +i_adc_ay: ld a,(de) ; ADC $nnnn,Y + inc de + add a,iyl ; add Y + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + jp i_adc +op_79_len: equ $-op_79 + + + + org op_7a + dump $ +i_ply: exx ; PLY [65C02] + inc l ; S++ + ld a,(hl) ; pop + exx + ld iyl,a ; set Y + ld c,a ; set N Z + jp (ix) ; main_loop +op_7a_len: equ $-op_7a + + + + org op_7b + dump $ + jp i_undoc_3 +op_7b_len: equ $-op_7b + + + + org op_7c + dump $ +i_jmp_ax: ld a,(de) ; JMP (nn,X) [65C02] + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 ; carry spans page + ld h,a + ld e,(hl) + inc hl + ld d,(hl) + jp (ix) ; main_loop +op_7c_len: equ $-op_7c + + + + org op_7d + dump $ +i_adc_ax: ld a,(de) ; ADC $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + jp i_adc +op_7d_len: equ $-op_7d + + + + org op_7e + dump $ +i_ror_ax: ld a,(de) ; ROR $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ex af,af' + rr (hl) ; x >> 1 + ld c,(hl) ; set N Z + ex af,af' ; set carry + jp write_loop +op_7e_len: equ $-op_7e + + + + org op_7f + dump $ +i_bbr_7: ld a,(de) ; BBR7 [65C02] + inc de + ld l,a + ld h,0 + bit 7,(hl) + jp z,i_bra + inc de + jp (ix) ; zread_loop +op_7f_len: equ $-op_7f + + + + org op_80 + dump $ +i_bra: ld a,(de) ; BRA [65C02] + inc de + ld l,a ; offset low + rla ; set carry with sign + sbc a,a ; form high byte for offset + ld h,a + add hl,de ; PC=PC+e + ex de,hl + jp (ix) ; main_loop +i_bra_ex: ex af,af' ; preseve C before branch + ld a,(de) + inc de + ld l,a ; offset low + rla ; set carry with sign + sbc a,a ; form high byte for offset + ld h,a + add hl,de ; PC=PC+e + ex de,hl + jp (ix) ; main_loop +op_80_len: equ $-op_80 + + + + org op_81 + dump $ +i_sta_ix: ld a,(de) ; STA ($xx,X) + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + ld (hl),b ; store A + jp (ix) ; zwrite_loop +op_81_len: equ $-op_81 + + + + org op_82 + dump $ + jp i_undoc_2 +op_82_len: equ $-op_82 + + + + org op_83 + dump $ + jp i_undoc_2 +op_83_len: equ $-op_83 + + + + org op_84 + dump $ +i_sty_z: ld a,(de) ; STY $nn + inc de + ld l,a + ld h,0 + ld a,iyl ; Y + ld (hl),a + jp (ix) ; zwrite_loop +op_84_len: equ $-op_84 + + + + org op_85 + dump $ +i_sta_z: ld a,(de) ; STA $nn + inc de + ld l,a + ld h,0 + ld (hl),b ; store A + jp (ix) ; zwrite_loop +op_85_len: equ $-op_85 + + + + org op_86 + dump $ +i_stx_z: ld a,(de) ; STX $nn + inc de + ld l,a + ld h,0 + ld a,iyh ; X + ld (hl),a + jp (ix) ; zwrite_loop +op_86_len: equ $-op_86 + + + + org op_87 + dump $ +i_smb_0: ld a,(de) ; SMB0 [65C02] + inc de + ld l,a + ld h,0 + set 0,(hl) + jp (ix) ; zwrite_loop +op_87_len: equ $-op_87 + + + + org op_88 + dump $ +i_dey: dec iyl ; Y-- + ld c,iyl ; set N Z + jp (ix) ; main_loop +op_88_len: equ $-op_88 + + + + org op_89 + dump $ +i_bit_i: ld a,(de) ; BIT #$nn + inc de + and b ; BIT test against A + ld c,a ; set Z + jp read_loop +op_89_len: equ $-op_89 + + + + org op_8a + dump $ +i_txa: ld b,iyh ; A=X + ld c,b ; set N Z + jp (ix) ; main_loop +op_8a_len: equ $-op_8a + + + + org op_8b + dump $ + jp i_undoc_2 +op_8b_len: equ $-op_8b + + + + org op_8c + dump $ +i_sty_a: ex de,hl ; STY $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ld a,iyl ; Y + ld (hl),a + jp write_loop +op_8c_len: equ $-op_8c + + + + org op_8d + dump $ +i_sta_a: ex de,hl ; STA $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ld (hl),b ; store A + jp write_loop +op_8d_len: equ $-op_8d + + + + org op_8e + dump $ +i_stx_a: ex de,hl ; STX $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ld a,iyh ; X + ld (hl),a + jp write_loop +op_8e_len: equ $-op_8e + + + + org op_8f + dump $ +i_bbs_0: ld a,(de) ; BBS0 [65C02] + inc de + ld l,a + ld h,0 + bit 0,(hl) + jp nz,i_bra ; ToDo: read after branch + inc de + jp (ix) ; zread_loop +op_8f_len: equ $-op_8f + + + + org op_90 + dump $ +i_bcc: ex af,af' + jp nc,i_bra_ex ; branch if C clear + ex af,af' + inc de + jp (ix) ; main_loop +op_90_len: equ $-op_90 + + + + org op_91 + dump $ +i_sta_iy: ld a,(de) ; STA ($nn),Y + inc de + ld l,a + ld h,0 + ld a,iyl ; Y + add a,(hl) + inc l + ld h,(hl) + ld l,a + ld a,0 + adc a,h + ld h,a + ld (hl),b ; store A + jp write_loop +op_91_len: equ $-op_91 + + + + org op_92 + dump $ +i_sta_iz: ld a,(de) ; STA ($nn) [65C02] + inc de + ld l,a + ld h,0 + ld a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + ld (hl),b ; store A + jp write_loop +op_92_len: equ $-op_92 + + + + org op_93 + dump $ + jp i_undoc_2 +op_93_len: equ $-op_93 + + + + org op_94 + dump $ +i_sty_zx: ld a,(de) ; STY $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld a,iyl ; Y + ld (hl),a + jp (ix) ; zwrite_loop +op_94_len: equ $-op_94 + + + + org op_95 + dump $ +i_sta_zx: ld a,(de) ; STA $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld (hl),b ; store A + jp (ix) ; zwrite_loop +op_95_len: equ $-op_95 + + + + org op_96 + dump $ +i_stx_zy: ld a,(de) ; STX $nn,Y + inc de + add a,iyl ; add Y (may wrap in zero page) + ld l,a + ld h,0 + ld a,iyh ; X + ld (hl),a + jp (ix) ; zwrite_loop +op_96_len: equ $-op_96 + + + + org op_97 + dump $ +i_smb_1: ld a,(de) ; SMB1 [65C02] + inc de + ld l,a + ld h,0 + set 1,(hl) + jp (ix) ; zwrite_loop +op_97_len: equ $-op_97 + + + + org op_98 + dump $ +i_tya: ld b,iyl ; A=Y + ld c,b ; set N Z + jp (ix) ; main_loop +op_98_len: equ $-op_98 + + + + org op_99 + dump $ +i_sta_ay: ld a,(de) ; STA $nnnn,Y + inc de + add a,iyl ; add Y + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ld (hl),b ; store A + jp write_loop +op_99_len: equ $-op_99 + + + + org op_9a + dump $ +i_txs: ld a,iyh ; X + exx + ld l,a ; set S (no flags set) + exx + jp (ix) ; main_loop +op_9a_len: equ $-op_9a + + + + org op_9b + dump $ + jp i_undoc_2 +op_9b_len: equ $-op_9b + + + + org op_9c + dump $ +i_stz_a: ex de,hl ; STZ $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ld (hl),0 + jp write_loop +op_9c_len: equ $-op_9c + + + + org op_9d + dump $ +i_sta_ax: ld a,(de) ; STA $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ld (hl),b ; store A + jp write_loop +op_9d_len: equ $-op_9d + + + + org op_9e + dump $ +i_stz_ax: ld a,(de) ; STZ $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ld (hl),0 + jp write_loop +op_9e_len: equ $-op_9e + + + + org op_9f + dump $ +i_bbs_1: ld a,(de) ; BBS1 [65C02] + inc de + ld l,a + ld h,0 + bit 1,(hl) + jp nz,i_bra + inc de + jp (ix) ; zread_loop +op_9f_len: equ $-op_9f + + + + org op_a0 + dump $ +i_ldy_i: ld a,(de) ; LDY #$nn + inc de + ld c,a ; set N Z + ld iyl,c ; set Y + jp (ix) ; main_loop +op_a0_len: equ $-op_a0 + + + + org op_a1 + dump $ +i_lda_ix: ld a,(de) ; LDA ($nn,X) + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + ld b,(hl) ; set A + ld c,b ; set N Z + jp (ix) ; zread_loop +op_a1_len: equ $-op_a1 + + + + org op_a2 + dump $ +i_ldx_i: ld a,(de) ; LDX #$nn + inc de + ld iyh,a ; set X + ld c,a ; set N Z + jp (ix) ; main_loop +op_a2_len: equ $-op_a2 + + + + org op_a3 + dump $ + jp i_undoc_2 +op_a3_len: equ $-op_a3 + + + + org op_a4 + dump $ +i_ldy_z: ld a,(de) ; LDY $nn + inc de + ld l,a + ld h,0 + ld c,(hl) ; set N Z + ld iyl,c ; set Y + jp (ix) ; zread_loop +op_a4_len: equ $-op_a4 + + + + org op_a5 + dump $ +i_lda_z: ld a,(de) ; LDA $nn + inc de + ld l,a + ld h,0 + ld b,(hl) ; set A + ld c,b ; set N Z + jp (ix) ; zread_loop +op_a5_len: equ $-op_a5 + + + + org op_a6 + dump $ +i_ldx_z: ld a,(de) ; LDX $nn + inc de + ld l,a + ld h,0 + ld c,(hl) ; set N Z + ld iyh,c ; set X + jp (ix) ; zread_loop +op_a6_len: equ $-op_a6 + + + + org op_a7 + dump $ +i_smb_2: ld a,(de) ; SMB2 [65C02] + inc de + ld l,a + ld h,0 + set 2,(hl) + jp (ix) ; zwrite_loop +op_a7_len: equ $-op_a7 + + + + org op_a8 + dump $ +i_tay: ld iyl,b ; Y=A + ld c,b ; set N Z + jp (ix) ; main_loop +op_a8_len: equ $-op_a8 + + + + org op_a9 + dump $ +i_lda_i: ld a,(de) ; LDA #$nn + inc de + ld b,a ; set A + ld c,b ; set N Z + jp (ix) ; main_loop +op_a9_len: equ $-op_a9 + + + + org op_aa + dump $ +i_tax: ld iyh,b ; X=A + ld c,b ; set N Z + jp (ix) ; main_loop +op_aa_len: equ $-op_aa + + + + org op_ab + dump $ + jp i_undoc_2 +op_ab_len: equ $-op_ab + + + + org op_ac + dump $ +i_ldy_a: ex de,hl ; LDY $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ld c,(hl) ; set N Z + ld iyl,c ; set Y + jp read_loop +op_ac_len: equ $-op_ac + + + + org op_ad + dump $ +i_lda_a: ex de,hl ; LDA $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ld b,(hl) ; set A + ld c,b ; set N Z + jp read_loop +op_ad_len: equ $-op_ad + + + + org op_ae + dump $ +i_ldx_a: ex de,hl ; LDX $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ld c,(hl) ; set N Z + ld iyh,c ; set X + jp read_loop +op_ae_len: equ $-op_ae + + + + org op_af + dump $ +i_bbs_2: ld a,(de) ; BBS2 [65C02] + inc de + ld l,a + ld h,0 + bit 2,(hl) + jp nz,i_bra + inc de + jp (ix) ; zread_loop +op_af_len: equ $-op_af + + + + org op_b0 + dump $ +i_bcs: ex af,af' + jp c,i_bra_ex ; branch if C set + ex af,af' + inc de + jp (ix) ; main_loop +op_b0_len: equ $-op_b0 + + + + org op_b1 + dump $ +i_lda_iy: ld a,(de) ; LDA ($nn),Y + inc de + ld l,a + ld h,0 + ld a,iyl ; Y + add a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,0 + adc a,h + ld h,a + ld b,(hl) ; set A + ld c,b ; set N Z + jp read_loop +op_b1_len: equ $-op_b1 + + + + org op_b2 + dump $ +i_lda_iz: ld a,(de) ; LDA ($nn) [65C02] + inc de + ld l,a + ld h,0 + ld a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + ld b,(hl) ; set A + ld c,b ; set N Z + jp read_loop +op_b2_len: equ $-op_b2 + + + + org op_b3 + dump $ + jp i_undoc_2 +op_b3_len: equ $-op_b3 + + + + org op_b4 + dump $ +i_ldy_zx: ld a,(de) ; LDY $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld c,(hl) ; set N Z + ld iyl,c ; set Y + jp (ix) ; zread_loop +op_b4_len: equ $-op_b4 + + + + org op_b5 + dump $ +i_lda_zx: ld a,(de) ; LDA $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld b,(hl) ; set A + ld c,b ; set N Z + jp (ix) ; zread_loop +op_b5_len: equ $-op_b5 + + + + org op_b6 + dump $ +i_ldx_zy: ld a,(de) ; LDX $nn,Y + inc de + add a,iyl ; add Y (may wrap in zero page) + ld l,a + ld h,0 + ld c,(hl) ; set N Z + ld iyh,c ; set X + jp (ix) ; zread_loop +op_b6_len: equ $-op_b6 + + + + org op_b7 + dump $ +i_smb_3: ld a,(de) ; SMB3 [65C02] + inc de + ld l,a + ld h,0 + set 3,(hl) + jp (ix) ; zwrite_loop +op_b7_len: equ $-op_b7 + + + + org op_b8 + dump $ +i_clv: exx ; clear overflow + ld e,0 + exx + jp (ix) ; main_loop +op_b8_len: equ $-op_b8 + + + + org op_b9 + dump $ +i_lda_ay: ld a,(de) ; LDA $nnnn,Y + inc de + add a,iyl ; add Y + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ld b,(hl) ; set A + ld c,b ; set N Z + jp read_loop +op_b9_len: equ $-op_b9 + + + + org op_ba + dump $ +i_tsx: exx + ld a,l ; S + exx + ld iyh,a ; X=S + ld c,a ; set N Z + jp (ix) ; main_loop +op_ba_len: equ $-op_ba + + + + org op_bb + dump $ + jp i_undoc_3 +op_bb_len: equ $-op_bb + + + + org op_bc + dump $ +i_ldy_ax: ld a,(de) ; LDY $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ld c,(hl) ; set N Z + ld iyl,c ; set Y + jp read_loop +op_bc_len: equ $-op_bc + + + + org op_bd + dump $ +i_lda_ax: ld a,(de) ; LDA $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ld b,(hl) ; set A + ld c,b ; set N Z + jp read_loop +op_bd_len: equ $-op_bd + + + + org op_be + dump $ +i_ldx_ay: ld a,(de) ; LDX $nnnn,Y + inc de + add a,iyl ; add Y + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ld c,(hl) ; set N Z + ld iyh,c ; set X + jp read_loop +op_be_len: equ $-op_be + + + + org op_bf + dump $ +i_bbs_3: ld a,(de) ; BBS3 [65C02] + inc de + ld l,a + ld h,0 + bit 3,(hl) + jp nz,i_bra + inc de + jp (ix) ; zread_loop +op_bf_len: equ $-op_bf + + + + org op_c0 + dump $ +i_cpy_i: ld h,d + ld l,e + inc de + ex af,af' ; carry + ld a,iyl ; Y + sub (hl) ; Y-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_c0_len: equ $-op_c0 + + + + org op_c1 + dump $ +i_cmp_ix: ld a,(de) ; CMP ($xx,X) + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + ex af,af' ; carry + ld a,b ; A + sub (hl) ; A-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_c1_len: equ $-op_c1 + + + + org op_c2 + dump $ + jp i_undoc_2 +op_c2_len: equ $-op_c2 + + + + org op_c3 + dump $ + jp i_undoc_2 +op_c3_len: equ $-op_c3 + + + + org op_c4 + dump $ +i_cpy_z: ld a,(de) ; CPY $nn + inc de + ld l,a + ld h,0 + ex af,af' ; carry + ld a,iyl ; Y + sub (hl) ; Y-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_c4_len: equ $-op_c4 + + + + org op_c5 + dump $ +i_cmp_z: ld a,(de) ; CMP $nn + inc de + ld l,a + ld h,0 + ex af,af' ; carry + ld a,b ; A + sub (hl) ; A-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_c5_len: equ $-op_c5 + + + + org op_c6 + dump $ +i_dec_z: ld a,(de) ; DEC $nn + inc de + ld l,a + ld h,0 + dec (hl) ; zero-page-- + ld c,(hl) ; set N Z + jp (ix) ; zread_write_loop +op_c6_len: equ $-op_c6 + + + + org op_c7 + dump $ +i_smb_4: ld a,(de) ; SMB4 [65C02] + inc de + ld l,a + ld h,0 + set 4,(hl) + jp (ix) ; zwrite_loop +op_c7_len: equ $-op_c7 + + + + org op_c8 + dump $ +i_iny: inc iyl ; Y++ + ld c,iyl ; set N Z + jp (ix) ; main_loop +op_c8_len: equ $-op_c8 + + + + org op_c9 + dump $ +i_cmp_i: ld h,d + ld l,e + inc de + ex af,af' ; carry + ld a,b ; A + sub (hl) ; A-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_c9_len: equ $-op_c9 + + + + org op_ca + dump $ +i_dex: dec iyh ; X-- + ld c,iyh ; set N Z + jp (ix) ; main_loop +op_ca_len: equ $-op_ca + + + + org op_cb + dump $ +i_wai: dec de ; WAI [65C02] + jp (ix) ; main_loop +op_cb_len: equ $-op_cb + + + + org op_cc + dump $ +i_cpy_a: ex de,hl ; CPY $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ex af,af' ; carry + ld a,iyl ; Y + sub (hl) ; Y-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_cc_len: equ $-op_cc + + + + org op_cd + dump $ +i_cmp_a: ex de,hl ; CMP $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ex af,af' ; carry + ld a,b ; A + sub (hl) ; A-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_cd_len: equ $-op_cd + + + + org op_ce + dump $ +i_dec_a: ex de,hl ; DEC $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + dec (hl) ; mem-- + ld c,(hl) ; set N Z + jp read_write_loop +op_ce_len: equ $-op_ce + + + + org op_cf + dump $ +i_bbs_4: ld a,(de) ; BBS4 [65C02] + inc de + ld l,a + ld h,0 + bit 4,(hl) + jp nz,i_bra + inc de + jp (ix) ; zread_loop +op_cf_len: equ $-op_cf + + + + org op_d0 + dump $ +i_bne: inc c + dec c + jp nz,i_bra ; branch if not zero + inc de + jp (ix) ; main_loop +op_d0_len: equ $-op_d0 + + + + org op_d1 + dump $ +i_cmp_iy: ld a,(de) ; CMP ($nn),Y + inc de + ld l,a + ld h,0 + ld a,iyl ; Y + add a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,0 + adc a,h + ld h,a + ex af,af' ; carry + ld a,b ; A + sub (hl) ; A-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_d1_len: equ $-op_d1 + + + + org op_d2 + dump $ +i_cmp_iz: ld a,(de) ; indirect zero-page [65C02] + inc de + ld l,a + ld h,0 + ld a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + ex af,af' ; carry + ld a,b ; A + sub (hl) ; A-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_d2_len: equ $-op_d2 + + + + org op_d3 + dump $ + jp i_undoc_2 +op_d3_len: equ $-op_d3 + + + + org op_d4 + dump $ + jp i_undoc_2 +op_d4_len: equ $-op_d4 + + + + org op_d5 + dump $ +i_cmp_zx: ld a,(de) ; CMP $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ex af,af' ; carry + ld a,b ; A + sub (hl) ; A-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_d5_len: equ $-op_d5 + + + + org op_d6 + dump $ +i_dec_zx: ld a,(de) ; DEC $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + dec (hl) ; zero-page-- + ld c,(hl) ; set N Z + jp (ix) ; zread_write_loop +op_d6_len: equ $-op_d6 + + + + org op_d7 + dump $ +i_smb_5: ld a,(de) ; SMB5 [65C02] + inc de + ld l,a + ld h,0 + set 5,(hl) + jp (ix) ; zwrite_loop +op_d7_len: equ $-op_d7 + + + + org op_d8 + dump $ +i_cld: exx + res 3,d ; clear D + exx + xor a ; NOP + ld (adc_daa),a ; use binary mode for adc + ld (sbc_daa),a ; use binary mode for sbc + jp (ix) ; main_loop +op_d8_len: equ $-op_d8 + + + + org op_d9 + dump $ +i_cmp_ay: ld a,(de) ; CMP $nnnn,Y + inc de + add a,iyl ; add Y + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ex af,af' ; carry + ld a,b ; A + sub (hl) ; A-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_d9_len: equ $-op_d9 + + + + org op_da + dump $ +i_phx: ld a,iyh ; PHX [65C02] + exx + ld (hl),a ; push X + dec l ; S-- + exx + jp (ix) ; main_loop +op_da_len: equ $-op_da + + + + org op_db + dump $ +i_stp: dec de ; STP [65C02] + jp i_sei ; disable interrupts +op_db_len: equ $-op_db + + + + org op_dc + dump $ + jp i_undoc_3 +op_dc_len: equ $-op_dc + + + + org op_dd + dump $ +i_cmp_ax: ld a,(de) ; CMP $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + ex af,af' ; carry + ld a,b ; A + sub (hl) ; A-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_dd_len: equ $-op_dd + + + + org op_de + dump $ +i_dec_ax: ld a,(de) ; DEC $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + dec (hl) ; mem-- + ld c,(hl) ; set N Z + jp read_write_loop +op_de_len: equ $-op_de + + + + org op_df + dump $ +i_bbs_5: ld a,(de) ; BBS5 [65C02] + inc de + ld l,a + ld h,0 + bit 5,(hl) + jp nz,i_bra + inc de + jp (ix) ; zread_loop +op_df_len: equ $-op_df + + + + org op_e0 + dump $ +i_cpx_i: ld h,d + ld l,e + inc de + ex af,af' ; carry + ld a,iyh ; X + sub (hl) ; X-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_e0_len: equ $-op_e0 + + + + org op_e1 + dump $ +i_sbc_ix: ld a,(de) ; SBC ($xx,X) + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + jp i_sbc +op_e1_len: equ $-op_e1 + + + + org op_e2 + dump $ + jp i_undoc_2 +op_e2_len: equ $-op_e2 + + + + org op_e3 + dump $ + jp i_undoc_2 +op_e3_len: equ $-op_e3 + + + + org op_e4 + dump $ +i_cpx_z: ld a,(de) ; CPX $nn + inc de + ld l,a + ld h,0 + ex af,af' ; carry + ld a,iyh ; X + sub (hl) ; X-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_e4_len: equ $-op_e4 + + + + org op_e5 + dump $ +i_sbc_z: ld a,(de) ; SBC $nn + inc de + ld l,a + ld h,0 + jp i_sbc +op_e5_len: equ $-op_e5 + + + + org op_e6 + dump $ +i_inc_z: ld a,(de) ; INC $nn + inc de + ld l,a + ld h,0 + inc (hl) ; zero-page++ + ld c,(hl) ; set N Z + jp (ix) ; zread_write_loop +op_e6_len: equ $-op_e6 + + + + org op_e7 + dump $ +i_smb_6: ld a,(de) ; SMB6 [65C02] + inc de + ld l,a + ld h,0 + set 6,(hl) + jp (ix) ; zwrite_loop +op_e7_len: equ $-op_e7 + + + + org op_e8 + dump $ +i_inx: inc iyh ; X++ + ld c,iyh ; set N Z + jp (ix) ; main_loop +op_e8_len: equ $-op_e8 + + + + org op_e9 + dump $ +i_sbc_i: ld h,d + ld l,e + inc de +i_sbc: ex af,af' ; carry + ccf ; uses inverted carry + ld a,b + sbc a,(hl) ; A-M-(1-C) +sbc_daa: nop + ld b,a ; set A + ld c,a ; set N Z + ccf ; no carry for overflow + exx + jp pe,adcsbc_v + ld e,%00000000 + exx + ex af,af' ; set carry + jp read_loop +op_e9_len: equ $-op_e9 + + + + org op_ea + dump $ +i_nop: jp (ix) ; main_loop +op_ea_len: equ $-op_ea + + + + org op_eb + dump $ + jp i_undoc_2 +op_eb_len: equ $-op_eb + + + + org op_ec + dump $ +i_cpx_a: ex de,hl ; CPX $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + ex af,af' ; carry + ld a,iyh ; X + sub (hl) ; X-x (result discarded) + ld c,a ; set N Z + ccf + ex af,af' ; set carry + jp read_loop +op_ec_len: equ $-op_ec + + + + org op_ed + dump $ +i_sbc_a: ex de,hl ; SBC $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + jp i_sbc +op_ed_len: equ $-op_ed + + + + org op_ee + dump $ +i_inc_a: ex de,hl ; INC $nnnn + ld e,(hl) + inc hl + ld d,(hl) + inc hl + ex de,hl + inc (hl) ; mem++ + ld c,(hl) ; set N Z + jp read_write_loop +op_ee_len: equ $-op_ee + + + + org op_ef + dump $ +i_bbs_6: ld a,(de) ; BBS6 [65C02] + inc de + ld l,a + ld h,0 + bit 6,(hl) + jp nz,i_bra + inc de + jp (ix) ; zread_loop +op_ef_len: equ $-op_ef + + + + org op_f0 + dump $ +i_beq: inc c + dec c + jp z,i_bra ; branch if zero + inc de + jp (ix) ; main_loop +op_f0_len: equ $-op_f0 + + + + org op_f1 + dump $ +i_sbc_iy: ld a,(de) ; SBC ($nn),Y + inc de + ld l,a + ld h,0 + ld a,iyl ; Y + add a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,0 + adc a,h + ld h,a + jp i_sbc +op_f1_len: equ $-op_f1 + + + + org op_f2 + dump $ +i_sbc_iz: ld a,(de) ; indirect zero-page [65C02] + inc de + ld l,a + ld h,0 + ld a,(hl) + inc l ; (may wrap in zero page) + ld h,(hl) + ld l,a + ld a,(hl) + inc hl + ld h,(hl) + ld l,a + jp i_sbc +op_f2_len: equ $-op_f2 + + + + org op_f3 + dump $ + jp i_undoc_2 +op_f3_len: equ $-op_f3 + + + + org op_f4 + dump $ + jp i_undoc_2 +op_f4_len: equ $-op_f4 + + + + org op_f5 + dump $ +i_sbc_zx: ld a,(de) ; SBC $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + jp i_sbc +op_f5_len: equ $-op_f5 + + + + org op_f6 + dump $ +i_inc_zx: ld a,(de) ; INC $nn,X + inc de + add a,iyh ; add X (may wrap in zero page) + ld l,a + ld h,0 + inc (hl) ; zero-page++ + ld c,(hl) ; set N Z + jp (ix) ; zread_write_loop +op_f6_len: equ $-op_f6 + + + + org op_f7 + dump $ +i_smb_7: ld a,(de) ; SMB7 [65C02] + inc de + ld l,a + ld h,0 + set 7,(hl) + jp (ix) ; zwrite_loop +op_f7_len: equ $-op_f7 + + + + org op_f8 + dump $ +i_sed: exx + set 3,d ; set D + exx + ld a,&27 ; DAA + ld (adc_daa),a ; use decimal mode for adc + ld (sbc_daa),a ; use decimal mode for sbc + jp (ix) ; main_loop +op_f8_len: equ $-op_f8 + + + + org op_f9 + dump $ +i_sbc_ay: ld a,(de) ; SBC $nnnn,Y + inc de + add a,iyl ; add Y + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + jp i_sbc +op_f9_len: equ $-op_f9 + + + + org op_fa + dump $ +i_plx: exx ; PLX [65C02] + inc l ; S++ + ld a,(hl) ; pop + exx + ld iyh,a ; set X + ld c,a ; set N Z + jp (ix) ; main_loop +op_fa_len: equ $-op_fa + + + + org op_fb + dump $ + jp i_undoc_3 +op_fb_len: equ $-op_fb + + + + org op_fc + dump $ + jp i_undoc_3 +op_fc_len: equ $-op_fc + + + + org op_fd + dump $ +i_sbc_ax: ld a,(de) ; SBC $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + jp i_sbc +op_fd_len: equ $-op_fd + + + + org op_fe + dump $ +i_inc_ax: ld a,(de) ; INC $nnnn,X + inc de + add a,iyh ; add X + ld l,a + ld a,(de) + inc de + adc a,0 + ld h,a + inc (hl) ; mem++ + ld c,(hl) ; set N Z + jp read_write_loop +op_fe_len: equ $-op_fe + + + + org op_ff + dump $ +i_bbs_7: ld a,(de) ; BBS7 [65C02] + inc de + ld l,a + ld h,0 + bit 7,(hl) + jp nz,i_bra + inc de + jp (ix) ; zread_loop +op_ff_len: equ $-op_ff