From abe3d67e349356d0cfe8848aef368fe5ce5b4982 Mon Sep 17 00:00:00 2001 From: Wilbert Pol Date: Mon, 5 Aug 2013 12:14:26 +0000 Subject: [PATCH] lh5801.c: Modernized cpu core(nw) --- src/emu/cpu/lh5801/5801tbl.c | 914 +++++++++++++++++------------------ src/emu/cpu/lh5801/lh5801.c | 368 ++++++-------- src/emu/cpu/lh5801/lh5801.h | 135 +++++- src/mess/drivers/pc1500.c | 46 +- 4 files changed, 744 insertions(+), 719 deletions(-) diff --git a/src/emu/cpu/lh5801/5801tbl.c b/src/emu/cpu/lh5801/5801tbl.c index ef373570fc1..8fee2f28fbd 100644 --- a/src/emu/cpu/lh5801/5801tbl.c +++ b/src/emu/cpu/lh5801/5801tbl.c @@ -4,472 +4,468 @@ (decrement, compare the same) (like in the m6502 processors) */ -INLINE UINT8 lh5801_add_generic(lh5801_state *cpustate, int left, int right, int carry) +UINT8 lh5801_cpu_device::lh5801_add_generic(int left, int right, int carry) { int res=left+right+carry; int v,c; - cpustate->t&=~(H|V|Z|C); + m_t&=~(H|V|Z|C); - if (!(res&0xff)) cpustate->t|=Z; + if (!(res&0xff)) m_t|=Z; c=res&0x100; - if (c) cpustate->t|=C; - if (((left&0xf)+(right&0xf)+carry)&0x10) cpustate->t|=H; + if (c) m_t|=C; + if (((left&0xf)+(right&0xf)+carry)&0x10) m_t|=H; v=((left&0x7f)+(right&0x7f)+carry)&0x80; - if ( (c&&!v)||(!c&&v) ) cpustate->t|=V; + if ( (c&&!v)||(!c&&v) ) m_t|=V; return res; } -INLINE UINT16 lh5801_readop_word(lh5801_state *cpustate) +UINT16 lh5801_cpu_device::lh5801_readop_word() { UINT16 r; - r=cpustate->direct->read_decrypted_byte(P++)<<8; - r|=cpustate->direct->read_decrypted_byte(P++); + r=m_direct->read_decrypted_byte(P++)<<8; + r|=m_direct->read_decrypted_byte(P++); return r; } -INLINE void lh5801_adc(lh5801_state *cpustate, UINT8 data) +void lh5801_cpu_device::lh5801_adc(UINT8 data) { - cpustate->a=lh5801_add_generic(cpustate,cpustate->a,data,cpustate->t&C); + m_a=lh5801_add_generic(m_a,data,m_t&C); } -INLINE void lh5801_add_mem(lh5801_state *cpustate, address_space &space, int addr, UINT8 data) +void lh5801_cpu_device::lh5801_add_mem(address_space &space, int addr, UINT8 data) { - int v=lh5801_add_generic(cpustate, space.read_byte(addr),data,0); + int v=lh5801_add_generic(space.read_byte(addr),data,0); space.write_byte(addr,v); } -INLINE void lh5801_adr(lh5801_state *cpustate, PAIR *reg) +void lh5801_cpu_device::lh5801_adr(PAIR *reg) { - reg->b.l=lh5801_add_generic(cpustate,reg->b.l,cpustate->a,0); - if (cpustate->t&C) { + reg->b.l=lh5801_add_generic(reg->b.l,m_a,0); + if (m_t&C) { reg->b.h++; } } -INLINE void lh5801_sbc(lh5801_state *cpustate, UINT8 data) +void lh5801_cpu_device::lh5801_sbc(UINT8 data) { - cpustate->a=lh5801_add_generic(cpustate,cpustate->a,data^0xff,cpustate->t&C); + m_a=lh5801_add_generic(m_a,data^0xff,m_t&C); } -INLINE void lh5801_cpa(lh5801_state *cpustate, UINT8 a, UINT8 b) +void lh5801_cpu_device::lh5801_cpa(UINT8 a, UINT8 b) { - lh5801_add_generic(cpustate,a, b^0xff, 1); + lh5801_add_generic(a, b^0xff, 1); } -INLINE UINT8 lh5801_decimaladd_generic(lh5801_state *cpustate, int left, int right, int carry) +UINT8 lh5801_cpu_device::lh5801_decimaladd_generic(int left, int right, int carry) { - int res=lh5801_add_generic(cpustate, left, right, carry); + int res=lh5801_add_generic(left, right, carry); UINT8 da; //DA values taken from official documentation - if (!(cpustate->t&C) && !(cpustate->t&H)) + if (!(m_t&C) && !(m_t&H)) da = 0x9a; - else if (!(cpustate->t&C) && (cpustate->t&H)) + else if (!(m_t&C) && (m_t&H)) da = 0xa0; - else if ((cpustate->t&C) && !(cpustate->t&H)) + else if ((m_t&C) && !(m_t&H)) da = 0xfa; - else //if ((cpustate->t&C) && (cpustate->t&H)) + else //if ((m_t&C) && (m_t&H)) da = 0x00; return res + da; } -INLINE void lh5801_dca(lh5801_state *cpustate, UINT8 data) +void lh5801_cpu_device::lh5801_dca(UINT8 data) { - cpustate->a += 0x66; //taken from official documentation - cpustate->a=lh5801_decimaladd_generic(cpustate, cpustate->a, data, cpustate->t&C); + m_a += 0x66; //taken from official documentation + m_a=lh5801_decimaladd_generic(m_a, data, m_t&C); } -INLINE void lh5801_dcs(lh5801_state *cpustate, UINT8 data) +void lh5801_cpu_device::lh5801_dcs(UINT8 data) { - cpustate->a=lh5801_decimaladd_generic(cpustate, cpustate->a, data^0xff, cpustate->t&C); + m_a=lh5801_decimaladd_generic(m_a, data^0xff, m_t&C); } -INLINE void lh5801_and(lh5801_state *cpustate, UINT8 data) +void lh5801_cpu_device::lh5801_and(UINT8 data) { - cpustate->a&=data; - cpustate->t&=~Z; - if (!cpustate->a) cpustate->t|=Z; + m_a&=data; + m_t&=~Z; + if (!m_a) m_t|=Z; } -INLINE void lh5801_and_mem(lh5801_state *cpustate, address_space &space, int addr, UINT8 data) +void lh5801_cpu_device::lh5801_and_mem(address_space &space, int addr, UINT8 data) { data&=space.read_byte(addr); - cpustate->t&=~Z; - if (!data) cpustate->t|=Z; + m_t&=~Z; + if (!data) m_t|=Z; space.write_byte(addr,data); } -INLINE void lh5801_bit(lh5801_state *cpustate, UINT8 a, UINT8 b) +void lh5801_cpu_device::lh5801_bit(UINT8 a, UINT8 b) { - cpustate->t&=~Z; - if (!(a&b)) cpustate->t|=Z; + m_t&=~Z; + if (!(a&b)) m_t|=Z; } -INLINE void lh5801_eor(lh5801_state *cpustate, UINT8 data) +void lh5801_cpu_device::lh5801_eor(UINT8 data) { - cpustate->a^=data; - cpustate->t&=~Z; - if (!cpustate->a) cpustate->t|=Z; + m_a^=data; + m_t&=~Z; + if (!m_a) m_t|=Z; } -INLINE void lh5801_ora(lh5801_state *cpustate, UINT8 data) +void lh5801_cpu_device::lh5801_ora(UINT8 data) { - cpustate->a|=data; - cpustate->t&=~Z; - if (!cpustate->a) cpustate->t|=Z; + m_a|=data; + m_t&=~Z; + if (!m_a) m_t|=Z; } -INLINE void lh5801_ora_mem(lh5801_state *cpustate, address_space &space, int addr, UINT8 data) +void lh5801_cpu_device::lh5801_ora_mem(address_space &space, int addr, UINT8 data) { data|=space.read_byte(addr); - cpustate->t&=~Z; - if (!data) cpustate->t|=Z; + m_t&=~Z; + if (!data) m_t|=Z; space.write_byte(addr,data); } -INLINE void lh5801_lda(lh5801_state *cpustate, UINT8 data) +void lh5801_cpu_device::lh5801_lda(UINT8 data) { - cpustate->a=data; - cpustate->t&=~Z; - if (!cpustate->a) cpustate->t|=Z; + m_a=data; + m_t&=~Z; + if (!m_a) m_t|=Z; } -INLINE void lh5801_lde(lh5801_state *cpustate, PAIR *reg) +void lh5801_cpu_device::lh5801_lde(PAIR *reg) { // or z flag depends on reg - cpustate->a=cpustate->program->read_byte(reg->w.l--); - cpustate->t&=~Z; - if (!cpustate->a) cpustate->t|=Z; + m_a=m_program->read_byte(reg->w.l--); + m_t&=~Z; + if (!m_a) m_t|=Z; } -INLINE void lh5801_sde(lh5801_state *cpustate, PAIR *reg) +void lh5801_cpu_device::lh5801_sde(PAIR *reg) { - cpustate->program->write_byte(reg->w.l--, cpustate->a); + m_program->write_byte(reg->w.l--, m_a); } -INLINE void lh5801_lin(lh5801_state *cpustate, PAIR *reg) +void lh5801_cpu_device::lh5801_lin(PAIR *reg) { // or z flag depends on reg - cpustate->a=cpustate->program->read_byte(reg->w.l++); - cpustate->t&=~Z; - if (!cpustate->a) cpustate->t|=Z; + m_a=m_program->read_byte(reg->w.l++); + m_t&=~Z; + if (!m_a) m_t|=Z; } -INLINE void lh5801_sin(lh5801_state *cpustate, PAIR *reg) +void lh5801_cpu_device::lh5801_sin(PAIR *reg) { - cpustate->program->write_byte(reg->w.l++, cpustate->a); + m_program->write_byte(reg->w.l++, m_a); } -INLINE void lh5801_dec(lh5801_state *cpustate, UINT8 *adr) +void lh5801_cpu_device::lh5801_dec(UINT8 *adr) { - *adr=lh5801_add_generic(cpustate,*adr,0xff,0); + *adr=lh5801_add_generic(*adr,0xff,0); } -INLINE void lh5801_inc(lh5801_state *cpustate, UINT8 *adr) +void lh5801_cpu_device::lh5801_inc(UINT8 *adr) { - *adr=lh5801_add_generic(cpustate,*adr,1,0); + *adr=lh5801_add_generic(*adr,1,0); } -INLINE void lh5801_pop(lh5801_state *cpustate) +void lh5801_cpu_device::lh5801_pop() { - cpustate->a=cpustate->program->read_byte(++S); - cpustate->t&=~Z; - if (!cpustate->a) cpustate->t|=Z; + m_a=m_program->read_byte(++S); + m_t&=~Z; + if (!m_a) m_t|=Z; } -INLINE void lh5801_pop_word(lh5801_state *cpustate, PAIR *reg) +void lh5801_cpu_device::lh5801_pop_word(PAIR *reg) { - reg->b.h=cpustate->program->read_byte(++S); - reg->b.l=cpustate->program->read_byte(++S); + reg->b.h=m_program->read_byte(++S); + reg->b.l=m_program->read_byte(++S); // z flag? } -INLINE void lh5801_rtn(lh5801_state *cpustate) +void lh5801_cpu_device::lh5801_rtn() { - P=cpustate->program->read_byte(++S)<<8; - P|=cpustate->program->read_byte(++S); + P=m_program->read_byte(++S)<<8; + P|=m_program->read_byte(++S); } -INLINE void lh5801_rti(lh5801_state *cpustate) +void lh5801_cpu_device::lh5801_rti() { - P=cpustate->program->read_byte(++S)<<8; - P|=cpustate->program->read_byte(++S); - cpustate->t=cpustate->program->read_byte(++S); + P=m_program->read_byte(++S)<<8; + P|=m_program->read_byte(++S); + m_t=m_program->read_byte(++S); } -INLINE void lh5801_push(lh5801_state *cpustate, UINT8 data) +void lh5801_cpu_device::lh5801_push(UINT8 data) { - cpustate->program->write_byte(S--, data); + m_program->write_byte(S--, data); } -INLINE void lh5801_push_word(lh5801_state *cpustate, UINT16 data) +void lh5801_cpu_device::lh5801_push_word(UINT16 data) { - cpustate->program->write_byte(S--, data&0xff); - cpustate->program->write_byte(S--, data>>8); + m_program->write_byte(S--, data&0xff); + m_program->write_byte(S--, data>>8); } -INLINE void lh5801_jmp(lh5801_state *cpustate, UINT16 adr) +void lh5801_cpu_device::lh5801_jmp(UINT16 adr) { P=adr; } -INLINE void lh5801_branch_plus(lh5801_state *cpustate, int doit) +void lh5801_cpu_device::lh5801_branch_plus(int doit) { - UINT8 t=cpustate->direct->read_decrypted_byte(P++); + UINT8 t=m_direct->read_decrypted_byte(P++); if (doit) { - cpustate->icount-=3; + m_icount-=3; P+=t; } } -INLINE void lh5801_branch_minus(lh5801_state *cpustate, int doit) +void lh5801_cpu_device::lh5801_branch_minus(int doit) { - UINT8 t=cpustate->direct->read_decrypted_byte(P++); + UINT8 t=m_direct->read_decrypted_byte(P++); if (doit) { - cpustate->icount-=3; + m_icount-=3; P-=t; } } -INLINE void lh5801_lop(lh5801_state *cpustate) +void lh5801_cpu_device::lh5801_lop() { - UINT8 t=cpustate->direct->read_decrypted_byte(P++); - cpustate->icount-=8; + UINT8 t=m_direct->read_decrypted_byte(P++); + m_icount-=8; if (UL--) { - cpustate->icount-=3; + m_icount-=3; P-=t; } } -INLINE void lh5801_sjp(lh5801_state *cpustate) +void lh5801_cpu_device::lh5801_sjp() { - UINT16 n=lh5801_readop_word(cpustate); - lh5801_push_word(cpustate,P); + UINT16 n=lh5801_readop_word(); + lh5801_push_word(P); P=n; } -INLINE void lh5801_vector(lh5801_state *cpustate, int doit, int nr) +void lh5801_cpu_device::lh5801_vector(int doit, int nr) { if (doit) { - lh5801_push_word(cpustate,P); - P=cpustate->program->read_byte(0xff00+nr)<<8; - P|=cpustate->program->read_byte(0xff00+nr+1); - cpustate->icount-=21-8; + lh5801_push_word(P); + P=m_program->read_byte(0xff00+nr)<<8; + P|=m_program->read_byte(0xff00+nr+1); + m_icount-=21-8; } - cpustate->t&=~Z; // after the jump!? + m_t&=~Z; // after the jump!? } -INLINE void lh5801_aex(lh5801_state *cpustate) +void lh5801_cpu_device::lh5801_aex() { - UINT8 t=cpustate->a; - cpustate->a=(t<<4)|(t>>4); + UINT8 t=m_a; + m_a=(t<<4)|(t>>4); // flags? } -INLINE void lh5801_drl(lh5801_state *cpustate, address_space &space, int adr) +void lh5801_cpu_device::lh5801_drl(address_space &space, int adr) { - UINT16 t=cpustate->a|(space.read_byte(adr)<<8); + UINT16 t=m_a|(space.read_byte(adr)<<8); - cpustate->a=t>>8; + m_a=t>>8; space.write_byte(adr,t>>4); } -INLINE void lh5801_drr(lh5801_state *cpustate, address_space &space, int adr) +void lh5801_cpu_device::lh5801_drr(address_space &space, int adr) { - UINT16 t=space.read_byte(adr)|(cpustate->a<<8); + UINT16 t=space.read_byte(adr)|(m_a<<8); - cpustate->a=t; + m_a=t; space.write_byte(adr,t>>4); } -INLINE void lh5801_rol(lh5801_state *cpustate) +void lh5801_cpu_device::lh5801_rol() { // maybe use of the adder - int n = cpustate->a; - cpustate->a = (n<<1) | (cpustate->t&C); + int n = m_a; + m_a = (n<<1) | (m_t&C); // flags cvhz - cpustate->t&=~(H|V|Z|C); - if (n&0x80) cpustate->t|=C; - if (!cpustate->a) cpustate->t|=Z; - if (cpustate->a & 0x10) cpustate->t|=H; - if ((BIT(n,6) && !BIT(n,7)) || (!BIT(n,6) && BIT(n,7))) cpustate->t|=V; + m_t&=~(H|V|Z|C); + if (n&0x80) m_t|=C; + if (!m_a) m_t|=Z; + if (m_a & 0x10) m_t|=H; + if ((BIT(n,6) && !BIT(n,7)) || (!BIT(n,6) && BIT(n,7))) m_t|=V; } -INLINE void lh5801_ror(lh5801_state *cpustate) +void lh5801_cpu_device::lh5801_ror() { - int n = cpustate->a; - cpustate->a=(n | ((cpustate->t&C)<<8))>>1; + int n = m_a; + m_a=(n | ((m_t&C)<<8))>>1; // flags cvhz - cpustate->t&=~(H|V|Z|C); - if (n&0x01) cpustate->t|=C; - if (!cpustate->a) cpustate->t|=Z; - if (cpustate->a & 0x08) cpustate->t|=H; - if ((BIT(n,0) && BIT(cpustate->a,1)) || (BIT(cpustate->a,0) && BIT(n,1))) cpustate->t|=V; + m_t&=~(H|V|Z|C); + if (n&0x01) m_t|=C; + if (!m_a) m_t|=Z; + if (m_a & 0x08) m_t|=H; + if ((BIT(n,0) && BIT(m_a,1)) || (BIT(m_a,0) && BIT(n,1))) m_t|=V; } -INLINE void lh5801_shl(lh5801_state *cpustate) +void lh5801_cpu_device::lh5801_shl() { - int n = cpustate->a; - cpustate->a<<=1; + int n = m_a; + m_a<<=1; // flags cvhz - cpustate->t&=~(H|V|Z|C); - if (n&0x80) cpustate->t|=C; - if (!cpustate->a) cpustate->t|=Z; - if (cpustate->a & 0x10) cpustate->t|=H; - if ((BIT(n,6) && !BIT(n,7)) || (!BIT(n,6) && BIT(n,7))) cpustate->t|=V; + m_t&=~(H|V|Z|C); + if (n&0x80) m_t|=C; + if (!m_a) m_t|=Z; + if (m_a & 0x10) m_t|=H; + if ((BIT(n,6) && !BIT(n,7)) || (!BIT(n,6) && BIT(n,7))) m_t|=V; } -INLINE void lh5801_shr(lh5801_state *cpustate) +void lh5801_cpu_device::lh5801_shr() { - int n = cpustate->a; - cpustate->a>>=1; + int n = m_a; + m_a>>=1; // flags cvhz - cpustate->t&=~(H|V|Z|C); - if (n & 0x01) cpustate->t|=C; - if (!cpustate->a) cpustate->t|=Z; - if (cpustate->a & 0x08) cpustate->t|=H; - if ((BIT(n,0) && BIT(cpustate->a,1)) || (BIT(cpustate->a,0) && BIT(n,1))) cpustate->t|=V; + m_t&=~(H|V|Z|C); + if (n & 0x01) m_t|=C; + if (!m_a) m_t|=Z; + if (m_a & 0x08) m_t|=H; + if ((BIT(n,0) && BIT(m_a,1)) || (BIT(m_a,0) && BIT(n,1))) m_t|=V; } -INLINE void lh5801_am(lh5801_state *cpustate, int value) +void lh5801_cpu_device::lh5801_am(int value) { - cpustate->tm=value; + m_tm=value; // jfkas?jfkl?jkd? } -INLINE void lh5801_ita(lh5801_state *cpustate) +void lh5801_cpu_device::lh5801_ita() { - if (cpustate->config&&cpustate->config->in) { - cpustate->a=cpustate->config->in(cpustate->device); - } else { - cpustate->a=0; - } - cpustate->t&=~Z; - if (!cpustate->a) cpustate->t|=Z; + m_a=m_in_func(); + m_t&=~Z; + if (!m_a) m_t|=Z; } -static void lh5801_instruction_fd(lh5801_state *cpustate) +void lh5801_cpu_device::lh5801_instruction_fd() { int oper; int adr; - oper=cpustate->direct->read_decrypted_byte(P++); + oper=m_direct->read_decrypted_byte(P++); switch (oper) { - case 0x01: lh5801_sbc(cpustate,cpustate->io->read_byte(X)); cpustate->icount-=11;break; - case 0x03: lh5801_adc(cpustate,cpustate->io->read_byte(X)); cpustate->icount-=11;break; - case 0x05: lh5801_lda(cpustate,cpustate->io->read_byte(X)); cpustate->icount-=10;break; - case 0x07: lh5801_cpa(cpustate,cpustate->a, cpustate->io->read_byte(X)); cpustate->icount-=11;break; - case 0x08: X=X;cpustate->icount-=11;break; //!!! - case 0x09: lh5801_and(cpustate,cpustate->io->read_byte(X)); cpustate->icount-=11;break; - case 0x0a: lh5801_pop_word(cpustate,&cpustate->x); cpustate->icount-=15;break; - case 0x0b: lh5801_ora(cpustate,cpustate->io->read_byte(X)); cpustate->icount-=11;break; - case 0x0c: lh5801_dcs(cpustate,cpustate->io->read_byte(X)); cpustate->icount-=17; break; - case 0x0d: lh5801_eor(cpustate,cpustate->io->read_byte(X)); cpustate->icount-=11;break; - case 0x0e: cpustate->io->write_byte(X,cpustate->a); cpustate->icount-=10;break; - case 0x0f: lh5801_bit(cpustate,cpustate->io->read_byte(X),cpustate->a); cpustate->icount-=11;break; - case 0x11: lh5801_sbc(cpustate,cpustate->io->read_byte(Y)); cpustate->icount-=11;break; - case 0x13: lh5801_adc(cpustate,cpustate->io->read_byte(Y)); cpustate->icount-=11;break; - case 0x15: lh5801_lda(cpustate,cpustate->io->read_byte(Y)); cpustate->icount-=10;break; - case 0x17: lh5801_cpa(cpustate,cpustate->a, cpustate->io->read_byte(Y)); cpustate->icount-=11;break; - case 0x18: X=Y;cpustate->icount-=11;break; - case 0x19: lh5801_and(cpustate,cpustate->io->read_byte(Y)); cpustate->icount-=11;break; - case 0x1a: lh5801_pop_word(cpustate,&cpustate->y); cpustate->icount-=15;break; - case 0x1b: lh5801_ora(cpustate,cpustate->io->read_byte(Y)); cpustate->icount-=11;break; - case 0x1c: lh5801_dcs(cpustate,cpustate->io->read_byte(Y)); cpustate->icount-=17; break; - case 0x1d: lh5801_eor(cpustate,cpustate->io->read_byte(Y)); cpustate->icount-=11;break; - case 0x1e: cpustate->io->write_byte(Y,cpustate->a); cpustate->icount-=10;break; - case 0x1f: lh5801_bit(cpustate,cpustate->io->read_byte(Y),cpustate->a); cpustate->icount-=11;break; - case 0x21: lh5801_sbc(cpustate,cpustate->io->read_byte(U)); cpustate->icount-=11;break; - case 0x23: lh5801_adc(cpustate,cpustate->io->read_byte(U)); cpustate->icount-=11;break; - case 0x25: lh5801_lda(cpustate,cpustate->io->read_byte(U)); cpustate->icount-=10;break; - case 0x27: lh5801_cpa(cpustate,cpustate->a, cpustate->io->read_byte(U)); cpustate->icount-=11;break; - case 0x28: X=U;cpustate->icount-=11;break; - case 0x29: lh5801_and(cpustate,cpustate->io->read_byte(U)); cpustate->icount-=11;break; - case 0x2a: lh5801_pop_word(cpustate,&cpustate->u); cpustate->icount-=15;break; - case 0x2b: lh5801_ora(cpustate,cpustate->io->read_byte(U)); cpustate->icount-=11;break; - case 0x2c: lh5801_dcs(cpustate,cpustate->io->read_byte(U)); cpustate->icount-=17; break; - case 0x2d: lh5801_eor(cpustate,cpustate->io->read_byte(U)); cpustate->icount-=11;break; - case 0x2e: cpustate->io->write_byte(U,cpustate->a); cpustate->icount-=10;break; - case 0x2f: lh5801_bit(cpustate,cpustate->io->read_byte(U),cpustate->a); cpustate->icount-=11;break; - case 0x40: lh5801_inc(cpustate,&XH);cpustate->icount-=9;break; - case 0x42: lh5801_dec(cpustate,&XH);cpustate->icount-=9;break; - case 0x48: X=S;cpustate->icount-=11;break; - case 0x49: lh5801_and_mem(cpustate, *cpustate->io, X, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=17;break; - case 0x4a: X=X;cpustate->icount-=11;break; //!!! - case 0x4b: lh5801_ora_mem(cpustate, *cpustate->io, X, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=17;break; - case 0x4c: cpustate->bf=0;/*off !*/ cpustate->icount-=8;break; - case 0x4d: lh5801_bit(cpustate,cpustate->io->read_byte(X), cpustate->direct->read_decrypted_byte(P++));cpustate->icount-=14;break; - case 0x4e: S=X;cpustate->icount-=11;break; - case 0x4f: lh5801_add_mem(cpustate, *cpustate->io, X, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=17;break; - case 0x50: lh5801_inc(cpustate,&YH);cpustate->icount-=9;break; - case 0x52: lh5801_dec(cpustate,&YH);cpustate->icount-=9;break; - case 0x58: X=P;cpustate->icount-=11;break; - case 0x59: lh5801_and_mem(cpustate, *cpustate->io, Y, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=17;break; - case 0x5a: Y=X;cpustate->icount-=11;break; - case 0x5b: lh5801_ora_mem(cpustate, *cpustate->io, Y, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=17;break; - case 0x5d: lh5801_bit(cpustate,cpustate->io->read_byte(Y), cpustate->direct->read_decrypted_byte(P++));cpustate->icount-=14;break; - case 0x5e: lh5801_jmp(cpustate,X);cpustate->icount-=11;break; // P=X - case 0x5f: lh5801_add_mem(cpustate, *cpustate->io, Y, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=17;break; - case 0x60: lh5801_inc(cpustate,&UH);cpustate->icount-=9;break; - case 0x62: lh5801_dec(cpustate,&UH);cpustate->icount-=9;break; - case 0x69: lh5801_and_mem(cpustate, *cpustate->io, U, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=17;break; - case 0x6a: U=X;cpustate->icount-=11;break; - case 0x6b: lh5801_ora_mem(cpustate, *cpustate->io, U, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=17;break; - case 0x6d: lh5801_bit(cpustate,cpustate->io->read_byte(X), cpustate->direct->read_decrypted_byte(P++));cpustate->icount-=14;break; - case 0x6f: lh5801_add_mem(cpustate, *cpustate->io, U, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=17;break; - case 0x81: cpustate->t|=IE; /*sie !*/cpustate->icount-=8;break; - case 0x88: lh5801_push_word(cpustate,X); cpustate->icount-=14;break; - case 0x8a: lh5801_pop(cpustate); cpustate->icount-=12; break; - case 0x8c: lh5801_dca(cpustate,cpustate->io->read_byte(X)); cpustate->icount-=19; break; - case 0x8e: /*cdv clears internal devider*/cpustate->icount-=8;break; - case 0x98: lh5801_push_word(cpustate,Y); cpustate->icount-=14;break; - case 0x9c: lh5801_dca(cpustate,cpustate->io->read_byte(Y)); cpustate->icount-=19; break; - case 0xa1: lh5801_sbc(cpustate,cpustate->io->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=17;break; - case 0xa3: lh5801_adc(cpustate,cpustate->io->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=17;break; - case 0xa5: lh5801_lda(cpustate,cpustate->io->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=16;break; - case 0xa7: lh5801_cpa(cpustate,cpustate->a, cpustate->io->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=17;break; - case 0xa8: lh5801_push_word(cpustate,U); cpustate->icount-=14;break; - case 0xa9: lh5801_and(cpustate,cpustate->io->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=17;break; - case 0xaa: lh5801_lda(cpustate,cpustate->t); cpustate->icount-=9;break; - case 0xab: lh5801_ora(cpustate,cpustate->io->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=17;break; - case 0xac: lh5801_dca(cpustate,cpustate->io->read_byte(U)); cpustate->icount-=19; break; - case 0xad: lh5801_eor(cpustate,cpustate->io->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=17;break; - case 0xae: cpustate->io->write_byte(lh5801_readop_word(cpustate),cpustate->a); cpustate->icount-=16;break; - case 0xaf: lh5801_bit(cpustate,cpustate->io->read_byte(lh5801_readop_word(cpustate)),cpustate->a); cpustate->icount-=17;break; - case 0xb1: /*hlt*/cpustate->icount-=8;break; - case 0xba: lh5801_ita(cpustate);cpustate->icount-=9;break; - case 0xbe: cpustate->t&=~IE; /*rie !*/cpustate->icount-=8;break; - case 0xc0: cpustate->dp=0; /*rdp !*/cpustate->icount-=8;break; - case 0xc1: cpustate->dp=1; /*sdp !*/cpustate->icount-=8;break; - case 0xc8: lh5801_push(cpustate,cpustate->a); cpustate->icount-=11;break; - case 0xca: lh5801_adr(cpustate,&cpustate->x);cpustate->icount-=11;break; - case 0xcc: /*atp sends a to data bus*/cpustate->icount-=9;break; - case 0xce: lh5801_am(cpustate,cpustate->a); cpustate->icount-=9; break; - case 0xd3: lh5801_drr(cpustate, *cpustate->io, X); cpustate->icount-=16; break; - case 0xd7: lh5801_drl(cpustate, *cpustate->io, X); cpustate->icount-=16; break; - case 0xda: lh5801_adr(cpustate,&cpustate->y);cpustate->icount-=11;break; - case 0xde: lh5801_am(cpustate,cpustate->a|0x100); cpustate->icount-=9; break; - case 0xea: lh5801_adr(cpustate,&cpustate->u);cpustate->icount-=11;break; + case 0x01: lh5801_sbc(m_io->read_byte(X)); m_icount-=11;break; + case 0x03: lh5801_adc(m_io->read_byte(X)); m_icount-=11;break; + case 0x05: lh5801_lda(m_io->read_byte(X)); m_icount-=10;break; + case 0x07: lh5801_cpa(m_a, m_io->read_byte(X)); m_icount-=11;break; + case 0x08: X=X;m_icount-=11;break; //!!! + case 0x09: lh5801_and(m_io->read_byte(X)); m_icount-=11;break; + case 0x0a: lh5801_pop_word(&m_x); m_icount-=15;break; + case 0x0b: lh5801_ora(m_io->read_byte(X)); m_icount-=11;break; + case 0x0c: lh5801_dcs(m_io->read_byte(X)); m_icount-=17; break; + case 0x0d: lh5801_eor(m_io->read_byte(X)); m_icount-=11;break; + case 0x0e: m_io->write_byte(X,m_a); m_icount-=10;break; + case 0x0f: lh5801_bit(m_io->read_byte(X),m_a); m_icount-=11;break; + case 0x11: lh5801_sbc(m_io->read_byte(Y)); m_icount-=11;break; + case 0x13: lh5801_adc(m_io->read_byte(Y)); m_icount-=11;break; + case 0x15: lh5801_lda(m_io->read_byte(Y)); m_icount-=10;break; + case 0x17: lh5801_cpa(m_a, m_io->read_byte(Y)); m_icount-=11;break; + case 0x18: X=Y;m_icount-=11;break; + case 0x19: lh5801_and(m_io->read_byte(Y)); m_icount-=11;break; + case 0x1a: lh5801_pop_word(&m_y); m_icount-=15;break; + case 0x1b: lh5801_ora(m_io->read_byte(Y)); m_icount-=11;break; + case 0x1c: lh5801_dcs(m_io->read_byte(Y)); m_icount-=17; break; + case 0x1d: lh5801_eor(m_io->read_byte(Y)); m_icount-=11;break; + case 0x1e: m_io->write_byte(Y,m_a); m_icount-=10;break; + case 0x1f: lh5801_bit(m_io->read_byte(Y),m_a); m_icount-=11;break; + case 0x21: lh5801_sbc(m_io->read_byte(U)); m_icount-=11;break; + case 0x23: lh5801_adc(m_io->read_byte(U)); m_icount-=11;break; + case 0x25: lh5801_lda(m_io->read_byte(U)); m_icount-=10;break; + case 0x27: lh5801_cpa(m_a, m_io->read_byte(U)); m_icount-=11;break; + case 0x28: X=U;m_icount-=11;break; + case 0x29: lh5801_and(m_io->read_byte(U)); m_icount-=11;break; + case 0x2a: lh5801_pop_word(&m_u); m_icount-=15;break; + case 0x2b: lh5801_ora(m_io->read_byte(U)); m_icount-=11;break; + case 0x2c: lh5801_dcs(m_io->read_byte(U)); m_icount-=17; break; + case 0x2d: lh5801_eor(m_io->read_byte(U)); m_icount-=11;break; + case 0x2e: m_io->write_byte(U,m_a); m_icount-=10;break; + case 0x2f: lh5801_bit(m_io->read_byte(U),m_a); m_icount-=11;break; + case 0x40: lh5801_inc(&XH);m_icount-=9;break; + case 0x42: lh5801_dec(&XH);m_icount-=9;break; + case 0x48: X=S;m_icount-=11;break; + case 0x49: lh5801_and_mem(*m_io, X, m_direct->read_decrypted_byte(P++)); m_icount-=17;break; + case 0x4a: X=X;m_icount-=11;break; //!!! + case 0x4b: lh5801_ora_mem(*m_io, X, m_direct->read_decrypted_byte(P++)); m_icount-=17;break; + case 0x4c: m_bf=0;/*off !*/ m_icount-=8;break; + case 0x4d: lh5801_bit(m_io->read_byte(X), m_direct->read_decrypted_byte(P++));m_icount-=14;break; + case 0x4e: S=X;m_icount-=11;break; + case 0x4f: lh5801_add_mem(*m_io, X, m_direct->read_decrypted_byte(P++)); m_icount-=17;break; + case 0x50: lh5801_inc(&YH);m_icount-=9;break; + case 0x52: lh5801_dec(&YH);m_icount-=9;break; + case 0x58: X=P;m_icount-=11;break; + case 0x59: lh5801_and_mem(*m_io, Y, m_direct->read_decrypted_byte(P++)); m_icount-=17;break; + case 0x5a: Y=X;m_icount-=11;break; + case 0x5b: lh5801_ora_mem(*m_io, Y, m_direct->read_decrypted_byte(P++)); m_icount-=17;break; + case 0x5d: lh5801_bit(m_io->read_byte(Y), m_direct->read_decrypted_byte(P++));m_icount-=14;break; + case 0x5e: lh5801_jmp(X);m_icount-=11;break; // P=X + case 0x5f: lh5801_add_mem(*m_io, Y, m_direct->read_decrypted_byte(P++)); m_icount-=17;break; + case 0x60: lh5801_inc(&UH);m_icount-=9;break; + case 0x62: lh5801_dec(&UH);m_icount-=9;break; + case 0x69: lh5801_and_mem(*m_io, U, m_direct->read_decrypted_byte(P++)); m_icount-=17;break; + case 0x6a: U=X;m_icount-=11;break; + case 0x6b: lh5801_ora_mem(*m_io, U, m_direct->read_decrypted_byte(P++)); m_icount-=17;break; + case 0x6d: lh5801_bit(m_io->read_byte(X), m_direct->read_decrypted_byte(P++));m_icount-=14;break; + case 0x6f: lh5801_add_mem(*m_io, U, m_direct->read_decrypted_byte(P++)); m_icount-=17;break; + case 0x81: m_t|=IE; /*sie !*/m_icount-=8;break; + case 0x88: lh5801_push_word(X); m_icount-=14;break; + case 0x8a: lh5801_pop(); m_icount-=12; break; + case 0x8c: lh5801_dca(m_io->read_byte(X)); m_icount-=19; break; + case 0x8e: /*cdv clears internal devider*/m_icount-=8;break; + case 0x98: lh5801_push_word(Y); m_icount-=14;break; + case 0x9c: lh5801_dca(m_io->read_byte(Y)); m_icount-=19; break; + case 0xa1: lh5801_sbc(m_io->read_byte(lh5801_readop_word())); m_icount-=17;break; + case 0xa3: lh5801_adc(m_io->read_byte(lh5801_readop_word())); m_icount-=17;break; + case 0xa5: lh5801_lda(m_io->read_byte(lh5801_readop_word())); m_icount-=16;break; + case 0xa7: lh5801_cpa(m_a, m_io->read_byte(lh5801_readop_word())); m_icount-=17;break; + case 0xa8: lh5801_push_word(U); m_icount-=14;break; + case 0xa9: lh5801_and(m_io->read_byte(lh5801_readop_word())); m_icount-=17;break; + case 0xaa: lh5801_lda(m_t); m_icount-=9;break; + case 0xab: lh5801_ora(m_io->read_byte(lh5801_readop_word())); m_icount-=17;break; + case 0xac: lh5801_dca(m_io->read_byte(U)); m_icount-=19; break; + case 0xad: lh5801_eor(m_io->read_byte(lh5801_readop_word())); m_icount-=17;break; + case 0xae: m_io->write_byte(lh5801_readop_word(),m_a); m_icount-=16;break; + case 0xaf: lh5801_bit(m_io->read_byte(lh5801_readop_word()),m_a); m_icount-=17;break; + case 0xb1: /*hlt*/m_icount-=8;break; + case 0xba: lh5801_ita();m_icount-=9;break; + case 0xbe: m_t&=~IE; /*rie !*/m_icount-=8;break; + case 0xc0: m_dp=0; /*rdp !*/m_icount-=8;break; + case 0xc1: m_dp=1; /*sdp !*/m_icount-=8;break; + case 0xc8: lh5801_push(m_a); m_icount-=11;break; + case 0xca: lh5801_adr(&m_x);m_icount-=11;break; + case 0xcc: /*atp sends a to data bus*/m_icount-=9;break; + case 0xce: lh5801_am(m_a); m_icount-=9; break; + case 0xd3: lh5801_drr(*m_io, X); m_icount-=16; break; + case 0xd7: lh5801_drl(*m_io, X); m_icount-=16; break; + case 0xda: lh5801_adr(&m_y);m_icount-=11;break; + case 0xde: lh5801_am(m_a|0x100); m_icount-=9; break; + case 0xea: lh5801_adr(&m_u);m_icount-=11;break; case 0xe9: - adr=lh5801_readop_word(cpustate); - lh5801_and_mem(cpustate, *cpustate->io, adr, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=23; + adr=lh5801_readop_word(); + lh5801_and_mem(*m_io, adr, m_direct->read_decrypted_byte(P++)); m_icount-=23; break; case 0xeb: - adr=lh5801_readop_word(cpustate); - lh5801_ora_mem(cpustate, *cpustate->io, adr, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=23; + adr=lh5801_readop_word(); + lh5801_ora_mem(*m_io, adr, m_direct->read_decrypted_byte(P++)); m_icount-=23; break; - case 0xec: cpustate->t=cpustate->a; cpustate->icount-=9;break; + case 0xec: m_t=m_a; m_icount-=9;break; case 0xed: - adr=lh5801_readop_word(cpustate); - lh5801_bit(cpustate,cpustate->io->read_byte(adr), cpustate->direct->read_decrypted_byte(P++)); - cpustate->icount-=20;break; + adr=lh5801_readop_word(); + lh5801_bit(m_io->read_byte(adr), m_direct->read_decrypted_byte(P++)); + m_icount-=20;break; case 0xef: - adr=lh5801_readop_word(cpustate); - lh5801_add_mem(cpustate, *cpustate->io, adr, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=23; + adr=lh5801_readop_word(); + lh5801_add_mem(*m_io, adr, m_direct->read_decrypted_byte(P++)); m_icount-=23; break; default: @@ -477,205 +473,205 @@ static void lh5801_instruction_fd(lh5801_state *cpustate) } } -static void lh5801_instruction(lh5801_state *cpustate) +void lh5801_cpu_device::lh5801_instruction() { int oper; int adr; - oper=cpustate->direct->read_decrypted_byte(P++); + oper=m_direct->read_decrypted_byte(P++); switch (oper) { - case 0x00: lh5801_sbc(cpustate,XL); cpustate->icount-=6;break; - case 0x01: lh5801_sbc(cpustate,cpustate->program->read_byte(X)); cpustate->icount-=7;break; - case 0x02: lh5801_adc(cpustate,XL); cpustate->icount-=6;break; - case 0x03: lh5801_adc(cpustate,cpustate->program->read_byte(X)); cpustate->icount-=7;break; - case 0x04: lh5801_lda(cpustate,XL); cpustate->icount-=5;break; - case 0x05: lh5801_lda(cpustate,cpustate->program->read_byte(X)); cpustate->icount-=6;break; - case 0x06: lh5801_cpa(cpustate,cpustate->a, XL); cpustate->icount-=6;break; - case 0x07: lh5801_cpa(cpustate,cpustate->a, cpustate->program->read_byte(X)); cpustate->icount-=7;break; - case 0x08: XH=cpustate->a; cpustate->icount-=5; break; - case 0x09: lh5801_and(cpustate,cpustate->program->read_byte(X)); cpustate->icount-=7;break; - case 0x0a: XL=cpustate->a; cpustate->icount-=5; break; - case 0x0b: lh5801_ora(cpustate,cpustate->program->read_byte(X)); cpustate->icount-=7;break; - case 0x0c: lh5801_dcs(cpustate,cpustate->program->read_byte(X)); cpustate->icount-=13; break; - case 0x0d: lh5801_eor(cpustate,cpustate->program->read_byte(X)); cpustate->icount-=7;break; - case 0x0e: cpustate->program->write_byte(X,cpustate->a); cpustate->icount-=6;break; - case 0x0f: lh5801_bit(cpustate,cpustate->program->read_byte(X),cpustate->a); cpustate->icount-=7;break; - case 0x10: lh5801_sbc(cpustate,YL); cpustate->icount-=6;break; - case 0x11: lh5801_sbc(cpustate,cpustate->program->read_byte(Y)); cpustate->icount-=7;break; - case 0x12: lh5801_adc(cpustate,YL); cpustate->icount-=6;break; - case 0x13: lh5801_adc(cpustate,cpustate->program->read_byte(Y)); cpustate->icount-=7;break; - case 0x14: lh5801_lda(cpustate,YL); cpustate->icount-=5;break; - case 0x15: lh5801_lda(cpustate,cpustate->program->read_byte(Y)); cpustate->icount-=6;break; - case 0x16: lh5801_cpa(cpustate,cpustate->a, YL); cpustate->icount-=6;break; - case 0x17: lh5801_cpa(cpustate,cpustate->a, cpustate->program->read_byte(Y)); cpustate->icount-=7;break; - case 0x18: YH=cpustate->a; cpustate->icount-=5; break; - case 0x19: lh5801_and(cpustate,cpustate->program->read_byte(Y)); cpustate->icount-=7;break; - case 0x1a: YL=cpustate->a; cpustate->icount-=5; break; - case 0x1b: lh5801_ora(cpustate,cpustate->program->read_byte(Y)); cpustate->icount-=7;break; - case 0x1c: lh5801_dcs(cpustate,cpustate->program->read_byte(Y)); cpustate->icount-=13; break; - case 0x1d: lh5801_eor(cpustate,cpustate->program->read_byte(Y)); cpustate->icount-=7;break; - case 0x1e: cpustate->program->write_byte(Y,cpustate->a); cpustate->icount-=6;break; - case 0x1f: lh5801_bit(cpustate,cpustate->program->read_byte(Y),cpustate->a); cpustate->icount-=7;break; - case 0x20: lh5801_sbc(cpustate,UL); cpustate->icount-=6;break; - case 0x21: lh5801_sbc(cpustate,cpustate->program->read_byte(U)); cpustate->icount-=7;break; - case 0x22: lh5801_adc(cpustate,UL); cpustate->icount-=6;break; - case 0x23: lh5801_adc(cpustate,cpustate->program->read_byte(U)); cpustate->icount-=7;break; - case 0x24: lh5801_lda(cpustate,UL); cpustate->icount-=5;break; - case 0x25: lh5801_lda(cpustate,cpustate->program->read_byte(U)); cpustate->icount-=6;break; - case 0x26: lh5801_cpa(cpustate,cpustate->a, UL); cpustate->icount-=6;break; - case 0x27: lh5801_cpa(cpustate,cpustate->a, cpustate->program->read_byte(U)); cpustate->icount-=7;break; - case 0x28: UH=cpustate->a; cpustate->icount-=5; break; - case 0x29: lh5801_and(cpustate,cpustate->program->read_byte(U)); cpustate->icount-=7;break; - case 0x2a: UL=cpustate->a; cpustate->icount-=5; break; - case 0x2b: lh5801_ora(cpustate,cpustate->program->read_byte(U)); cpustate->icount-=7;break; - case 0x2c: lh5801_dcs(cpustate,cpustate->program->read_byte(U)); cpustate->icount-=13; break; - case 0x2d: lh5801_eor(cpustate,cpustate->program->read_byte(U)); cpustate->icount-=7;break; - case 0x2e: cpustate->program->write_byte(U,cpustate->a); cpustate->icount-=6;break; - case 0x2f: lh5801_bit(cpustate,cpustate->program->read_byte(U),cpustate->a); cpustate->icount-=7;break; - case 0x38: /*nop*/cpustate->icount-=5;break; - case 0x40: lh5801_inc(cpustate,&XL);cpustate->icount-=5;break; - case 0x41: lh5801_sin(cpustate,&cpustate->x); cpustate->icount-=6;break; - case 0x42: lh5801_dec(cpustate,&XL);cpustate->icount-=5;break; - case 0x43: lh5801_sde(cpustate,&cpustate->x); cpustate->icount-=6;break; - case 0x44: X++;cpustate->icount-=5;break; - case 0x45: lh5801_lin(cpustate,&cpustate->x);cpustate->icount-=6;break; - case 0x46: X--;cpustate->icount-=5;break; - case 0x47: lh5801_lde(cpustate,&cpustate->x);cpustate->icount-=6;break; - case 0x48: XH=cpustate->direct->read_decrypted_byte(P++);cpustate->icount-=6;break; - case 0x49: lh5801_and_mem(cpustate, *cpustate->program, X, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=13;break; - case 0x4a: XL=cpustate->direct->read_decrypted_byte(P++);cpustate->icount-=6;break; - case 0x4b: lh5801_ora_mem(cpustate, *cpustate->program, X, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=13;break; - case 0x4c: lh5801_cpa(cpustate,XH, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=7;break; - case 0x4d: lh5801_bit(cpustate,cpustate->program->read_byte(X), cpustate->direct->read_decrypted_byte(P++));cpustate->icount-=10;break; - case 0x4e: lh5801_cpa(cpustate,XL, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=7;break; - case 0x4f: lh5801_add_mem(cpustate, *cpustate->program, X, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=13;break; - case 0x50: lh5801_inc(cpustate,&YL);cpustate->icount-=5;break; - case 0x51: lh5801_sin(cpustate,&cpustate->y); cpustate->icount-=6;break; - case 0x52: lh5801_dec(cpustate,&YL);cpustate->icount-=5;break; - case 0x53: lh5801_sde(cpustate,&cpustate->y); cpustate->icount-=6;break; - case 0x54: Y++;cpustate->icount-=5;break; - case 0x55: lh5801_lin(cpustate,&cpustate->y);cpustate->icount-=6;break; - case 0x56: Y--;cpustate->icount-=5;break; - case 0x57: lh5801_lde(cpustate,&cpustate->y);cpustate->icount-=6;break; - case 0x58: YH=cpustate->direct->read_decrypted_byte(P++);cpustate->icount-=6;break; - case 0x59: lh5801_and_mem(cpustate, *cpustate->program, Y, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=13;break; - case 0x5a: YL=cpustate->direct->read_decrypted_byte(P++);cpustate->icount-=6;break; - case 0x5b: lh5801_ora_mem(cpustate, *cpustate->program, Y, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=13;break; - case 0x5c: lh5801_cpa(cpustate,YH, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=7;break; - case 0x5d: lh5801_bit(cpustate,cpustate->program->read_byte(Y), cpustate->direct->read_decrypted_byte(P++));cpustate->icount-=10;break; - case 0x5e: lh5801_cpa(cpustate,YL, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=7;break; - case 0x5f: lh5801_add_mem(cpustate, *cpustate->program, Y, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=13;break; - case 0x60: lh5801_inc(cpustate,&UL);cpustate->icount-=5;break; - case 0x61: lh5801_sin(cpustate,&cpustate->u); cpustate->icount-=6;break; - case 0x62: lh5801_dec(cpustate,&UL);cpustate->icount-=5;break; - case 0x63: lh5801_sde(cpustate,&cpustate->u); cpustate->icount-=6;break; - case 0x64: U++;cpustate->icount-=5;break; - case 0x65: lh5801_lin(cpustate,&cpustate->u);cpustate->icount-=6;break; - case 0x66: U--;cpustate->icount-=5;break; - case 0x67: lh5801_lde(cpustate,&cpustate->u);cpustate->icount-=6;break; - case 0x68: UH=cpustate->direct->read_decrypted_byte(P++);cpustate->icount-=6;break; - case 0x69: lh5801_and_mem(cpustate, *cpustate->program, U, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=13;break; - case 0x6a: UL=cpustate->direct->read_decrypted_byte(P++);cpustate->icount-=6;break; - case 0x6b: lh5801_ora_mem(cpustate, *cpustate->program, U, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=13;break; - case 0x6c: lh5801_cpa(cpustate,UH, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=7;break; - case 0x6d: lh5801_bit(cpustate,cpustate->program->read_byte(U), cpustate->direct->read_decrypted_byte(P++));cpustate->icount-=10;break; - case 0x6e: lh5801_cpa(cpustate,UL, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=7;break; - case 0x6f: lh5801_add_mem(cpustate, *cpustate->program, U, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=13;break; - case 0x80: lh5801_sbc(cpustate,XH); cpustate->icount-=6;break; - case 0x81: lh5801_branch_plus(cpustate,!(cpustate->t&C)); cpustate->icount-=8; break; - case 0x82: lh5801_adc(cpustate,XH); cpustate->icount-=6;break; - case 0x83: lh5801_branch_plus(cpustate,cpustate->t&C); cpustate->icount-=8; break; - case 0x84: lh5801_lda(cpustate,XH); cpustate->icount-=5;break; - case 0x85: lh5801_branch_plus(cpustate,!(cpustate->t&H)); cpustate->icount-=8; break; - case 0x86: lh5801_cpa(cpustate,cpustate->a, XH); cpustate->icount-=6;break; - case 0x87: lh5801_branch_plus(cpustate,cpustate->t&H); cpustate->icount-=8; break; - case 0x88: lh5801_lop(cpustate); break; - case 0x89: lh5801_branch_plus(cpustate,!(cpustate->t&Z)); cpustate->icount-=8; break; - case 0x8a: lh5801_rti(cpustate); cpustate->icount-=14; break; - case 0x8b: lh5801_branch_plus(cpustate,cpustate->t&Z); cpustate->icount-=8; break; - case 0x8c: lh5801_dca(cpustate,cpustate->program->read_byte(X)); cpustate->icount-=15; break; - case 0x8d: lh5801_branch_plus(cpustate,!(cpustate->t&V)); cpustate->icount-=8; break; - case 0x8e: lh5801_branch_plus(cpustate,1); cpustate->icount-=5; break; - case 0x8f: lh5801_branch_plus(cpustate,cpustate->t&V); cpustate->icount-=8; break; - case 0x90: lh5801_sbc(cpustate,YH); cpustate->icount-=6;break; - case 0x91: lh5801_branch_minus(cpustate,!(cpustate->t&C)); cpustate->icount-=8; break; - case 0x92: lh5801_adc(cpustate,YH); cpustate->icount-=6;break; - case 0x93: lh5801_branch_minus(cpustate,cpustate->t&C); cpustate->icount-=8; break; - case 0x94: lh5801_lda(cpustate,YH); cpustate->icount-=5;break; - case 0x95: lh5801_branch_minus(cpustate,!(cpustate->t&H)); cpustate->icount-=8; break; - case 0x96: lh5801_cpa(cpustate,cpustate->a, YH); cpustate->icount-=6;break; - case 0x97: lh5801_branch_minus(cpustate,cpustate->t&H); cpustate->icount-=8; break; - case 0x99: lh5801_branch_minus(cpustate,!(cpustate->t&Z)); cpustate->icount-=8; break; - case 0x9a: lh5801_rtn(cpustate); cpustate->icount-=11; break; - case 0x9b: lh5801_branch_minus(cpustate,cpustate->t&Z); cpustate->icount-=8; break; - case 0x9c: lh5801_dca(cpustate,cpustate->program->read_byte(Y)); cpustate->icount-=15; break; - case 0x9d: lh5801_branch_minus(cpustate,!(cpustate->t&V)); cpustate->icount-=8; break; - case 0x9e: lh5801_branch_minus(cpustate,1); cpustate->icount-=6; break; - case 0x9f: lh5801_branch_minus(cpustate,cpustate->t&V); cpustate->icount-=8; break; - case 0xa0: lh5801_sbc(cpustate,UH); cpustate->icount-=6;break; - case 0xa2: lh5801_adc(cpustate,UH); cpustate->icount-=6;break; - case 0xa1: lh5801_sbc(cpustate,cpustate->program->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=13;break; - case 0xa3: lh5801_adc(cpustate,cpustate->program->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=13;break; - case 0xa4: lh5801_lda(cpustate,UH); cpustate->icount-=5;break; - case 0xa5: lh5801_lda(cpustate,cpustate->program->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=12;break; - case 0xa6: lh5801_cpa(cpustate,cpustate->a, UH); cpustate->icount-=6;break; - case 0xa7: lh5801_cpa(cpustate,cpustate->a, cpustate->program->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=13;break; - case 0xa8: cpustate->pv=1;/*spv!*/ cpustate->icount-=4; break; - case 0xa9: lh5801_and(cpustate,cpustate->program->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=13;break; - case 0xaa: S=lh5801_readop_word(cpustate);cpustate->icount-=6;break; - case 0xab: lh5801_ora(cpustate,cpustate->program->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=13;break; - case 0xac: lh5801_dca(cpustate,cpustate->program->read_byte(U)); cpustate->icount-=15; break; - case 0xad: lh5801_eor(cpustate,cpustate->program->read_byte(lh5801_readop_word(cpustate))); cpustate->icount-=13;break; - case 0xae: cpustate->program->write_byte(lh5801_readop_word(cpustate),cpustate->a); cpustate->icount-=12;break; - case 0xaf: lh5801_bit(cpustate,cpustate->program->read_byte(lh5801_readop_word(cpustate)),cpustate->a); cpustate->icount-=13;break; - case 0xb1: lh5801_sbc(cpustate,cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=7;break; - case 0xb3: lh5801_adc(cpustate,cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=7;break; - case 0xb5: lh5801_lda(cpustate,cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=6;break; - case 0xb7: lh5801_cpa(cpustate,cpustate->a, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=7;break; - case 0xb8: cpustate->pv=0;/*rpv!*/ cpustate->icount-=4; break; - case 0xb9: lh5801_and(cpustate,cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=7;break; - case 0xba: lh5801_jmp(cpustate,lh5801_readop_word(cpustate)); cpustate->icount-=12;break; - case 0xbb: lh5801_ora(cpustate,cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=7;break; - case 0xbd: lh5801_eor(cpustate,cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=7;break; - case 0xbe: lh5801_sjp(cpustate); cpustate->icount-=19; break; - case 0xbf: lh5801_bit(cpustate,cpustate->a, cpustate->direct->read_decrypted_byte(P++));cpustate->icount-=7;break; - case 0xc1: lh5801_vector(cpustate,!(cpustate->t&C), cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=8;break; - case 0xc3: lh5801_vector(cpustate,cpustate->t&C, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=8;break; - case 0xc5: lh5801_vector(cpustate,!(cpustate->t&H), cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=8;break; - case 0xc7: lh5801_vector(cpustate,cpustate->t&H, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=8;break; - case 0xc9: lh5801_vector(cpustate,!(cpustate->t&Z), cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=8;break; - case 0xcb: lh5801_vector(cpustate,cpustate->t&Z, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=8;break; - case 0xcd: lh5801_vector(cpustate,1, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=7;break; - case 0xcf: lh5801_vector(cpustate,cpustate->t&V, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=8;break; - case 0xd1: lh5801_ror(cpustate); cpustate->icount-=6; break; - case 0xd3: lh5801_drr(cpustate, *cpustate->program, X); cpustate->icount-=12; break; - case 0xd5: lh5801_shr(cpustate); cpustate->icount-=6; break; - case 0xd7: lh5801_drl(cpustate, *cpustate->program, X); cpustate->icount-=12; break; - case 0xd9: lh5801_shl(cpustate); cpustate->icount-=6; break; - case 0xdb: lh5801_rol(cpustate); cpustate->icount-=6; break; - case 0xdd: lh5801_inc(cpustate,&cpustate->a);cpustate->icount-=5;break; - case 0xdf: lh5801_dec(cpustate,&cpustate->a);cpustate->icount-=5;break; - case 0xe1: cpustate->pu=1;/*spu!*/ cpustate->icount-=4; break; - case 0xe3: cpustate->pu=0;/*rpu!*/ cpustate->icount-=4; break; + case 0x00: lh5801_sbc(XL); m_icount-=6;break; + case 0x01: lh5801_sbc(m_program->read_byte(X)); m_icount-=7;break; + case 0x02: lh5801_adc(XL); m_icount-=6;break; + case 0x03: lh5801_adc(m_program->read_byte(X)); m_icount-=7;break; + case 0x04: lh5801_lda(XL); m_icount-=5;break; + case 0x05: lh5801_lda(m_program->read_byte(X)); m_icount-=6;break; + case 0x06: lh5801_cpa(m_a, XL); m_icount-=6;break; + case 0x07: lh5801_cpa(m_a, m_program->read_byte(X)); m_icount-=7;break; + case 0x08: XH=m_a; m_icount-=5; break; + case 0x09: lh5801_and(m_program->read_byte(X)); m_icount-=7;break; + case 0x0a: XL=m_a; m_icount-=5; break; + case 0x0b: lh5801_ora(m_program->read_byte(X)); m_icount-=7;break; + case 0x0c: lh5801_dcs(m_program->read_byte(X)); m_icount-=13; break; + case 0x0d: lh5801_eor(m_program->read_byte(X)); m_icount-=7;break; + case 0x0e: m_program->write_byte(X,m_a); m_icount-=6;break; + case 0x0f: lh5801_bit(m_program->read_byte(X),m_a); m_icount-=7;break; + case 0x10: lh5801_sbc(YL); m_icount-=6;break; + case 0x11: lh5801_sbc(m_program->read_byte(Y)); m_icount-=7;break; + case 0x12: lh5801_adc(YL); m_icount-=6;break; + case 0x13: lh5801_adc(m_program->read_byte(Y)); m_icount-=7;break; + case 0x14: lh5801_lda(YL); m_icount-=5;break; + case 0x15: lh5801_lda(m_program->read_byte(Y)); m_icount-=6;break; + case 0x16: lh5801_cpa(m_a, YL); m_icount-=6;break; + case 0x17: lh5801_cpa(m_a, m_program->read_byte(Y)); m_icount-=7;break; + case 0x18: YH=m_a; m_icount-=5; break; + case 0x19: lh5801_and(m_program->read_byte(Y)); m_icount-=7;break; + case 0x1a: YL=m_a; m_icount-=5; break; + case 0x1b: lh5801_ora(m_program->read_byte(Y)); m_icount-=7;break; + case 0x1c: lh5801_dcs(m_program->read_byte(Y)); m_icount-=13; break; + case 0x1d: lh5801_eor(m_program->read_byte(Y)); m_icount-=7;break; + case 0x1e: m_program->write_byte(Y,m_a); m_icount-=6;break; + case 0x1f: lh5801_bit(m_program->read_byte(Y),m_a); m_icount-=7;break; + case 0x20: lh5801_sbc(UL); m_icount-=6;break; + case 0x21: lh5801_sbc(m_program->read_byte(U)); m_icount-=7;break; + case 0x22: lh5801_adc(UL); m_icount-=6;break; + case 0x23: lh5801_adc(m_program->read_byte(U)); m_icount-=7;break; + case 0x24: lh5801_lda(UL); m_icount-=5;break; + case 0x25: lh5801_lda(m_program->read_byte(U)); m_icount-=6;break; + case 0x26: lh5801_cpa(m_a, UL); m_icount-=6;break; + case 0x27: lh5801_cpa(m_a, m_program->read_byte(U)); m_icount-=7;break; + case 0x28: UH=m_a; m_icount-=5; break; + case 0x29: lh5801_and(m_program->read_byte(U)); m_icount-=7;break; + case 0x2a: UL=m_a; m_icount-=5; break; + case 0x2b: lh5801_ora(m_program->read_byte(U)); m_icount-=7;break; + case 0x2c: lh5801_dcs(m_program->read_byte(U)); m_icount-=13; break; + case 0x2d: lh5801_eor(m_program->read_byte(U)); m_icount-=7;break; + case 0x2e: m_program->write_byte(U,m_a); m_icount-=6;break; + case 0x2f: lh5801_bit(m_program->read_byte(U),m_a); m_icount-=7;break; + case 0x38: /*nop*/m_icount-=5;break; + case 0x40: lh5801_inc(&XL);m_icount-=5;break; + case 0x41: lh5801_sin(&m_x); m_icount-=6;break; + case 0x42: lh5801_dec(&XL);m_icount-=5;break; + case 0x43: lh5801_sde(&m_x); m_icount-=6;break; + case 0x44: X++;m_icount-=5;break; + case 0x45: lh5801_lin(&m_x);m_icount-=6;break; + case 0x46: X--;m_icount-=5;break; + case 0x47: lh5801_lde(&m_x);m_icount-=6;break; + case 0x48: XH=m_direct->read_decrypted_byte(P++);m_icount-=6;break; + case 0x49: lh5801_and_mem(*m_program, X, m_direct->read_decrypted_byte(P++)); m_icount-=13;break; + case 0x4a: XL=m_direct->read_decrypted_byte(P++);m_icount-=6;break; + case 0x4b: lh5801_ora_mem(*m_program, X, m_direct->read_decrypted_byte(P++)); m_icount-=13;break; + case 0x4c: lh5801_cpa(XH, m_direct->read_decrypted_byte(P++)); m_icount-=7;break; + case 0x4d: lh5801_bit(m_program->read_byte(X), m_direct->read_decrypted_byte(P++));m_icount-=10;break; + case 0x4e: lh5801_cpa(XL, m_direct->read_decrypted_byte(P++)); m_icount-=7;break; + case 0x4f: lh5801_add_mem(*m_program, X, m_direct->read_decrypted_byte(P++)); m_icount-=13;break; + case 0x50: lh5801_inc(&YL);m_icount-=5;break; + case 0x51: lh5801_sin(&m_y); m_icount-=6;break; + case 0x52: lh5801_dec(&YL);m_icount-=5;break; + case 0x53: lh5801_sde(&m_y); m_icount-=6;break; + case 0x54: Y++;m_icount-=5;break; + case 0x55: lh5801_lin(&m_y);m_icount-=6;break; + case 0x56: Y--;m_icount-=5;break; + case 0x57: lh5801_lde(&m_y);m_icount-=6;break; + case 0x58: YH=m_direct->read_decrypted_byte(P++);m_icount-=6;break; + case 0x59: lh5801_and_mem(*m_program, Y, m_direct->read_decrypted_byte(P++)); m_icount-=13;break; + case 0x5a: YL=m_direct->read_decrypted_byte(P++);m_icount-=6;break; + case 0x5b: lh5801_ora_mem(*m_program, Y, m_direct->read_decrypted_byte(P++)); m_icount-=13;break; + case 0x5c: lh5801_cpa(YH, m_direct->read_decrypted_byte(P++)); m_icount-=7;break; + case 0x5d: lh5801_bit(m_program->read_byte(Y), m_direct->read_decrypted_byte(P++));m_icount-=10;break; + case 0x5e: lh5801_cpa(YL, m_direct->read_decrypted_byte(P++)); m_icount-=7;break; + case 0x5f: lh5801_add_mem(*m_program, Y, m_direct->read_decrypted_byte(P++)); m_icount-=13;break; + case 0x60: lh5801_inc(&UL);m_icount-=5;break; + case 0x61: lh5801_sin(&m_u); m_icount-=6;break; + case 0x62: lh5801_dec(&UL);m_icount-=5;break; + case 0x63: lh5801_sde(&m_u); m_icount-=6;break; + case 0x64: U++;m_icount-=5;break; + case 0x65: lh5801_lin(&m_u);m_icount-=6;break; + case 0x66: U--;m_icount-=5;break; + case 0x67: lh5801_lde(&m_u);m_icount-=6;break; + case 0x68: UH=m_direct->read_decrypted_byte(P++);m_icount-=6;break; + case 0x69: lh5801_and_mem(*m_program, U, m_direct->read_decrypted_byte(P++)); m_icount-=13;break; + case 0x6a: UL=m_direct->read_decrypted_byte(P++);m_icount-=6;break; + case 0x6b: lh5801_ora_mem(*m_program, U, m_direct->read_decrypted_byte(P++)); m_icount-=13;break; + case 0x6c: lh5801_cpa(UH, m_direct->read_decrypted_byte(P++)); m_icount-=7;break; + case 0x6d: lh5801_bit(m_program->read_byte(U), m_direct->read_decrypted_byte(P++));m_icount-=10;break; + case 0x6e: lh5801_cpa(UL, m_direct->read_decrypted_byte(P++)); m_icount-=7;break; + case 0x6f: lh5801_add_mem(*m_program, U, m_direct->read_decrypted_byte(P++)); m_icount-=13;break; + case 0x80: lh5801_sbc(XH); m_icount-=6;break; + case 0x81: lh5801_branch_plus(!(m_t&C)); m_icount-=8; break; + case 0x82: lh5801_adc(XH); m_icount-=6;break; + case 0x83: lh5801_branch_plus(m_t&C); m_icount-=8; break; + case 0x84: lh5801_lda(XH); m_icount-=5;break; + case 0x85: lh5801_branch_plus(!(m_t&H)); m_icount-=8; break; + case 0x86: lh5801_cpa(m_a, XH); m_icount-=6;break; + case 0x87: lh5801_branch_plus(m_t&H); m_icount-=8; break; + case 0x88: lh5801_lop(); break; + case 0x89: lh5801_branch_plus(!(m_t&Z)); m_icount-=8; break; + case 0x8a: lh5801_rti(); m_icount-=14; break; + case 0x8b: lh5801_branch_plus(m_t&Z); m_icount-=8; break; + case 0x8c: lh5801_dca(m_program->read_byte(X)); m_icount-=15; break; + case 0x8d: lh5801_branch_plus(!(m_t&V)); m_icount-=8; break; + case 0x8e: lh5801_branch_plus(1); m_icount-=5; break; + case 0x8f: lh5801_branch_plus(m_t&V); m_icount-=8; break; + case 0x90: lh5801_sbc(YH); m_icount-=6;break; + case 0x91: lh5801_branch_minus(!(m_t&C)); m_icount-=8; break; + case 0x92: lh5801_adc(YH); m_icount-=6;break; + case 0x93: lh5801_branch_minus(m_t&C); m_icount-=8; break; + case 0x94: lh5801_lda(YH); m_icount-=5;break; + case 0x95: lh5801_branch_minus(!(m_t&H)); m_icount-=8; break; + case 0x96: lh5801_cpa(m_a, YH); m_icount-=6;break; + case 0x97: lh5801_branch_minus(m_t&H); m_icount-=8; break; + case 0x99: lh5801_branch_minus(!(m_t&Z)); m_icount-=8; break; + case 0x9a: lh5801_rtn(); m_icount-=11; break; + case 0x9b: lh5801_branch_minus(m_t&Z); m_icount-=8; break; + case 0x9c: lh5801_dca(m_program->read_byte(Y)); m_icount-=15; break; + case 0x9d: lh5801_branch_minus(!(m_t&V)); m_icount-=8; break; + case 0x9e: lh5801_branch_minus(1); m_icount-=6; break; + case 0x9f: lh5801_branch_minus(m_t&V); m_icount-=8; break; + case 0xa0: lh5801_sbc(UH); m_icount-=6;break; + case 0xa2: lh5801_adc(UH); m_icount-=6;break; + case 0xa1: lh5801_sbc(m_program->read_byte(lh5801_readop_word())); m_icount-=13;break; + case 0xa3: lh5801_adc(m_program->read_byte(lh5801_readop_word())); m_icount-=13;break; + case 0xa4: lh5801_lda(UH); m_icount-=5;break; + case 0xa5: lh5801_lda(m_program->read_byte(lh5801_readop_word())); m_icount-=12;break; + case 0xa6: lh5801_cpa(m_a, UH); m_icount-=6;break; + case 0xa7: lh5801_cpa(m_a, m_program->read_byte(lh5801_readop_word())); m_icount-=13;break; + case 0xa8: m_pv=1;/*spv!*/ m_icount-=4; break; + case 0xa9: lh5801_and(m_program->read_byte(lh5801_readop_word())); m_icount-=13;break; + case 0xaa: S=lh5801_readop_word();m_icount-=6;break; + case 0xab: lh5801_ora(m_program->read_byte(lh5801_readop_word())); m_icount-=13;break; + case 0xac: lh5801_dca(m_program->read_byte(U)); m_icount-=15; break; + case 0xad: lh5801_eor(m_program->read_byte(lh5801_readop_word())); m_icount-=13;break; + case 0xae: m_program->write_byte(lh5801_readop_word(),m_a); m_icount-=12;break; + case 0xaf: lh5801_bit(m_program->read_byte(lh5801_readop_word()),m_a); m_icount-=13;break; + case 0xb1: lh5801_sbc(m_direct->read_decrypted_byte(P++)); m_icount-=7;break; + case 0xb3: lh5801_adc(m_direct->read_decrypted_byte(P++)); m_icount-=7;break; + case 0xb5: lh5801_lda(m_direct->read_decrypted_byte(P++)); m_icount-=6;break; + case 0xb7: lh5801_cpa(m_a, m_direct->read_decrypted_byte(P++)); m_icount-=7;break; + case 0xb8: m_pv=0;/*rpv!*/ m_icount-=4; break; + case 0xb9: lh5801_and(m_direct->read_decrypted_byte(P++)); m_icount-=7;break; + case 0xba: lh5801_jmp(lh5801_readop_word()); m_icount-=12;break; + case 0xbb: lh5801_ora(m_direct->read_decrypted_byte(P++)); m_icount-=7;break; + case 0xbd: lh5801_eor(m_direct->read_decrypted_byte(P++)); m_icount-=7;break; + case 0xbe: lh5801_sjp(); m_icount-=19; break; + case 0xbf: lh5801_bit(m_a, m_direct->read_decrypted_byte(P++));m_icount-=7;break; + case 0xc1: lh5801_vector(!(m_t&C), m_direct->read_decrypted_byte(P++)); m_icount-=8;break; + case 0xc3: lh5801_vector(m_t&C, m_direct->read_decrypted_byte(P++)); m_icount-=8;break; + case 0xc5: lh5801_vector(!(m_t&H), m_direct->read_decrypted_byte(P++)); m_icount-=8;break; + case 0xc7: lh5801_vector(m_t&H, m_direct->read_decrypted_byte(P++)); m_icount-=8;break; + case 0xc9: lh5801_vector(!(m_t&Z), m_direct->read_decrypted_byte(P++)); m_icount-=8;break; + case 0xcb: lh5801_vector(m_t&Z, m_direct->read_decrypted_byte(P++)); m_icount-=8;break; + case 0xcd: lh5801_vector(1, m_direct->read_decrypted_byte(P++)); m_icount-=7;break; + case 0xcf: lh5801_vector(m_t&V, m_direct->read_decrypted_byte(P++)); m_icount-=8;break; + case 0xd1: lh5801_ror(); m_icount-=6; break; + case 0xd3: lh5801_drr(*m_program, X); m_icount-=12; break; + case 0xd5: lh5801_shr(); m_icount-=6; break; + case 0xd7: lh5801_drl(*m_program, X); m_icount-=12; break; + case 0xd9: lh5801_shl(); m_icount-=6; break; + case 0xdb: lh5801_rol(); m_icount-=6; break; + case 0xdd: lh5801_inc(&m_a);m_icount-=5;break; + case 0xdf: lh5801_dec(&m_a);m_icount-=5;break; + case 0xe1: m_pu=1;/*spu!*/ m_icount-=4; break; + case 0xe3: m_pu=0;/*rpu!*/ m_icount-=4; break; case 0xe9: - adr=lh5801_readop_word(cpustate);lh5801_and_mem(cpustate, *cpustate->program, adr, cpustate->direct->read_decrypted_byte(P++)); - cpustate->icount-=19;break; + adr=lh5801_readop_word();lh5801_and_mem(*m_program, adr, m_direct->read_decrypted_byte(P++)); + m_icount-=19;break; case 0xeb: - adr=lh5801_readop_word(cpustate);lh5801_ora_mem(cpustate, *cpustate->program, adr, cpustate->direct->read_decrypted_byte(P++)); - cpustate->icount-=19;break; + adr=lh5801_readop_word();lh5801_ora_mem(*m_program, adr, m_direct->read_decrypted_byte(P++)); + m_icount-=19;break; case 0xed: - adr=lh5801_readop_word(cpustate);lh5801_bit(cpustate,cpustate->program->read_byte(adr), cpustate->direct->read_decrypted_byte(P++)); - cpustate->icount-=16;break; + adr=lh5801_readop_word();lh5801_bit(m_program->read_byte(adr), m_direct->read_decrypted_byte(P++)); + m_icount-=16;break; case 0xef: - adr=lh5801_readop_word(cpustate); - lh5801_add_mem(cpustate, *cpustate->program, adr, cpustate->direct->read_decrypted_byte(P++)); cpustate->icount-=19; + adr=lh5801_readop_word(); + lh5801_add_mem(*m_program, adr, m_direct->read_decrypted_byte(P++)); m_icount-=19; break; - case 0xf1: lh5801_aex(cpustate); cpustate->icount-=6; break; - case 0xf5: cpustate->program->write_byte(Y++, cpustate->program->read_byte(X++)); cpustate->icount-=7; break; //tin - case 0xf7: lh5801_cpa(cpustate,cpustate->a, cpustate->program->read_byte(X++));cpustate->icount-=7; break; //cin - case 0xf9: cpustate->t&=~C;cpustate->icount-=4;break; - case 0xfb: cpustate->t|=C;cpustate->icount-=4;break; - case 0xfd: lh5801_instruction_fd(cpustate);break; + case 0xf1: lh5801_aex(); m_icount-=6; break; + case 0xf5: m_program->write_byte(Y++, m_program->read_byte(X++)); m_icount-=7; break; //tin + case 0xf7: lh5801_cpa(m_a, m_program->read_byte(X++));m_icount-=7; break; //cin + case 0xf9: m_t&=~C;m_icount-=4;break; + case 0xfb: m_t|=C;m_icount-=4;break; + case 0xfd: lh5801_instruction_fd();break; case 0xc0: case 0xc2: case 0xc4: case 0xc6: case 0xc8: case 0xca: case 0xcc: case 0xce: case 0xd0: case 0xd2: case 0xd4: case 0xd6: @@ -683,7 +679,7 @@ static void lh5801_instruction(lh5801_state *cpustate) case 0xe0: case 0xe2: case 0xe4: case 0xe6: case 0xe8: case 0xea: case 0xec: case 0xee: case 0xf0: case 0xf2: case 0xf4: case 0xf6: - lh5801_vector(cpustate,1, oper);cpustate->icount-=4;break; + lh5801_vector(1, oper);m_icount-=4;break; default: logerror("lh5801 illegal opcode at %.4x %.2x\n",P-1, oper); } diff --git a/src/emu/cpu/lh5801/lh5801.c b/src/emu/cpu/lh5801/lh5801.c index febcc7fe05b..5c2151dbc87 100644 --- a/src/emu/cpu/lh5801/lh5801.c +++ b/src/emu/cpu/lh5801/lh5801.c @@ -54,50 +54,18 @@ enum LH5801_IRQ_STATE }; -struct lh5801_state -{ - const lh5801_cpu_core *config; - legacy_cpu_device *device; - address_space *program; //ME0 - address_space *io; //ME1 - direct_read_data *direct; - PAIR s, p, u, x, y; - int tm; //9 bit - - UINT8 t, a; - - int bf, dp, pu, pv; - - UINT16 oldpc; - - int irq_state; - - UINT8 ir_flipflop[3]; //interrupt request flipflop: IR0, IR1, IR2 - int lines_status[2]; //MI and NMI lines status - - int idle; - int icount; -}; - -INLINE lh5801_state *get_safe_token(device_t *device) -{ - assert(device != NULL); - assert(device->type() == LH5801); - return (lh5801_state *)downcast(device)->token(); -} - -#define P cpustate->p.w.l -#define S cpustate->s.w.l -#define U cpustate->u.w.l -#define UL cpustate->u.b.l -#define UH cpustate->u.b.h -#define X cpustate->x.w.l -#define XL cpustate->x.b.l -#define XH cpustate->x.b.h -#define Y cpustate->y.w.l -#define YL cpustate->y.b.l -#define YH cpustate->y.b.h +#define P m_p.w.l +#define S m_s.w.l +#define U m_u.w.l +#define UL m_u.b.l +#define UH m_u.b.h +#define X m_x.w.l +#define XL m_x.b.l +#define XH m_x.b.h +#define Y m_y.w.l +#define YL m_y.b.l +#define YH m_y.b.h #define C 0x01 #define IE 0x02 @@ -105,243 +73,195 @@ INLINE lh5801_state *get_safe_token(device_t *device) #define V 0x08 #define H 0x10 + +const device_type LH5801 = &device_creator; + + +lh5801_cpu_device::lh5801_cpu_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock) + : cpu_device(mconfig, LH5801, "LH5801", tag, owner, clock, "lh5801", __FILE__) + , m_program_config("program", ENDIANNESS_LITTLE, 8, 16, 0) + , m_io_config("io", ENDIANNESS_LITTLE, 8, 16, 0) + , m_in_func(*this) +{ +} + + /*************************************************************** * include the opcode macros, functions and tables ***************************************************************/ #include "5801tbl.c" -static CPU_INIT( lh5801 ) +void lh5801_cpu_device::device_start() { - lh5801_state *cpustate = get_safe_token(device); + m_program = &space(AS_PROGRAM); + m_io = &space(AS_IO); + m_direct = &m_program->direct(); - memset(cpustate, 0, sizeof(*cpustate)); - cpustate->config = (const lh5801_cpu_core *) device->static_config(); - cpustate->device = device; - cpustate->program = &device->space(AS_PROGRAM); - cpustate->io = &device->space(AS_IO); - cpustate->direct = &cpustate->program->direct(); + m_in_func.resolve_safe(0); + + m_s.w.l = 0; + m_p.w.l = 0; + m_u.w.l = 0; + m_x.w.l = 0; + m_y.w.l = 0; + m_tm = 0; + m_t = 0; + m_a = 0; + m_bf = 0; + m_dp = 0; + m_pu = 0; + m_pv = 0; + m_oldpc = 0; + m_irq_state = 0; + memset(m_ir_flipflop, 0, sizeof(m_ir_flipflop)); + memset(m_lines_status, 0, sizeof(m_lines_status)); + m_idle = 0; + + save_item(NAME(m_s.w.l)); + save_item(NAME(m_p.w.l)); + save_item(NAME(m_u.w.l)); + save_item(NAME(m_x.w.l)); + save_item(NAME(m_y.w.l)); + save_item(NAME(m_tm)); + save_item(NAME(m_t)); + save_item(NAME(m_a)); + save_item(NAME(m_bf)); + save_item(NAME(m_dp)); + save_item(NAME(m_pu)); + save_item(NAME(m_pv)); + save_item(NAME(m_oldpc)); + save_item(NAME(m_irq_state)); + save_item(NAME(m_ir_flipflop)); + save_item(NAME(m_lines_status)); + save_item(NAME(m_idle)); + + state_add( LH5801_P, "P", m_p.w.l ).formatstr("%04X"); + state_add( LH5801_S, "S", m_s.w.l ).formatstr("%04X"); + state_add( LH5801_U, "U", m_u.w.l ).formatstr("%04X"); + state_add( LH5801_X, "X", m_x.w.l ).formatstr("%04X"); + state_add( LH5801_Y, "Y", m_y.w.l ).formatstr("%04X"); + state_add( LH5801_T, "T", m_t ).formatstr("%02X"); + state_add( LH5801_A, "A", m_a ).formatstr("%02X"); + state_add( LH5801_TM, "TM", m_tm ).formatstr("%03X"); + state_add( LH5801_PV, "PV", m_pv ).formatstr("%04X"); + state_add( LH5801_PU, "PU", m_pu ).formatstr("%04X"); + state_add( LH5801_BF, "BF", m_bf ).formatstr("%04X"); + state_add( LH5801_DP, "DP", m_dp ).formatstr("%04X"); + + state_add(STATE_GENPC, "GENPC", m_p.w.l).noshow(); + state_add(STATE_GENFLAGS, "GENFLAGS", m_t).noshow().formatstr("%8s"); + + m_icountptr = &m_icount; } -static CPU_RESET( lh5801 ) +void lh5801_cpu_device::state_string_export(const device_state_entry &entry, astring &string) { - lh5801_state *cpustate = get_safe_token(device); + switch (entry.index()) + { + case STATE_GENFLAGS: + string.printf("%c%c%c%c%c%c%c%c", + m_t&0x80?'1':'0', + m_t&0x40?'1':'0', + m_t&0x20?'1':'0', + m_t&0x10?'H':'.', + m_t&0x08?'V':'.', + m_t&0x04?'Z':'.', + m_t&0x02?'I':'.', + m_t&0x01?'C':'.'); + break; + } +} - P = (cpustate->program->read_byte(0xfffe)<<8) | cpustate->program->read_byte(0xffff); +void lh5801_cpu_device::device_reset() +{ + P = (m_program->read_byte(0xfffe)<<8) | m_program->read_byte(0xffff); - cpustate->idle=0; + m_idle=0; - memset(cpustate->ir_flipflop, 0, sizeof(cpustate->ir_flipflop)); - memset(cpustate->lines_status, 0, sizeof(cpustate->lines_status)); + memset(m_ir_flipflop, 0, sizeof(m_ir_flipflop)); + memset(m_lines_status, 0, sizeof(m_lines_status)); } -static void check_irq(device_t *device) +void lh5801_cpu_device::check_irq() { - lh5801_state *cpustate = get_safe_token(device); - - if (cpustate->ir_flipflop[0]) + if (m_ir_flipflop[0]) { //NMI interrupt - cpustate->ir_flipflop[0] = 0; - lh5801_push(cpustate,cpustate->t); - cpustate->t&=~IE; - lh5801_push_word(cpustate,P); - P = (cpustate->program->read_byte(0xfffc)<<8) | cpustate->program->read_byte(0xfffd); + m_ir_flipflop[0] = 0; + lh5801_push(m_t); + m_t&=~IE; + lh5801_push_word(P); + P = (m_program->read_byte(0xfffc)<<8) | m_program->read_byte(0xfffd); } - else if (cpustate->ir_flipflop[1] && (cpustate->t & IE)) + else if (m_ir_flipflop[1] && (m_t & IE)) { //counter interrupt (counter not yet implemented) - cpustate->ir_flipflop[1] = 0; - lh5801_push(cpustate,cpustate->t); - cpustate->t&=~IE; - lh5801_push_word(cpustate,P); - P = (cpustate->program->read_byte(0xfffa)<<8) | cpustate->program->read_byte(0xfffb); + m_ir_flipflop[1] = 0; + lh5801_push(m_t); + m_t&=~IE; + lh5801_push_word(P); + P = (m_program->read_byte(0xfffa)<<8) | m_program->read_byte(0xfffb); } - else if (cpustate->ir_flipflop[2] && (cpustate->t & IE)) + else if (m_ir_flipflop[2] && (m_t & IE)) { //MI interrupt - cpustate->ir_flipflop[2] = 0; - lh5801_push(cpustate, cpustate->t); - cpustate->t&=~IE; - lh5801_push_word(cpustate, P); - P = (cpustate->program->read_byte(0xfff8)<<8) | cpustate->program->read_byte(0xfff9); + m_ir_flipflop[2] = 0; + lh5801_push(m_t); + m_t&=~IE; + lh5801_push_word(P); + P = (m_program->read_byte(0xfff8)<<8) | m_program->read_byte(0xfff9); } } -static CPU_EXECUTE( lh5801 ) +void lh5801_cpu_device::execute_run() { - lh5801_state *cpustate = get_safe_token(device); - do { - check_irq(device); + check_irq(); - if (cpustate->idle) - cpustate->icount = 0; + if (m_idle) + m_icount = 0; else { - cpustate->oldpc = P; + m_oldpc = P; - debugger_instruction_hook(device, P); - lh5801_instruction(cpustate); + debugger_instruction_hook(this, P); + lh5801_instruction(); } - } while (cpustate->icount > 0); + } while (m_icount > 0); } -static void set_irq_line(lh5801_state *cpustate, int irqline, int state) +void lh5801_cpu_device::execute_set_input(int irqline, int state) { switch( irqline) { case LH5801_LINE_MI: - if (cpustate->lines_status[0] == CLEAR_LINE && state == ASSERT_LINE) + if (m_lines_status[0] == CLEAR_LINE && state == ASSERT_LINE) { - cpustate->idle = 0; - cpustate->ir_flipflop[2] = 1; + m_idle = 0; + m_ir_flipflop[2] = 1; } - cpustate->lines_status[0] = state; + m_lines_status[0] = state; break; case INPUT_LINE_NMI: - if (cpustate->lines_status[1] == CLEAR_LINE && state == ASSERT_LINE) + if (m_lines_status[1] == CLEAR_LINE && state == ASSERT_LINE) { - cpustate->idle = 0; - cpustate->ir_flipflop[0] = 1; + m_idle = 0; + m_ir_flipflop[0] = 1; } - cpustate->lines_status[1] = state; + m_lines_status[1] = state; break; } } - - -/************************************************************************** - * Generic set_info - **************************************************************************/ - -static CPU_SET_INFO( lh5801 ) +offs_t lh5801_cpu_device::disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) { - lh5801_state *cpustate = get_safe_token(device); - switch (state) - { - /* --- the following bits of info are set as 64-bit signed integers --- */ - case CPUINFO_INT_INPUT_STATE + LH5801_LINE_MI: set_irq_line(cpustate, LH5801_LINE_MI, info->i); break; - case CPUINFO_INT_INPUT_STATE + INPUT_LINE_NMI: set_irq_line(cpustate, INPUT_LINE_NMI, info->i); break; - - case CPUINFO_INT_PC: - case CPUINFO_INT_REGISTER + LH5801_P: P = info->i; break; - case CPUINFO_INT_SP: - case CPUINFO_INT_REGISTER + LH5801_S: S = info->i; break; - case CPUINFO_INT_REGISTER + LH5801_U: U = info->i; break; - case CPUINFO_INT_REGISTER + LH5801_X: X = info->i; break; - case CPUINFO_INT_REGISTER + LH5801_Y: Y = info->i; break; - case CPUINFO_INT_REGISTER + LH5801_T: cpustate->t = info->i; break; - case CPUINFO_INT_REGISTER + LH5801_TM: cpustate->tm = info->i; break; - case CPUINFO_INT_REGISTER + LH5801_BF: cpustate->bf = info->i; break; - case CPUINFO_INT_REGISTER + LH5801_PV: cpustate->pv = info->i; break; - case CPUINFO_INT_REGISTER + LH5801_PU: cpustate->pu = info->i; break; - case CPUINFO_INT_REGISTER + LH5801_DP: cpustate->dp = info->i; break; - } + extern CPU_DISASSEMBLE( lh5801 ); + return CPU_DISASSEMBLE_NAME(lh5801)(this, buffer, pc, oprom, opram, options); } - - -/************************************************************************** - * Generic get_info - **************************************************************************/ - -CPU_GET_INFO( lh5801 ) -{ - lh5801_state *cpustate = (device != NULL && device->token() != NULL) ? get_safe_token(device) : NULL; - - switch (state) - { - /* --- the following bits of info are returned as 64-bit signed integers --- */ - case CPUINFO_INT_CONTEXT_SIZE: info->i = sizeof(lh5801_state); break; - case CPUINFO_INT_INPUT_LINES: info->i = 2; break; - case CPUINFO_INT_DEFAULT_IRQ_VECTOR: info->i = 0; break; - case CPUINFO_INT_ENDIANNESS: info->i = ENDIANNESS_LITTLE; break; - case CPUINFO_INT_CLOCK_MULTIPLIER: info->i = 1; break; - case CPUINFO_INT_CLOCK_DIVIDER: info->i = 1; break; - case CPUINFO_INT_MIN_INSTRUCTION_BYTES: info->i = 1; break; - case CPUINFO_INT_MAX_INSTRUCTION_BYTES: info->i = 5; break; - case CPUINFO_INT_MIN_CYCLES: info->i = 2; break; - case CPUINFO_INT_MAX_CYCLES: info->i = 19; break; - - case CPUINFO_INT_DATABUS_WIDTH + AS_PROGRAM: info->i = 8; break; - case CPUINFO_INT_ADDRBUS_WIDTH + AS_PROGRAM: info->i = 16; break; - case CPUINFO_INT_ADDRBUS_SHIFT + AS_PROGRAM: info->i = 0; break; - case CPUINFO_INT_DATABUS_WIDTH + AS_DATA: info->i = 0; break; - case CPUINFO_INT_ADDRBUS_WIDTH + AS_DATA: info->i = 0; break; - case CPUINFO_INT_ADDRBUS_SHIFT + AS_DATA: info->i = 0; break; - case CPUINFO_INT_DATABUS_WIDTH + AS_IO: info->i = 8; break; - case CPUINFO_INT_ADDRBUS_WIDTH + AS_IO: info->i = 16; break; - case CPUINFO_INT_ADDRBUS_SHIFT + AS_IO: info->i = 0; break; - - case CPUINFO_INT_INPUT_STATE: info->i = cpustate->irq_state; break; - - case CPUINFO_INT_PREVIOUSPC: info->i = cpustate->oldpc; break; - - case CPUINFO_INT_PC: - case CPUINFO_INT_REGISTER + LH5801_P: info->i = P; break; - case CPUINFO_INT_SP: - case CPUINFO_INT_REGISTER + LH5801_S: info->i = S; break; - case CPUINFO_INT_REGISTER + LH5801_U: info->i = U; break; - case CPUINFO_INT_REGISTER + LH5801_X: info->i = X; break; - case CPUINFO_INT_REGISTER + LH5801_Y: info->i = Y; break; - case CPUINFO_INT_REGISTER + LH5801_T: info->i = cpustate->t; break; - case CPUINFO_INT_REGISTER + LH5801_TM: info->i = cpustate->tm; break; - case CPUINFO_INT_REGISTER + LH5801_IN: info->i = cpustate->config->in(device); break; - case CPUINFO_INT_REGISTER + LH5801_BF: info->i = cpustate->bf; break; - case CPUINFO_INT_REGISTER + LH5801_PV: info->i = cpustate->pv; break; - case CPUINFO_INT_REGISTER + LH5801_PU: info->i = cpustate->pu; break; - case CPUINFO_INT_REGISTER + LH5801_DP: info->i = cpustate->dp; break; - - /* --- the following bits of info are returned as pointers to data or functions --- */ - case CPUINFO_FCT_SET_INFO: info->setinfo = CPU_SET_INFO_NAME(lh5801); break; - case CPUINFO_FCT_INIT: info->init = CPU_INIT_NAME(lh5801); break; - case CPUINFO_FCT_RESET: info->reset = CPU_RESET_NAME(lh5801); break; - case CPUINFO_FCT_EXIT: info->exit = NULL; break; - case CPUINFO_FCT_EXECUTE: info->execute = CPU_EXECUTE_NAME(lh5801); break; - case CPUINFO_FCT_BURN: info->burn = NULL; break; - case CPUINFO_FCT_DISASSEMBLE: info->disassemble = CPU_DISASSEMBLE_NAME(lh5801); break; - case CPUINFO_PTR_INSTRUCTION_COUNTER: info->icount = &cpustate->icount; break; - - /* --- the following bits of info are returned as NULL-terminated strings --- */ - case CPUINFO_STR_NAME: strcpy(info->s, "LH5801"); break; - case CPUINFO_STR_FAMILY: strcpy(info->s, "LH5801"); break; - case CPUINFO_STR_VERSION: strcpy(info->s, "1.0alpha"); break; - case CPUINFO_STR_SOURCE_FILE: strcpy(info->s, __FILE__); break; - case CPUINFO_STR_CREDITS: strcpy(info->s, "Copyright Peter Trauner, all rights reserved."); break; - - case CPUINFO_STR_FLAGS: - sprintf(info->s, "%s%s%s%s%s%s%s%s", - cpustate->t&0x80?"1":"0", - cpustate->t&0x40?"1":"0", - cpustate->t&0x20?"1":"0", - cpustate->t&0x10?"H":".", - cpustate->t&8?"V":".", - cpustate->t&4?"Z":".", - cpustate->t&2?"I":".", - cpustate->t&1?"C":"."); - break; - - case CPUINFO_STR_REGISTER + LH5801_P: sprintf(info->s, "P:%04X", cpustate->p.w.l); break; - case CPUINFO_STR_REGISTER + LH5801_S: sprintf(info->s, "S:%04X", cpustate->s.w.l); break; - case CPUINFO_STR_REGISTER + LH5801_U: sprintf(info->s, "U:%04X", cpustate->u.w.l); break; - case CPUINFO_STR_REGISTER + LH5801_X: sprintf(info->s, "X:%04X", cpustate->x.w.l); break; - case CPUINFO_STR_REGISTER + LH5801_Y: sprintf(info->s, "Y:%04X", cpustate->y.w.l); break; - case CPUINFO_STR_REGISTER + LH5801_T: sprintf(info->s, "T:%02X", cpustate->t); break; - case CPUINFO_STR_REGISTER + LH5801_A: sprintf(info->s, "A:%02X", cpustate->a); break; - case CPUINFO_STR_REGISTER + LH5801_TM: sprintf(info->s, "TM:%03X", cpustate->tm); break; - case CPUINFO_STR_REGISTER + LH5801_IN: sprintf(info->s, "IN:%02X", cpustate->config->in(device)); break; - case CPUINFO_STR_REGISTER + LH5801_PV: sprintf(info->s, "PV:%04X", cpustate->pv); break; - case CPUINFO_STR_REGISTER + LH5801_PU: sprintf(info->s, "PU:%04X", cpustate->pu); break; - case CPUINFO_STR_REGISTER + LH5801_BF: sprintf(info->s, "BF:%04X", cpustate->bf); break; - case CPUINFO_STR_REGISTER + LH5801_DP: sprintf(info->s, "DP:%04X", cpustate->dp); break; - } -} - -DEFINE_LEGACY_CPU_DEVICE(LH5801, lh5801); diff --git a/src/emu/cpu/lh5801/lh5801.h b/src/emu/cpu/lh5801/lh5801.h index 4501f41381d..34ae0b4d50b 100644 --- a/src/emu/cpu/lh5801/lh5801.h +++ b/src/emu/cpu/lh5801/lh5801.h @@ -64,21 +64,136 @@ pc 8bit */ - -typedef UINT8 (*lh5801_in_func)(device_t *device); - -struct lh5801_cpu_core -{ - lh5801_in_func in; -}; - // input lines enum { LH5801_LINE_MI, //maskable interrupt }; -DECLARE_LEGACY_CPU_DEVICE(LH5801, lh5801); -extern CPU_DISASSEMBLE( lh5801 ); + +#define MCFG_LH5801_IN(_devcb) \ + lh5801_cpu_device::set_in_func(*device, DEVCB2_##_devcb); + + +class lh5801_cpu_device : public cpu_device +{ +public: + // construction/destruction + lh5801_cpu_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock); + + // static configuration helpers + template static devcb2_base &set_in_func(device_t &device, _Object object) { return downcast(device).m_in_func.set_callback(object); } + +protected: + // device-level overrides + virtual void device_start(); + virtual void device_reset(); + + // device_execute_interface overrides + virtual UINT32 execute_min_cycles() const { return 2; } + virtual UINT32 execute_max_cycles() const { return 19; } + virtual UINT32 execute_input_lines() const { return 2; } + virtual UINT32 execute_default_irq_vector() const { return 0; } + virtual void execute_run(); + virtual void execute_set_input(int inputnum, int state); + + // device_memory_interface overrides + virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : NULL ); } + + // device_state_interface overrides + void state_string_export(const device_state_entry &entry, astring &string); + + // device_disasm_interface overrides + virtual UINT32 disasm_min_opcode_bytes() const { return 1; } + virtual UINT32 disasm_max_opcode_bytes() const { return 5; } + virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options); + +private: + address_space_config m_program_config; + address_space_config m_io_config; + + devcb2_read8 m_in_func; + + address_space *m_program; //ME0 + address_space *m_io; //ME1 + direct_read_data *m_direct; + + PAIR m_s; + PAIR m_p; + PAIR m_u; + PAIR m_x; + PAIR m_y; + int m_tm; //9 bit + + UINT8 m_t, m_a; + + int m_bf; + int m_dp; + int m_pu; + int m_pv; + + UINT16 m_oldpc; + + int m_irq_state; + + UINT8 m_ir_flipflop[3]; //interrupt request flipflop: IR0, IR1, IR2 + int m_lines_status[2]; //MI and NMI lines status + + int m_idle; + int m_icount; + + void check_irq(); + void lh5801_instruction_fd(); + void lh5801_instruction(); + UINT8 lh5801_add_generic(int left, int right, int carry); + UINT16 lh5801_readop_word(); + void lh5801_adc(UINT8 data); + void lh5801_add_mem(address_space &space, int addr, UINT8 data); + void lh5801_adr(PAIR *reg); + void lh5801_sbc(UINT8 data); + void lh5801_cpa(UINT8 a, UINT8 b); + UINT8 lh5801_decimaladd_generic(int left, int right, int carry); + void lh5801_dca(UINT8 data); + void lh5801_dcs(UINT8 data); + void lh5801_and(UINT8 data); + void lh5801_and_mem(address_space &space, int addr, UINT8 data); + void lh5801_bit(UINT8 a, UINT8 b); + void lh5801_eor(UINT8 data); + void lh5801_ora(UINT8 data); + void lh5801_ora_mem(address_space &space, int addr, UINT8 data); + void lh5801_lda(UINT8 data); + void lh5801_lde(PAIR *reg); + void lh5801_sde(PAIR *reg); + void lh5801_lin(PAIR *reg); + void lh5801_sin(PAIR *reg); + void lh5801_dec(UINT8 *adr); + void lh5801_inc(UINT8 *adr); + void lh5801_pop(); + void lh5801_pop_word(PAIR *reg); + void lh5801_rtn(); + void lh5801_rti(); + void lh5801_push(UINT8 data); + void lh5801_push_word(UINT16 data); + void lh5801_jmp(UINT16 adr); + void lh5801_branch_plus(int doit); + void lh5801_branch_minus(int doit); + void lh5801_lop(); + void lh5801_sjp(); + void lh5801_vector(int doit, int nr); + void lh5801_aex(); + void lh5801_drl(address_space &space, int adr); + void lh5801_drr(address_space &space, int adr); + void lh5801_rol(); + void lh5801_ror(); + void lh5801_shl(); + void lh5801_shr(); + void lh5801_am(int value); + void lh5801_ita(); + +}; + + +extern const device_type LH5801; + #endif /* __LH5801_H__ */ diff --git a/src/mess/drivers/pc1500.c b/src/mess/drivers/pc1500.c index 672a2d1b360..d699112c102 100644 --- a/src/mess/drivers/pc1500.c +++ b/src/mess/drivers/pc1500.c @@ -40,7 +40,7 @@ public: DECLARE_READ8_MEMBER( port_b_r ); DECLARE_WRITE8_MEMBER( port_c_w ); - static UINT8 pc1500_kb_r(device_t *device); + DECLARE_READ8_MEMBER( pc1500_kb_r ); virtual void palette_init(); }; @@ -60,29 +60,28 @@ static ADDRESS_MAP_START( pc1500_mem_io , AS_IO, 8, pc1500_state) AM_RANGE( 0xf000, 0xf00f) AM_DEVREADWRITE("lh5810", lh5810_device, data_r, data_w) ADDRESS_MAP_END -UINT8 pc1500_state::pc1500_kb_r(device_t *device) +READ8_MEMBER( pc1500_state::pc1500_kb_r ) { - pc1500_state *state = device->machine().driver_data(); UINT8 data = 0xff; - if (!device->started()) return 0; + if (!started()) return 0; - if (!(state->m_kb_matrix & 0x01)) - data &= state->ioport("KEY0")->read(); - if (!(state->m_kb_matrix & 0x02)) - data &= state->ioport("KEY1")->read(); - if (!(state->m_kb_matrix & 0x04)) - data &= state->ioport("KEY2")->read(); - if (!(state->m_kb_matrix & 0x08)) - data &= state->ioport("KEY3")->read(); - if (!(state->m_kb_matrix & 0x10)) - data &= state->ioport("KEY4")->read(); - if (!(state->m_kb_matrix & 0x20)) - data &= state->ioport("KEY5")->read(); - if (!(state->m_kb_matrix & 0x40)) - data &= state->ioport("KEY6")->read(); - if (!(state->m_kb_matrix & 0x80)) - data &= state->ioport("KEY7")->read(); + if (!(m_kb_matrix & 0x01)) + data &= ioport("KEY0")->read(); + if (!(m_kb_matrix & 0x02)) + data &= ioport("KEY1")->read(); + if (!(m_kb_matrix & 0x04)) + data &= ioport("KEY2")->read(); + if (!(m_kb_matrix & 0x08)) + data &= ioport("KEY3")->read(); + if (!(m_kb_matrix & 0x10)) + data &= ioport("KEY4")->read(); + if (!(m_kb_matrix & 0x20)) + data &= ioport("KEY5")->read(); + if (!(m_kb_matrix & 0x40)) + data &= ioport("KEY6")->read(); + if (!(m_kb_matrix & 0x80)) + data &= ioport("KEY7")->read(); return data; } @@ -263,11 +262,6 @@ void pc1500_state::palette_init() palette_set_color(machine(), 1, MAKE_RGB(92, 83, 88)); } -static const lh5801_cpu_core lh5801_pc1500_config = -{ - pc1500_state::pc1500_kb_r -}; - static const lh5810_interface lh5810_pc1500_config = { DEVCB_DRIVER_MEMBER(pc1500_state, port_a_r), //port A read @@ -282,7 +276,7 @@ static MACHINE_CONFIG_START( pc1500, pc1500_state ) MCFG_CPU_ADD("maincpu", LH5801, 1300000) //1.3 MHz MCFG_CPU_PROGRAM_MAP( pc1500_mem ) MCFG_CPU_IO_MAP( pc1500_mem_io ) - MCFG_CPU_CONFIG( lh5801_pc1500_config ) + MCFG_LH5801_IN(READ8(pc1500_state,pc1500_kb_r)) MCFG_SCREEN_ADD("screen", LCD) MCFG_SCREEN_REFRESH_RATE(50)