diff --git a/bsnes.cfg b/bsnes.cfg new file mode 100644 index 00000000..f9249f54 --- /dev/null +++ b/bsnes.cfg @@ -0,0 +1,21 @@ +#[bsnes v0.007 configuration file] + +#[video mode] +# 0: 256x224w +# 1: 512x448w +# 2: 960x720w +video.mode = 1 + +#[video memory type] +# true: video ram (VRAM) +# false: system ram (SRAM) +# +# VRAM results in the image being stretched in hardware, +# which is generally much faster, and automatically adds +# bilinear filtering (if the card supports it). +# +# However, some video cards end up taking a major speed +# loss when this option is enabled. It is also the only +# way to guarantee that the output image will not be +# filtered. +video.use_vram = true diff --git a/bsnes_g2.exe b/bsnes_g2.exe index 02e0cd26..2b27685d 100644 Binary files a/bsnes_g2.exe and b/bsnes_g2.exe differ diff --git a/demo_1.smc b/demo_1.smc new file mode 100644 index 00000000..b2716e5b Binary files /dev/null and b/demo_1.smc differ diff --git a/demo_1.srm b/demo_1.srm new file mode 100644 index 00000000..e2c8fe92 Binary files /dev/null and b/demo_1.srm differ diff --git a/demo_2.smc b/demo_2.smc new file mode 100644 index 00000000..fb32878f Binary files /dev/null and b/demo_2.smc differ diff --git a/demo_2.srm b/demo_2.srm new file mode 100644 index 00000000..e2c8fe92 Binary files /dev/null and b/demo_2.srm differ diff --git a/src/base.h b/src/base.h index 0e35f1c8..0be99a9b 100644 --- a/src/base.h +++ b/src/base.h @@ -1,20 +1,4 @@ -//platform-independant includes -#include -#include -#include - -//typecasts -typedef unsigned char byte; -typedef unsigned short word; -typedef unsigned long ulong; - -typedef unsigned char uint8; -typedef unsigned short uint16; -typedef unsigned long uint32; - -typedef signed char int8; -typedef signed short int16; -typedef signed long int32; +#include "lib/libbase.h" //structs typedef struct { diff --git a/src/clock/bclock/bclock.cpp b/src/clock/bclock/bclock.cpp index b46ccf8f..4c38f5d9 100644 --- a/src/clock/bclock/bclock.cpp +++ b/src/clock/bclock/bclock.cpp @@ -71,9 +71,7 @@ void bClock::inc_vcounter() { cc1.frame_lines = 262; } } - cc1.render_frame = true; - cpu->frame(); - if(frameskip.notify_ppu == true)ppu->frame(); + signal_frame = true; } if(status.interlace == false && status.interlace_field == 1 && status.vcounter == 240) { @@ -83,13 +81,7 @@ void bClock::inc_vcounter() { } cc1.dram_refreshed = false; - - cpu->scanline(); - if(frameskip.notify_ppu == true)ppu->scanline(); - -//if(status.vcounter == visible_scanlines()) { -// cc1.render_frame = true; -//} + signal_scanline = true; } /* @@ -121,12 +113,6 @@ uint32 new_cycles, cycles; inc_vcounter(); } } - cc1.last_pos = cc1.pos; - - if(cc1.pos > cc1.frequency) { - cc1.pos -= cc1.frequency; - cc1.last_pos -= cc1.frequency; - } if(status.interlace == false && status.interlace_field == 1 && status.vcounter == 240) { status.hcounter = status.hcycles >> 2; @@ -134,6 +120,12 @@ uint32 new_cycles, cycles; //1288 = 322 * 4, 1306 = 326 * 4 + 2 status.hcounter = (status.hcycles - ((status.hcycles > 1288) << 1) - ((status.hcycles > 1306) << 1)) >> 2; } + + cc1.last_pos = cc1.pos; + if(cc1.pos > cc1.frequency) { + cc1.pos -= cc1.frequency; + cc1.last_pos -= cc1.frequency; + } } void bClock::set_frameskip(uint8 fs) { @@ -141,21 +133,11 @@ void bClock::set_frameskip(uint8 fs) { frameskip.new_count = fs; } -bool bClock::update_frame() { - if(cc1.render_frame == true) { - cc1.render_frame = false; - return true; - } - return false; -} - void bClock::power() { reset(); } void bClock::reset() { - cc1.render_frame = false; - //upon SNES reset, start at scanline 0 non-interlace cc1.frame_cycles = 262 * 1364; cc1.frame_lines = 262; @@ -178,6 +160,8 @@ void bClock::reset() { cc2.pos = 0; + signal_scanline = false; + signal_frame = false; sync(); } @@ -185,6 +169,18 @@ void bClock::run() { cpu->run(); if(frameskip.notify_ppu == true)ppu->run(); sync(); + + if(signal_frame == true) { + signal_frame = false; + cpu->frame(); + if(frameskip.notify_ppu == true)ppu->frame(); + } + + if(signal_scanline == true) { + signal_scanline = false; + cpu->scanline(); + if(frameskip.notify_ppu == true)ppu->scanline(); + } } void bClock::add_cc1_cycles(uint32 cycles) { diff --git a/src/clock/bclock/bclock.h b/src/clock/bclock/bclock.h index befb6448..89b32d2b 100644 --- a/src/clock/bclock/bclock.h +++ b/src/clock/bclock/bclock.h @@ -4,6 +4,7 @@ struct { bool changed, notify_ppu; uint8 count, new_count, pos; }frameskip; +bool signal_scanline, signal_frame; void frameskip_update_status(); void inc_vcounter(); void dram_refresh_test(); @@ -16,8 +17,6 @@ public: uint16 line_cycles; bool dram_refreshed; //whether or not dram has been refreshed on this line uint16 dram_refresh_pos; - - bool render_frame; }cc1; struct { uint32 frequency; @@ -25,7 +24,6 @@ public: }cc2; void set_frameskip(uint8 fs); - bool update_frame(); void add_cc1_cycles(uint32 cycles); void add_cc2_cycles(uint32 cycles); diff --git a/src/clock/clock.h b/src/clock/clock.h index 551a1eb1..4795c330 100644 --- a/src/clock/clock.h +++ b/src/clock/clock.h @@ -22,7 +22,6 @@ public: virtual uint16 visible_scanlines(); virtual void set_frameskip(uint8 fs); - virtual bool update_frame() = 0; virtual void add_cc1_cycles(uint32 cycles) = 0; virtual void add_cc2_cycles(uint32 cycles) = 0; diff --git a/src/cpu/bcpu/bcpu.cpp b/src/cpu/bcpu/bcpu.cpp index bc9d9c0d..9552a471 100644 --- a/src/cpu/bcpu/bcpu.cpp +++ b/src/cpu/bcpu/bcpu.cpp @@ -58,17 +58,26 @@ void bCPU::irq(uint16 addr) { void bCPU::run() { uint16 v, h, hc, vs; + v = clock->vcounter(); + h = clock->hcounter(); + hc = clock->hcycles(); + vs = clock->visible_scanlines(); + +//HDMA test + if(v < vs && h >= 278) { + if(status.hdma_triggered == false) { + status.hdma_triggered = true; + dma->hdma_run(); + return; + } + } + switch(cpustate) { case CPUSTATE_RUN: case CPUSTATE_WAI: - v = clock->vcounter(); - h = clock->hcounter(); - hc = clock->hcycles(); - vs = clock->visible_scanlines(); - //NMI test if(v >= (vs + 1) && status.nmi_triggered == false) { - if((v == (vs + 1) && hc >= 12) || (v >= (vs + 1))) { + if((v == (vs + 1) && hc >= 12) || (v > (vs + 1))) { status.nmi_triggered = true; status.nmi_pin = 0; if(status.nmi_enabled == true) { @@ -104,12 +113,6 @@ uint16 v, h, hc, vs; } } - //HDMA test - if(v < vs && h >= 278 && dma->hdma_triggered == false) { - dma->hdma_run(); - dma->hdma_triggered = true; - } - exec_opcode(); break; case CPUSTATE_DMA: @@ -123,16 +126,25 @@ uint16 v, h, hc, vs; void bCPU::scanline() { uint16 v = clock->vcounter(); + status.hdma_triggered = false; + if(v == 225 && status.auto_joypad_poll == true) { snes->poll_input(); +//When the SNES auto-polls the joypads, it writes 1, then 0 to +//$4016, then reads from each 16 times to get the joypad state +//information. As a result, the joypad read positions are set +//to 16 after such a poll. Position 16 is the controller +//connected status bit. + status.joypad1_read_pos = 16; } if(status.virq_enabled == false) { status.irq_pin = 1; } - dma->hdma_triggered = false; } void bCPU::frame() { + status.hdma_triggered = false; + status.nmi_triggered = false; status.r4210_read = false; @@ -165,6 +177,10 @@ void bCPU::reset() { dma->reset(); mmio_reset(); + optbl = optbl_e; + + status.hdma_triggered = false; + status.nmi_triggered = false; status.nmi_pin = 1; status.r4210_read = false; @@ -290,6 +306,8 @@ void bCPU::stack_write(uint8 value) { bCPU::bCPU() { dma = new bDMA(this); mmio = new bCPUMMIO(this); + + init_op_tables(); } bCPU::~bCPU() { diff --git a/src/cpu/bcpu/bcpu.h b/src/cpu/bcpu/bcpu.h index bb66f18b..8bbcb791 100644 --- a/src/cpu/bcpu/bcpu.h +++ b/src/cpu/bcpu/bcpu.h @@ -30,8 +30,6 @@ struct { uint32 hdma_address, hdma_iaddress; bool hdma_completed; }channel[8]; -bool hdma_triggered; - void hdma_write(uint8 i, uint8 l, uint8 x); void hdma_run(); void hdma_initialize(); @@ -58,6 +56,10 @@ bCPU *cpu; }; class bCPU : public CPU { +private: +typedef void (bCPU::*op)(); +op *optbl, optbl_e[256], optbl_MX[256], optbl_Mx[256], optbl_mX[256], optbl_mx[256]; + public: enum { CPUSTATE_RUN = 0, CPUSTATE_DMA, CPUSTATE_WAI, CPUSTATE_STP }; uint8 cpustate; @@ -72,6 +74,8 @@ CPUReg24 aa, rd; uint8 dp, sp; struct { + bool hdma_triggered; + bool nmi_triggered; bool nmi_pin; bool r4210_read; @@ -175,406 +179,285 @@ struct { void cpu_c6(uint16 a); void cpu_io(); +//opcode functions + void init_op_tables(); + //op_adc - void flags_adc_b(); - void flags_adc_w(); + inline void flags_adc_b(); + inline void flags_adc_w(); void op_adc_constb(); void op_adc_constw(); - void op_adc_const(); void op_adc_addrb(); void op_adc_addrw(); - void op_adc_addr(); void op_adc_addrxb(); void op_adc_addrxw(); - void op_adc_addrx(); void op_adc_dpb(); void op_adc_dpw(); - void op_adc_dp(); void op_adc_idpb(); void op_adc_idpw(); - void op_adc_idp(); void op_adc_ildpb(); void op_adc_ildpw(); - void op_adc_ildp(); void op_adc_longb(); void op_adc_longw(); - void op_adc_long(); void op_adc_longxb(); void op_adc_longxw(); - void op_adc_longx(); void op_adc_addryb(); void op_adc_addryw(); - void op_adc_addry(); void op_adc_dpxb(); void op_adc_dpxw(); - void op_adc_dpx(); void op_adc_idpxb(); void op_adc_idpxw(); - void op_adc_idpx(); void op_adc_idpyb(); void op_adc_idpyw(); - void op_adc_idpy(); void op_adc_ildpyb(); void op_adc_ildpyw(); - void op_adc_ildpy(); void op_adc_srb(); void op_adc_srw(); - void op_adc_sr(); void op_adc_isryb(); void op_adc_isryw(); - void op_adc_isry(); //op_and - void flags_and_b(); - void flags_and_w(); + inline void flags_and_b(); + inline void flags_and_w(); void op_and_constb(); void op_and_constw(); - void op_and_const(); void op_and_addrb(); void op_and_addrw(); - void op_and_addr(); void op_and_addrxb(); void op_and_addrxw(); - void op_and_addrx(); void op_and_dpb(); void op_and_dpw(); - void op_and_dp(); void op_and_idpb(); void op_and_idpw(); - void op_and_idp(); void op_and_ildpb(); void op_and_ildpw(); - void op_and_ildp(); void op_and_longb(); void op_and_longw(); - void op_and_long(); void op_and_longxb(); void op_and_longxw(); - void op_and_longx(); void op_and_addryb(); void op_and_addryw(); - void op_and_addry(); void op_and_dpxb(); void op_and_dpxw(); - void op_and_dpx(); void op_and_idpxb(); void op_and_idpxw(); - void op_and_idpx(); void op_and_idpyb(); void op_and_idpyw(); - void op_and_idpy(); void op_and_ildpyb(); void op_and_ildpyw(); - void op_and_ildpy(); void op_and_srb(); void op_and_srw(); - void op_and_sr(); void op_and_isryb(); void op_and_isryw(); - void op_and_isry(); //op_cmp - void flags_cmp_b(); - void flags_cmp_w(); + inline void flags_cmp_b(); + inline void flags_cmp_w(); void op_cmp_constb(); void op_cmp_constw(); - void op_cmp_const(); void op_cmp_addrb(); void op_cmp_addrw(); - void op_cmp_addr(); void op_cmp_addrxb(); void op_cmp_addrxw(); - void op_cmp_addrx(); void op_cmp_dpb(); void op_cmp_dpw(); - void op_cmp_dp(); void op_cmp_idpb(); void op_cmp_idpw(); - void op_cmp_idp(); void op_cmp_ildpb(); void op_cmp_ildpw(); - void op_cmp_ildp(); void op_cmp_longb(); void op_cmp_longw(); - void op_cmp_long(); void op_cmp_longxb(); void op_cmp_longxw(); - void op_cmp_longx(); void op_cmp_addryb(); void op_cmp_addryw(); - void op_cmp_addry(); void op_cmp_dpxb(); void op_cmp_dpxw(); - void op_cmp_dpx(); void op_cmp_idpxb(); void op_cmp_idpxw(); - void op_cmp_idpx(); void op_cmp_idpyb(); void op_cmp_idpyw(); - void op_cmp_idpy(); void op_cmp_ildpyb(); void op_cmp_ildpyw(); - void op_cmp_ildpy(); void op_cmp_srb(); void op_cmp_srw(); - void op_cmp_sr(); void op_cmp_isryb(); void op_cmp_isryw(); - void op_cmp_isry(); //op_eor - void flags_eor_b(); - void flags_eor_w(); + inline void flags_eor_b(); + inline void flags_eor_w(); void op_eor_constb(); void op_eor_constw(); - void op_eor_const(); void op_eor_addrb(); void op_eor_addrw(); - void op_eor_addr(); void op_eor_addrxb(); void op_eor_addrxw(); - void op_eor_addrx(); void op_eor_dpb(); void op_eor_dpw(); - void op_eor_dp(); void op_eor_idpb(); void op_eor_idpw(); - void op_eor_idp(); void op_eor_ildpb(); void op_eor_ildpw(); - void op_eor_ildp(); void op_eor_longb(); void op_eor_longw(); - void op_eor_long(); void op_eor_longxb(); void op_eor_longxw(); - void op_eor_longx(); void op_eor_addryb(); void op_eor_addryw(); - void op_eor_addry(); void op_eor_dpxb(); void op_eor_dpxw(); - void op_eor_dpx(); void op_eor_idpxb(); void op_eor_idpxw(); - void op_eor_idpx(); void op_eor_idpyb(); void op_eor_idpyw(); - void op_eor_idpy(); void op_eor_ildpyb(); void op_eor_ildpyw(); - void op_eor_ildpy(); void op_eor_srb(); void op_eor_srw(); - void op_eor_sr(); void op_eor_isryb(); void op_eor_isryw(); - void op_eor_isry(); //op_incdec void op_incb(); void op_incw(); - void op_inc(); void op_inc_addrb(); void op_inc_addrw(); - void op_inc_addr(); void op_inc_addrxb(); void op_inc_addrxw(); - void op_inc_addrx(); void op_inc_dpb(); void op_inc_dpw(); - void op_inc_dp(); void op_inc_dpxb(); void op_inc_dpxw(); - void op_inc_dpx(); void op_inxb(); void op_inxw(); - void op_inx(); void op_inyb(); void op_inyw(); - void op_iny(); void op_decb(); void op_decw(); - void op_dec(); void op_dec_addrb(); void op_dec_addrw(); - void op_dec_addr(); void op_dec_addrxb(); void op_dec_addrxw(); - void op_dec_addrx(); void op_dec_dpb(); void op_dec_dpw(); - void op_dec_dp(); void op_dec_dpxb(); void op_dec_dpxw(); - void op_dec_dpx(); void op_dexb(); void op_dexw(); - void op_dex(); void op_deyb(); void op_deyw(); - void op_dey(); //op_lda - void flags_lda_b(); - void flags_lda_w(); + inline void flags_lda_b(); + inline void flags_lda_w(); void op_lda_constb(); void op_lda_constw(); - void op_lda_const(); void op_lda_addrb(); void op_lda_addrw(); - void op_lda_addr(); void op_lda_addrxb(); void op_lda_addrxw(); - void op_lda_addrx(); void op_lda_dpb(); void op_lda_dpw(); - void op_lda_dp(); void op_lda_idpb(); void op_lda_idpw(); - void op_lda_idp(); void op_lda_ildpb(); void op_lda_ildpw(); - void op_lda_ildp(); void op_lda_longb(); void op_lda_longw(); - void op_lda_long(); void op_lda_longxb(); void op_lda_longxw(); - void op_lda_longx(); void op_lda_addryb(); void op_lda_addryw(); - void op_lda_addry(); void op_lda_dpxb(); void op_lda_dpxw(); - void op_lda_dpx(); void op_lda_idpxb(); void op_lda_idpxw(); - void op_lda_idpx(); void op_lda_idpyb(); void op_lda_idpyw(); - void op_lda_idpy(); void op_lda_ildpyb(); void op_lda_ildpyw(); - void op_lda_ildpy(); void op_lda_srb(); void op_lda_srw(); - void op_lda_sr(); void op_lda_isryb(); void op_lda_isryw(); - void op_lda_isry(); //op_misc - void flags_bit_b(); - void flags_bit_w(); + inline void flags_bit_b(); + inline void flags_bit_w(); void op_bit_constb(); void op_bit_constw(); - void op_bit_const(); void op_bit_addrb(); void op_bit_addrw(); - void op_bit_addr(); void op_bit_addrxb(); void op_bit_addrxw(); - void op_bit_addrx(); void op_bit_dpb(); void op_bit_dpw(); - void op_bit_dp(); void op_bit_dpxb(); void op_bit_dpxw(); - void op_bit_dpx(); - void flags_cpx_b(); - void flags_cpx_w(); + inline void flags_cpx_b(); + inline void flags_cpx_w(); void op_cpx_constb(); void op_cpx_constw(); - void op_cpx_const(); void op_cpx_addrb(); void op_cpx_addrw(); - void op_cpx_addr(); void op_cpx_dpb(); void op_cpx_dpw(); - void op_cpx_dp(); - void flags_cpy_b(); - void flags_cpy_w(); + inline void flags_cpy_b(); + inline void flags_cpy_w(); void op_cpy_constb(); void op_cpy_constw(); - void op_cpy_const(); void op_cpy_addrb(); void op_cpy_addrw(); - void op_cpy_addr(); void op_cpy_dpb(); void op_cpy_dpw(); - void op_cpy_dp(); - void flags_ldx_b(); - void flags_ldx_w(); + inline void flags_ldx_b(); + inline void flags_ldx_w(); void op_ldx_constb(); void op_ldx_constw(); - void op_ldx_const(); void op_ldx_addrb(); void op_ldx_addrw(); - void op_ldx_addr(); void op_ldx_addryb(); void op_ldx_addryw(); - void op_ldx_addry(); void op_ldx_dpb(); void op_ldx_dpw(); - void op_ldx_dp(); void op_ldx_dpyb(); void op_ldx_dpyw(); - void op_ldx_dpy(); - void flags_ldy_b(); - void flags_ldy_w(); + inline void flags_ldy_b(); + inline void flags_ldy_w(); void op_ldy_constb(); void op_ldy_constw(); - void op_ldy_const(); void op_ldy_addrb(); void op_ldy_addrw(); - void op_ldy_addr(); void op_ldy_addrxb(); void op_ldy_addrxw(); - void op_ldy_addrx(); void op_ldy_dpb(); void op_ldy_dpw(); - void op_ldy_dp(); void op_ldy_dpxb(); void op_ldy_dpxw(); - void op_ldy_dpx(); void op_stx_addrb(); void op_stx_addrw(); - void op_stx_addr(); void op_stx_dpb(); void op_stx_dpw(); - void op_stx_dp(); void op_stx_dpyb(); void op_stx_dpyw(); - void op_stx_dpy(); void op_sty_addrb(); void op_sty_addrw(); - void op_sty_addr(); void op_sty_dpb(); void op_sty_dpw(); - void op_sty_dp(); void op_sty_dpxb(); void op_sty_dpxw(); - void op_sty_dpx(); void op_stz_addrb(); void op_stz_addrw(); - void op_stz_addr(); void op_stz_addrxb(); void op_stz_addrxw(); - void op_stz_addrx(); void op_stz_dpb(); void op_stz_dpw(); - void op_stz_dp(); void op_stz_dpxb(); void op_stz_dpxw(); - void op_stz_dpx(); void op_xba(); void op_trb_addrb(); void op_trb_addrw(); - void op_trb_addr(); void op_trb_dpb(); void op_trb_dpw(); - void op_trb_dp(); void op_tsb_addrb(); void op_tsb_addrw(); - void op_tsb_addr(); void op_tsb_dpb(); void op_tsb_dpw(); - void op_tsb_dp(); void op_mvn(); void op_mvp(); void op_brk(); @@ -595,80 +478,57 @@ struct { void op_sep(); void op_taxb(); void op_taxw(); - void op_tax(); void op_tayb(); void op_tayw(); - void op_tay(); void op_tcd(); void op_tcs(); void op_tdc(); void op_tsc(); void op_tsxb(); void op_tsxw(); - void op_tsx(); void op_txab(); void op_txaw(); - void op_txa(); void op_txsb(); void op_txsw(); - void op_txs(); void op_txyb(); void op_txyw(); - void op_txy(); void op_tyab(); void op_tyaw(); - void op_tya(); void op_tyxb(); void op_tyxw(); - void op_tyx(); //op_ora - void flags_ora_b(); - void flags_ora_w(); + inline void flags_ora_b(); + inline void flags_ora_w(); void op_ora_constb(); void op_ora_constw(); - void op_ora_const(); void op_ora_addrb(); void op_ora_addrw(); - void op_ora_addr(); void op_ora_addrxb(); void op_ora_addrxw(); - void op_ora_addrx(); void op_ora_dpb(); void op_ora_dpw(); - void op_ora_dp(); void op_ora_idpb(); void op_ora_idpw(); - void op_ora_idp(); void op_ora_ildpb(); void op_ora_ildpw(); - void op_ora_ildp(); void op_ora_longb(); void op_ora_longw(); - void op_ora_long(); void op_ora_longxb(); void op_ora_longxw(); - void op_ora_longx(); void op_ora_addryb(); void op_ora_addryw(); - void op_ora_addry(); void op_ora_dpxb(); void op_ora_dpxw(); - void op_ora_dpx(); void op_ora_idpxb(); void op_ora_idpxw(); - void op_ora_idpx(); void op_ora_idpyb(); void op_ora_idpyw(); - void op_ora_idpy(); void op_ora_ildpyb(); void op_ora_ildpyw(); - void op_ora_ildpy(); void op_ora_srb(); void op_ora_srw(); - void op_ora_sr(); void op_ora_isryb(); void op_ora_isryw(); - void op_ora_isry(); //op_pc void op_jmp_addr(); void op_jmp_long(); @@ -680,7 +540,6 @@ struct { void op_jsr_iaddrx(); void op_rtie(); void op_rtin(); - void op_rti(); void op_rts(); void op_rtl(); void op_bra(); @@ -694,183 +553,128 @@ struct { void op_bvc(); void op_bvs(); //op_sbc - void flags_sbc_b(); - void flags_sbc_w(); + inline void flags_sbc_b(); + inline void flags_sbc_w(); void op_sbc_constb(); void op_sbc_constw(); - void op_sbc_const(); void op_sbc_addrb(); void op_sbc_addrw(); - void op_sbc_addr(); void op_sbc_addrxb(); void op_sbc_addrxw(); - void op_sbc_addrx(); void op_sbc_dpb(); void op_sbc_dpw(); - void op_sbc_dp(); void op_sbc_idpb(); void op_sbc_idpw(); - void op_sbc_idp(); void op_sbc_ildpb(); void op_sbc_ildpw(); - void op_sbc_ildp(); void op_sbc_longb(); void op_sbc_longw(); - void op_sbc_long(); void op_sbc_longxb(); void op_sbc_longxw(); - void op_sbc_longx(); void op_sbc_addryb(); void op_sbc_addryw(); - void op_sbc_addry(); void op_sbc_dpxb(); void op_sbc_dpxw(); - void op_sbc_dpx(); void op_sbc_idpxb(); void op_sbc_idpxw(); - void op_sbc_idpx(); void op_sbc_idpyb(); void op_sbc_idpyw(); - void op_sbc_idpy(); void op_sbc_ildpyb(); void op_sbc_ildpyw(); - void op_sbc_ildpy(); void op_sbc_srb(); void op_sbc_srw(); - void op_sbc_sr(); void op_sbc_isryb(); void op_sbc_isryw(); - void op_sbc_isry(); //op_shift void op_aslb(); void op_aslw(); - void op_asl(); void op_asl_addrb(); void op_asl_addrw(); - void op_asl_addr(); void op_asl_addrxb(); void op_asl_addrxw(); - void op_asl_addrx(); void op_asl_dpb(); void op_asl_dpw(); - void op_asl_dp(); void op_asl_dpxb(); void op_asl_dpxw(); - void op_asl_dpx(); void op_lsrb(); void op_lsrw(); - void op_lsr(); void op_lsr_addrb(); void op_lsr_addrw(); - void op_lsr_addr(); void op_lsr_addrxb(); void op_lsr_addrxw(); - void op_lsr_addrx(); void op_lsr_dpb(); void op_lsr_dpw(); - void op_lsr_dp(); void op_lsr_dpxb(); void op_lsr_dpxw(); - void op_lsr_dpx(); void op_rolb(); void op_rolw(); - void op_rol(); void op_rol_addrb(); void op_rol_addrw(); - void op_rol_addr(); void op_rol_addrxb(); void op_rol_addrxw(); - void op_rol_addrx(); void op_rol_dpb(); void op_rol_dpw(); - void op_rol_dp(); void op_rol_dpxb(); void op_rol_dpxw(); - void op_rol_dpx(); void op_rorb(); void op_rorw(); - void op_ror(); void op_ror_addrb(); void op_ror_addrw(); - void op_ror_addr(); void op_ror_addrxb(); void op_ror_addrxw(); - void op_ror_addrx(); void op_ror_dpb(); void op_ror_dpw(); - void op_ror_dp(); void op_ror_dpxb(); void op_ror_dpxw(); - void op_ror_dpx(); //op_sta void op_sta_addrb(); void op_sta_addrw(); - void op_sta_addr(); void op_sta_addrxb(); void op_sta_addrxw(); - void op_sta_addrx(); void op_sta_dpb(); void op_sta_dpw(); - void op_sta_dp(); void op_sta_idpb(); void op_sta_idpw(); - void op_sta_idp(); void op_sta_ildpb(); void op_sta_ildpw(); - void op_sta_ildp(); void op_sta_longb(); void op_sta_longw(); - void op_sta_long(); void op_sta_longxb(); void op_sta_longxw(); - void op_sta_longx(); void op_sta_addryb(); void op_sta_addryw(); - void op_sta_addry(); void op_sta_dpxb(); void op_sta_dpxw(); - void op_sta_dpx(); void op_sta_idpxb(); void op_sta_idpxw(); - void op_sta_idpx(); void op_sta_idpyb(); void op_sta_idpyw(); - void op_sta_idpy(); void op_sta_ildpyb(); void op_sta_ildpyw(); - void op_sta_ildpy(); void op_sta_srb(); void op_sta_srw(); - void op_sta_sr(); void op_sta_isryb(); void op_sta_isryw(); - void op_sta_isry(); //op_stack void op_phab(); void op_phaw(); - void op_pha(); void op_phb(); void op_phd(); void op_phk(); void op_php(); void op_phxb(); void op_phxw(); - void op_phx(); void op_phyb(); void op_phyw(); - void op_phy(); void op_plab(); void op_plaw(); - void op_pla(); void op_plb(); void op_pld(); void op_plp(); void op_plxb(); void op_plxw(); - void op_plx(); void op_plyb(); void op_plyw(); - void op_ply(); void op_pea(); void op_pei(); void op_per(); diff --git a/src/cpu/bcpu/bcpu_exec.cpp b/src/cpu/bcpu/bcpu_exec.cpp index 5b147ef5..b809ce03 100644 --- a/src/cpu/bcpu/bcpu_exec.cpp +++ b/src/cpu/bcpu/bcpu_exec.cpp @@ -1,280 +1,519 @@ void bCPU::exec_opcode() { -byte op; - op = op_read(); - switch(op) { -/* 0x */ - case 0x00:op_brk(); break; - case 0x01:op_ora_idpx(); break; - case 0x02:op_cop(); break; - case 0x03:op_ora_sr(); break; - case 0x04:op_tsb_dp(); break; - case 0x05:op_ora_dp(); break; - case 0x06:op_asl_dp(); break; - case 0x07:op_ora_ildp(); break; - case 0x08:op_php(); break; - case 0x09:op_ora_const();break; - case 0x0a:op_asl(); break; - case 0x0b:op_phd(); break; - case 0x0c:op_tsb_addr(); break; - case 0x0d:op_ora_addr(); break; - case 0x0e:op_asl_addr(); break; - case 0x0f:op_ora_long(); break; -/* 1x */ - case 0x10:op_bpl(); break; - case 0x11:op_ora_idpy(); break; - case 0x12:op_ora_idp(); break; - case 0x13:op_ora_isry(); break; - case 0x14:op_trb_dp(); break; - case 0x15:op_ora_dpx(); break; - case 0x16:op_asl_dpx(); break; - case 0x17:op_ora_ildpy();break; - case 0x18:op_clc(); break; - case 0x19:op_ora_addry();break; - case 0x1a:op_inc(); break; - case 0x1b:op_tcs(); break; - case 0x1c:op_trb_addr(); break; - case 0x1d:op_ora_addrx();break; - case 0x1e:op_asl_addrx();break; - case 0x1f:op_ora_longx();break; -/* 2x */ - case 0x20:op_jsr_addr(); break; - case 0x21:op_and_idpx(); break; - case 0x22:op_jsr_long(); break; - case 0x23:op_and_sr(); break; - case 0x24:op_bit_dp(); break; - case 0x25:op_and_dp(); break; - case 0x26:op_rol_dp(); break; - case 0x27:op_and_ildp(); break; - case 0x28:op_plp(); break; - case 0x29:op_and_const();break; - case 0x2a:op_rol(); break; - case 0x2b:op_pld(); break; - case 0x2c:op_bit_addr(); break; - case 0x2d:op_and_addr(); break; - case 0x2e:op_rol_addr(); break; - case 0x2f:op_and_long(); break; -/* 3x */ - case 0x30:op_bmi(); break; - case 0x31:op_and_idpy(); break; - case 0x32:op_and_idp(); break; - case 0x33:op_and_isry(); break; - case 0x34:op_bit_dpx(); break; - case 0x35:op_and_dpx(); break; - case 0x36:op_rol_dpx(); break; - case 0x37:op_and_ildpy();break; - case 0x38:op_sec(); break; - case 0x39:op_and_addry();break; - case 0x3a:op_dec(); break; - case 0x3b:op_tsc(); break; - case 0x3c:op_bit_addrx();break; - case 0x3d:op_and_addrx();break; - case 0x3e:op_rol_addrx();break; - case 0x3f:op_and_longx();break; -/* 4x */ - case 0x40:op_rti(); break; - case 0x41:op_eor_idpx(); break; - case 0x42:op_wdm(); break; - case 0x43:op_eor_sr(); break; - case 0x44:op_mvp(); break; - case 0x45:op_eor_dp(); break; - case 0x46:op_lsr_dp(); break; - case 0x47:op_eor_ildp(); break; - case 0x48:op_pha(); break; - case 0x49:op_eor_const();break; - case 0x4a:op_lsr(); break; - case 0x4b:op_phk(); break; - case 0x4c:op_jmp_addr(); break; - case 0x4d:op_eor_addr(); break; - case 0x4e:op_lsr_addr(); break; - case 0x4f:op_eor_long(); break; -/* 5x */ - case 0x50:op_bvc(); break; - case 0x51:op_eor_idpy(); break; - case 0x52:op_eor_idp(); break; - case 0x53:op_eor_isry(); break; - case 0x54:op_mvn(); break; - case 0x55:op_eor_dpx(); break; - case 0x56:op_lsr_dpx(); break; - case 0x57:op_eor_ildpy();break; - case 0x58:op_cli(); break; - case 0x59:op_eor_addry();break; - case 0x5a:op_phy(); break; - case 0x5b:op_tcd(); break; - case 0x5c:op_jmp_long(); break; - case 0x5d:op_eor_addrx();break; - case 0x5e:op_lsr_addrx();break; - case 0x5f:op_eor_longx();break; -/* 6x */ - case 0x60:op_rts(); break; - case 0x61:op_adc_idpx(); break; - case 0x62:op_per(); break; - case 0x63:op_adc_sr(); break; - case 0x64:op_stz_dp(); break; - case 0x65:op_adc_dp(); break; - case 0x66:op_ror_dp(); break; - case 0x67:op_adc_ildp(); break; - case 0x68:op_pla(); break; - case 0x69:op_adc_const();break; - case 0x6a:op_ror(); break; - case 0x6b:op_rtl(); break; - case 0x6c:op_jmp_iaddr();break; - case 0x6d:op_adc_addr(); break; - case 0x6e:op_ror_addr(); break; - case 0x6f:op_adc_long(); break; -/* 7x */ - case 0x70:op_bvs(); break; - case 0x71:op_adc_idpy(); break; - case 0x72:op_adc_idp(); break; - case 0x73:op_adc_isry(); break; - case 0x74:op_stz_dpx(); break; - case 0x75:op_adc_dpx(); break; - case 0x76:op_ror_dpx(); break; - case 0x77:op_adc_ildpy(); break; - case 0x78:op_sei(); break; - case 0x79:op_adc_addry(); break; - case 0x7a:op_ply(); break; - case 0x7b:op_tdc(); break; - case 0x7c:op_jmp_iaddrx();break; - case 0x7d:op_adc_addrx(); break; - case 0x7e:op_ror_addrx(); break; - case 0x7f:op_adc_longx(); break; -/* 8x */ - case 0x80:op_bra(); break; - case 0x81:op_sta_idpx(); break; - case 0x82:op_brl(); break; - case 0x83:op_sta_sr(); break; - case 0x84:op_sty_dp(); break; - case 0x85:op_sta_dp(); break; - case 0x86:op_stx_dp(); break; - case 0x87:op_sta_ildp(); break; - case 0x88:op_dey(); break; - case 0x89:op_bit_const();break; - case 0x8a:op_txa(); break; - case 0x8b:op_phb(); break; - case 0x8c:op_sty_addr(); break; - case 0x8d:op_sta_addr(); break; - case 0x8e:op_stx_addr(); break; - case 0x8f:op_sta_long(); break; -/* 9x */ - case 0x90:op_bcc(); break; - case 0x91:op_sta_idpy(); break; - case 0x92:op_sta_idp(); break; - case 0x93:op_sta_isry(); break; - case 0x94:op_sty_dpx(); break; - case 0x95:op_sta_dpx(); break; - case 0x96:op_stx_dpy(); break; - case 0x97:op_sta_ildpy();break; - case 0x98:op_tya(); break; - case 0x99:op_sta_addry();break; - case 0x9a:op_txs(); break; - case 0x9b:op_txy(); break; - case 0x9c:op_stz_addr(); break; - case 0x9d:op_sta_addrx();break; - case 0x9e:op_stz_addrx();break; - case 0x9f:op_sta_longx();break; -/* ax */ - case 0xa0:op_ldy_const();break; - case 0xa1:op_lda_idpx(); break; - case 0xa2:op_ldx_const();break; - case 0xa3:op_lda_sr(); break; - case 0xa4:op_ldy_dp(); break; - case 0xa5:op_lda_dp(); break; - case 0xa6:op_ldx_dp(); break; - case 0xa7:op_lda_ildp(); break; - case 0xa8:op_tay(); break; - case 0xa9:op_lda_const();break; - case 0xaa:op_tax(); break; - case 0xab:op_plb(); break; - case 0xac:op_ldy_addr(); break; - case 0xad:op_lda_addr(); break; - case 0xae:op_ldx_addr(); break; - case 0xaf:op_lda_long(); break; -/* bx */ - case 0xb0:op_bcs(); break; - case 0xb1:op_lda_idpy(); break; - case 0xb2:op_lda_idp(); break; - case 0xb3:op_lda_isry(); break; - case 0xb4:op_ldy_dpx(); break; - case 0xb5:op_lda_dpx(); break; - case 0xb6:op_ldx_dpy(); break; - case 0xb7:op_lda_ildpy();break; - case 0xb8:op_clv(); break; - case 0xb9:op_lda_addry();break; - case 0xba:op_tsx(); break; - case 0xbb:op_tyx(); break; - case 0xbc:op_ldy_addrx();break; - case 0xbd:op_lda_addrx();break; - case 0xbe:op_ldx_addry();break; - case 0xbf:op_lda_longx();break; -/* cx */ - case 0xc0:op_cpy_const();break; - case 0xc1:op_cmp_idpx(); break; - case 0xc2:op_rep(); break; - case 0xc3:op_cmp_sr(); break; - case 0xc4:op_cpy_dp(); break; - case 0xc5:op_cmp_dp(); break; - case 0xc6:op_dec_dp(); break; - case 0xc7:op_cmp_ildp(); break; - case 0xc8:op_iny(); break; - case 0xc9:op_cmp_const();break; - case 0xca:op_dex(); break; - case 0xcb:op_wai(); break; - case 0xcc:op_cpy_addr(); break; - case 0xcd:op_cmp_addr(); break; - case 0xce:op_dec_addr(); break; - case 0xcf:op_cmp_long(); break; -/* dx */ - case 0xd0:op_bne(); break; - case 0xd1:op_cmp_idpy(); break; - case 0xd2:op_cmp_idp(); break; - case 0xd3:op_cmp_isry(); break; - case 0xd4:op_pei(); break; - case 0xd5:op_cmp_dpx(); break; - case 0xd6:op_dec_dpx(); break; - case 0xd7:op_cmp_ildpy(); break; - case 0xd8:op_cld(); break; - case 0xd9:op_cmp_addry(); break; - case 0xda:op_phx(); break; - case 0xdb:op_stp(); break; - case 0xdc:op_jmp_iladdr();break; - case 0xdd:op_cmp_addrx(); break; - case 0xde:op_dec_addrx(); break; - case 0xdf:op_cmp_longx(); break; -/* ex */ - case 0xe0:op_cpx_const();break; - case 0xe1:op_sbc_idpx(); break; - case 0xe2:op_sep(); break; - case 0xe3:op_sbc_sr(); break; - case 0xe4:op_cpx_dp(); break; - case 0xe5:op_sbc_dp(); break; - case 0xe6:op_inc_dp(); break; - case 0xe7:op_sbc_ildp(); break; - case 0xe8:op_inx(); break; - case 0xe9:op_sbc_const();break; - case 0xea:op_nop(); break; - case 0xeb:op_xba(); break; - case 0xec:op_cpx_addr(); break; - case 0xed:op_sbc_addr(); break; - case 0xee:op_inc_addr(); break; - case 0xef:op_sbc_long(); break; -/* fx */ - case 0xf0:op_beq(); break; - case 0xf1:op_sbc_idpy(); break; - case 0xf2:op_sbc_idp(); break; - case 0xf3:op_sbc_isry(); break; - case 0xf4:op_pea(); break; - case 0xf5:op_sbc_dpx(); break; - case 0xf6:op_inc_dpx(); break; - case 0xf7:op_sbc_ildpy(); break; - case 0xf8:op_sed(); break; - case 0xf9:op_sbc_addry(); break; - case 0xfa:op_plx(); break; - case 0xfb:op_xce(); break; - case 0xfc:op_jsr_iaddrx();break; - case 0xfd:op_sbc_addrx(); break; - case 0xfe:op_inc_addrx(); break; - case 0xff:op_sbc_longx(); break; - } - + (this->*optbl[op_read()])(); snes->notify(SNES::CPU_EXEC_OPCODE); } + +void bCPU::init_op_tables() { + optbl = optbl_e; + +/* 0x */ + optbl[0x00] = op_brk; + optbl[0x01] = op_ora_idpxb; + optbl[0x02] = op_cop; + optbl[0x03] = op_ora_srb; + optbl[0x04] = op_tsb_dpb; + optbl[0x05] = op_ora_dpb; + optbl[0x06] = op_asl_dpb; + optbl[0x07] = op_ora_ildpb; + optbl[0x08] = op_php; + optbl[0x09] = op_ora_constb; + optbl[0x0a] = op_aslb; + optbl[0x0b] = op_phd; + optbl[0x0c] = op_tsb_addrb; + optbl[0x0d] = op_ora_addrb; + optbl[0x0e] = op_asl_addrb; + optbl[0x0f] = op_ora_longb; +/* 1x */ + optbl[0x10] = op_bpl; + optbl[0x11] = op_ora_idpyb; + optbl[0x12] = op_ora_idpb; + optbl[0x13] = op_ora_isryb; + optbl[0x14] = op_trb_dpb; + optbl[0x15] = op_ora_dpxb; + optbl[0x16] = op_asl_dpxb; + optbl[0x17] = op_ora_ildpyb; + optbl[0x18] = op_clc; + optbl[0x19] = op_ora_addryb; + optbl[0x1a] = op_incb; + optbl[0x1b] = op_tcs; + optbl[0x1c] = op_trb_addrb; + optbl[0x1d] = op_ora_addrxb; + optbl[0x1e] = op_asl_addrxb; + optbl[0x1f] = op_ora_longxb; +/* 2x */ + optbl[0x20] = op_jsr_addr; + optbl[0x21] = op_and_idpxb; + optbl[0x22] = op_jsr_long; + optbl[0x23] = op_and_srb; + optbl[0x24] = op_bit_dpb; + optbl[0x25] = op_and_dpb; + optbl[0x26] = op_rol_dpb; + optbl[0x27] = op_and_ildpb; + optbl[0x28] = op_plp; + optbl[0x29] = op_and_constb; + optbl[0x2a] = op_rolb; + optbl[0x2b] = op_pld; + optbl[0x2c] = op_bit_addrb; + optbl[0x2d] = op_and_addrb; + optbl[0x2e] = op_rol_addrb; + optbl[0x2f] = op_and_longb; +/* 3x */ + optbl[0x30] = op_bmi; + optbl[0x31] = op_and_idpyb; + optbl[0x32] = op_and_idpb; + optbl[0x33] = op_and_isryb; + optbl[0x34] = op_bit_dpxb; + optbl[0x35] = op_and_dpxb; + optbl[0x36] = op_rol_dpxb; + optbl[0x37] = op_and_ildpyb; + optbl[0x38] = op_sec; + optbl[0x39] = op_and_addryb; + optbl[0x3a] = op_decb; + optbl[0x3b] = op_tsc; + optbl[0x3c] = op_bit_addrxb; + optbl[0x3d] = op_and_addrxb; + optbl[0x3e] = op_rol_addrxb; + optbl[0x3f] = op_and_longxb; +/* 4x */ + optbl[0x40] = op_rtie; + optbl[0x41] = op_eor_idpxb; + optbl[0x42] = op_wdm; + optbl[0x43] = op_eor_srb; + optbl[0x44] = op_mvp; + optbl[0x45] = op_eor_dpb; + optbl[0x46] = op_lsr_dpb; + optbl[0x47] = op_eor_ildpb; + optbl[0x48] = op_phab; + optbl[0x49] = op_eor_constb; + optbl[0x4a] = op_lsrb; + optbl[0x4b] = op_phk; + optbl[0x4c] = op_jmp_addr; + optbl[0x4d] = op_eor_addrb; + optbl[0x4e] = op_lsr_addrb; + optbl[0x4f] = op_eor_longb; +/* 5x */ + optbl[0x50] = op_bvc; + optbl[0x51] = op_eor_idpyb; + optbl[0x52] = op_eor_idpb; + optbl[0x53] = op_eor_isryb; + optbl[0x54] = op_mvn; + optbl[0x55] = op_eor_dpxb; + optbl[0x56] = op_lsr_dpxb; + optbl[0x57] = op_eor_ildpyb; + optbl[0x58] = op_cli; + optbl[0x59] = op_eor_addryb; + optbl[0x5a] = op_phyb; + optbl[0x5b] = op_tcd; + optbl[0x5c] = op_jmp_long; + optbl[0x5d] = op_eor_addrxb; + optbl[0x5e] = op_lsr_addrxb; + optbl[0x5f] = op_eor_longxb; +/* 6x */ + optbl[0x60] = op_rts; + optbl[0x61] = op_adc_idpxb; + optbl[0x62] = op_per; + optbl[0x63] = op_adc_srb; + optbl[0x64] = op_stz_dpb; + optbl[0x65] = op_adc_dpb; + optbl[0x66] = op_ror_dpb; + optbl[0x67] = op_adc_ildpb; + optbl[0x68] = op_plab; + optbl[0x69] = op_adc_constb; + optbl[0x6a] = op_rorb; + optbl[0x6b] = op_rtl; + optbl[0x6c] = op_jmp_iaddr; + optbl[0x6d] = op_adc_addrb; + optbl[0x6e] = op_ror_addrb; + optbl[0x6f] = op_adc_longb; +/* 7x */ + optbl[0x70] = op_bvs; + optbl[0x71] = op_adc_idpyb; + optbl[0x72] = op_adc_idpb; + optbl[0x73] = op_adc_isryb; + optbl[0x74] = op_stz_dpxb; + optbl[0x75] = op_adc_dpxb; + optbl[0x76] = op_ror_dpxb; + optbl[0x77] = op_adc_ildpyb; + optbl[0x78] = op_sei; + optbl[0x79] = op_adc_addryb; + optbl[0x7a] = op_plyb; + optbl[0x7b] = op_tdc; + optbl[0x7c] = op_jmp_iaddrx; + optbl[0x7d] = op_adc_addrxb; + optbl[0x7e] = op_ror_addrxb; + optbl[0x7f] = op_adc_longxb; +/* 8x */ + optbl[0x80] = op_bra; + optbl[0x81] = op_sta_idpxb; + optbl[0x82] = op_brl; + optbl[0x83] = op_sta_srb; + optbl[0x84] = op_sty_dpb; + optbl[0x85] = op_sta_dpb; + optbl[0x86] = op_stx_dpb; + optbl[0x87] = op_sta_ildpb; + optbl[0x88] = op_deyb; + optbl[0x89] = op_bit_constb; + optbl[0x8a] = op_txab; + optbl[0x8b] = op_phb; + optbl[0x8c] = op_sty_addrb; + optbl[0x8d] = op_sta_addrb; + optbl[0x8e] = op_stx_addrb; + optbl[0x8f] = op_sta_longb; +/* 9x */ + optbl[0x90] = op_bcc; + optbl[0x91] = op_sta_idpyb; + optbl[0x92] = op_sta_idpb; + optbl[0x93] = op_sta_isryb; + optbl[0x94] = op_sty_dpxb; + optbl[0x95] = op_sta_dpxb; + optbl[0x96] = op_stx_dpyb; + optbl[0x97] = op_sta_ildpyb; + optbl[0x98] = op_tyab; + optbl[0x99] = op_sta_addryb; + optbl[0x9a] = op_txsb; + optbl[0x9b] = op_txyb; + optbl[0x9c] = op_stz_addrb; + optbl[0x9d] = op_sta_addrxb; + optbl[0x9e] = op_stz_addrxb; + optbl[0x9f] = op_sta_longxb; +/* ax */ + optbl[0xa0] = op_ldy_constb; + optbl[0xa1] = op_lda_idpxb; + optbl[0xa2] = op_ldx_constb; + optbl[0xa3] = op_lda_srb; + optbl[0xa4] = op_ldy_dpb; + optbl[0xa5] = op_lda_dpb; + optbl[0xa6] = op_ldx_dpb; + optbl[0xa7] = op_lda_ildpb; + optbl[0xa8] = op_tayb; + optbl[0xa9] = op_lda_constb; + optbl[0xaa] = op_taxb; + optbl[0xab] = op_plb; + optbl[0xac] = op_ldy_addrb; + optbl[0xad] = op_lda_addrb; + optbl[0xae] = op_ldx_addrb; + optbl[0xaf] = op_lda_longb; +/* bx */ + optbl[0xb0] = op_bcs; + optbl[0xb1] = op_lda_idpyb; + optbl[0xb2] = op_lda_idpb; + optbl[0xb3] = op_lda_isryb; + optbl[0xb4] = op_ldy_dpxb; + optbl[0xb5] = op_lda_dpxb; + optbl[0xb6] = op_ldx_dpyb; + optbl[0xb7] = op_lda_ildpyb; + optbl[0xb8] = op_clv; + optbl[0xb9] = op_lda_addryb; + optbl[0xba] = op_tsxb; + optbl[0xbb] = op_tyxb; + optbl[0xbc] = op_ldy_addrxb; + optbl[0xbd] = op_lda_addrxb; + optbl[0xbe] = op_ldx_addryb; + optbl[0xbf] = op_lda_longxb; +/* cx */ + optbl[0xc0] = op_cpy_constb; + optbl[0xc1] = op_cmp_idpxb; + optbl[0xc2] = op_rep; + optbl[0xc3] = op_cmp_srb; + optbl[0xc4] = op_cpy_dpb; + optbl[0xc5] = op_cmp_dpb; + optbl[0xc6] = op_dec_dpb; + optbl[0xc7] = op_cmp_ildpb; + optbl[0xc8] = op_inyb; + optbl[0xc9] = op_cmp_constb; + optbl[0xca] = op_dexb; + optbl[0xcb] = op_wai; + optbl[0xcc] = op_cpy_addrb; + optbl[0xcd] = op_cmp_addrb; + optbl[0xce] = op_dec_addrb; + optbl[0xcf] = op_cmp_longb; +/* dx */ + optbl[0xd0] = op_bne; + optbl[0xd1] = op_cmp_idpyb; + optbl[0xd2] = op_cmp_idpb; + optbl[0xd3] = op_cmp_isryb; + optbl[0xd4] = op_pei; + optbl[0xd5] = op_cmp_dpxb; + optbl[0xd6] = op_dec_dpxb; + optbl[0xd7] = op_cmp_ildpyb; + optbl[0xd8] = op_cld; + optbl[0xd9] = op_cmp_addryb; + optbl[0xda] = op_phxb; + optbl[0xdb] = op_stp; + optbl[0xdc] = op_jmp_iladdr; + optbl[0xdd] = op_cmp_addrxb; + optbl[0xde] = op_dec_addrxb; + optbl[0xdf] = op_cmp_longxb; +/* ex */ + optbl[0xe0] = op_cpx_constb; + optbl[0xe1] = op_sbc_idpxb; + optbl[0xe2] = op_sep; + optbl[0xe3] = op_sbc_srb; + optbl[0xe4] = op_cpx_dpb; + optbl[0xe5] = op_sbc_dpb; + optbl[0xe6] = op_inc_dpb; + optbl[0xe7] = op_sbc_ildpb; + optbl[0xe8] = op_inxb; + optbl[0xe9] = op_sbc_constb; + optbl[0xea] = op_nop; + optbl[0xeb] = op_xba; + optbl[0xec] = op_cpx_addrb; + optbl[0xed] = op_sbc_addrb; + optbl[0xee] = op_inc_addrb; + optbl[0xef] = op_sbc_longb; +/* fx */ + optbl[0xf0] = op_beq; + optbl[0xf1] = op_sbc_idpyb; + optbl[0xf2] = op_sbc_idpb; + optbl[0xf3] = op_sbc_isryb; + optbl[0xf4] = op_pea; + optbl[0xf5] = op_sbc_dpxb; + optbl[0xf6] = op_inc_dpxb; + optbl[0xf7] = op_sbc_ildpyb; + optbl[0xf8] = op_sed; + optbl[0xf9] = op_sbc_addryb; + optbl[0xfa] = op_plxb; + optbl[0xfb] = op_xce; + optbl[0xfc] = op_jsr_iaddrx; + optbl[0xfd] = op_sbc_addrxb; + optbl[0xfe] = op_inc_addrxb; + optbl[0xff] = op_sbc_longxb; + + memcpy(optbl_MX, optbl_e, sizeof(optbl_e)); + memcpy(optbl_Mx, optbl_e, sizeof(optbl_e)); + memcpy(optbl_mX, optbl_e, sizeof(optbl_e)); + memcpy(optbl_mx, optbl_e, sizeof(optbl_e)); + +/* adc */ + optbl_mX[0x69] = optbl_mx[0x69] = op_adc_constw; + optbl_mX[0x6d] = optbl_mx[0x6d] = op_adc_addrw; + optbl_mX[0x7d] = optbl_mx[0x7d] = op_adc_addrxw; + optbl_mX[0x65] = optbl_mx[0x65] = op_adc_dpw; + optbl_mX[0x72] = optbl_mx[0x72] = op_adc_idpw; + optbl_mX[0x67] = optbl_mx[0x67] = op_adc_ildpw; + optbl_mX[0x6f] = optbl_mx[0x6f] = op_adc_longw; + optbl_mX[0x7f] = optbl_mx[0x7f] = op_adc_longxw; + optbl_mX[0x79] = optbl_mx[0x79] = op_adc_addryw; + optbl_mX[0x75] = optbl_mx[0x75] = op_adc_dpxw; + optbl_mX[0x61] = optbl_mx[0x61] = op_adc_idpxw; + optbl_mX[0x71] = optbl_mx[0x71] = op_adc_idpyw; + optbl_mX[0x77] = optbl_mx[0x77] = op_adc_ildpyw; + optbl_mX[0x63] = optbl_mx[0x63] = op_adc_srw; + optbl_mX[0x73] = optbl_mx[0x73] = op_adc_isryw; + +/* and */ + optbl_mX[0x29] = optbl_mx[0x29] = op_and_constw; + optbl_mX[0x2d] = optbl_mx[0x2d] = op_and_addrw; + optbl_mX[0x3d] = optbl_mx[0x3d] = op_and_addrxw; + optbl_mX[0x25] = optbl_mx[0x25] = op_and_dpw; + optbl_mX[0x32] = optbl_mx[0x32] = op_and_idpw; + optbl_mX[0x27] = optbl_mx[0x27] = op_and_ildpw; + optbl_mX[0x2f] = optbl_mx[0x2f] = op_and_longw; + optbl_mX[0x3f] = optbl_mx[0x3f] = op_and_longxw; + optbl_mX[0x39] = optbl_mx[0x39] = op_and_addryw; + optbl_mX[0x35] = optbl_mx[0x35] = op_and_dpxw; + optbl_mX[0x21] = optbl_mx[0x21] = op_and_idpxw; + optbl_mX[0x31] = optbl_mx[0x31] = op_and_idpyw; + optbl_mX[0x37] = optbl_mx[0x37] = op_and_ildpyw; + optbl_mX[0x23] = optbl_mx[0x23] = op_and_srw; + optbl_mX[0x33] = optbl_mx[0x33] = op_and_isryw; + +/* cmp */ + optbl_mX[0xc9] = optbl_mx[0xc9] = op_cmp_constw; + optbl_mX[0xcd] = optbl_mx[0xcd] = op_cmp_addrw; + optbl_mX[0xdd] = optbl_mx[0xdd] = op_cmp_addrxw; + optbl_mX[0xc5] = optbl_mx[0xc5] = op_cmp_dpw; + optbl_mX[0xd2] = optbl_mx[0xd2] = op_cmp_idpw; + optbl_mX[0xc7] = optbl_mx[0xc7] = op_cmp_ildpw; + optbl_mX[0xcf] = optbl_mx[0xcf] = op_cmp_longw; + optbl_mX[0xdf] = optbl_mx[0xdf] = op_cmp_longxw; + optbl_mX[0xd9] = optbl_mx[0xd9] = op_cmp_addryw; + optbl_mX[0xd5] = optbl_mx[0xd5] = op_cmp_dpxw; + optbl_mX[0xc1] = optbl_mx[0xc1] = op_cmp_idpxw; + optbl_mX[0xd1] = optbl_mx[0xd1] = op_cmp_idpyw; + optbl_mX[0xd7] = optbl_mx[0xd7] = op_cmp_ildpyw; + optbl_mX[0xc3] = optbl_mx[0xc3] = op_cmp_srw; + optbl_mX[0xd3] = optbl_mx[0xd3] = op_cmp_isryw; + +/* eor */ + optbl_mX[0x49] = optbl_mx[0x49] = op_eor_constw; + optbl_mX[0x4d] = optbl_mx[0x4d] = op_eor_addrw; + optbl_mX[0x5d] = optbl_mx[0x5d] = op_eor_addrxw; + optbl_mX[0x45] = optbl_mx[0x45] = op_eor_dpw; + optbl_mX[0x52] = optbl_mx[0x52] = op_eor_idpw; + optbl_mX[0x47] = optbl_mx[0x47] = op_eor_ildpw; + optbl_mX[0x4f] = optbl_mx[0x4f] = op_eor_longw; + optbl_mX[0x5f] = optbl_mx[0x5f] = op_eor_longxw; + optbl_mX[0x59] = optbl_mx[0x59] = op_eor_addryw; + optbl_mX[0x55] = optbl_mx[0x55] = op_eor_dpxw; + optbl_mX[0x41] = optbl_mx[0x41] = op_eor_idpxw; + optbl_mX[0x51] = optbl_mx[0x51] = op_eor_idpyw; + optbl_mX[0x57] = optbl_mx[0x57] = op_eor_ildpyw; + optbl_mX[0x43] = optbl_mx[0x43] = op_eor_srw; + optbl_mX[0x53] = optbl_mx[0x53] = op_eor_isryw; + +/* lda */ + optbl_mX[0xa9] = optbl_mx[0xa9] = op_lda_constw; + optbl_mX[0xad] = optbl_mx[0xad] = op_lda_addrw; + optbl_mX[0xbd] = optbl_mx[0xbd] = op_lda_addrxw; + optbl_mX[0xa5] = optbl_mx[0xa5] = op_lda_dpw; + optbl_mX[0xb2] = optbl_mx[0xb2] = op_lda_idpw; + optbl_mX[0xa7] = optbl_mx[0xa7] = op_lda_ildpw; + optbl_mX[0xaf] = optbl_mx[0xaf] = op_lda_longw; + optbl_mX[0xbf] = optbl_mx[0xbf] = op_lda_longxw; + optbl_mX[0xb9] = optbl_mx[0xb9] = op_lda_addryw; + optbl_mX[0xb5] = optbl_mx[0xb5] = op_lda_dpxw; + optbl_mX[0xa1] = optbl_mx[0xa1] = op_lda_idpxw; + optbl_mX[0xb1] = optbl_mx[0xb1] = op_lda_idpyw; + optbl_mX[0xb7] = optbl_mx[0xb7] = op_lda_ildpyw; + optbl_mX[0xa3] = optbl_mx[0xa3] = op_lda_srw; + optbl_mX[0xb3] = optbl_mx[0xb3] = op_lda_isryw; + +/* ora */ + optbl_mX[0x09] = optbl_mx[0x09] = op_ora_constw; + optbl_mX[0x0d] = optbl_mx[0x0d] = op_ora_addrw; + optbl_mX[0x1d] = optbl_mx[0x1d] = op_ora_addrxw; + optbl_mX[0x05] = optbl_mx[0x05] = op_ora_dpw; + optbl_mX[0x12] = optbl_mx[0x12] = op_ora_idpw; + optbl_mX[0x07] = optbl_mx[0x07] = op_ora_ildpw; + optbl_mX[0x0f] = optbl_mx[0x0f] = op_ora_longw; + optbl_mX[0x1f] = optbl_mx[0x1f] = op_ora_longxw; + optbl_mX[0x19] = optbl_mx[0x19] = op_ora_addryw; + optbl_mX[0x15] = optbl_mx[0x15] = op_ora_dpxw; + optbl_mX[0x01] = optbl_mx[0x01] = op_ora_idpxw; + optbl_mX[0x11] = optbl_mx[0x11] = op_ora_idpyw; + optbl_mX[0x17] = optbl_mx[0x17] = op_ora_ildpyw; + optbl_mX[0x03] = optbl_mx[0x03] = op_ora_srw; + optbl_mX[0x13] = optbl_mx[0x13] = op_ora_isryw; + +/* sbc */ + optbl_mX[0xe9] = optbl_mx[0xe9] = op_sbc_constw; + optbl_mX[0xed] = optbl_mx[0xed] = op_sbc_addrw; + optbl_mX[0xfd] = optbl_mx[0xfd] = op_sbc_addrxw; + optbl_mX[0xe5] = optbl_mx[0xe5] = op_sbc_dpw; + optbl_mX[0xf2] = optbl_mx[0xf2] = op_sbc_idpw; + optbl_mX[0xe7] = optbl_mx[0xe7] = op_sbc_ildpw; + optbl_mX[0xef] = optbl_mx[0xef] = op_sbc_longw; + optbl_mX[0xff] = optbl_mx[0xff] = op_sbc_longxw; + optbl_mX[0xf9] = optbl_mx[0xf9] = op_sbc_addryw; + optbl_mX[0xf5] = optbl_mx[0xf5] = op_sbc_dpxw; + optbl_mX[0xe1] = optbl_mx[0xe1] = op_sbc_idpxw; + optbl_mX[0xf1] = optbl_mx[0xf1] = op_sbc_idpyw; + optbl_mX[0xf7] = optbl_mx[0xf7] = op_sbc_ildpyw; + optbl_mX[0xe3] = optbl_mx[0xe3] = op_sbc_srw; + optbl_mX[0xf3] = optbl_mx[0xf3] = op_sbc_isryw; + +/* sta */ + optbl_mX[0x8d] = optbl_mx[0x8d] = op_sta_addrw; + optbl_mX[0x9d] = optbl_mx[0x9d] = op_sta_addrxw; + optbl_mX[0x85] = optbl_mx[0x85] = op_sta_dpw; + optbl_mX[0x92] = optbl_mx[0x92] = op_sta_idpw; + optbl_mX[0x87] = optbl_mx[0x87] = op_sta_ildpw; + optbl_mX[0x8f] = optbl_mx[0x8f] = op_sta_longw; + optbl_mX[0x9f] = optbl_mx[0x9f] = op_sta_longxw; + optbl_mX[0x99] = optbl_mx[0x99] = op_sta_addryw; + optbl_mX[0x95] = optbl_mx[0x95] = op_sta_dpxw; + optbl_mX[0x81] = optbl_mx[0x81] = op_sta_idpxw; + optbl_mX[0x91] = optbl_mx[0x91] = op_sta_idpyw; + optbl_mX[0x97] = optbl_mx[0x97] = op_sta_ildpyw; + optbl_mX[0x83] = optbl_mx[0x83] = op_sta_srw; + optbl_mX[0x93] = optbl_mx[0x93] = op_sta_isryw; + +/* incdec */ + optbl_mX[0x1a] = optbl_mx[0x1a] = op_incw; + optbl_mX[0xee] = optbl_mx[0xee] = op_inc_addrw; + optbl_mX[0xfe] = optbl_mx[0xfe] = op_inc_addrxw; + optbl_mX[0xe6] = optbl_mx[0xe6] = op_inc_dpw; + optbl_mX[0xf6] = optbl_mx[0xf6] = op_inc_dpxw; + optbl_mX[0x3a] = optbl_mx[0x3a] = op_decw; + optbl_mX[0xce] = optbl_mx[0xce] = op_dec_addrw; + optbl_mX[0xde] = optbl_mx[0xde] = op_dec_addrxw; + optbl_mX[0xc6] = optbl_mx[0xc6] = op_dec_dpw; + optbl_mX[0xd6] = optbl_mx[0xd6] = op_dec_dpxw; + + optbl_Mx[0xe8] = optbl_mx[0xe8] = op_inxw; + optbl_Mx[0xc8] = optbl_mx[0xc8] = op_inyw; + optbl_Mx[0xca] = optbl_mx[0xca] = op_dexw; + optbl_Mx[0x88] = optbl_mx[0x88] = op_deyw; + +/* misc */ + optbl_mX[0x89] = optbl_mx[0x89] = op_bit_constw; + optbl_mX[0x2c] = optbl_mx[0x2c] = op_bit_addrw; + optbl_mX[0x3c] = optbl_mx[0x3c] = op_bit_addrxw; + optbl_mX[0x24] = optbl_mx[0x24] = op_bit_dpw; + optbl_mX[0x34] = optbl_mx[0x34] = op_bit_dpxw; + optbl_mX[0x9c] = optbl_mx[0x9c] = op_stz_addrw; + optbl_mX[0x9e] = optbl_mx[0x9e] = op_stz_addrxw; + optbl_mX[0x64] = optbl_mx[0x64] = op_stz_dpw; + optbl_mX[0x74] = optbl_mx[0x74] = op_stz_dpxw; + optbl_mX[0x1c] = optbl_mx[0x1c] = op_trb_addrw; + optbl_mX[0x14] = optbl_mx[0x14] = op_trb_dpw; + optbl_mX[0x0c] = optbl_mx[0x0c] = op_tsb_addrw; + optbl_mX[0x04] = optbl_mx[0x04] = op_tsb_dpw; + optbl_mX[0x8a] = optbl_mx[0x8a] = op_txaw; + optbl_mX[0x98] = optbl_mx[0x98] = op_tyaw; + + optbl_Mx[0xe0] = optbl_mx[0xe0] = op_cpx_constw; + optbl_Mx[0xec] = optbl_mx[0xec] = op_cpx_addrw; + optbl_Mx[0xe4] = optbl_mx[0xe4] = op_cpx_dpw; + optbl_Mx[0xc0] = optbl_mx[0xc0] = op_cpy_constw; + optbl_Mx[0xcc] = optbl_mx[0xcc] = op_cpy_addrw; + optbl_Mx[0xc4] = optbl_mx[0xc4] = op_cpy_dpw; + optbl_Mx[0xa2] = optbl_mx[0xa2] = op_ldx_constw; + optbl_Mx[0xae] = optbl_mx[0xae] = op_ldx_addrw; + optbl_Mx[0xbe] = optbl_mx[0xbe] = op_ldx_addryw; + optbl_Mx[0xa6] = optbl_mx[0xa6] = op_ldx_dpw; + optbl_Mx[0xb6] = optbl_mx[0xb6] = op_ldx_dpyw; + optbl_Mx[0xa0] = optbl_mx[0xa0] = op_ldy_constw; + optbl_Mx[0xac] = optbl_mx[0xac] = op_ldy_addrw; + optbl_Mx[0xbc] = optbl_mx[0xbc] = op_ldy_addrxw; + optbl_Mx[0xa4] = optbl_mx[0xa4] = op_ldy_dpw; + optbl_Mx[0xb4] = optbl_mx[0xb4] = op_ldy_dpxw; + optbl_Mx[0x8e] = optbl_mx[0x8e] = op_stx_addrw; + optbl_Mx[0x86] = optbl_mx[0x86] = op_stx_dpw; + optbl_Mx[0x96] = optbl_mx[0x96] = op_stx_dpyw; + optbl_Mx[0x8c] = optbl_mx[0x8c] = op_sty_addrw; + optbl_Mx[0x84] = optbl_mx[0x84] = op_sty_dpw; + optbl_Mx[0x94] = optbl_mx[0x94] = op_sty_dpxw; + optbl_Mx[0xaa] = optbl_mx[0xaa] = op_taxw; + optbl_Mx[0xa8] = optbl_mx[0xa8] = op_tayw; + optbl_Mx[0xba] = optbl_mx[0xba] = op_tsxw; + optbl_Mx[0x9a] = optbl_mx[0x9a] = op_txsw; + optbl_Mx[0x9b] = optbl_mx[0x9b] = op_txyw; + optbl_Mx[0xbb] = optbl_mx[0xbb] = op_tyxw; + +/* pc */ + optbl_MX[0x40] = optbl_Mx[0x40] = op_rtin; + optbl_mX[0x40] = optbl_mx[0x40] = op_rtin; + +/* shift */ + optbl_mX[0x0a] = optbl_mx[0x0a] = op_aslw; + optbl_mX[0x0e] = optbl_mx[0x0e] = op_asl_addrw; + optbl_mX[0x1e] = optbl_mx[0x1e] = op_asl_addrxw; + optbl_mX[0x06] = optbl_mx[0x06] = op_asl_dpw; + optbl_mX[0x16] = optbl_mx[0x16] = op_asl_dpxw; + optbl_mX[0x4a] = optbl_mx[0x4a] = op_lsrw; + optbl_mX[0x4e] = optbl_mx[0x4e] = op_lsr_addrw; + optbl_mX[0x5e] = optbl_mx[0x5e] = op_lsr_addrxw; + optbl_mX[0x46] = optbl_mx[0x46] = op_lsr_dpw; + optbl_mX[0x56] = optbl_mx[0x56] = op_lsr_dpxw; + optbl_mX[0x2a] = optbl_mx[0x2a] = op_rolw; + optbl_mX[0x2e] = optbl_mx[0x2e] = op_rol_addrw; + optbl_mX[0x3e] = optbl_mx[0x3e] = op_rol_addrxw; + optbl_mX[0x26] = optbl_mx[0x26] = op_rol_dpw; + optbl_mX[0x36] = optbl_mx[0x36] = op_rol_dpxw; + optbl_mX[0x6a] = optbl_mx[0x6a] = op_rorw; + optbl_mX[0x6e] = optbl_mx[0x6e] = op_ror_addrw; + optbl_mX[0x7e] = optbl_mx[0x7e] = op_ror_addrxw; + optbl_mX[0x66] = optbl_mx[0x66] = op_ror_dpw; + optbl_mX[0x76] = optbl_mx[0x76] = op_ror_dpxw; + +/* stack */ + optbl_mX[0x48] = optbl_mx[0x48] = op_phaw; + optbl_mX[0x68] = optbl_mx[0x68] = op_plaw; + + optbl_Mx[0xda] = optbl_mx[0xda] = op_phxw; + optbl_Mx[0x5a] = optbl_mx[0x5a] = op_phyw; + optbl_Mx[0xfa] = optbl_mx[0xfa] = op_plxw; + optbl_Mx[0x7a] = optbl_mx[0x7a] = op_plyw; +} diff --git a/src/cpu/bcpu/bcpu_mmio.cpp b/src/cpu/bcpu/bcpu_mmio.cpp index 6d4df3f3..c782ff6d 100644 --- a/src/cpu/bcpu/bcpu_mmio.cpp +++ b/src/cpu/bcpu/bcpu_mmio.cpp @@ -177,7 +177,7 @@ uint8 bCPU::mmio_r4218() { uint8 r = 0x00; uint16 v = clock->vcounter(); if(status.auto_joypad_poll == false)return 0x00; //can't read joypad if auto polling not enabled - if(v >= 225 && v <= 227)return 0x00; //can't read joypad while SNES is polling input +//if(v >= 225 && v <= 227)return 0x00; //can't read joypad while SNES is polling input r |= (uint8)snes->get_input_status(SNES::DEV_JOYPAD1, SNES::JOYPAD_A) << 7; r |= (uint8)snes->get_input_status(SNES::DEV_JOYPAD1, SNES::JOYPAD_X) << 6; r |= (uint8)snes->get_input_status(SNES::DEV_JOYPAD1, SNES::JOYPAD_L) << 5; @@ -190,7 +190,7 @@ uint8 bCPU::mmio_r4219() { uint8 r = 0x00; uint16 v = clock->vcounter(); if(status.auto_joypad_poll == false)return 0x00; //can't read joypad if auto polling not enabled - if(v >= 225 && v <= 227)return 0x00; //can't read joypad while SNES is polling input +//if(v >= 225 && v <= 227)return 0x00; //can't read joypad while SNES is polling input r |= (uint8)snes->get_input_status(SNES::DEV_JOYPAD1, SNES::JOYPAD_B) << 7; r |= (uint8)snes->get_input_status(SNES::DEV_JOYPAD1, SNES::JOYPAD_Y) << 6; r |= (uint8)snes->get_input_status(SNES::DEV_JOYPAD1, SNES::JOYPAD_SELECT) << 5; @@ -250,9 +250,11 @@ void bCPU::mmio_w2183(uint8 value) { //JOYSER0 void bCPU::mmio_w4016(uint8 value) { - status.joypad1_strobe_value = value; - if(value == 1)snes->poll_input(); - if(value == 0)status.joypad1_read_pos = 0; + status.joypad1_strobe_value = (value & 1); + if(value == 1) { + snes->poll_input(); + status.joypad1_read_pos = 0; + } } //NMITIMEN @@ -320,22 +322,24 @@ void bCPU::mmio_w420a(uint8 value) { //DMAEN void bCPU::mmio_w420b(uint8 value) { + if(value != 0x00) { + clock->add_cc1_cycles(18); + } + for(int i=0;i<8;i++) { - dma->channel[i].active = !!(value & (1 << i)); - if(dma->channel[i].active == true) { + if(value & (1 << i)) { + dma->channel[i].active = true; dma->channel[i].hdma_active = false; + clock->add_cc1_cycles(8); + cpustate = CPUSTATE_DMA; } } - cpustate = CPUSTATE_DMA; } //HDMAEN void bCPU::mmio_w420c(uint8 value) { for(int i=0;i<8;i++) { dma->channel[i].hdma_active = !!(value & (1 << i)); - if(dma->channel[i].hdma_active == true) { - dma->channel[i].active = false; - } } } @@ -610,9 +614,10 @@ uint8 x, active_channels = 0; if(channel[i].hdma_indirect == false) { channel[i].hdma_iaddress = channel[i].hdma_address; } else { - channel[i].hdma_iaddress = mem_bus->read(channel[i].hdma_address++); - channel[i].hdma_iaddress |= mem_bus->read(channel[i].hdma_address++) << 8; + channel[i].hdma_iaddress = mem_bus->read(channel[i].hdma_address); + channel[i].hdma_iaddress |= mem_bus->read(channel[i].hdma_address + 1) << 8; channel[i].hdma_iaddress |= channel[i].hdma_indirect_bank << 16; + channel[i].hdma_address += 2; clock->add_cc1_cycles(16); } } @@ -648,7 +653,7 @@ uint8 x, active_channels = 0; void bDMA::hdma_initialize() { uint8 active_channels = 0; for(int i=0;i<8;i++) { - if(!channel[i].hdma_active) { + if(channel[i].hdma_active == false) { channel[i].hdma_completed = true; continue; } @@ -687,9 +692,8 @@ void bDMA::reset() { channel[i].hdma_line_counter = 0; channel[i].hdma_address = 0; channel[i].hdma_iaddress = 0; - channel[i].hdma_completed = false; + channel[i].hdma_completed = true; } - hdma_triggered = false; } bDMA::bDMA(bCPU *_cpu) { diff --git a/src/cpu/bcpu/bcpu_op_adc.cpp b/src/cpu/bcpu/bcpu_op_adc.cpp index 2bfe4ab6..fdf6e152 100644 --- a/src/cpu/bcpu/bcpu_op_adc.cpp +++ b/src/cpu/bcpu/bcpu_op_adc.cpp @@ -1,4 +1,4 @@ -void bCPU::flags_adc_b() { +inline void bCPU::flags_adc_b() { int32 r = regs.a.l + rd.l + regs.p.c; //bcd if(regs.p.d) { @@ -12,7 +12,7 @@ int32 r = regs.a.l + rd.l + regs.p.c; regs.a.l = r; } -void bCPU::flags_adc_w() { +inline void bCPU::flags_adc_w() { int32 r = regs.a.w + rd.w + regs.p.c; //bcd if(regs.p.d) { @@ -47,8 +47,6 @@ void bCPU::op_adc_constw() { flags_adc_w(); } -void bCPU::op_adc_const() { (regs.p.m)?op_adc_constb():op_adc_constw(); } - /********************** *** 0x6d: adc addr *** ********************** @@ -74,8 +72,6 @@ void bCPU::op_adc_addrw() { flags_adc_w(); } -void bCPU::op_adc_addr() { (regs.p.m)?op_adc_addrb():op_adc_addrw(); } - /************************ *** 0x7d: adc addr,x *** ************************ @@ -104,8 +100,6 @@ void bCPU::op_adc_addrxw() { flags_adc_w(); } -void bCPU::op_adc_addrx() { (regs.p.m)?op_adc_addrxb():op_adc_addrxw(); } - /******************** *** 0x65: adc dp *** ******************** @@ -131,8 +125,6 @@ void bCPU::op_adc_dpw() { flags_adc_w(); } -void bCPU::op_adc_dp() { (regs.p.m)?op_adc_dpb():op_adc_dpw(); } - /********************** *** 0x72: adc (dp) *** ********************** @@ -164,8 +156,6 @@ void bCPU::op_adc_idpw() { flags_adc_w(); } -void bCPU::op_adc_idp() { (regs.p.m)?op_adc_idpb():op_adc_idpw(); } - /********************** *** 0x67: adc [dp] *** ********************** @@ -200,8 +190,6 @@ void bCPU::op_adc_ildpw() { flags_adc_w(); } -void bCPU::op_adc_ildp() { (regs.p.m)?op_adc_ildpb():op_adc_ildpw(); } - /********************** *** 0x6f: adc long *** ********************** @@ -230,8 +218,6 @@ void bCPU::op_adc_longw() { flags_adc_w(); } -void bCPU::op_adc_long() { (regs.p.m)?op_adc_longb():op_adc_longw(); } - /************************ *** 0x7f: adc long,x *** ************************ @@ -260,8 +246,6 @@ void bCPU::op_adc_longxw() { flags_adc_w(); } -void bCPU::op_adc_longx() { (regs.p.m)?op_adc_longxb():op_adc_longxw(); } - /************************ *** 0x79: adc addr,y *** ************************ @@ -290,8 +274,6 @@ void bCPU::op_adc_addryw() { flags_adc_w(); } -void bCPU::op_adc_addry() { (regs.p.m)?op_adc_addryb():op_adc_addryw(); } - /********************** *** 0x75: adc dp,x *** ********************** @@ -320,8 +302,6 @@ void bCPU::op_adc_dpxw() { flags_adc_w(); } -void bCPU::op_adc_dpx() { (regs.p.m)?op_adc_dpxb():op_adc_dpxw(); } - /************************ *** 0x61: adc (dp,x) *** ************************ @@ -356,8 +336,6 @@ void bCPU::op_adc_idpxw() { flags_adc_w(); } -void bCPU::op_adc_idpx() { (regs.p.m)?op_adc_idpxb():op_adc_idpxw(); } - /************************ *** 0x71: adc (dp),y *** ************************ @@ -392,8 +370,6 @@ void bCPU::op_adc_idpyw() { flags_adc_w(); } -void bCPU::op_adc_idpy() { (regs.p.m)?op_adc_idpyb():op_adc_idpyw(); } - /************************ *** 0x77: adc [dp],y *** ************************ @@ -428,8 +404,6 @@ void bCPU::op_adc_ildpyw() { flags_adc_w(); } -void bCPU::op_adc_ildpy() { (regs.p.m)?op_adc_ildpyb():op_adc_ildpyw(); } - /********************** *** 0x63: adc sr,s *** ********************** @@ -455,8 +429,6 @@ void bCPU::op_adc_srw() { flags_adc_w(); } -void bCPU::op_adc_sr() { (regs.p.m)?op_adc_srb():op_adc_srw(); } - /************************** *** 0x73: adc (sr,s),y *** ************************** @@ -490,5 +462,3 @@ void bCPU::op_adc_isryw() { rd.h = op_read(OPMODE_DBR, aa.w + regs.y.w + 1); //7a flags_adc_w(); } - -void bCPU::op_adc_isry() { (regs.p.m)?op_adc_isryb():op_adc_isryw(); } diff --git a/src/cpu/bcpu/bcpu_op_and.cpp b/src/cpu/bcpu/bcpu_op_and.cpp index c6d0f3b3..4960ae05 100644 --- a/src/cpu/bcpu/bcpu_op_and.cpp +++ b/src/cpu/bcpu/bcpu_op_and.cpp @@ -1,9 +1,9 @@ -void bCPU::flags_and_b() { +inline void bCPU::flags_and_b() { regs.p.n = !!(regs.a.l & 0x80); regs.p.z = (regs.a.l == 0); } -void bCPU::flags_and_w() { +inline void bCPU::flags_and_w() { regs.p.n = !!(regs.a.w & 0x8000); regs.p.z = (regs.a.w == 0); } @@ -27,8 +27,6 @@ void bCPU::op_and_constw() { flags_and_w(); } -void bCPU::op_and_const() { (regs.p.m)?op_and_constb():op_and_constw(); } - /********************** *** 0x2d: and addr *** ********************** @@ -54,8 +52,6 @@ void bCPU::op_and_addrw() { flags_and_w(); } -void bCPU::op_and_addr() { (regs.p.m)?op_and_addrb():op_and_addrw(); } - /************************ *** 0x3d: and addr,x *** ************************ @@ -84,8 +80,6 @@ void bCPU::op_and_addrxw() { flags_and_w(); } -void bCPU::op_and_addrx() { (regs.p.m)?op_and_addrxb():op_and_addrxw(); } - /******************** *** 0x25: and dp *** ******************** @@ -111,8 +105,6 @@ void bCPU::op_and_dpw() { flags_and_w(); } -void bCPU::op_and_dp() { (regs.p.m)?op_and_dpb():op_and_dpw(); } - /********************** *** 0x32: and (dp) *** ********************** @@ -144,8 +136,6 @@ void bCPU::op_and_idpw() { flags_and_w(); } -void bCPU::op_and_idp() { (regs.p.m)?op_and_idpb():op_and_idpw(); } - /********************** *** 0x27: and [dp] *** ********************** @@ -180,8 +170,6 @@ void bCPU::op_and_ildpw() { flags_and_w(); } -void bCPU::op_and_ildp() { (regs.p.m)?op_and_ildpb():op_and_ildpw(); } - /********************** *** 0x2f: and long *** ********************** @@ -210,8 +198,6 @@ void bCPU::op_and_longw() { flags_and_w(); } -void bCPU::op_and_long() { (regs.p.m)?op_and_longb():op_and_longw(); } - /************************ *** 0x3f: and long,x *** ************************ @@ -240,8 +226,6 @@ void bCPU::op_and_longxw() { flags_and_w(); } -void bCPU::op_and_longx() { (regs.p.m)?op_and_longxb():op_and_longxw(); } - /************************ *** 0x39: and addr,y *** ************************ @@ -270,8 +254,6 @@ void bCPU::op_and_addryw() { flags_and_w(); } -void bCPU::op_and_addry() { (regs.p.m)?op_and_addryb():op_and_addryw(); } - /********************** *** 0x35: and dp,x *** ********************** @@ -300,8 +282,6 @@ void bCPU::op_and_dpxw() { flags_and_w(); } -void bCPU::op_and_dpx() { (regs.p.m)?op_and_dpxb():op_and_dpxw(); } - /************************ *** 0x21: and (dp,x) *** ************************ @@ -336,8 +316,6 @@ void bCPU::op_and_idpxw() { flags_and_w(); } -void bCPU::op_and_idpx() { (regs.p.m)?op_and_idpxb():op_and_idpxw(); } - /************************ *** 0x31: and (dp),y *** ************************ @@ -372,8 +350,6 @@ void bCPU::op_and_idpyw() { flags_and_w(); } -void bCPU::op_and_idpy() { (regs.p.m)?op_and_idpyb():op_and_idpyw(); } - /************************ *** 0x37: and [dp],y *** ************************ @@ -408,8 +384,6 @@ void bCPU::op_and_ildpyw() { flags_and_w(); } -void bCPU::op_and_ildpy() { (regs.p.m)?op_and_ildpyb():op_and_ildpyw(); } - /********************** *** 0x23: and sr,s *** ********************** @@ -435,8 +409,6 @@ void bCPU::op_and_srw() { flags_and_w(); } -void bCPU::op_and_sr() { (regs.p.m)?op_and_srb():op_and_srw(); } - /************************** *** 0x33: and (sr,s),y *** ************************** @@ -470,5 +442,3 @@ void bCPU::op_and_isryw() { regs.a.h &= op_read(OPMODE_DBR, aa.w + regs.y.w + 1); //7a flags_and_w(); } - -void bCPU::op_and_isry() { (regs.p.m)?op_and_isryb():op_and_isryw(); } diff --git a/src/cpu/bcpu/bcpu_op_cmp.cpp b/src/cpu/bcpu/bcpu_op_cmp.cpp index af58527a..fd370f3c 100644 --- a/src/cpu/bcpu/bcpu_op_cmp.cpp +++ b/src/cpu/bcpu/bcpu_op_cmp.cpp @@ -1,11 +1,11 @@ -void bCPU::flags_cmp_b() { +inline void bCPU::flags_cmp_b() { int32 r = regs.a.l - rd.l; regs.p.n = !!(r & 0x80); regs.p.z = ((uint8)r == 0); regs.p.c = (r >= 0); } -void bCPU::flags_cmp_w() { +inline void bCPU::flags_cmp_w() { int32 r = regs.a.w - rd.w; regs.p.n = !!(r & 0x8000); regs.p.z = ((uint16)r == 0); @@ -31,8 +31,6 @@ void bCPU::op_cmp_constw() { flags_cmp_w(); } -void bCPU::op_cmp_const() { (regs.p.m)?op_cmp_constb():op_cmp_constw(); } - /********************** *** 0xcd: cmp addr *** ********************** @@ -58,8 +56,6 @@ void bCPU::op_cmp_addrw() { flags_cmp_w(); } -void bCPU::op_cmp_addr() { (regs.p.m)?op_cmp_addrb():op_cmp_addrw(); } - /************************ *** 0xdd: cmp addr,x *** ************************ @@ -88,8 +84,6 @@ void bCPU::op_cmp_addrxw() { flags_cmp_w(); } -void bCPU::op_cmp_addrx() { (regs.p.m)?op_cmp_addrxb():op_cmp_addrxw(); } - /******************** *** 0xc5: cmp dp *** ******************** @@ -115,8 +109,6 @@ void bCPU::op_cmp_dpw() { flags_cmp_w(); } -void bCPU::op_cmp_dp() { (regs.p.m)?op_cmp_dpb():op_cmp_dpw(); } - /********************** *** 0xd2: cmp (dp) *** ********************** @@ -148,8 +140,6 @@ void bCPU::op_cmp_idpw() { flags_cmp_w(); } -void bCPU::op_cmp_idp() { (regs.p.m)?op_cmp_idpb():op_cmp_idpw(); } - /********************** *** 0xc7: cmp [dp] *** ********************** @@ -184,8 +174,6 @@ void bCPU::op_cmp_ildpw() { flags_cmp_w(); } -void bCPU::op_cmp_ildp() { (regs.p.m)?op_cmp_ildpb():op_cmp_ildpw(); } - /********************** *** 0xcf: cmp long *** ********************** @@ -214,8 +202,6 @@ void bCPU::op_cmp_longw() { flags_cmp_w(); } -void bCPU::op_cmp_long() { (regs.p.m)?op_cmp_longb():op_cmp_longw(); } - /************************ *** 0xdf: cmp long,x *** ************************ @@ -244,8 +230,6 @@ void bCPU::op_cmp_longxw() { flags_cmp_w(); } -void bCPU::op_cmp_longx() { (regs.p.m)?op_cmp_longxb():op_cmp_longxw(); } - /************************ *** 0xd9: cmp addr,y *** ************************ @@ -274,8 +258,6 @@ void bCPU::op_cmp_addryw() { flags_cmp_w(); } -void bCPU::op_cmp_addry() { (regs.p.m)?op_cmp_addryb():op_cmp_addryw(); } - /********************** *** 0xd5: cmp dp,x *** ********************** @@ -304,8 +286,6 @@ void bCPU::op_cmp_dpxw() { flags_cmp_w(); } -void bCPU::op_cmp_dpx() { (regs.p.m)?op_cmp_dpxb():op_cmp_dpxw(); } - /************************ *** 0xc1: cmp (dp,x) *** ************************ @@ -340,8 +320,6 @@ void bCPU::op_cmp_idpxw() { flags_cmp_w(); } -void bCPU::op_cmp_idpx() { (regs.p.m)?op_cmp_idpxb():op_cmp_idpxw(); } - /************************ *** 0xd1: cmp (dp),y *** ************************ @@ -376,8 +354,6 @@ void bCPU::op_cmp_idpyw() { flags_cmp_w(); } -void bCPU::op_cmp_idpy() { (regs.p.m)?op_cmp_idpyb():op_cmp_idpyw(); } - /************************ *** 0xd7: cmp [dp],y *** ************************ @@ -412,8 +388,6 @@ void bCPU::op_cmp_ildpyw() { flags_cmp_w(); } -void bCPU::op_cmp_ildpy() { (regs.p.m)?op_cmp_ildpyb():op_cmp_ildpyw(); } - /********************** *** 0xc3: cmp sr,s *** ********************** @@ -439,8 +413,6 @@ void bCPU::op_cmp_srw() { flags_cmp_w(); } -void bCPU::op_cmp_sr() { (regs.p.m)?op_cmp_srb():op_cmp_srw(); } - /************************** *** 0xd3: cmp (sr,s),y *** ************************** @@ -474,5 +446,3 @@ void bCPU::op_cmp_isryw() { rd.h = op_read(OPMODE_DBR, aa.w + regs.y.w + 1); //7a flags_cmp_w(); } - -void bCPU::op_cmp_isry() { (regs.p.m)?op_cmp_isryb():op_cmp_isryw(); } diff --git a/src/cpu/bcpu/bcpu_op_eor.cpp b/src/cpu/bcpu/bcpu_op_eor.cpp index 0f444c14..98508be7 100644 --- a/src/cpu/bcpu/bcpu_op_eor.cpp +++ b/src/cpu/bcpu/bcpu_op_eor.cpp @@ -1,9 +1,9 @@ -void bCPU::flags_eor_b() { +inline void bCPU::flags_eor_b() { regs.p.n = !!(regs.a.l & 0x80); regs.p.z = (regs.a.l == 0); } -void bCPU::flags_eor_w() { +inline void bCPU::flags_eor_w() { regs.p.n = !!(regs.a.w & 0x8000); regs.p.z = (regs.a.w == 0); } @@ -27,8 +27,6 @@ void bCPU::op_eor_constw() { flags_eor_w(); } -void bCPU::op_eor_const() { (regs.p.m)?op_eor_constb():op_eor_constw(); } - /********************** *** 0x4d: eor addr *** ********************** @@ -54,8 +52,6 @@ void bCPU::op_eor_addrw() { flags_eor_w(); } -void bCPU::op_eor_addr() { (regs.p.m)?op_eor_addrb():op_eor_addrw(); } - /************************ *** 0x5d: eor addr,x *** ************************ @@ -84,8 +80,6 @@ void bCPU::op_eor_addrxw() { flags_eor_w(); } -void bCPU::op_eor_addrx() { (regs.p.m)?op_eor_addrxb():op_eor_addrxw(); } - /******************** *** 0x45: eor dp *** ******************** @@ -111,8 +105,6 @@ void bCPU::op_eor_dpw() { flags_eor_w(); } -void bCPU::op_eor_dp() { (regs.p.m)?op_eor_dpb():op_eor_dpw(); } - /********************** *** 0x52: eor (dp) *** ********************** @@ -144,8 +136,6 @@ void bCPU::op_eor_idpw() { flags_eor_w(); } -void bCPU::op_eor_idp() { (regs.p.m)?op_eor_idpb():op_eor_idpw(); } - /********************** *** 0x47: eor [dp] *** ********************** @@ -180,8 +170,6 @@ void bCPU::op_eor_ildpw() { flags_eor_w(); } -void bCPU::op_eor_ildp() { (regs.p.m)?op_eor_ildpb():op_eor_ildpw(); } - /********************** *** 0x4f: eor long *** ********************** @@ -210,8 +198,6 @@ void bCPU::op_eor_longw() { flags_eor_w(); } -void bCPU::op_eor_long() { (regs.p.m)?op_eor_longb():op_eor_longw(); } - /************************ *** 0x5f: eor long,x *** ************************ @@ -240,8 +226,6 @@ void bCPU::op_eor_longxw() { flags_eor_w(); } -void bCPU::op_eor_longx() { (regs.p.m)?op_eor_longxb():op_eor_longxw(); } - /************************ *** 0x59: eor addr,y *** ************************ @@ -270,8 +254,6 @@ void bCPU::op_eor_addryw() { flags_eor_w(); } -void bCPU::op_eor_addry() { (regs.p.m)?op_eor_addryb():op_eor_addryw(); } - /********************** *** 0x55: eor dp,x *** ********************** @@ -300,8 +282,6 @@ void bCPU::op_eor_dpxw() { flags_eor_w(); } -void bCPU::op_eor_dpx() { (regs.p.m)?op_eor_dpxb():op_eor_dpxw(); } - /************************ *** 0x41: eor (dp,x) *** ************************ @@ -336,8 +316,6 @@ void bCPU::op_eor_idpxw() { flags_eor_w(); } -void bCPU::op_eor_idpx() { (regs.p.m)?op_eor_idpxb():op_eor_idpxw(); } - /************************ *** 0x51: eor (dp),y *** ************************ @@ -372,8 +350,6 @@ void bCPU::op_eor_idpyw() { flags_eor_w(); } -void bCPU::op_eor_idpy() { (regs.p.m)?op_eor_idpyb():op_eor_idpyw(); } - /************************ *** 0x57: eor [dp],y *** ************************ @@ -408,8 +384,6 @@ void bCPU::op_eor_ildpyw() { flags_eor_w(); } -void bCPU::op_eor_ildpy() { (regs.p.m)?op_eor_ildpyb():op_eor_ildpyw(); } - /********************** *** 0x43: eor sr,s *** ********************** @@ -435,8 +409,6 @@ void bCPU::op_eor_srw() { flags_eor_w(); } -void bCPU::op_eor_sr() { (regs.p.m)?op_eor_srb():op_eor_srw(); } - /************************** *** 0x53: eor (sr,s),y *** ************************** @@ -470,5 +442,3 @@ void bCPU::op_eor_isryw() { regs.a.h ^= op_read(OPMODE_DBR, aa.w + regs.y.w + 1); //7a flags_eor_w(); } - -void bCPU::op_eor_isry() { (regs.p.m)?op_eor_isryb():op_eor_isryw(); } diff --git a/src/cpu/bcpu/bcpu_op_incdec.cpp b/src/cpu/bcpu/bcpu_op_incdec.cpp index fe34ae2a..64a28e0c 100644 --- a/src/cpu/bcpu/bcpu_op_incdec.cpp +++ b/src/cpu/bcpu/bcpu_op_incdec.cpp @@ -19,8 +19,6 @@ void bCPU::op_incw() { regs.p.z = (regs.a.w == 0); } -void bCPU::op_inc() { (regs.p.m)?op_incb():op_incw(); } - /********************** *** 0xee: inc addr *** ********************** @@ -58,8 +56,6 @@ void bCPU::op_inc_addrw() { regs.p.z = (rd.w == 0); } -void bCPU::op_inc_addr() { (regs.p.m)?op_inc_addrb():op_inc_addrw(); } - /************************ *** 0xfe: inc addr,x *** ************************ @@ -100,8 +96,6 @@ void bCPU::op_inc_addrxw() { regs.p.z = (rd.w == 0); } -void bCPU::op_inc_addrx() { (regs.p.m)?op_inc_addrxb():op_inc_addrxw(); } - /******************** *** 0xe6: inc dp *** ******************** @@ -139,8 +133,6 @@ void bCPU::op_inc_dpw() { regs.p.z = (rd.w == 0); } -void bCPU::op_inc_dp() { (regs.p.m)?op_inc_dpb():op_inc_dpw(); } - /********************** *** 0xf6: inc dp,x *** ********************** @@ -181,8 +173,6 @@ void bCPU::op_inc_dpxw() { regs.p.z = (rd.w == 0); } -void bCPU::op_inc_dpx() { (regs.p.m)?op_inc_dpxb():op_inc_dpxw(); } - /***************** *** 0xe8: inx *** ***************** @@ -204,8 +194,6 @@ void bCPU::op_inxw() { regs.p.z = (regs.x.w == 0); } -void bCPU::op_inx() { (regs.p.x)?op_inxb():op_inxw(); } - /***************** *** 0xc8: iny *** ***************** @@ -227,8 +215,6 @@ void bCPU::op_inyw() { regs.p.z = (regs.y.w == 0); } -void bCPU::op_iny() { (regs.p.x)?op_inyb():op_inyw(); } - /***************** *** 0x3a: dec *** ***************** @@ -250,8 +236,6 @@ void bCPU::op_decw() { regs.p.z = (regs.a.w == 0); } -void bCPU::op_dec() { (regs.p.m)?op_decb():op_decw(); } - /********************** *** 0xce: dec addr *** ********************** @@ -289,8 +273,6 @@ void bCPU::op_dec_addrw() { regs.p.z = (rd.w == 0); } -void bCPU::op_dec_addr() { (regs.p.m)?op_dec_addrb():op_dec_addrw(); } - /************************ *** 0xde: dec addr,x *** ************************ @@ -331,8 +313,6 @@ void bCPU::op_dec_addrxw() { regs.p.z = (rd.w == 0); } -void bCPU::op_dec_addrx() { (regs.p.m)?op_dec_addrxb():op_dec_addrxw(); } - /******************** *** 0xc6: dec dp *** ******************** @@ -370,8 +350,6 @@ void bCPU::op_dec_dpw() { regs.p.z = (rd.w == 0); } -void bCPU::op_dec_dp() { (regs.p.m)?op_dec_dpb():op_dec_dpw(); } - /********************** *** 0xd6: dec dp,x *** ********************** @@ -412,8 +390,6 @@ void bCPU::op_dec_dpxw() { regs.p.z = (rd.w == 0); } -void bCPU::op_dec_dpx() { (regs.p.m)?op_dec_dpxb():op_dec_dpxw(); } - /***************** *** 0xca: dex *** ***************** @@ -435,8 +411,6 @@ void bCPU::op_dexw() { regs.p.z = (regs.x.w == 0); } -void bCPU::op_dex() { (regs.p.x)?op_dexb():op_dexw(); } - /***************** *** 0x88: dey *** ***************** @@ -457,5 +431,3 @@ void bCPU::op_deyw() { regs.p.n = !!(regs.y.w & 0x8000); regs.p.z = (regs.y.w == 0); } - -void bCPU::op_dey() { (regs.p.x)?op_deyb():op_deyw(); } diff --git a/src/cpu/bcpu/bcpu_op_lda.cpp b/src/cpu/bcpu/bcpu_op_lda.cpp index 568a0cc8..09acc1a6 100644 --- a/src/cpu/bcpu/bcpu_op_lda.cpp +++ b/src/cpu/bcpu/bcpu_op_lda.cpp @@ -1,9 +1,9 @@ -void bCPU::flags_lda_b() { +inline void bCPU::flags_lda_b() { regs.p.n = !!(regs.a.l & 0x80); regs.p.z = (regs.a.l == 0); } -void bCPU::flags_lda_w() { +inline void bCPU::flags_lda_w() { regs.p.n = !!(regs.a.w & 0x8000); regs.p.z = (regs.a.w == 0); } @@ -27,8 +27,6 @@ void bCPU::op_lda_constw() { flags_lda_w(); } -void bCPU::op_lda_const() { (regs.p.m)?op_lda_constb():op_lda_constw(); } - /********************** *** 0xad: lda addr *** ********************** @@ -54,8 +52,6 @@ void bCPU::op_lda_addrw() { flags_lda_w(); } -void bCPU::op_lda_addr() { (regs.p.m)?op_lda_addrb():op_lda_addrw(); } - /************************ *** 0xbd: lda addr,x *** ************************ @@ -84,8 +80,6 @@ void bCPU::op_lda_addrxw() { flags_lda_w(); } -void bCPU::op_lda_addrx() { (regs.p.m)?op_lda_addrxb():op_lda_addrxw(); } - /******************** *** 0xa5: lda dp *** ******************** @@ -111,8 +105,6 @@ void bCPU::op_lda_dpw() { flags_lda_w(); } -void bCPU::op_lda_dp() { (regs.p.m)?op_lda_dpb():op_lda_dpw(); } - /********************** *** 0xb2: lda (dp) *** ********************** @@ -144,8 +136,6 @@ void bCPU::op_lda_idpw() { flags_lda_w(); } -void bCPU::op_lda_idp() { (regs.p.m)?op_lda_idpb():op_lda_idpw(); } - /********************** *** 0xa7: lda [dp] *** ********************** @@ -180,8 +170,6 @@ void bCPU::op_lda_ildpw() { flags_lda_w(); } -void bCPU::op_lda_ildp() { (regs.p.m)?op_lda_ildpb():op_lda_ildpw(); } - /********************** *** 0xaf: lda long *** ********************** @@ -210,8 +198,6 @@ void bCPU::op_lda_longw() { flags_lda_w(); } -void bCPU::op_lda_long() { (regs.p.m)?op_lda_longb():op_lda_longw(); } - /************************ *** 0xbf: lda long,x *** ************************ @@ -240,8 +226,6 @@ void bCPU::op_lda_longxw() { flags_lda_w(); } -void bCPU::op_lda_longx() { (regs.p.m)?op_lda_longxb():op_lda_longxw(); } - /************************ *** 0xb9: lda addr,y *** ************************ @@ -270,8 +254,6 @@ void bCPU::op_lda_addryw() { flags_lda_w(); } -void bCPU::op_lda_addry() { (regs.p.m)?op_lda_addryb():op_lda_addryw(); } - /********************** *** 0xb5: lda dp,x *** ********************** @@ -300,8 +282,6 @@ void bCPU::op_lda_dpxw() { flags_lda_w(); } -void bCPU::op_lda_dpx() { (regs.p.m)?op_lda_dpxb():op_lda_dpxw(); } - /************************ *** 0xa1: lda (dp,x) *** ************************ @@ -336,8 +316,6 @@ void bCPU::op_lda_idpxw() { flags_lda_w(); } -void bCPU::op_lda_idpx() { (regs.p.m)?op_lda_idpxb():op_lda_idpxw(); } - /************************ *** 0xb1: lda (dp),y *** ************************ @@ -372,8 +350,6 @@ void bCPU::op_lda_idpyw() { flags_lda_w(); } -void bCPU::op_lda_idpy() { (regs.p.m)?op_lda_idpyb():op_lda_idpyw(); } - /************************ *** 0xb7: lda [dp],y *** ************************ @@ -408,8 +384,6 @@ void bCPU::op_lda_ildpyw() { flags_lda_w(); } -void bCPU::op_lda_ildpy() { (regs.p.m)?op_lda_ildpyb():op_lda_ildpyw(); } - /********************** *** 0xa3: lda sr,s *** ********************** @@ -435,8 +409,6 @@ void bCPU::op_lda_srw() { flags_lda_w(); } -void bCPU::op_lda_sr() { (regs.p.m)?op_lda_srb():op_lda_srw(); } - /************************** *** 0xb3: lda (sr,s),y *** ************************** @@ -470,5 +442,3 @@ void bCPU::op_lda_isryw() { regs.a.h = op_read(OPMODE_DBR, aa.w + regs.y.w + 1); //7a flags_lda_w(); } - -void bCPU::op_lda_isry() { (regs.p.m)?op_lda_isryb():op_lda_isryw(); } diff --git a/src/cpu/bcpu/bcpu_op_misc.cpp b/src/cpu/bcpu/bcpu_op_misc.cpp index fab75e4c..f09ded99 100644 --- a/src/cpu/bcpu/bcpu_op_misc.cpp +++ b/src/cpu/bcpu/bcpu_op_misc.cpp @@ -1,10 +1,10 @@ -void bCPU::flags_bit_b() { +inline void bCPU::flags_bit_b() { regs.p.n = !!(rd.l & 0x80); regs.p.v = !!(rd.l & 0x40); regs.p.z = ((rd.l & regs.a.l) == 0); } -void bCPU::flags_bit_w() { +inline void bCPU::flags_bit_w() { regs.p.n = !!(rd.w & 0x8000); regs.p.v = !!(rd.w & 0x4000); regs.p.z = ((rd.w & regs.a.w) == 0); @@ -20,17 +20,15 @@ cycles: */ void bCPU::op_bit_constb() { rd.l = op_read(); //2 - flags_bit_b(); + regs.p.z = ((rd.l & regs.a.l) == 0); } void bCPU::op_bit_constw() { rd.l = op_read(); //2 rd.h = op_read(); //2a - flags_bit_w(); + regs.p.z = ((rd.w & regs.a.w) == 0); } -void bCPU::op_bit_const() { (regs.p.m)?op_bit_constb():op_bit_constw(); } - /********************** *** 0x2c: bit addr *** ********************** @@ -56,8 +54,6 @@ void bCPU::op_bit_addrw() { flags_bit_w(); } -void bCPU::op_bit_addr() { (regs.p.m)?op_bit_addrb():op_bit_addrw(); } - /************************ *** 0x3c: bit addr,x *** ************************ @@ -86,8 +82,6 @@ void bCPU::op_bit_addrxw() { flags_bit_w(); } -void bCPU::op_bit_addrx() { (regs.p.m)?op_bit_addrxb():op_bit_addrxw(); } - /******************** *** 0x24: bit dp *** ******************** @@ -113,8 +107,6 @@ void bCPU::op_bit_dpw() { flags_bit_w(); } -void bCPU::op_bit_dp() { (regs.p.m)?op_bit_dpb():op_bit_dpw(); } - /********************** *** 0x34: bit dp,x *** ********************** @@ -143,16 +135,14 @@ void bCPU::op_bit_dpxw() { flags_bit_w(); } -void bCPU::op_bit_dpx() { (regs.p.m)?op_bit_dpxb():op_bit_dpxw(); } - -void bCPU::flags_cpx_b() { +inline void bCPU::flags_cpx_b() { int32 r = regs.x.l - rd.l; regs.p.n = !!(r & 0x80); regs.p.z = ((uint8)r == 0); regs.p.c = (r >= 0); } -void bCPU::flags_cpx_w() { +inline void bCPU::flags_cpx_w() { int32 r = regs.x.w - rd.w; regs.p.n = !!(r & 0x8000); regs.p.z = ((uint16)r == 0); @@ -178,8 +168,6 @@ void bCPU::op_cpx_constw() { flags_cpx_w(); } -void bCPU::op_cpx_const() { (regs.p.x)?op_cpx_constb():op_cpx_constw(); } - /********************** *** 0xec: cpx addr *** ********************** @@ -205,8 +193,6 @@ void bCPU::op_cpx_addrw() { flags_cpx_w(); } -void bCPU::op_cpx_addr() { (regs.p.x)?op_cpx_addrb():op_cpx_addrw(); } - /******************** *** 0xe4: cpx dp *** ******************** @@ -232,16 +218,14 @@ void bCPU::op_cpx_dpw() { flags_cpx_w(); } -void bCPU::op_cpx_dp() { (regs.p.x)?op_cpx_dpb():op_cpx_dpw(); } - -void bCPU::flags_cpy_b() { +inline void bCPU::flags_cpy_b() { int32 r = regs.y.l - rd.l; regs.p.n = !!(r & 0x80); regs.p.z = ((uint8)r == 0); regs.p.c = (r >= 0); } -void bCPU::flags_cpy_w() { +inline void bCPU::flags_cpy_w() { int32 r = regs.y.w - rd.w; regs.p.n = !!(r & 0x8000); regs.p.z = ((uint16)r == 0); @@ -267,8 +251,6 @@ void bCPU::op_cpy_constw() { flags_cpy_w(); } -void bCPU::op_cpy_const() { (regs.p.x)?op_cpy_constb():op_cpy_constw(); } - /********************** *** 0xcc: cpy addr *** ********************** @@ -294,8 +276,6 @@ void bCPU::op_cpy_addrw() { flags_cpy_w(); } -void bCPU::op_cpy_addr() { (regs.p.x)?op_cpy_addrb():op_cpy_addrw(); } - /******************** *** 0xc4: cpy dp *** ******************** @@ -321,14 +301,12 @@ void bCPU::op_cpy_dpw() { flags_cpy_w(); } -void bCPU::op_cpy_dp() { (regs.p.x)?op_cpy_dpb():op_cpy_dpw(); } - -void bCPU::flags_ldx_b() { +inline void bCPU::flags_ldx_b() { regs.p.n = !!(regs.x.l & 0x80); regs.p.z = (regs.x.l == 0); } -void bCPU::flags_ldx_w() { +inline void bCPU::flags_ldx_w() { regs.p.n = !!(regs.x.w & 0x8000); regs.p.z = (regs.x.w == 0); } @@ -352,8 +330,6 @@ void bCPU::op_ldx_constw() { flags_ldx_w(); } -void bCPU::op_ldx_const() { (regs.p.x)?op_ldx_constb():op_ldx_constw(); } - /********************** *** 0xae: ldx addr *** ********************** @@ -379,8 +355,6 @@ void bCPU::op_ldx_addrw() { flags_ldx_w(); } -void bCPU::op_ldx_addr() { (regs.p.x)?op_ldx_addrb():op_ldx_addrw(); } - /************************ *** 0xbe: ldx addr,y *** ************************ @@ -409,8 +383,6 @@ void bCPU::op_ldx_addryw() { flags_ldx_w(); } -void bCPU::op_ldx_addry() { (regs.p.x)?op_ldx_addryb():op_ldx_addryw(); } - /******************** *** 0xa6: ldx dp *** ******************** @@ -436,8 +408,6 @@ void bCPU::op_ldx_dpw() { flags_ldx_w(); } -void bCPU::op_ldx_dp() { (regs.p.x)?op_ldx_dpb():op_ldx_dpw(); } - /********************** *** 0xb6: ldx dp,y *** ********************** @@ -466,14 +436,12 @@ void bCPU::op_ldx_dpyw() { flags_ldx_w(); } -void bCPU::op_ldx_dpy() { (regs.p.x)?op_ldx_dpyb():op_ldx_dpyw(); } - -void bCPU::flags_ldy_b() { +inline void bCPU::flags_ldy_b() { regs.p.n = !!(regs.y.l & 0x80); regs.p.z = (regs.y.l == 0); } -void bCPU::flags_ldy_w() { +inline void bCPU::flags_ldy_w() { regs.p.n = !!(regs.y.w & 0x8000); regs.p.z = (regs.y.w == 0); } @@ -497,8 +465,6 @@ void bCPU::op_ldy_constw() { flags_ldy_w(); } -void bCPU::op_ldy_const() { (regs.p.x)?op_ldy_constb():op_ldy_constw(); } - /********************** *** 0xac: ldy addr *** ********************** @@ -524,8 +490,6 @@ void bCPU::op_ldy_addrw() { flags_ldy_w(); } -void bCPU::op_ldy_addr() { (regs.p.x)?op_ldy_addrb():op_ldy_addrw(); } - /************************ *** 0xbc: ldy addr,x *** ************************ @@ -554,8 +518,6 @@ void bCPU::op_ldy_addrxw() { flags_ldy_w(); } -void bCPU::op_ldy_addrx() { (regs.p.x)?op_ldy_addrxb():op_ldy_addrxw(); } - /******************** *** 0xa4: ldy dp *** ******************** @@ -581,8 +543,6 @@ void bCPU::op_ldy_dpw() { flags_ldy_w(); } -void bCPU::op_ldy_dp() { (regs.p.x)?op_ldy_dpb():op_ldy_dpw(); } - /********************** *** 0xb4: ldy dp,x *** ********************** @@ -611,8 +571,6 @@ void bCPU::op_ldy_dpxw() { flags_ldy_w(); } -void bCPU::op_ldy_dpx() { (regs.p.x)?op_ldy_dpxb():op_ldy_dpxw(); } - /********************** *** 0x8e: stx addr *** ********************** @@ -636,8 +594,6 @@ void bCPU::op_stx_addrw() { op_write(OPMODE_DBR, aa.w + 1, regs.x.h); //4a } -void bCPU::op_stx_addr() { (regs.p.x)?op_stx_addrb():op_stx_addrw(); } - /******************** *** 0x86: stx dp *** ******************** @@ -661,8 +617,6 @@ void bCPU::op_stx_dpw() { op_write(OPMODE_DP, dp + 1, regs.x.h); //3a } -void bCPU::op_stx_dp() { (regs.p.x)?op_stx_dpb():op_stx_dpw(); } - /********************** *** 0x96: stx dp,y *** ********************** @@ -689,8 +643,6 @@ void bCPU::op_stx_dpyw() { op_write(OPMODE_DP, dp + regs.y.w + 1, regs.x.h); //4a } -void bCPU::op_stx_dpy() { (regs.p.x)?op_stx_dpyb():op_stx_dpyw(); } - /********************** *** 0x8c: sty addr *** ********************** @@ -714,8 +666,6 @@ void bCPU::op_sty_addrw() { op_write(OPMODE_DBR, aa.w + 1, regs.y.h); //4a } -void bCPU::op_sty_addr() { (regs.p.x)?op_sty_addrb():op_sty_addrw(); } - /******************** *** 0x84: sty dp *** ******************** @@ -739,8 +689,6 @@ void bCPU::op_sty_dpw() { op_write(OPMODE_DP, dp + 1, regs.y.h); //3a } -void bCPU::op_sty_dp() { (regs.p.x)?op_sty_dpb():op_sty_dpw(); } - /********************** *** 0x94: sty dp,x *** ********************** @@ -767,8 +715,6 @@ void bCPU::op_sty_dpxw() { op_write(OPMODE_DP, dp + regs.x.w + 1, regs.y.h); //4a } -void bCPU::op_sty_dpx() { (regs.p.x)?op_sty_dpxb():op_sty_dpxw(); } - /********************** *** 0x9c: stz addr *** ********************** @@ -792,8 +738,6 @@ void bCPU::op_stz_addrw() { op_write(OPMODE_DBR, aa.w + 1, 0); //4a } -void bCPU::op_stz_addr() { (regs.p.m)?op_stz_addrb():op_stz_addrw(); } - /************************ *** 0x9e: stz addr,x *** ************************ @@ -820,8 +764,6 @@ void bCPU::op_stz_addrxw() { op_write(OPMODE_DBR, aa.w + regs.x.w + 1, 0); //4a } -void bCPU::op_stz_addrx() { (regs.p.m)?op_stz_addrxb():op_stz_addrxw(); } - /******************** *** 0x64: stz dp *** ******************** @@ -845,8 +787,6 @@ void bCPU::op_stz_dpw() { op_write(OPMODE_DP, dp + 1, 0); //3a } -void bCPU::op_stz_dp() { (regs.p.m)?op_stz_dpb():op_stz_dpw(); } - /********************** *** 0x74: stz dp,x *** ********************** @@ -873,8 +813,6 @@ void bCPU::op_stz_dpxw() { op_write(OPMODE_DP, dp + regs.x.w + 1, 0); //4a } -void bCPU::op_stz_dpx() { (regs.p.m)?op_stz_dpxb():op_stz_dpxw(); } - /***************** *** 0xeb: xba *** ***************** @@ -928,8 +866,6 @@ void bCPU::op_trb_addrw() { op_write(OPMODE_DBR, aa.w, rd.l); //6 } -void bCPU::op_trb_addr() { (regs.p.m)?op_trb_addrb():op_trb_addrw(); } - /******************** *** 0x14: trb dp *** ******************** @@ -965,8 +901,6 @@ void bCPU::op_trb_dpw() { op_write(OPMODE_DP, dp, rd.l); //5 } -void bCPU::op_trb_dp() { (regs.p.m)?op_trb_dpb():op_trb_dpw(); } - /********************** *** 0x0c: tsb addr *** ********************** @@ -1002,8 +936,6 @@ void bCPU::op_tsb_addrw() { op_write(OPMODE_DBR, aa.w, rd.l); //6 } -void bCPU::op_tsb_addr() { (regs.p.m)?op_tsb_addrb():op_tsb_addrw(); } - /******************** *** 0x04: tsb dp *** ******************** @@ -1039,8 +971,6 @@ void bCPU::op_tsb_dpw() { op_write(OPMODE_DP, dp, rd.l); //5 } -void bCPU::op_tsb_dp() { (regs.p.m)?op_tsb_dpb():op_tsb_dpw(); } - /************************** *** 0x54: mvn src,dest *** ************************** @@ -1219,6 +1149,14 @@ bool c = regs.p.c; regs.x.h = 0x00; regs.y.h = 0x00; regs.s.h = 0x01; + optbl = optbl_e; + } else { + switch((regs.p >> 4) & 3) { + case 0:optbl = optbl_mx;break; + case 1:optbl = optbl_mX;break; + case 2:optbl = optbl_Mx;break; + case 3:optbl = optbl_MX;break; + } } } @@ -1343,6 +1281,13 @@ void bCPU::op_rep() { regs.p &= ~rd.l; if(regs.e) { regs.p |= 0x30; + } else { + switch((regs.p >> 4) & 3) { + case 0:optbl = optbl_mx;break; + case 1:optbl = optbl_mX;break; + case 2:optbl = optbl_Mx;break; + case 3:optbl = optbl_MX;break; + } } } @@ -1360,6 +1305,13 @@ void bCPU::op_sep() { regs.p |= rd.l; if(regs.e) { regs.p |= 0x30; + } else { + switch((regs.p >> 4) & 3) { + case 0:optbl = optbl_mx;break; + case 1:optbl = optbl_mX;break; + case 2:optbl = optbl_Mx;break; + case 3:optbl = optbl_MX;break; + } } if(regs.p.x) { regs.x.h = 0x00; @@ -1388,8 +1340,6 @@ void bCPU::op_taxw() { regs.p.z = (regs.x.w == 0); } -void bCPU::op_tax() { (regs.p.x)?op_taxb():op_taxw(); } - /***************** *** 0xa8: tay *** ***************** @@ -1411,8 +1361,6 @@ void bCPU::op_tayw() { regs.p.z = (regs.y.w == 0); } -void bCPU::op_tay() { (regs.p.x)?op_tayb():op_tayw(); } - /***************** *** 0x5b: tcd *** ***************** @@ -1496,8 +1444,6 @@ void bCPU::op_tsxw() { regs.p.z = (regs.x.w == 0); } -void bCPU::op_tsx() { (regs.p.x)?op_tsxb():op_tsxw(); } - /***************** *** 0x8a: txa *** ***************** @@ -1519,8 +1465,6 @@ void bCPU::op_txaw() { regs.p.z = (regs.a.w == 0); } -void bCPU::op_txa() { (regs.p.m)?op_txab():op_txaw(); } - /***************** *** 0x9a: txs *** ***************** @@ -1542,8 +1486,6 @@ void bCPU::op_txsw() { regs.p.z = (regs.s.w == 0); } -void bCPU::op_txs() { (regs.p.x)?op_txsb():op_txsw(); } - /***************** *** 0x9b: txy *** ***************** @@ -1565,8 +1507,6 @@ void bCPU::op_txyw() { regs.p.z = (regs.y.w == 0); } -void bCPU::op_txy() { (regs.p.x)?op_txyb():op_txyw(); } - /***************** *** 0x98: tya *** ***************** @@ -1588,8 +1528,6 @@ void bCPU::op_tyaw() { regs.p.z = (regs.a.w == 0); } -void bCPU::op_tya() { (regs.p.m)?op_tyab():op_tyaw(); } - /***************** *** 0xbb: tyx *** ***************** @@ -1610,5 +1548,3 @@ void bCPU::op_tyxw() { regs.p.n = !!(regs.x.w & 0x8000); regs.p.z = (regs.x.w == 0); } - -void bCPU::op_tyx() { (regs.p.x)?op_tyxb():op_tyxw(); } diff --git a/src/cpu/bcpu/bcpu_op_ora.cpp b/src/cpu/bcpu/bcpu_op_ora.cpp index d31bbabf..33e86b90 100644 --- a/src/cpu/bcpu/bcpu_op_ora.cpp +++ b/src/cpu/bcpu/bcpu_op_ora.cpp @@ -1,9 +1,9 @@ -void bCPU::flags_ora_b() { +inline void bCPU::flags_ora_b() { regs.p.n = !!(regs.a.l & 0x80); regs.p.z = (regs.a.l == 0); } -void bCPU::flags_ora_w() { +inline void bCPU::flags_ora_w() { regs.p.n = !!(regs.a.w & 0x8000); regs.p.z = (regs.a.w == 0); } @@ -27,8 +27,6 @@ void bCPU::op_ora_constw() { flags_ora_w(); } -void bCPU::op_ora_const() { (regs.p.m)?op_ora_constb():op_ora_constw(); } - /********************** *** 0x0d: ora addr *** ********************** @@ -54,8 +52,6 @@ void bCPU::op_ora_addrw() { flags_ora_w(); } -void bCPU::op_ora_addr() { (regs.p.m)?op_ora_addrb():op_ora_addrw(); } - /************************ *** 0x1d: ora addr,x *** ************************ @@ -84,8 +80,6 @@ void bCPU::op_ora_addrxw() { flags_ora_w(); } -void bCPU::op_ora_addrx() { (regs.p.m)?op_ora_addrxb():op_ora_addrxw(); } - /******************** *** 0x05: ora dp *** ******************** @@ -111,8 +105,6 @@ void bCPU::op_ora_dpw() { flags_ora_w(); } -void bCPU::op_ora_dp() { (regs.p.m)?op_ora_dpb():op_ora_dpw(); } - /********************** *** 0x12: ora (dp) *** ********************** @@ -144,8 +136,6 @@ void bCPU::op_ora_idpw() { flags_ora_w(); } -void bCPU::op_ora_idp() { (regs.p.m)?op_ora_idpb():op_ora_idpw(); } - /********************** *** 0x07: ora [dp] *** ********************** @@ -180,8 +170,6 @@ void bCPU::op_ora_ildpw() { flags_ora_w(); } -void bCPU::op_ora_ildp() { (regs.p.m)?op_ora_ildpb():op_ora_ildpw(); } - /********************** *** 0x0f: ora long *** ********************** @@ -210,8 +198,6 @@ void bCPU::op_ora_longw() { flags_ora_w(); } -void bCPU::op_ora_long() { (regs.p.m)?op_ora_longb():op_ora_longw(); } - /************************ *** 0x1f: ora long,x *** ************************ @@ -240,8 +226,6 @@ void bCPU::op_ora_longxw() { flags_ora_w(); } -void bCPU::op_ora_longx() { (regs.p.m)?op_ora_longxb():op_ora_longxw(); } - /************************ *** 0x19: ora addr,y *** ************************ @@ -270,8 +254,6 @@ void bCPU::op_ora_addryw() { flags_ora_w(); } -void bCPU::op_ora_addry() { (regs.p.m)?op_ora_addryb():op_ora_addryw(); } - /********************** *** 0x15: ora dp,x *** ********************** @@ -300,8 +282,6 @@ void bCPU::op_ora_dpxw() { flags_ora_w(); } -void bCPU::op_ora_dpx() { (regs.p.m)?op_ora_dpxb():op_ora_dpxw(); } - /************************ *** 0x01: ora (dp,x) *** ************************ @@ -336,8 +316,6 @@ void bCPU::op_ora_idpxw() { flags_ora_w(); } -void bCPU::op_ora_idpx() { (regs.p.m)?op_ora_idpxb():op_ora_idpxw(); } - /************************ *** 0x11: ora (dp),y *** ************************ @@ -372,8 +350,6 @@ void bCPU::op_ora_idpyw() { flags_ora_w(); } -void bCPU::op_ora_idpy() { (regs.p.m)?op_ora_idpyb():op_ora_idpyw(); } - /************************ *** 0x17: ora [dp],y *** ************************ @@ -408,8 +384,6 @@ void bCPU::op_ora_ildpyw() { flags_ora_w(); } -void bCPU::op_ora_ildpy() { (regs.p.m)?op_ora_ildpyb():op_ora_ildpyw(); } - /********************** *** 0x03: ora sr,s *** ********************** @@ -435,8 +409,6 @@ void bCPU::op_ora_srw() { flags_ora_w(); } -void bCPU::op_ora_sr() { (regs.p.m)?op_ora_srb():op_ora_srw(); } - /************************** *** 0x13: ora (sr,s),y *** ************************** @@ -470,5 +442,3 @@ void bCPU::op_ora_isryw() { regs.a.h |= op_read(OPMODE_DBR, aa.w + regs.y.w + 1); //7a flags_ora_w(); } - -void bCPU::op_ora_isry() { (regs.p.m)?op_ora_isryb():op_ora_isryw(); } diff --git a/src/cpu/bcpu/bcpu_op_pc.cpp b/src/cpu/bcpu/bcpu_op_pc.cpp index fb499632..2ec8b225 100644 --- a/src/cpu/bcpu/bcpu_op_pc.cpp +++ b/src/cpu/bcpu/bcpu_op_pc.cpp @@ -193,9 +193,14 @@ void bCPU::op_rtin() { regs.y.h = 0x00; } regs.pc.d = rd.d; -} -void bCPU::op_rti() { (regs.e)?op_rtie():op_rtin(); } + switch((regs.p >> 4) & 3) { + case 0:optbl = optbl_mx;break; + case 1:optbl = optbl_mX;break; + case 2:optbl = optbl_Mx;break; + case 3:optbl = optbl_MX;break; + } +} /***************** *** 0x60: rts *** diff --git a/src/cpu/bcpu/bcpu_op_sbc.cpp b/src/cpu/bcpu/bcpu_op_sbc.cpp index 5e4b36cf..012a7ff5 100644 --- a/src/cpu/bcpu/bcpu_op_sbc.cpp +++ b/src/cpu/bcpu/bcpu_op_sbc.cpp @@ -1,4 +1,4 @@ -void bCPU::flags_sbc_b() { +inline void bCPU::flags_sbc_b() { int32 r = regs.a.l - rd.l - !regs.p.c; //bcd if(regs.p.d) { @@ -12,7 +12,7 @@ int32 r = regs.a.l - rd.l - !regs.p.c; regs.a.l = r; } -void bCPU::flags_sbc_w() { +inline void bCPU::flags_sbc_w() { int32 r = regs.a.w - rd.w - !regs.p.c; //bcd if(regs.p.d) { @@ -47,8 +47,6 @@ void bCPU::op_sbc_constw() { flags_sbc_w(); } -void bCPU::op_sbc_const() { (regs.p.m)?op_sbc_constb():op_sbc_constw(); } - /********************** *** 0xed: sbc addr *** ********************** @@ -74,8 +72,6 @@ void bCPU::op_sbc_addrw() { flags_sbc_w(); } -void bCPU::op_sbc_addr() { (regs.p.m)?op_sbc_addrb():op_sbc_addrw(); } - /************************ *** 0xfd: sbc addr,x *** ************************ @@ -104,8 +100,6 @@ void bCPU::op_sbc_addrxw() { flags_sbc_w(); } -void bCPU::op_sbc_addrx() { (regs.p.m)?op_sbc_addrxb():op_sbc_addrxw(); } - /******************** *** 0xe5: sbc dp *** ******************** @@ -131,8 +125,6 @@ void bCPU::op_sbc_dpw() { flags_sbc_w(); } -void bCPU::op_sbc_dp() { (regs.p.m)?op_sbc_dpb():op_sbc_dpw(); } - /********************** *** 0xf2: sbc (dp) *** ********************** @@ -164,8 +156,6 @@ void bCPU::op_sbc_idpw() { flags_sbc_w(); } -void bCPU::op_sbc_idp() { (regs.p.m)?op_sbc_idpb():op_sbc_idpw(); } - /********************** *** 0xe7: sbc [dp] *** ********************** @@ -200,8 +190,6 @@ void bCPU::op_sbc_ildpw() { flags_sbc_w(); } -void bCPU::op_sbc_ildp() { (regs.p.m)?op_sbc_ildpb():op_sbc_ildpw(); } - /********************** *** 0xef: sbc long *** ********************** @@ -230,8 +218,6 @@ void bCPU::op_sbc_longw() { flags_sbc_w(); } -void bCPU::op_sbc_long() { (regs.p.m)?op_sbc_longb():op_sbc_longw(); } - /************************ *** 0xff: sbc long,x *** ************************ @@ -260,8 +246,6 @@ void bCPU::op_sbc_longxw() { flags_sbc_w(); } -void bCPU::op_sbc_longx() { (regs.p.m)?op_sbc_longxb():op_sbc_longxw(); } - /************************ *** 0xf9: sbc addr,y *** ************************ @@ -290,8 +274,6 @@ void bCPU::op_sbc_addryw() { flags_sbc_w(); } -void bCPU::op_sbc_addry() { (regs.p.m)?op_sbc_addryb():op_sbc_addryw(); } - /********************** *** 0xf5: sbc dp,x *** ********************** @@ -320,8 +302,6 @@ void bCPU::op_sbc_dpxw() { flags_sbc_w(); } -void bCPU::op_sbc_dpx() { (regs.p.m)?op_sbc_dpxb():op_sbc_dpxw(); } - /************************ *** 0xe1: sbc (dp,x) *** ************************ @@ -356,8 +336,6 @@ void bCPU::op_sbc_idpxw() { flags_sbc_w(); } -void bCPU::op_sbc_idpx() { (regs.p.m)?op_sbc_idpxb():op_sbc_idpxw(); } - /************************ *** 0xf1: sbc (dp),y *** ************************ @@ -392,8 +370,6 @@ void bCPU::op_sbc_idpyw() { flags_sbc_w(); } -void bCPU::op_sbc_idpy() { (regs.p.m)?op_sbc_idpyb():op_sbc_idpyw(); } - /************************ *** 0xf7: sbc [dp],y *** ************************ @@ -428,8 +404,6 @@ void bCPU::op_sbc_ildpyw() { flags_sbc_w(); } -void bCPU::op_sbc_ildpy() { (regs.p.m)?op_sbc_ildpyb():op_sbc_ildpyw(); } - /********************** *** 0xe3: sbc sr,s *** ********************** @@ -455,8 +429,6 @@ void bCPU::op_sbc_srw() { flags_sbc_w(); } -void bCPU::op_sbc_sr() { (regs.p.m)?op_sbc_srb():op_sbc_srw(); } - /************************** *** 0xf3: sbc (sr,s),y *** ************************** @@ -490,5 +462,3 @@ void bCPU::op_sbc_isryw() { rd.h = op_read(OPMODE_DBR, aa.w + regs.y.w + 1); //7a flags_sbc_w(); } - -void bCPU::op_sbc_isry() { (regs.p.m)?op_sbc_isryb():op_sbc_isryw(); } diff --git a/src/cpu/bcpu/bcpu_op_shift.cpp b/src/cpu/bcpu/bcpu_op_shift.cpp index 927712c6..23171da3 100644 --- a/src/cpu/bcpu/bcpu_op_shift.cpp +++ b/src/cpu/bcpu/bcpu_op_shift.cpp @@ -21,8 +21,6 @@ void bCPU::op_aslw() { regs.p.z = (regs.a.w == 0); } -void bCPU::op_asl() { (regs.p.m)?op_aslb():op_aslw(); } - /********************** *** 0x0e: asl addr *** ********************** @@ -62,8 +60,6 @@ void bCPU::op_asl_addrw() { regs.p.z = (rd.w == 0); } -void bCPU::op_asl_addr() { (regs.p.m)?op_asl_addrb():op_asl_addrw(); } - /************************ *** 0x1e: asl addr,x *** ************************ @@ -106,8 +102,6 @@ void bCPU::op_asl_addrxw() { regs.p.z = (rd.w == 0); } -void bCPU::op_asl_addrx() { (regs.p.m)?op_asl_addrxb():op_asl_addrxw(); } - /******************** *** 0x06: asl dp *** ******************** @@ -147,8 +141,6 @@ void bCPU::op_asl_dpw() { regs.p.z = (rd.w == 0); } -void bCPU::op_asl_dp() { (regs.p.m)?op_asl_dpb():op_asl_dpw(); } - /********************** *** 0x16: asl dp,x *** ********************** @@ -191,8 +183,6 @@ void bCPU::op_asl_dpxw() { regs.p.z = (rd.w == 0); } -void bCPU::op_asl_dpx() { (regs.p.m)?op_asl_dpxb():op_asl_dpxw(); } - /***************** *** 0x4a: lsr *** ***************** @@ -216,8 +206,6 @@ void bCPU::op_lsrw() { regs.p.z = (regs.a.w == 0); } -void bCPU::op_lsr() { (regs.p.m)?op_lsrb():op_lsrw(); } - /********************** *** 0x4e: lsr addr *** ********************** @@ -257,8 +245,6 @@ void bCPU::op_lsr_addrw() { regs.p.z = (rd.w == 0); } -void bCPU::op_lsr_addr() { (regs.p.m)?op_lsr_addrb():op_lsr_addrw(); } - /************************ *** 0x5e: lsr addr,x *** ************************ @@ -301,8 +287,6 @@ void bCPU::op_lsr_addrxw() { regs.p.z = (rd.w == 0); } -void bCPU::op_lsr_addrx() { (regs.p.m)?op_lsr_addrxb():op_lsr_addrxw(); } - /******************** *** 0x46: lsr dp *** ******************** @@ -342,8 +326,6 @@ void bCPU::op_lsr_dpw() { regs.p.z = (rd.w == 0); } -void bCPU::op_lsr_dp() { (regs.p.m)?op_lsr_dpb():op_lsr_dpw(); } - /********************** *** 0x56: lsr dp,x *** ********************** @@ -386,8 +368,6 @@ void bCPU::op_lsr_dpxw() { regs.p.z = (rd.w == 0); } -void bCPU::op_lsr_dpx() { (regs.p.m)?op_lsr_dpxb():op_lsr_dpxw(); } - /***************** *** 0x2a: rol *** ***************** @@ -415,8 +395,6 @@ uint16 c = regs.p.c; regs.p.z = (regs.a.w == 0); } -void bCPU::op_rol() { (regs.p.m)?op_rolb():op_rolw(); } - /********************** *** 0x2e: rol addr *** ********************** @@ -460,8 +438,6 @@ uint16 c = regs.p.c; regs.p.z = (rd.w == 0); } -void bCPU::op_rol_addr() { (regs.p.m)?op_rol_addrb():op_rol_addrw(); } - /************************ *** 0x3e: rol addr,x *** ************************ @@ -508,8 +484,6 @@ uint16 c = regs.p.c; regs.p.z = (rd.w == 0); } -void bCPU::op_rol_addrx() { (regs.p.m)?op_rol_addrxb():op_rol_addrxw(); } - /******************** *** 0x26: rol dp *** ******************** @@ -553,8 +527,6 @@ uint16 c = regs.p.c; regs.p.z = (rd.w == 0); } -void bCPU::op_rol_dp() { (regs.p.m)?op_rol_dpb():op_rol_dpw(); } - /********************** *** 0x36: rol dp,x *** ********************** @@ -601,8 +573,6 @@ uint16 c = regs.p.c; regs.p.z = (rd.w == 0); } -void bCPU::op_rol_dpx() { (regs.p.m)?op_rol_dpxb():op_rol_dpxw(); } - /***************** *** 0x6a: ror *** ***************** @@ -630,8 +600,6 @@ uint16 c = (regs.p.c)?0x8000:0; regs.p.z = (regs.a.w == 0); } -void bCPU::op_ror() { (regs.p.m)?op_rorb():op_rorw(); } - /********************** *** 0x6e: ror addr *** ********************** @@ -675,8 +643,6 @@ uint16 c = (regs.p.c)?0x8000:0; regs.p.z = (rd.w == 0); } -void bCPU::op_ror_addr() { (regs.p.m)?op_ror_addrb():op_ror_addrw(); } - /************************ *** 0x7e: ror addr,x *** ************************ @@ -723,8 +689,6 @@ uint16 c = (regs.p.c)?0x8000:0; regs.p.z = (rd.w == 0); } -void bCPU::op_ror_addrx() { (regs.p.m)?op_ror_addrxb():op_ror_addrxw(); } - /******************** *** 0x66: ror dp *** ******************** @@ -768,8 +732,6 @@ uint16 c = (regs.p.c)?0x8000:0; regs.p.z = (rd.w == 0); } -void bCPU::op_ror_dp() { (regs.p.m)?op_ror_dpb():op_ror_dpw(); } - /********************** *** 0x76: ror dp,x *** ********************** @@ -815,5 +777,3 @@ uint16 c = (regs.p.c)?0x8000:0; regs.p.n = !!(rd.w & 0x8000); regs.p.z = (rd.w == 0); } - -void bCPU::op_ror_dpx() { (regs.p.m)?op_ror_dpxb():op_ror_dpxw(); } diff --git a/src/cpu/bcpu/bcpu_op_sta.cpp b/src/cpu/bcpu/bcpu_op_sta.cpp index 4dc9bf4b..eb88afaf 100644 --- a/src/cpu/bcpu/bcpu_op_sta.cpp +++ b/src/cpu/bcpu/bcpu_op_sta.cpp @@ -21,8 +21,6 @@ void bCPU::op_sta_addrw() { op_write(OPMODE_DBR, aa.w + 1, regs.a.h); //4a } -void bCPU::op_sta_addr() { (regs.p.m)?op_sta_addrb():op_sta_addrw(); } - /************************ *** 0x9d: sta addr,x *** ************************ @@ -49,8 +47,6 @@ void bCPU::op_sta_addrxw() { op_write(OPMODE_DBR, aa.w + regs.x.w + 1, regs.a.h); //4a } -void bCPU::op_sta_addrx() { (regs.p.m)?op_sta_addrxb():op_sta_addrxw(); } - /******************** *** 0x85: sta dp *** ******************** @@ -74,8 +70,6 @@ void bCPU::op_sta_dpw() { op_write(OPMODE_DP, dp + 1, regs.a.h); //3a } -void bCPU::op_sta_dp() { (regs.p.m)?op_sta_dpb():op_sta_dpw(); } - /********************** *** 0x92: sta (dp) *** ********************** @@ -105,8 +99,6 @@ void bCPU::op_sta_idpw() { op_write(OPMODE_DBR, aa.w + 1, regs.a.h); //5 } -void bCPU::op_sta_idp() { (regs.p.m)?op_sta_idpb():op_sta_idpw(); } - /********************** *** 0x87: sta [dp] *** ********************** @@ -139,8 +131,6 @@ void bCPU::op_sta_ildpw() { op_write(OPMODE_LONG, aa.d + 1, regs.a.h); //6a } -void bCPU::op_sta_ildp() { (regs.p.m)?op_sta_ildpb():op_sta_ildpw(); } - /********************** *** 0x8f: sta long *** ********************** @@ -167,8 +157,6 @@ void bCPU::op_sta_longw() { op_write(OPMODE_LONG, aa.d + 1, regs.a.h); //5a } -void bCPU::op_sta_long() { (regs.p.m)?op_sta_longb():op_sta_longw(); } - /************************ *** 0x9f: sta long,x *** ************************ @@ -195,8 +183,6 @@ void bCPU::op_sta_longxw() { op_write(OPMODE_LONG, aa.d + regs.x.w + 1, regs.a.h); //5a } -void bCPU::op_sta_longx() { (regs.p.m)?op_sta_longxb():op_sta_longxw(); } - /************************ *** 0x99: sta addr,y *** ************************ @@ -223,8 +209,6 @@ void bCPU::op_sta_addryw() { op_write(OPMODE_DBR, aa.w + regs.y.w + 1, regs.a.h); //4a } -void bCPU::op_sta_addry() { (regs.p.m)?op_sta_addryb():op_sta_addryw(); } - /********************** *** 0x95: sta dp,x *** ********************** @@ -251,8 +235,6 @@ void bCPU::op_sta_dpxw() { op_write(OPMODE_DP, dp + regs.x.w + 1, regs.a.h); //4a } -void bCPU::op_sta_dpx() { (regs.p.m)?op_sta_dpxb():op_sta_dpxw(); } - /************************ *** 0x81: sta (dp,x) *** ************************ @@ -285,8 +267,6 @@ void bCPU::op_sta_idpxw() { op_write(OPMODE_DBR, aa.w + 1, regs.a.h); //6a } -void bCPU::op_sta_idpx() { (regs.p.m)?op_sta_idpxb():op_sta_idpxw(); } - /************************ *** 0x91: sta (dp),y *** ************************ @@ -319,8 +299,6 @@ void bCPU::op_sta_idpyw() { op_write(OPMODE_DBR, aa.w + regs.y.w + 1, regs.a.h); //5a } -void bCPU::op_sta_idpy() { (regs.p.m)?op_sta_idpyb():op_sta_idpyw(); } - /************************ *** 0x97: sta [dp],y *** ************************ @@ -353,8 +331,6 @@ void bCPU::op_sta_ildpyw() { op_write(OPMODE_LONG, aa.d + regs.y.w + 1, regs.a.h); //6a } -void bCPU::op_sta_ildpy() { (regs.p.m)?op_sta_ildpyb():op_sta_ildpyw(); } - /********************** *** 0x83: sta sr,s *** ********************** @@ -378,8 +354,6 @@ void bCPU::op_sta_srw() { op_write(OPMODE_SP, sp + 1, regs.a.h); //4a } -void bCPU::op_sta_sr() { (regs.p.m)?op_sta_srb():op_sta_srw(); } - /************************** *** 0x93: sta (sr,s),y *** ************************** @@ -411,5 +385,3 @@ void bCPU::op_sta_isryw() { op_write(OPMODE_DBR, aa.w + regs.y.w, regs.a.l); //7 op_write(OPMODE_DBR, aa.w + regs.y.w + 1, regs.a.h); //7a } - -void bCPU::op_sta_isry() { (regs.p.m)?op_sta_isryb():op_sta_isryw(); } diff --git a/src/cpu/bcpu/bcpu_op_stack.cpp b/src/cpu/bcpu/bcpu_op_stack.cpp index defddb1a..bb741e84 100644 --- a/src/cpu/bcpu/bcpu_op_stack.cpp +++ b/src/cpu/bcpu/bcpu_op_stack.cpp @@ -18,8 +18,6 @@ void bCPU::op_phaw() { stack_write(regs.a.l); //3 } -void bCPU::op_pha() { (regs.p.m)?op_phab():op_phaw(); } - /***************** *** 0x8b: phb *** ***************** @@ -94,8 +92,6 @@ void bCPU::op_phxw() { stack_write(regs.x.l); //3 } -void bCPU::op_phx() { (regs.p.x)?op_phxb():op_phxw(); } - /***************** *** 0x5a: phy *** ***************** @@ -116,8 +112,6 @@ void bCPU::op_phyw() { stack_write(regs.y.l); //3 } -void bCPU::op_phy() { (regs.p.x)?op_phyb():op_phyw(); } - /***************** *** 0x68: pla *** ***************** @@ -145,8 +139,6 @@ void bCPU::op_plaw() { regs.p.z = (regs.a.w == 0); } -void bCPU::op_pla() { (regs.p.m)?op_plab():op_plaw(); } - /***************** *** 0xab: plb *** ***************** @@ -196,7 +188,16 @@ void bCPU::op_plp() { cpu_io(); //2 cpu_io(); //3 regs.p = stack_read(); //4 - if(regs.e)regs.p |= 0x30; + if(regs.e) { + regs.p |= 0x30; + } else { + switch((regs.p >> 4) & 3) { + case 0:optbl = optbl_mx;break; + case 1:optbl = optbl_mX;break; + case 2:optbl = optbl_Mx;break; + case 3:optbl = optbl_MX;break; + } + } if(regs.p.x) { regs.x.h = 0x00; regs.y.h = 0x00; @@ -230,8 +231,6 @@ void bCPU::op_plxw() { regs.p.z = (regs.x.w == 0); } -void bCPU::op_plx() { (regs.p.x)?op_plxb():op_plxw(); } - /***************** *** 0x7a: ply *** ***************** @@ -259,8 +258,6 @@ void bCPU::op_plyw() { regs.p.z = (regs.y.w == 0); } -void bCPU::op_ply() { (regs.p.x)?op_plyb():op_plyw(); } - /********************** *** 0xf4: pea addr *** ********************** diff --git a/src/lib/libbase.h b/src/lib/libbase.h new file mode 100644 index 00000000..ed7810d9 --- /dev/null +++ b/src/lib/libbase.h @@ -0,0 +1,30 @@ +/* + libbase : version 0.01 ~byuu +*/ + +#ifndef __LIBBASE +#define __LIBBASE + +#include +#include +#include +#include + +typedef unsigned char byte; +typedef unsigned short word; +typedef unsigned long ulong; + +typedef unsigned char uint8; +typedef unsigned short uint16; +typedef unsigned long uint32; + +typedef signed char int8; +typedef signed short int16; +typedef signed long int32; + +#ifdef null +#undef null +#endif +#define null 0xffffffff + +#endif diff --git a/src/lib/libconfig.cpp b/src/lib/libconfig.cpp new file mode 100644 index 00000000..5fb4cf31 --- /dev/null +++ b/src/lib/libconfig.cpp @@ -0,0 +1,304 @@ +#include "libbase.h" +#include "libconfig.h" + +bool config_item::changed() { + return (is_string == true) ? (*strsource != strdef) : (*source != def); +} + +config_item::config_item() { + is_string = false; + source = 0; + strsource = 0; + def = 0; + strdef = ""; + type = 0; + name = ""; +} + +void config::add(uint32 *variable, char *name, uint32 def, uint32 type) { +int n; + if(item_count >= 4096)return; + n = item_count; + + item[n] = new config_item(); + + item[n]->is_string = false; + item[n]->name = name; + item[n]->source = variable; + item[n]->def = def; + item[n]->type = type; + *item[n]->source = item[n]->def; + + item_count++; +} + +void config::add(string *variable, char *name, char *def, uint32 type) { +int n; + if(item_count >= 4096)return; + n = item_count; + + item[n] = new config_item(); + item[n]->is_string = true; + item[n]->name = name; + item[n]->strsource = variable; + item[n]->strdef = def; + *item[n]->strsource = item[n]->strdef; + + item_count++; +} + +uint32 config::find(char *name) { + for(int i=0;iname == name) { + return i; + } + } + return null; +} + +uint32 config::get(char *name) { +int i = find(name); + if(i == null)return 0; + return *item[i]->source; +} + +string &config::strget(char *name) { +int i = find(name); + if(i == null) { + static string not_found; + not_found = ""; + return not_found; + } + return *item[i]->strsource; +} + +void config::set(char *name, uint32 value) { +int i = find(name); + if(i == null)return; + *item[i]->source = value; +} + +void config::set(char *name, char *value) { +int i = find(name); + if(i == null)return; + *item[i]->strsource = value; +} + +void config::load(char *fn) { +FILE *fp; +char *buffer; +int i, fsize; +uint32 l; + fp = fopen(fn, "rb"); +/* file doesn't exist yet, do nothing */ + if(!fp)return; + + fseek(fp, 0, SEEK_END); + fsize = ftell(fp); + fseek(fp, 0, SEEK_SET); + +/* blank file, do nothing */ + if(fsize == 0) { + fclose(fp); + return; + } + + buffer = (char*)malloc(fsize + 1); + fread(buffer, 1, fsize, fp); + fclose(fp); + buffer[fsize] = 0; + + data = buffer; + free(buffer); + replace(data, "\r\n", "\n"); + qreplace(data, "\t", " "); + + split(line, "\n", data); + + for(i=0;isource = 1; + } else if(part[1] == "false" || part[1] == "no" || part[1] == "off" || part[1] == "disabled") { + *item[l]->source = 0; + } else if(item[l]->type == HEX) { + *item[l]->source = strhex(part[1]); + } else { /* fall back on DEC */ + *item[l]->source = strdec(part[1]); + } + } + } + } +} + +/* create a text string from config item[i] to be output via config->save() */ +void config::set_newline(int i) { +char t[16]; + if(item[i]->is_string == true) { + newline = item[i]->name; + newline += " = \""; + newline += *item[i]->strsource; + newline += "\""; + } else { + newline = item[i]->name; + newline += " = "; + switch(item[i]->type) { + case TRUEFALSE: + newline += (*item[i]->source)?"true":"false"; + break; + case YESNO: + newline += (*item[i]->source)?"yes":"no"; + break; + case ONOFF: + newline += (*item[i]->source)?"on":"off"; + break; + case ENABLED: + newline += (*item[i]->source)?"enabled":"disabled"; + break; + case HEX: + sprintf(t, "%x", *item[i]->source); + newline += t; + break; + case DEC: + default: + sprintf(t, "%d", *item[i]->source); + newline += t; + break; + } + } +} + +void config::save(char *fn) { +FILE *fp; +int i, fsize; +uint32 l; +char *buffer; +uint8 set[4096]; +bool blank = false; + fp = fopen(fn, "rb"); + if(!fp) { + blank = true; + } else { + fseek(fp, 0, SEEK_END); + fsize = ftell(fp); + fseek(fp, 0, SEEK_SET); + + if(fsize == 0) { + blank = true; + } else { + buffer = (char*)malloc(fsize + 1); + fread(buffer, 1, fsize, fp); + fclose(fp); + buffer[fsize] = 0; + + data = buffer; + free(buffer); + } + } + + fp = fopen(fn, "wb"); +/* no write access? */ + if(!fp)return; + +/* list of config items. if the item is set in the + existing config file, then don't test it to see + if it needs to be written again later on */ + memset(set, 0, item_count); + + if(blank == false) { + replace(data, "\r\n", "\n"); + qreplace(data, "\t", " "); + + split(line, "\n", data); + split(oldline, "\n", data); + + for(i=0;ichanged() == false)continue; + + set_newline(i); + /* prevent a newline from appearing at the top of the file + when the config file is created for the first time */ + if(lines_written == 0 && blank == false)fprintf(fp, "\r\n"); + fprintf(fp, "%s\r\n", *newline); + lines_written++; + } + + fclose(fp); +} + +config::config() { + item_count = 0; +} + +config::~config() { + for(int i=0;i=0;i--) { + delete((_string*)list[i]); + } +} + +uint32 count(string &str) { + return str.count; +} + +void strresize(_string &str, uint32 size) { +char *t; +int sl; + if(str.size == size)return; + sl = strlen(str.s); + t = (char*)malloc(size + 1); + strcpy(t, str.s); + free(str.s); + str.s = t; + str.size = size; +} + +char *strptr(_string &str) { + return str.s; +} + +void strcpy(_string &dest, char *src) { +int srclen = strlen(src); + if(srclen > dest.size) { strresize(dest, srclen); } + strcpy(dest.s, src); +} + +void strset(_string &dest, uint32 pos, uint8 c) { +char *s; + if(pos > dest.size) { strresize(dest, pos); } + dest.s[pos] = c; +} + +void strcat(_string &dest, char *src) { +int srclen, destlen; + srclen = strlen(src); + destlen = strlen(dest.s); + if(srclen + destlen > dest.size) { strresize(dest, srclen + destlen); } + strcat(dest.s, src); +} + +void strinsert(_string &dest, char *src, uint32 pos) { +_string *s = new _string(); + strcpy(*s, strptr(dest) + pos); + strset(dest, pos, 0); + strcat(dest, src); + strcat(dest, *s); + delete(s); +} + +void strremove(_string &dest, uint32 start, uint32 length) { +int destlen; +char *s; +int i, sl = strlen(dest.s); + if(start > dest.size) { strresize(dest, start); } + if(!length) { + strset(dest, start, 0); + return; + } + s = dest.s; + for(i=start;i= 'A' && dest[i] <= 'Z') { + if(dest[i] != src[i] && dest[i] + 0x20 != src[i])return false; + } else if(dest[i] >='a' && dest[i] <= 'z') { + if(dest[i] != src[i] && dest[i] - 0x20 != src[i])return false; + } else { + if(dest[i] != src[i])return false; + } + } + return true; +} + +void strlower(char *str) { +int i, sl = strlen(str); + for(i=0;i= 'A' && str[i] <= 'Z')str[i] += 0x20; + } +} + +void strupper(char *str) { +int i, sl = strlen(str); + for(i=0;i= 'a' && str[i] <= 'z')str[i] -= 0x20; + } +} + +uint32 strpos(char *str, char *key) { +int i, ssl = strlen(str), ksl = strlen(key); + if(ksl > ssl)return null; + for(i=0;i<=ssl-ksl;i++) { + if(!memcmp(str+i, key, ksl))return i; + } + return null; +} + +uint32 strqpos(char *str, char *key) { +int i, z, ssl = strlen(str), ksl = strlen(key); +uint8 x; + if(ksl > ssl)return null; + for(i=0;i<=ssl-ksl;) { + x = str[i]; + if(x == '\"' || x == '\'') { + z = i++; + while(str[i] != x && i < ssl)i++; + if(i >= ssl)i = z; + } + if(!memcmp(str+i, key, ksl)) { + return i; + } else { + i++; + } + } + return null; +} + +void strtr(char *dest, char *before, char *after) { +int i, l, sl = strlen(dest), bsl = strlen(before), asl = strlen(after); + if((bsl != asl) || bsl == 0)return; + for(i=0;i ssl)return 1; + if(!memcmp(str, key, ksl))return 0; + return 1; +} + +uint32 stribegin(char *str, char *key) { +int i, ssl = strlen(str), ksl = strlen(key); + if(ksl > ssl)return 1; + for(i=0;i= 'A' && str[i] <= 'Z') { + if(str[i] != key[i] && str[i]+0x20 != key[i])return 1; + } else if(str[i] >= 'a' && str[i] <= 'z') { + if(str[i] != key[i] && str[i]-0x20 != key[i])return 1; + } else { + if(str[i] != key[i])return 1; + } + } + return 0; +} + +uint32 strend(char *str, char *key) { +int i, ssl = strlen(str), ksl = strlen(key); + if(ksl > ssl)return 1; + if(!memcmp(str + ssl - ksl, key, ksl))return 0; + return 1; +} + +uint32 striend(char *str, char *key) { +int i, z, ssl = strlen(str), ksl = strlen(key); + if(ksl > ssl)return 1; + for(i=ssl-ksl, z=0;i= 'A' && str[i] <= 'Z') { + if(str[i] != key[z] && str[i]+0x20 != key[z])return 1; + } else if(str[i] >= 'a' && str[i] <= 'z') { + if(str[i] != key[z] && str[i]-0x20 != key[z])return 1; + } else { + if(str[i] != key[z])return 1; + } + } + return 0; +} + +void strltrim(char *str, char *key) { +int i, ssl = strlen(str), ksl = strlen(key); + if(ksl > ssl)return; + if(!strbegin(str, key)) { + for(i=0;i ssl)return; + if(!stribegin(str, key)) { + for(i=0;i ssl)return; + if(!strend(str, key)) { + str[ssl - ksl] = 0; + } +} + +void strirtrim(char *str, char *key) { +int ssl = strlen(str), ksl = strlen(key); + if(ksl > ssl)return; + if(!striend(str, key)) { + str[ssl - ksl] = 0; + } +} + +/* does not work on type char* because function increases string length */ +void strquote(_string &str) { +static string t; + t = "\""; + t += str; + t += "\""; + str = t; +} + +bool strunquote(char *str) { +int i, ssl = strlen(str); +/* make sure string is long enough to have quotes */ + if(ssl < 2)return false; + +/* make sure string actually has quotes */ + if(str[0] == '\"' && str[ssl - 1] == '\"'); + else if(str[0] == '\'' && str[ssl - 1] == '\''); + else return false; + +/* now remove them */ + for(i=0;i= '0' && str[i] <= '9'); + else if(str[i] >= 'A' && str[i] <= 'F'); + else if(str[i] >= 'a' && str[i] <= 'f'); + else break; + } + for(--i;i>=0;i--, m+=4) { + x = str[i]; + if(x >= '0' && x <= '9')x -= '0'; + else if(x >= 'A' && x <= 'F')x -= 'A' - 0x0a; + else if(x >= 'a' && x <= 'f')x -= 'a' - 0x0a; + else return r; + r |= x << m; + } + return r; +} + +int strdec(char *str) { +uint32 m = 1; +int i, r = 0, ssl = strlen(str); +uint8 x; + for(i=0;i= '0' && str[i] <= '9'); + else if(str[i] == '-' && i == 0); + else break; + } + for(--i;i>=0;i--, m*=10) { + x = str[i]; + if(x >= '0' && x <= '9')x -= '0'; + else if(i == 0 && str[i] == '-') { + r *= -1; + return r; + } + else return r; + r += x * m; + } + return r; +} + +uint32 strbin(char *str) { +uint32 r = 0, m = 0; +int i, ssl = strlen(str); +uint8 x; + for(i=0;i=0;i--, m++) { + x = str[i]; + if(str[i] == '0' || str[i] == '1')x -= '0'; + else return r; + r |= x << m; + } + return r; +} + +#include "libstring_math.cpp" +#include "libstring_split.cpp" +#include "libstring_replace.cpp" +#include "libstring_sprintf.cpp" diff --git a/src/lib/libstring.h b/src/lib/libstring.h new file mode 100644 index 00000000..fd924a94 --- /dev/null +++ b/src/lib/libstring.h @@ -0,0 +1,276 @@ +/* + libstring : version 0.04 ~byuu +*/ + +#ifndef __LIBSTRING +#define __LIBSTRING + +#include "libvector.h" + +class string; +class _string; + +uint32 count(string &str); +void strresize(_string &str, uint32 size); +char* strptr(_string &str); +void strcpy(_string &dest, char *src); +void strset(_string &dest, uint32 pos, uint8 c); +void strcat(_string &dest, char *src); +void strinsert(_string &dest, char *src, uint32 pos); +void strremove(_string &dest, uint32 start, uint32 length = 0); +bool stricmp(char *dest, char *src); +void strlower(char *str); +void strupper(char *str); +uint32 strpos(char *str, char *key); +uint32 strqpos(char *str, char *key); +void strtr(char *dest, char *before, char *after); +uint32 strbegin(char *str, char *key); +uint32 stribegin(char *str, char *key); +uint32 strend(char *str, char *key); +uint32 striend(char *str, char *key); +void strltrim(char *str, char *key); +void striltrim(char *str, char *key); +void strrtrim(char *str, char *key); +void strirtrim(char *str, char *key); +void strquote(_string &str); +bool strunquote(char *str); +uint32 strhex(char *str); +int strdec(char *str); +uint32 strbin(char *str); +uint32 strmath(char *in_str); +uint32 strmathentity(char *str); +void replace (_string &str, char *key, char *token); +void qreplace(_string &str, char *key, char *token); +void split (string &dest, char *key, char *src); +void qsplit(string &dest, char *key, char *src); +void sprintf(_string &str, char *s, ...); + +class _string { +public: +char *s; +uint32 size; + +/* * */ + inline char* operator*() { return s; } + +/* = */ + inline _string& operator=(char *cpy); + inline _string& operator=(_string &cpy); + inline _string& operator=(string &cpy); + +/* += */ + inline _string& operator+=(char *cat); + inline _string& operator+=(_string &cat); + inline _string& operator+=(string &cat); + +/* -= */ + inline _string& operator-=(char *cut); + inline _string& operator-=(_string &cut); + inline _string& operator-=(string &cut); + +/* == */ + inline bool operator==(char *cmp); + inline bool operator==(_string &cmp); + inline bool operator==(string &cmp); + +/* != */ + inline bool operator!=(char *cmp); + inline bool operator!=(_string &cmp); + inline bool operator!=(string &cmp); + + inline operator char*() { return s; } + + _string(); + ~_string(); +}; + +class string { +public: +vector<_string*> list; +uint32 count, listcount; + void addto(uint32 num); //creates all needed strings to make list[num] valid + _string &str(uint32 num); //gets a _string reference, creating it + new strings if needed + +/* * */ + inline char* operator*() { return strptr(str(0)); } + +/* = */ + inline string& operator=(char *cpy); + inline string& operator=(_string &cpy); + inline string& operator=(string &cpy); + +/* += */ + inline string& operator+=(char *cat); + inline string& operator+=(_string &cat); + inline string& operator+=(string &cat); + +/* -= */ + inline string& operator-=(char *cut); + inline string& operator-=(_string &cut); + inline string& operator-=(string &cut); + +/* == */ + inline bool operator==(char *cmp); + inline bool operator==(_string &cmp); + inline bool operator==(string &cmp); + +/* != */ + inline bool operator!=(char *cmp); + inline bool operator!=(_string &cmp); + inline bool operator!=(string &cmp); + + inline operator char*() { return str(0).s; } + inline operator _string&() { return str(0); } + inline _string& operator[](uint32 i) { return str(i); } + inline _string& operator[](int i) { return str(i); } + + string(); + ~string(); +}; + +// +// = +// +inline _string& _string::operator=(char *cpy) { + strcpy(*this, cpy); + return *this; +} +inline _string& _string::operator=(_string &cpy) { + strcpy(*this, cpy); + return *this; +} +inline _string& _string::operator=(string &cpy) { + strcpy(*this, cpy.str(0)); + return *this; +} + +inline string& string::operator=(char *cpy) { + strcpy(str(0), cpy); + return *this; +} +inline string& string::operator=(_string &cpy) { + strcpy(str(0), cpy); + return *this; +} +inline string& string::operator=(string &cpy) { + strcpy(str(0), cpy.str(0)); + return *this; +} + +// +// += +// +inline _string& _string::operator+=(char *cat) { + strcat(*this, cat); + return *this; +} +inline _string& _string::operator+=(_string &cat) { + strcat(*this, cat); + return *this; +} +inline _string& _string::operator+=(string &cat) { + strcat(*this, cat.str(0)); + return *this; +} + +inline string& string::operator+=(char *cat) { + strcat(str(0), cat); + return *this; +} +inline string& string::operator+=(_string &cat) { + strcat(str(0), cat); + return *this; +} +inline string& string::operator+=(string &cat) { + strcat(str(0), cat.str(0)); + return *this; +} + +// +// -= +// +inline _string& _string::operator-=(char *cut) { + strrtrim(*this, cut); + return *this; +} +inline _string& _string::operator-=(_string &cut) { + strrtrim(*this, cut); + return *this; +} +inline _string& _string::operator-=(string &cut) { + strrtrim(*this, cut.str(0)); + return *this; +} + +inline string& string::operator-=(char *cut) { + strrtrim(str(0), cut); + return *this; +} +inline string& string::operator-=(_string &cut) { + strrtrim(str(0), cut); + return *this; +} +inline string& string::operator-=(string &cut) { + strrtrim(str(0), cut.str(0)); + return *this; +} + +// +// == +// +inline bool _string::operator==(char *cmp) { + if(!strcmp(*this, cmp))return true; + return false; +} +inline bool _string::operator==(_string &cmp) { + if(!strcmp(*this, cmp))return true; + return false; +} +inline bool _string::operator==(string &cmp) { + if(!strcmp(*this, cmp.str(0)))return true; + return false; +} + +inline bool string::operator==(char *cmp) { + if(!strcmp(str(0), cmp))return true; + return false; +} +inline bool string::operator==(_string &cmp) { + if(!strcmp(str(0), cmp))return true; + return false; +} +inline bool string::operator==(string &cmp) { + if(!strcmp(str(0), cmp.str(0)))return true; + return false; +} + +// +// != +// +inline bool _string::operator!=(char *cmp) { + if(!strcmp(*this, cmp))return false; + return true; +} +inline bool _string::operator!=(_string &cmp) { + if(!strcmp(*this, cmp))return false; + return true; +} +inline bool _string::operator!=(string &cmp) { + if(!strcmp(*this, cmp.str(0)))return false; + return true; +} + +inline bool string::operator!=(char *cmp) { + if(!strcmp(str(0), cmp))return false; + return true; +} +inline bool string::operator!=(_string &cmp) { + if(!strcmp(str(0), cmp))return false; + return true; +} +inline bool string::operator!=(string &cmp) { + if(!strcmp(str(0), cmp.str(0)))return false; + return true; +} + +#endif diff --git a/src/lib/libstring_math.cpp b/src/lib/libstring_math.cpp new file mode 100644 index 00000000..e2c26697 --- /dev/null +++ b/src/lib/libstring_math.cpp @@ -0,0 +1,177 @@ +#define STRMATH_ADD 1 +#define STRMATH_SUB 2 +#define STRMATH_MUL 3 +#define STRMATH_DIV 4 +#define STRMATH_MOD 5 +#define STRMATH_AND 6 +#define STRMATH_OR 7 +#define STRMATH_XOR 8 +#define STRMATH_SHL 9 +#define STRMATH_SHR 10 + +#define STRMATH_LINKED 64 + +#define STRMATHMODE_NEG 1 +#define STRMATHMODE_NOT 2 + +#define __strunktonum() \ + if (s1[0] == '0' && s1[1] == 'x')r = strhex(s1 + 2); \ + else if(s1[0] == '0' && s1[1] == 'b')r = strbin(s1 + 2); \ + else r = strdec(s1) + +#define __strmath_setmode() \ + if (str[i] == '-') { mode = STRMATHMODE_NEG; i++; } \ + else if(str[i] == '~') { mode = STRMATHMODE_NOT; i++; } \ + else if(str[i] == '+') { i++; } \ + else mode=0 + +#define __strmath_modeset() \ + if (mode == STRMATHMODE_NEG)r *= -1; \ + else if(mode == STRMATHMODE_NOT)r =~ r + +#define __strmath_set(__x) \ + s1[z] = 0; \ + z = 0; \ + __strunktonum(); \ + __strmath_modeset(); \ + array[array_size++] = r; \ + array_gate[array_size] = __x + +/*************************************** +strmath(str) + resolves all math entities from within + str, and returns numerical result + example: strmath("5+5")=10 +***************************************/ +uint32 p_strmath(char *str) { +int i = 0, ssl = strlen(str); +uint8 x, mode = 0; +uint32 r, array[128], array_size = 0, z = 0; +uint8 array_gate[128]; +char *s1; + if(!ssl)return 0; + s1 = (char*)malloc(ssl + 1); + __strmath_setmode(); + while(i < ssl) { + x = str[i++]; + if (x == '+') { __strmath_set(STRMATH_ADD); __strmath_setmode(); } + else if(x == '-') { __strmath_set(STRMATH_SUB); __strmath_setmode(); } + else if(x == '*') { __strmath_set(STRMATH_MUL); __strmath_setmode(); } + else if(x == '/') { __strmath_set(STRMATH_DIV); __strmath_setmode(); } + else if(x == '%') { __strmath_set(STRMATH_MOD); __strmath_setmode(); } + else if(x == '&') { __strmath_set(STRMATH_AND); __strmath_setmode(); } + else if(x == '|') { __strmath_set(STRMATH_OR ); __strmath_setmode(); } + else if(x == '^') { __strmath_set(STRMATH_XOR); __strmath_setmode(); } + else if(x == '<' && str[i] == '<') { __strmath_set(STRMATH_SHL); i++; __strmath_setmode(); } + else if(x == '>' && str[i] == '>') { __strmath_set(STRMATH_SHR); i++; __strmath_setmode(); } + else s1[z++] = x; + } + s1[z] = 0; + __strunktonum(); + __strmath_modeset(); + array[array_size++] = r; + free(s1); + + for(i=1;i>= array[i]; array_gate[i] = STRMATH_LINKED; } + } + + for(i=1;i maxpdepth)maxpdepth = pdepth; + } else if(str[i]==')') { + if(pdepth == 0) { + free(str); + return null; //error! too many )'s + } + pdepth --; + } + } + + if(pdepth != 0) { + free(str); + return null; //error! unequal ('s to )'s + } + + pdepth = maxpdepth; + while(pdepth) { + cpdepth = 0; + for(i=0;i' && str[i+1] == '>'))return 1; + } + return 0; +} diff --git a/src/lib/libstring_replace.cpp b/src/lib/libstring_replace.cpp new file mode 100644 index 00000000..9857ec16 --- /dev/null +++ b/src/lib/libstring_replace.cpp @@ -0,0 +1,82 @@ +void replace(_string &str, char *key, char *token) { +int i, z, ksl = strlen(key), tsl = strlen(token), ssl = strlen(str); +uint32 replace_count = 0, size = ssl; +char *data; + if(ksl > ssl)return; + if(tsl > ksl) { //the new string may be longer than the old string... + for(i=0;i<=ssl-ksl;) { //so let's find out how big of a string we'll need... + if(!memcmp(str.s + i, key, ksl)) { + replace_count++; + i += ksl; + } else i++; + } + size = ssl + ((tsl - ksl) * replace_count); + if(size > str.size)strresize(str, size); + } + data = (char*)malloc(size + 1); + for(i=z=0;i ssl)return; + if(tsl > ksl) { + for(i=0;i<=ssl-ksl;) { + x = str.s[i]; + if(x == '\"' || x == '\'') { + l = i; + i++; + while(str.s[i++] != x) { + if(i == ssl) { + i = l; + break; + } + } + } + if(!memcmp(str.s + i, key, ksl)) { + replace_count++; + i += ksl; + } else i++; + } + size = ssl + ((tsl - ksl) * replace_count); + if(size > str.size)strresize(str, size); + } + data = (char*)malloc(size + 1); + for(i=z=0;i= ssl)i = l; + else { + memcpy(data + z, str.s + l, i - l); + z += i - l; + } + } + if(i <= ssl - ksl) { + if(!memcmp(str.s + i, key, ksl)) { + memcpy(data + z, token, tsl); + z += tsl; + i += ksl; + replace_count++; + } else data[z++] = str.s[i++]; + } else data[z++] = str.s[i++]; + } + data[z] = 0; + strcpy(str, data); + free(data); +} diff --git a/src/lib/libstring_split.cpp b/src/lib/libstring_split.cpp new file mode 100644 index 00000000..1e2eefbe --- /dev/null +++ b/src/lib/libstring_split.cpp @@ -0,0 +1,41 @@ +void split(string &dest, char *key, char *src) { +int i, ssl = strlen(src), ksl = strlen(key); +uint8 x; +uint32 lp = 0, split_count = 0; + for(i=0;i<=ssl-ksl;) { + if(!memcmp(src + i, key, ksl)) { + x = src[i]; + src[i] = 0; + strcpy(dest[split_count++], src + lp); + src[i] = x; + i += ksl; + lp = i; + } else i++; + } + strcpy(dest[split_count++], src + lp); + dest.count = split_count; +} + +void qsplit(string &dest, char *key, char *src) { +int i, z, ssl = strlen(src), ksl = strlen(key); +uint8 x; +uint32 lp = 0, split_count = 0; + for(i=0;i<=ssl-ksl;) { + x = src[i]; + if(x=='\"' || x=='\'') { + z = i++; + while(src[i] != x && i < ssl)i++; + if(i >= ssl)i = z; + } + if(!memcmp(src + i, key, ksl)) { + x = src[i]; + src[i] = 0; + strcpy(dest[split_count++], src + lp); + src[i] = x; + i += ksl; + lp = i; + } else i++; + } + strcpy(dest[split_count++], src + lp); + dest.count = split_count; +} diff --git a/src/lib/libstring_sprintf.cpp b/src/lib/libstring_sprintf.cpp new file mode 100644 index 00000000..ab86833d --- /dev/null +++ b/src/lib/libstring_sprintf.cpp @@ -0,0 +1,69 @@ +void numtobin(char *s, uint32 num) { +uint32 mask = 0x80000000, len = 0, z = 0; + for(;mask;mask>>=1,len++) { if(num&mask)break; } + len = 32 - len; + do { + if(num&(1<<(len-1)))s[z++] = '1'; + else s[z++] = '0'; + }while(--len); + s[z] = 0; +} + +void sprintf(_string &str, char *s, ...) { +va_list args; +char t[2], n[256]; +int i, l, sl, z; +uint8 pad_type, pad_len; +uint32 num; +char *r; + va_start(args, s); + strcpy(str, ""); + for(i=0;i= '0' && s[i+2] <= '9')) { + pad_type = 1; + if(s[i+3] >= '0' && s[i+3] <= '9') { pad_len = (s[i+2]-'0')*10 + (s[i+3]-'0'); i+=4; } + else { pad_len = (s[i+2]-'0'); i+=3; } + } + else if(s[i] >= '0' && s[i] <= '9') { + pad_type = 2; + if(s[i+1] >= '0' && s[i+1] <= '9') { pad_len = (s[i]-'0')*10 + (s[i+1]-'0'); i+=2; } + else { pad_len = (s[i]-'0'); i+=1; } + } + else { pad_type = 0; } + + if(s[i] == 'd') { + num = va_arg(args, uint32); + sprintf(n, "%d", num); + } else if(s[i] == 'x') { + num = va_arg(args, uint32); + sprintf(n, "%x", num); + } else if(s[i] == 'b') { + num = va_arg(args, uint32); + numtobin(n, num); + } else if(s[i] == 's') { + r = va_arg(args, char*); + } + + if(pad_type != 0) { + if(s[i] == 's')sl = strlen(r); + else sl = strlen(n); + if(sl < pad_len) { + while(sl < pad_len) { + strcat(str, (pad_type == 1)?"0":" "); + sl++; + } + } + } + + if(s[i] == 's')strcat(str, r); + else strcat(str, n); + } else { + t[0] = s[i]; + t[1] = 0; + strcat(str, t); + } + } + va_end(args); +} diff --git a/src/lib/libvector.h b/src/lib/libvector.h new file mode 100644 index 00000000..d0e98ac0 --- /dev/null +++ b/src/lib/libvector.h @@ -0,0 +1,71 @@ +/* + libvector : version 0.01 ~byuu +*/ + +#ifndef __LIBVECTOR +#define __LIBVECTOR + +template class vector { +public: +T *array; +int size, sizelimit; + int findsize(int newsize) { + int r = 1; + while(r >= 1) { + r <<= 1; + if(r > sizelimit)return sizelimit; + if(r >= newsize)return r; + } + return size; + } + + void resize(int newsize) { + T *newarray; + newsize = findsize(newsize); + + if(newsize > sizelimit)newsize = sizelimit; + if(newsize == size)return; + + newarray = (T*)malloc(sizeof(T) * newsize); + if(newsize >= size) { + memcpy(newarray, array, sizeof(T) * size); + } else { + memcpy(newarray, array, sizeof(T) * newsize); + } + free(array); + + array = newarray; + size = newsize; + } + + vector(int newsize, int newsizelimit) { + size = newsize; + sizelimit = newsizelimit; + array = (T*)malloc(sizeof(T) * size); + } + + vector(int newsize) { + size = newsize; + sizelimit = 1 << 24; + array = (T*)malloc(sizeof(T) * size); + } + + vector() { + size = 16; + sizelimit = 1 << 24; + array = (T*)malloc(sizeof(T) * size); + } + + ~vector() { + if(array)free(array); + } + + inline T &operator[](int index) { + static T __null = (T)0; + if(index >= size)resize(index + 1); + if(index > sizelimit)return __null; + return array[index]; + } +}; + +#endif diff --git a/src/memory/bmemory/bmemory.cpp b/src/memory/bmemory/bmemory.cpp index ce5313fb..f9affb43 100644 --- a/src/memory/bmemory/bmemory.cpp +++ b/src/memory/bmemory/bmemory.cpp @@ -307,6 +307,15 @@ uint32 b, w; snes->notify(SNES::MEM_WRITE, addr, value); } +void bMemBus::power() { + memset(wram, 0, 0x020000); + reset(); +} + +void bMemBus::reset() { + fastROM = false; +} + bMemBus::bMemBus() { rom = new bROM(); diff --git a/src/memory/bmemory/bmemory.h b/src/memory/bmemory/bmemory.h index e5803e33..c45e079f 100644 --- a/src/memory/bmemory/bmemory.h +++ b/src/memory/bmemory/bmemory.h @@ -26,6 +26,9 @@ byte *wram; uint8 read (uint32 addr); void write(uint32 addr, byte value); + void power(); + void reset(); + bMemBus(); ~bMemBus(); }; diff --git a/src/memory/memory.h b/src/memory/memory.h index 9004dc5c..61812599 100644 --- a/src/memory/memory.h +++ b/src/memory/memory.h @@ -33,6 +33,9 @@ bool fastROM; virtual bool set_mmio_mapper(uint16 addr, MMIO *mapper); virtual uint8 speed(uint32 addr); + virtual void power() = 0; + virtual void reset() = 0; + MemBus(); ~MemBus(); }; diff --git a/src/ppu/bppu/bppu.cpp b/src/ppu/bppu/bppu.cpp index 85f64779..ae6025c9 100644 --- a/src/ppu/bppu/bppu.cpp +++ b/src/ppu/bppu/bppu.cpp @@ -7,11 +7,25 @@ void bPPU::run() {} void bPPU::scanline() { uint16 v = clock->vcounter(); if(v > 0 && v < clock->visible_scanlines()) { + if(clock->interlace() || regs.oam_halve == true) { + output->frame_mode |= PPUOutput::INTERLACE; + output->scanline_mode[v] |= PPUOutput::INTERLACE; + } + if(regs.bg_mode == 5 || regs.bg_mode == 6) { + output->frame_mode |= PPUOutput::DOUBLEWIDTH; + output->scanline_mode[v] |= PPUOutput::DOUBLEWIDTH; + } render_line(v); } } -void bPPU::frame() {} +void bPPU::frame() { + snes->notify(SNES::RENDER_FRAME); + output->frame_mode = PPUOutput::NORMAL; + for(int i=0;i<239;i++) { + output->scanline_mode[i] = PPUOutput::NORMAL; + } +} void bPPU::power() { memset(vram, 0, 65536); @@ -21,7 +35,8 @@ void bPPU::power() { } void bPPU::reset() { - memset(output, 0, 512 * 478 * 2); + memset(output->buffer, 0, 512 * 478 * 2); + frame(); //$2100 regs.display_disabled = 0; diff --git a/src/ppu/bppu/bppu_mmio.cpp b/src/ppu/bppu/bppu_mmio.cpp index f87f067e..4122ff31 100644 --- a/src/ppu/bppu/bppu_mmio.cpp +++ b/src/ppu/bppu/bppu_mmio.cpp @@ -487,13 +487,6 @@ uint16 r = regs.vcounter; //STAT77 uint8 bPPU::mmio_r213e() { uint8 r = 0x00; - r |= clock->interlace_field() << 7; - if(!(cpu->pio_status() & 0x80)) { - r |= 1 << 6; - } else if(regs.counters_latched == true) { - r |= 1 << 6; - regs.counters_latched = false; - } r |= 0x01; //PPU1 version number return r; } @@ -503,6 +496,14 @@ uint8 bPPU::mmio_r213f() { uint8 r = 0x00; regs.latch_hcounter = 0; regs.latch_vcounter = 0; + + r |= clock->interlace_field() << 7; + if(!(cpu->pio_status() & 0x80)) { + r |= 1 << 6; + } else if(regs.counters_latched == true) { + r |= 1 << 6; + regs.counters_latched = false; + } r |= (1 << 5); r |= 0x03; //PPU2 version number return r; diff --git a/src/ppu/bppu/bppu_render.cpp b/src/ppu/bppu/bppu_render.cpp index cbac39e2..9640a9a6 100644 --- a/src/ppu/bppu/bppu_render.cpp +++ b/src/ppu/bppu/bppu_render.cpp @@ -113,7 +113,7 @@ void bPPU::render_line_mode7() { void bPPU::render_line(uint16 line) { if(regs.display_disabled == true) { - memset(output + (line << 1) * 512, 0, 2048); + memset(output->buffer + (line << 1) * 512, 0, 2048); return; } diff --git a/src/ppu/bppu/bppu_render.h b/src/ppu/bppu/bppu_render.h index 7ee49de5..128b54ec 100644 --- a/src/ppu/bppu/bppu_render.h +++ b/src/ppu/bppu/bppu_render.h @@ -56,8 +56,8 @@ struct { }current_sprite; void render_line_to_output(); -uint16 addsub_pixels(uint8 x, uint8 cdest_index, uint8 cdest_bg, uint8 csrc_index, uint8 csrc_bg); -uint16 addsub_pixel(uint8 x, uint8 cdest_index, uint8 cdest_bg); +inline uint16 addsub_pixels(uint8 x, uint8 cdest_index, uint8 cdest_bg, uint8 csrc_index, uint8 csrc_bg); +inline uint16 addsub_pixel(uint8 x, uint8 cdest_index, uint8 cdest_bg); void render_bg_tile(uint8 color_depth, uint8 bg, uint16 tile_num); void set_pixel(uint8 bg, uint16 x, uint8 pal_index); void set_layer_pixels(uint8 layer_count, uint8 *layer_bg_lookup); diff --git a/src/ppu/bppu/bppu_render_main.cpp b/src/ppu/bppu/bppu_render_main.cpp index c6acc8ca..875a77ce 100644 --- a/src/ppu/bppu/bppu_render_main.cpp +++ b/src/ppu/bppu/bppu_render_main.cpp @@ -14,7 +14,7 @@ namespace bPPUAddSubTables { }; }; -uint16 bPPU::addsub_pixels(uint8 x, uint8 cdest_index, uint8 cdest_bg, uint8 csrc_index, uint8 csrc_bg) { +inline uint16 bPPU::addsub_pixels(uint8 x, uint8 cdest_index, uint8 cdest_bg, uint8 csrc_index, uint8 csrc_bg) { int r, g, b; uint16 cdest = pal_pixel(cdest_index); uint16 csrc = pal_pixel(csrc_index); @@ -52,7 +52,7 @@ uint16 res; return ((r) | (g << 5) | (b << 10)); } -uint16 bPPU::addsub_pixel(uint8 x, uint8 cdest_index, uint8 cdest_bg) { +inline uint16 bPPU::addsub_pixel(uint8 x, uint8 cdest_index, uint8 cdest_bg) { int r, g, b; uint16 cdest = pal_pixel(cdest_index); uint16 csrc = (regs.color_r) | (regs.color_g << 5) | (regs.color_b << 10); @@ -190,16 +190,17 @@ uint8 *dest; void bPPU::render_line_to_output() { int x, x1; -uint16 *ptr, *ptri, *ltable; +uint16 *ptr, *ltable; uint16 c, cx, cy; -uint16 screen_width = (regs.bg_mode == 5 || regs.bg_mode == 6)?512:256; -uint16 vline_pos = clock->vcounter(); +uint16 screen_width; +uint16 v, vline_pos = clock->vcounter(); + v = vline_pos; + screen_width = (output->scanline_mode[v] & PPUOutput::DOUBLEWIDTH)?512:256; - if(clock->interlace() == false) { - ptr = (uint16*)output + ((vline_pos << 1) ) * 512; - ptri = (uint16*)output + ((vline_pos << 1) + 1) * 512; + if(!(output->scanline_mode[v] & PPUOutput::INTERLACE)) { + ptr = (uint16*)output->buffer + ((vline_pos << 1)) * 512; } else { - ptr = (uint16*)output + ((vline_pos << 1) + clock->interlace_field()) * 512; + ptr = (uint16*)output->buffer + ((vline_pos << 1) + clock->interlace_field()) * 512; } ltable = (uint16*)light_table + (regs.display_brightness * 65536); @@ -244,16 +245,12 @@ uint16 vline_pos = clock->vcounter(); break; } - if(clock->interlace() == false) { - *(ptr + (x1 )) = *(ltable + cx); - *(ptri + (x1++)) = *(ltable + cx); - if(screen_width != 256)continue; - *(ptr + (x1 )) = *(ltable + cx); - *(ptri + (x1++)) = *(ltable + cx); + if(screen_width == 256) { + *(ptr + (x1)) = *(ltable + cx); + x1 += 2; } else { - *(ptr + (x1++)) = *(ltable + cx); - if(screen_width != 256)continue; - *(ptr + (x1++)) = *(ltable + cx); + *(ptr + (x1)) = *(ltable + cx); + x1 += 1; } } } diff --git a/src/ppu/ppu.cpp b/src/ppu/ppu.cpp index c29f8817..9b0466a4 100644 --- a/src/ppu/ppu.cpp +++ b/src/ppu/ppu.cpp @@ -1,11 +1,23 @@ #include "../base.h" +PPUOutput::PPUOutput() { + buffer = (uint16*)memalloc(512 * 478 * 2, "PPUOutput::buffer"); + memset(buffer, 0, 512 * 478 * 2); + frame_mode = NORMAL; + for(int i=0;i<239;i++) { + scanline_mode[i] = NORMAL; + } +} + +PPUOutput::~PPUOutput() { + if(buffer)memfree(buffer, "PPUOutput::buffer"); +} + PPU::PPU() { mmio = &mmio_unmapped; - output = (uint16*)memalloc(512 * 478 * 2, "PPU::output"); - memset(output, 0, 512 * 478 * 2); + output = new PPUOutput(); } PPU::~PPU() { - if(output)memfree(output, "PPU::output"); + if(output)delete(output); } diff --git a/src/ppu/ppu.h b/src/ppu/ppu.h index d68452b0..c008bcc3 100644 --- a/src/ppu/ppu.h +++ b/src/ppu/ppu.h @@ -1,7 +1,21 @@ +class PPUOutput { +public: +enum { + NORMAL = 0, + INTERLACE = 1, + DOUBLEWIDTH = 2 +}; +uint8 frame_mode; +uint8 scanline_mode[239]; +uint16 *buffer; + PPUOutput(); + ~PPUOutput(); +}; + class PPU { public: -uint16 *output; -MMIO *mmio; +PPUOutput *output; +MMIO *mmio; virtual uint8 vram_read (uint16 addr) = 0; virtual void vram_write (uint16 addr, uint8 value) = 0; virtual uint8 oam_read (uint16 addr) = 0; diff --git a/src/reader/reader.cpp b/src/reader/reader.cpp index a6089f7c..d430885b 100644 --- a/src/reader/reader.cpp +++ b/src/reader/reader.cpp @@ -12,7 +12,12 @@ int i; char *filetype = fn + i; /* make sure we support this file format before loading it */ - if(strcmp(filetype, ".smc"))return false; + if(stricmp(filetype, ".smc") && + stricmp(filetype, ".swc") && + stricmp(filetype, ".fig") && + stricmp(filetype, ".ufo") && + stricmp(filetype, ".gd3") && + stricmp(filetype, ".078"))return false; fp = fopen(fn, "rb"); if(!fp)return false; @@ -21,7 +26,12 @@ char *filetype = fn + i; fsize = ftell(fp); fseek(fp, 0, SEEK_SET); - if(!strcmp(filetype, ".smc")) { + if(!stricmp(filetype, ".smc") || + !stricmp(filetype, ".swc") || + !stricmp(filetype, ".fig") || + !stricmp(filetype, ".ufo") || + !stricmp(filetype, ".gd3") || + !stricmp(filetype, ".078")) { /* remove header if it exists */ if((fsize & 0xfff) == 0x200) { fsize -= 0x200; diff --git a/src/snes/snes.cpp b/src/snes/snes.cpp index e26a8ca3..a5510833 100644 --- a/src/snes/snes.cpp +++ b/src/snes/snes.cpp @@ -8,7 +8,7 @@ void SNES::power() { clock->power(); cpu->power(); ppu->power(); - mem_bus->fastROM = false; + mem_bus->power(); int i; mem_bus->flush_mmio_mappers(); @@ -17,6 +17,8 @@ int i; for(i=0x2180;i<=0x2183;i++)mem_bus->set_mmio_mapper(i, cpu->mmio); mem_bus->set_mmio_mapper(0x21c2, cpu->mmio); mem_bus->set_mmio_mapper(0x21c3, cpu->mmio); + mem_bus->set_mmio_mapper(0x4016, cpu->mmio); + mem_bus->set_mmio_mapper(0x4017, cpu->mmio); for(i=0x4200;i<=0x421f;i++)mem_bus->set_mmio_mapper(i, cpu->mmio); for(i=0x4300;i<=0x437f;i++)mem_bus->set_mmio_mapper(i, cpu->mmio); } @@ -25,7 +27,7 @@ void SNES::reset() { clock->reset(); cpu->reset(); ppu->reset(); - mem_bus->fastROM = false; + mem_bus->reset(); } /*************************** diff --git a/src/snes/snes.h b/src/snes/snes.h index 022d880f..aeff4b21 100644 --- a/src/snes/snes.h +++ b/src/snes/snes.h @@ -28,6 +28,7 @@ enum { //debugging functions enum { NO_ACTION = 0, + RENDER_FRAME, CPU_EXEC_OPCODE, MEM_READ, MEM_WRITE, VRAM_READ, VRAM_WRITE, diff --git a/src/win/Makefile b/src/win/Makefile index 09278bbb..f0d80f1e 100644 --- a/src/win/Makefile +++ b/src/win/Makefile @@ -1,6 +1,7 @@ CC = cl CFLAGS = /nologo /O2 /Ob2 OBJS = winmain.obj \ + libstring.obj libconfig.obj \ clock.obj bclock.obj \ memory.obj bmemory.obj \ reader.obj \ @@ -21,6 +22,14 @@ clean: winmain.obj: *.cpp *.h $(CC) $(CFLAGS) /c winmain.cpp +################# +### libraries ### +################# +libstring.obj: ../lib/*.cpp ../lib/*.h + $(CC) $(CFLAGS) /c ../lib/libstring.cpp +libconfig.obj: ../lib/*.cpp ../lib/*.h + $(CC) $(CFLAGS) /c ../lib/libconfig.cpp + ############# ### clock ### ############# diff --git a/src/win/bsnes.cpp b/src/win/bsnes.cpp index 40da0a78..1450a00d 100644 --- a/src/win/bsnes.cpp +++ b/src/win/bsnes.cpp @@ -33,10 +33,10 @@ void bSNES::run() { switch(run_status) { case RUN: - while(clock->update_frame() == false) { + while(update_frame == false) { clock->run(); } - render_frame(); + update_frame = false; return; case STOP: break; @@ -53,8 +53,8 @@ void bSNES::run() { break; case RUNTOFRAME: clock->run(); - if(clock->update_frame() == true) { - render_frame(); + if(update_frame == true) { + update_frame = false; set_status(STOP); disassemble_cpu_op(); } else if(w_bp->hit() == true) { @@ -83,14 +83,10 @@ void bSNES::run() { } break; } - - if(clock->update_frame() == true) { - render_frame(); - } } void bSNES::render_frame() { - renderer.update(); + renderer->update(); } /*********************** @@ -229,6 +225,15 @@ void bSNES::write(uint8 type, uint32 addr, uint8 value) { } void bSNES::notify(uint32 message, uint32 param1, uint32 param2) { +/* system messages */ + switch(message) { + case RENDER_FRAME: + update_frame = true; + render_frame(); + break; + } + +/* debugging messages */ if(is_debugger_enabled == false)return; switch(message) { @@ -262,6 +267,9 @@ void bSNES::notify(uint32 message, uint32 param1, uint32 param2) { void bSNES::disassemble_cpu_op() { char t[512]; +/* don't disassemble opcodes when no ROM is loaded */ + if(is_debugger_activated == false)return; + /* don't disassemble opcodes that won't be printed to console/traced to log anyway */ if(!w_console->can_write(Console::CPU_MESSAGE) && !w_console->tracing_enabled)return; @@ -311,6 +319,10 @@ void bSNES::debugger_update() { disassemble_cpu_op(); } +bool bSNES::debugger_activated() { + return is_debugger_activated; +} + void bSNES::debugger_activate() { HWND hwnd; uint32 i, style; @@ -343,6 +355,8 @@ uint32 i, style; SetWindowLong(hwnd, GWL_STYLE, style); } InvalidateRect(w_memory->hwnd, 0, TRUE); + + is_debugger_activated = true; } void bSNES::debugger_deactivate() { @@ -378,11 +392,14 @@ uint32 i, style; } w_memory->clear(); InvalidateRect(w_memory->hwnd, 0, TRUE); + + is_debugger_activated = false; } bSNES::bSNES() { - run_status = STOP; + run_status = STOP; debug_command = false; + update_frame = false; debugger_disable(); } diff --git a/src/win/bsnes.h b/src/win/bsnes.h index 3838a528..bcb23c0b 100644 --- a/src/win/bsnes.h +++ b/src/win/bsnes.h @@ -8,12 +8,18 @@ bool l, r, select, start; class bSNES : public SNES { private: +//If true, indicates a ROM is loaded and debugger output +//is possible. +bool is_debugger_activated; + //When true, notify() ignores read/write requests, as they //have been generated by the debugging interface and not by //the emulator. bool debug_command; uint32 run_status; +bool update_frame; + bJoypad joypad1, joypad2; public: @@ -56,6 +62,7 @@ struct { //whether or not the debugger *can* be used //e.g., debugger cannot be used without ROM loaded + bool debugger_activated(); void debugger_activate(); void debugger_deactivate(); diff --git a/src/win/config.cpp b/src/win/config.cpp new file mode 100644 index 00000000..1c28ad53 --- /dev/null +++ b/src/win/config.cpp @@ -0,0 +1,15 @@ +#define __config_add(name, def, type) add(&name, #name, def, type) + +class Config : public config { +public: + +struct { + uint32 mode; + uint32 use_vram; +}video; + + Config() { + __config_add(video.mode, 1, DEC); + __config_add(video.use_vram, true, TRUEFALSE); + } +}cfg; diff --git a/src/win/lib.cpp b/src/win/lib.cpp index 2c9b27f3..8486ece7 100644 --- a/src/win/lib.cpp +++ b/src/win/lib.cpp @@ -68,44 +68,6 @@ va_list args; } } -uint32 strhex(char *str) { -uint32 r = 0, m = 0; -int i, ssl = strlen(str); -uint8 x; - for(i=0;i= '0' && str[i] <= '9'); - else if(str[i] >= 'A' && str[i] <= 'F'); - else if(str[i] >= 'a' && str[i] <= 'f'); - else break; - } - for(--i;i>=0;i--, m+=4) { - x = str[i]; - if(x >= '0' && x <= '9')x -= '0'; - else if(x >= 'A' && x <= 'F')x -= 'A' - 0x0a; - else if(x >= 'a' && x <= 'f')x -= 'a' - 0x0a; - else return r; - r |= x << m; - } - return r; -} - -uint32 strdec(char *str) { -uint32 m = 1; -int i, r = 0, ssl = strlen(str); -uint8 x; - for(i=0;i= '0' && str[i] <= '9'); - else break; - } - for(--i;i>=0;i--, m*=10) { - x = str[i]; - if(x >= '0' && x <= '9')x -= '0'; - else return r; - r += x * m; - } - return r; -} - uint32 load_file(char *fn, uint8 **buffer) { FILE *fp; uint8 *data; diff --git a/src/win/timer.cpp b/src/win/timer.cpp new file mode 100644 index 00000000..36e973fc --- /dev/null +++ b/src/win/timer.cpp @@ -0,0 +1,43 @@ +class fpstimer { +private: +SYSTEMTIME st; +int second, ticks; +public: + void start(); + void tick(); + int get_ticks(); + void reset(); + bool second_passed(); + + fpstimer(); +}; + +void fpstimer::start() { + GetSystemTime(&st); + second = st.wSecond; +} + +void fpstimer::tick() { + ticks++; +} + +int fpstimer::get_ticks() { + return ticks; +} + +void fpstimer::reset() { + ticks = 0; +} + +bool fpstimer::second_passed() { + GetSystemTime(&st); + if(st.wSecond != second) { + second = st.wSecond; + return true; + } + return false; +} + +fpstimer::fpstimer() { + second = ticks = 0; +} diff --git a/src/win/ui.cpp b/src/win/ui.cpp index 68c587c4..b7f18d31 100644 --- a/src/win/ui.cpp +++ b/src/win/ui.cpp @@ -29,6 +29,7 @@ void CreateWindows() { } void init_ui0() { + renderer = new Render(); w_main = new MainWindow(); w_console = new Console(); w_bp = new BreakpointEditor(); @@ -39,7 +40,7 @@ void init_ui1() { CreateFonts(); CreateWindows(); SetFocus(w_main->hwnd); - renderer.set_window(w_main->hwnd); - renderer.to_windowed(); + renderer->set_window(w_main->hwnd); + renderer->to_windowed(); bsnes->debugger_deactivate(); } diff --git a/src/win/ui.h b/src/win/ui.h index e5384512..e2c8d5b9 100644 --- a/src/win/ui.h +++ b/src/win/ui.h @@ -141,7 +141,7 @@ bool visible, menu_visible; class MainWindow : public Window { public: -uint8 video_mode, frameskip; +uint8 frameskip; void set_frameskip(uint8 fs); void set_video_mode(uint8 mode); void menu_load(); @@ -227,7 +227,7 @@ uint32 edit_mode, edit_addr, edit_mask; MemoryEditor *w_memory; #include -class render { +class Render { public: LPDIRECTDRAW lpdd; LPDIRECTDRAWSURFACE lpdds, lpddsb; @@ -239,13 +239,14 @@ uint8 color_depth; void set_window(HWND hwnd_handle); void to_windowed(); void to_fullscreen(); + void set_source_window(RECT *rs); void redraw(); void update16(); void update32(); void update(); void destroy(); void update_color_lookup_table(); - render(); + Render(); }; -render renderer; +Render *renderer; diff --git a/src/win/ui_main.cpp b/src/win/ui_main.cpp index 9746b55c..1d5bf2d1 100644 --- a/src/win/ui_main.cpp +++ b/src/win/ui_main.cpp @@ -12,35 +12,37 @@ void MainWindow::set_frameskip(uint8 fs) { CheckMenuItem(w_main->hmenu, MENU_SETTINGS_FRAMESKIP_OFF + fs, MF_CHECKED); clock->set_frameskip(fs); + w_main->frameskip = fs; } void MainWindow::set_video_mode(uint8 mode) { + hide(); CheckMenuItem(w_main->hmenu, MENU_SETTINGS_VIDEOMODE_256x224w, MF_UNCHECKED); CheckMenuItem(w_main->hmenu, MENU_SETTINGS_VIDEOMODE_512x448w, MF_UNCHECKED); CheckMenuItem(w_main->hmenu, MENU_SETTINGS_VIDEOMODE_960x720w, MF_UNCHECKED); switch(mode) { case VIDEOMODE_256x224w: CheckMenuItem(w_main->hmenu, MENU_SETTINGS_VIDEOMODE_256x224w, MF_CHECKED); - w_main->resize(256, 223); + resize(256, 223); break; case VIDEOMODE_512x448w: CheckMenuItem(w_main->hmenu, MENU_SETTINGS_VIDEOMODE_512x448w, MF_CHECKED); - w_main->resize(512, 446); + resize(512, 446); break; case VIDEOMODE_960x720w: CheckMenuItem(w_main->hmenu, MENU_SETTINGS_VIDEOMODE_960x720w, MF_CHECKED); - w_main->resize(960, 720); + resize(960, 720); break; } if(bsnes->debugger_enabled() == true) { - w_main->to_bottom(); - w_main->to_right(); + to_bottom(); + to_right(); } else { - w_main->to_middle(); - w_main->to_center(); + to_middle(); + to_center(); } - video_mode = mode; - w_main->show(); + cfg.video.mode = mode; + show(); } void MainWindow::menu_load() { @@ -135,7 +137,7 @@ long __stdcall wndproc_main(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) { PostQuitMessage(0); break; case WM_PAINT: - renderer.redraw(); + renderer->redraw(); break; } return DefWindowProc(hwnd, msg, wparam, lparam); @@ -199,11 +201,10 @@ HMENU hsubmenu, hbranchmenu; AppendMenu(hsubmenu, MF_STRING, MENU_SETTINGS_DEBUGGER, "&Debugger"); AppendMenu(w_main->hmenu, MF_STRING | MF_POPUP, (unsigned int)hsubmenu, "&Settings"); - w_main->set_video_mode(w_main->video_mode); - w_main->set_frameskip(0); w_main->show_menu(); + w_main->set_video_mode(cfg.video.mode); + w_main->set_frameskip(0); } MainWindow::MainWindow() { - video_mode = VIDEOMODE_512x448w; } diff --git a/src/win/ui_render.cpp b/src/win/ui_render.cpp index c124bd44..19b81736 100644 --- a/src/win/ui_render.cpp +++ b/src/win/ui_render.cpp @@ -4,14 +4,14 @@ //mov eax,[array+eax*4] -> lea ebx,[parray] ; mov ebx,[ebx+eax*4] uint32 color_lookup_table[65536]; -render::render() { +Render::Render() { lpdd = 0; lpdds = 0; lpddsb = 0; lpddc = 0; } -void render::update_color_lookup_table() { +void Render::update_color_lookup_table() { int i, r, g, b; lpdds->GetSurfaceDesc(&ddsd); color_depth = ddsd.ddpfPixelFormat.dwRGBBitCount; @@ -45,9 +45,9 @@ int i, r, g, b; } } -void render::set_window(HWND hwnd_handle) { hwnd = hwnd_handle; } +void Render::set_window(HWND hwnd_handle) { hwnd = hwnd_handle; } -void render::to_windowed() { +void Render::to_windowed() { destroy(); DirectDrawCreate(0, &lpdd, 0); lpdd->SetCooperativeLevel(hwnd, DDSCL_NORMAL); @@ -65,7 +65,12 @@ void render::to_windowed() { memset(&ddsd, 0, sizeof(DDSURFACEDESC)); ddsd.dwSize = sizeof(DDSURFACEDESC); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; - ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY; + ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; + if(cfg.video.use_vram) { + ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY; + } else { + ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY; + } ddsd.dwWidth = 512; ddsd.dwHeight = 478; lpdd->CreateSurface(&ddsd, &lpddsb, 0); @@ -74,7 +79,7 @@ void render::to_windowed() { update(); } -void render::to_fullscreen() { +void Render::to_fullscreen() { destroy(); DirectDrawCreate(0, &lpdd, 0); lpdd->SetCooperativeLevel(hwnd, DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE); @@ -93,7 +98,12 @@ void render::to_fullscreen() { memset(&ddsd, 0, sizeof(DDSURFACEDESC)); ddsd.dwSize = sizeof(DDSURFACEDESC); ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; - ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY; + ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN; + if(cfg.video.use_vram) { + ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY; + } else { + ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY; + } ddsd.dwWidth = 512; ddsd.dwHeight = 478; lpdd->CreateSurface(&ddsd, &lpddsb, 0); @@ -102,7 +112,16 @@ void render::to_fullscreen() { update(); } -void render::redraw() { +void Render::set_source_window(RECT *rs) { + switch(ppu->output->frame_mode) { + case 0:SetRect(rs, 0, 0, 256, 223);break; + case 1:SetRect(rs, 0, 0, 256, 446);break; + case 2:SetRect(rs, 0, 0, 512, 223);break; + case 3:SetRect(rs, 0, 0, 512, 446);break; + } +} + +void Render::redraw() { RECT rd, rs; POINT p; HRESULT hr; @@ -110,87 +129,177 @@ HRESULT hr; ClientToScreen(hwnd, &p); GetClientRect(hwnd, &rd); OffsetRect(&rd, p.x, p.y); - if(clock->overscan() == false) { - SetRect(&rs, 0, 2, 512, 448); - } else { - SetRect(&rs, 0, 2 + 15, 512, 448 + 15); - } + set_source_window(&rs); hr = lpdds->Blt(&rd, lpddsb, &rs, DDBLT_WAIT, 0); if(hr == DDERR_SURFACELOST) { lpdds->Restore(); lpddsb->Restore(); } + +uint32 fps; +char s[256], t[256]; + fps_timer->tick(); + if(fps_timer->second_passed() == true) { + sprintf(s, "bsnes v" BSNES_VERSION " ~byuu"); + if(rom_image->loaded() == true) { + fps = fps_timer->get_ticks(); + if(w_main->frameskip == 0) { + sprintf(t, " : %d fps", fps); + } else { + sprintf(t, " : %d fps [fs: %d]", fps * (1 + w_main->frameskip), w_main->frameskip); + } + strcat(s, t); + } + SetWindowText(w_main->hwnd, s); + fps_timer->reset(); + } } -void render::update16() { +void Render::update16() { HRESULT hr; hr = lpddsb->Lock(0, &ddsd, DDLOCK_WAIT, 0); if(hr != DD_OK)return; -uint16 *_src_data = (uint16*)ppu->output; -uint16 *_dest_data = (uint16*)ddsd.lpSurface; -uint32 _pitch = ddsd.lPitch; - __asm { - mov edi,_dest_data - mov edx,_pitch - add edi,edx - add edi,edx - sub edx,1024 - mov esi,_src_data - add esi,2048 - mov ebx,478-2 - xor eax,eax - loop_y: - mov ecx,512 - loop_x: - lodsw - mov eax,dword ptr[color_lookup_table+eax*4] - stosw - dec ecx - jnz loop_x - add edi,edx - dec ebx - jnz loop_y +uint16 *src = (uint16*)ppu->output->buffer; +uint16 *dest = (uint16*)ddsd.lpSurface; +uint32 pitch; +int x, y; +/* skip first scanline */ + src += 1024; + + if(clock->overscan() == true) { + if(ppu->output->frame_mode & PPUOutput::INTERLACE) { + src += 1024 * 16; + } else { + src += 1024 * 8; + } } + if(ppu->output->frame_mode == PPUOutput::NORMAL) { + /* 256x223 */ + pitch = (ddsd.lPitch >> 1) - 256; + y = 223; + while(y--) { + x = 256; + while(x--) { + *dest++ = color_lookup_table[*src]; + src += 2; + } + dest += pitch; + src += 512; + } + } else if(ppu->output->frame_mode == PPUOutput::INTERLACE) { + /* 256x446 */ + pitch = (ddsd.lPitch >> 1) - 256; + y = 446; + while(y--) { + x = 256; + while(x--) { + *dest++ = color_lookup_table[*src]; + src += 2; + } + dest += pitch; + } + } else if(ppu->output->frame_mode == PPUOutput::DOUBLEWIDTH) { + /* 512x223 */ + pitch = (ddsd.lPitch >> 1) - 512; + y = 223; + while(y--) { + x = 512; + while(x--) { + *dest++ = color_lookup_table[*src++]; + } + dest += pitch; + src += 512; + } + } else { + /* 512x446 */ + pitch = (ddsd.lPitch >> 1) - 512; + y = 446; + while(y--) { + x = 512; + while(x--) { + *dest++ = color_lookup_table[*src++]; + } + dest += pitch; + } + } lpddsb->Unlock(0); } -void render::update32() { +void Render::update32() { HRESULT hr; hr = lpddsb->Lock(0, &ddsd, DDLOCK_WAIT, 0); if(hr != DD_OK)return; -uint16 *_src_data = (uint16*)ppu->output; -uint32 *_dest_data = (uint32*)ddsd.lpSurface; -uint32 _pitch = ddsd.lPitch; - __asm { - mov edi,_dest_data - mov edx,_pitch - add edi,edx - add edi,edx - sub edx,2048 - mov esi,_src_data - add esi,2048 - mov ebx,478-2 - loop_y: - mov ecx,512 - loop_x: - lodsw - and eax,0xffff - mov eax,dword ptr[color_lookup_table+eax*4] - stosd - dec ecx - jnz loop_x - add edi,edx - dec ebx - jnz loop_y +uint16 *src = (uint16*)ppu->output->buffer; +uint32 *dest = (uint32*)ddsd.lpSurface; +uint32 pitch; +int x, y; +/* skip first scanline */ + src += 1024; + + if(clock->overscan() == true) { + if(ppu->output->frame_mode & PPUOutput::INTERLACE) { + src += 1024 * 16; + } else { + src += 1024 * 8; + } } + if(ppu->output->frame_mode == PPUOutput::NORMAL) { + /* 256x223 */ + pitch = (ddsd.lPitch >> 2) - 256; + y = 223; + while(y--) { + x = 256; + while(x--) { + *dest++ = color_lookup_table[*src]; + src += 2; + } + dest += pitch; + src += 512; + } + } else if(ppu->output->frame_mode == PPUOutput::INTERLACE) { + /* 256x446 */ + pitch = (ddsd.lPitch >> 2) - 256; + y = 446; + while(y--) { + x = 256; + while(x--) { + *dest++ = color_lookup_table[*src]; + src += 2; + } + dest += pitch; + } + } else if(ppu->output->frame_mode == PPUOutput::DOUBLEWIDTH) { + /* 512x223 */ + pitch = (ddsd.lPitch >> 2) - 512; + y = 223; + while(y--) { + x = 512; + while(x--) { + *dest++ = color_lookup_table[*src++]; + } + dest += pitch; + src += 512; + } + } else { + /* 512x446 */ + pitch = (ddsd.lPitch >> 2) - 512; + y = 446; + while(y--) { + x = 512; + while(x--) { + *dest++ = color_lookup_table[*src++]; + } + dest += pitch; + } + } lpddsb->Unlock(0); } -void render::update() { +void Render::update() { switch(color_depth) { case 15: case 16: @@ -203,7 +312,7 @@ void render::update() { redraw(); } -void render::destroy() { +void Render::destroy() { if(lpddc) { lpddc->Release(); lpddc = 0; diff --git a/src/win/winmain.cpp b/src/win/winmain.cpp index 361eca32..0b81b322 100644 --- a/src/win/winmain.cpp +++ b/src/win/winmain.cpp @@ -1,11 +1,16 @@ #define INTERFACE_MAIN -#define BSNES_VERSION "0.006" +#define BSNES_VERSION "0.007" #include "winmain.h" #include "../base.h" +#include "config.cpp" + #include "bsnes.h" #include "ui.h" +#include "timer.cpp" +fpstimer *fps_timer; + #include "lib.cpp" #include "rom.cpp" @@ -31,7 +36,13 @@ void term_snes() { int __stdcall WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { MSG msg; +string cfg_fn; + _getcwd(cfg_fn, 4096); + cfg_fn += "\\bsnes.cfg"; + cfg.load(cfg_fn); meminit(); + fps_timer = new fpstimer(); + fps_timer->start(); rom_image = new ROMImage(); init_ui0(); @@ -56,6 +67,8 @@ MSG msg; bsnes->run(); } + cfg.save(cfg_fn); + delete(rom_image); term_snes(); memterm(); return 0; diff --git a/src/win/winmain.h b/src/win/winmain.h index 93a4753a..f990b93c 100644 --- a/src/win/winmain.h +++ b/src/win/winmain.h @@ -1,3 +1,8 @@ //can't use common dialogs with this defined... //#define WIN32_LEAN_AND_MEAN #include +#include +#include "../lib/libbase.h" +#include "../lib/libvector.h" +#include "../lib/libstring.h" +#include "../lib/libconfig.h"