6502/r65emu
1
0
Fork 0
mirror of https://github.com/jscrane/r65emu.git synced 2024-06-07 16:34:44 +00:00
Code Issues Projects Releases Wiki Activity

_memory -> _mem

Browse Source
This commit is contained in:
Stephen Crane 2014-11-21 12:44:52 +00:00
parent c5422b8c43
commit ff399c5ef1
3 changed files with 107 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cpu.h
View File

@ -20,8 +20,8 @@ public:
void debug() { _debug = !_debug; } void debug() { _debug = !_debug; }
protected: protected:
CPU (Memory &m, jmp_buf *e, statfn s): _memory(m), _err(e), _status(s){} CPU (Memory &mem, jmp_buf *e, statfn s): _mem(mem), _err(e), _status(s){}
Memory &_memory; Memory &_mem;
jmp_buf *_err; jmp_buf *_err;
statfn _status; statfn _status;
bool _debug; bool _debug;

2
r6502.cpp
View File

@ -10,7 +10,7 @@
P.bits.D,P.bits.I,P.bits.Z,P.bits.C,PC P.bits.D,P.bits.I,P.bits.Z,P.bits.C,PC
inline void r6502::step() { inline void r6502::step() {
byte op = _memory[PC]; byte op = _mem[PC];
#ifdef CPU_DEBUG #ifdef CPU_DEBUG
if (_debug) { if (_debug) {
flags(); flags();

208
r6502.h
View File

@ -42,16 +42,16 @@ private:
/* stack */ /* stack */
inline void pusha (Memory::address ret) { inline void pusha (Memory::address ret) {
_memory[0x0100+S--] = ret >> 8; _mem[0x0100+S--] = ret >> 8;
_memory[0x0100+S--] = ret & 0xff; _mem[0x0100+S--] = ret & 0xff;
} }
inline void pushb (byte b) { inline void pushb (byte b) {
_memory[0x0100+S--] = b; _mem[0x0100+S--] = b;
} }
inline byte popb () { inline byte popb () {
return _memory[++S+0x0100]; return _mem[++S+0x0100];
} }
inline Memory::address popa () { inline Memory::address popa () {
@ -64,7 +64,7 @@ private:
static const Memory::address ibvec = 0xfffe; static const Memory::address ibvec = 0xfffe;
inline Memory::address vector(Memory::address v) { inline Memory::address vector(Memory::address v) {
return (_memory[v+1] << 8) | _memory[v]; return (_mem[v+1] << 8) | _mem[v];
} }
/* operators */ /* operators */
@ -80,19 +80,19 @@ private:
/* modes */ /* modes */
inline Memory::address _a () { inline Memory::address _a () {
Memory::address a = _memory[PC++]; Memory::address a = _mem[PC++];
return a | (_memory[PC++] << 8); return a | (_mem[PC++] << 8);
} }
inline Memory::address _ax () { return _a()+X; } inline Memory::address _ax () { return _a()+X; }
inline Memory::address _ay () { return _a()+Y; } inline Memory::address _ay () { return _a()+Y; }
inline Memory::address _z () { return _memory[PC++]; } inline Memory::address _z () { return _mem[PC++]; }
inline Memory::address _zx () { return (_z()+X) & 0xff; } inline Memory::address _zx () { return (_z()+X) & 0xff; }
inline Memory::address _zy () { return (_z()+Y) & 0xff; } inline Memory::address _zy () { return (_z()+Y) & 0xff; }
inline Memory::address _i (Memory::address a) { inline Memory::address _i (Memory::address a) {
return (_memory[a+1]<<8)|_memory[a]; return (_mem[a+1]<<8)|_mem[a];
} }
inline Memory::address _ix () { return _i(_zx()); } inline Memory::address _ix () { return _i(_zx()); }
inline Memory::address _iy () { return _i(_memory[PC++])+Y; } inline Memory::address _iy () { return _i(_mem[PC++])+Y; }
void _adc (byte a); void _adc (byte a);
void _sbc (byte a) { if (P.bits.D) sbcd(a); else _adc(~a); } void _sbc (byte a) { if (P.bits.D) sbcd(a); else _adc(~a); }
@ -102,31 +102,31 @@ private:
N=b>>1; if (C) N|=0x80; C=b&1; return Z=N; N=b>>1; if (C) N|=0x80; C=b&1; return Z=N;
} }
inline void _ror (Memory::address a) { inline void _ror (Memory::address a) {
_memory[a] = __ror(_memory[a]); _mem[a] = __ror(_mem[a]);
} }
inline byte __rol (byte b) { inline byte __rol (byte b) {
N=b<<1; if (C) N|=1; C=(b&0x80)!=0; return Z=N; N=b<<1; if (C) N|=1; C=(b&0x80)!=0; return Z=N;
} }
inline void _rol (Memory::address a) { inline void _rol (Memory::address a) {
_memory[a] = __rol(_memory[a]); _mem[a] = __rol(_mem[a]);
} }
inline byte __asl (byte b) { C=(b&0x80)!=0; return Z=N=b<<1; } inline byte __asl (byte b) { C=(b&0x80)!=0; return Z=N=b<<1; }
inline void _asl (Memory::address a) { inline void _asl (Memory::address a) {
_memory[a] = __asl(_memory[a]); _mem[a] = __asl(_mem[a]);
} }
inline byte __lsr (byte b) { C=b&1; Z=b>>1; N=0; return Z; } inline byte __lsr (byte b) { C=b&1; Z=b>>1; N=0; return Z; }
inline void _lsr (Memory::address a) { inline void _lsr (Memory::address a) {
_memory[a] = __lsr(_memory[a]); _mem[a] = __lsr(_mem[a]);
} }
inline void _inc (Memory::address a) { inline void _inc (Memory::address a) {
Z=N=1+_memory[a]; _memory[a]=Z; Z=N=1+_mem[a]; _mem[a]=Z;
} }
inline void _dec (Memory::address a) { inline void _dec (Memory::address a) {
Z=N=_memory[a]-1; _memory[a]=Z; Z=N=_mem[a]-1; _mem[a]=Z;
} }
inline void _bit (byte z) { V=((z & 0x40)!=0); N=(z & 0x80); Z=(A & z); } inline void _bit (byte z) { V=((z & 0x40)!=0); N=(z & 0x80); Z=(A & z); }
inline void _bra() { inline void _bra() {
byte b = _memory[PC]; byte b = _mem[PC];
PC += b; PC += b;
if (b > 127) PC -= 0x0100; if (b > 127) PC -= 0x0100;
} }
@ -136,179 +136,179 @@ private:
/* operations */ /* operations */
void brk (); void brk ();
void ora_ix () { _ora (_memory[_ix()]); } void ora_ix () { _ora (_mem[_ix()]); }
void ill (); void ill ();
void nop2 () { PC++; } void nop2 () { PC++; }
void ora_z () { _ora (_memory[_z()]); } void ora_z () { _ora (_mem[_z()]); }
void asl_z () { _asl (_z()); } void asl_z () { _asl (_z()); }
void php (); void php ();
void ora_ () { _ora (_memory[PC++]); } void ora_ () { _ora (_mem[PC++]); }
void asl () { C=(A&0x80)!=0; Z=N=A<<=1; } void asl () { C=(A&0x80)!=0; Z=N=A<<=1; }
void nop3 () { PC+=2; } void nop3 () { PC+=2; }
void ora_a () { _ora (_memory[_a()]); } void ora_a () { _ora (_mem[_a()]); }
void asl_a () { _asl (_a()); } void asl_a () { _asl (_a()); }
// 10 // 10
void bpl () { if (!(N & 0x80)) _bra(); PC++; } void bpl () { if (!(N & 0x80)) _bra(); PC++; }
void ora_iy () { _ora (_memory[_iy()]); } void ora_iy () { _ora (_mem[_iy()]); }
void ora_zx () { _ora (_memory[_zx()]); } void ora_zx () { _ora (_mem[_zx()]); }
void asl_zx () { _asl (_zx()); } void asl_zx () { _asl (_zx()); }
void clc () { C=0; } void clc () { C=0; }
void ora_ay () { _ora (_memory[_ay()]); } void ora_ay () { _ora (_mem[_ay()]); }
void nop () { } void nop () { }
void ora_ax () { _ora (_memory[_ax()]); } void ora_ax () { _ora (_mem[_ax()]); }
void asl_ax () { _asl (_ax()); } void asl_ax () { _asl (_ax()); }
// 20 // 20
void jsr (); void jsr ();
void and_ix () { _and (_memory[_ix()]); } void and_ix () { _and (_mem[_ix()]); }
void bit_z () { _bit (_memory[_z()]); } void bit_z () { _bit (_mem[_z()]); }
void and_z () { _and (_memory[_z()]); } void and_z () { _and (_mem[_z()]); }
void rol_z () { _rol (_z()); } void rol_z () { _rol (_z()); }
void plp (); void plp ();
void and_ () { _and (_memory[PC++]); } void and_ () { _and (_mem[PC++]); }
void rol () { A=__rol (A); } void rol () { A=__rol (A); }
void bit_a () { _bit (_memory[_a()]); } void bit_a () { _bit (_mem[_a()]); }
void and_a () { _and (_memory[_a()]); } void and_a () { _and (_mem[_a()]); }
void rol_a () { _rol (_a()); } void rol_a () { _rol (_a()); }
// 30 // 30
void bmi () { if (N & 0x80) _bra(); PC++; } void bmi () { if (N & 0x80) _bra(); PC++; }
void and_iy () { _and (_memory[_iy()]); } void and_iy () { _and (_mem[_iy()]); }
void and_zx () { _and (_memory[_zx()]); } void and_zx () { _and (_mem[_zx()]); }
void rol_zx () { _rol (_zx()); } void rol_zx () { _rol (_zx()); }
void sec () { C=1; } void sec () { C=1; }
void and_ay () { _and (_memory[_ay()]); } void and_ay () { _and (_mem[_ay()]); }
void and_ax () { _and (_memory[_ax()]); } void and_ax () { _and (_mem[_ax()]); }
void rol_ax () { _rol (_ax()); } void rol_ax () { _rol (_ax()); }
// 40 // 40
void rti (); void rti ();
void eor_ix () { _eor (_memory[_ix()]); } void eor_ix () { _eor (_mem[_ix()]); }
void eor_z () { _eor (_memory[_z()]); } void eor_z () { _eor (_mem[_z()]); }
void lsr_z () { _lsr (_z()); } void lsr_z () { _lsr (_z()); }
void pha () { pushb (A); } void pha () { pushb (A); }
void eor_ () { _eor (_memory[PC++]); } void eor_ () { _eor (_mem[PC++]); }
void lsr_ () { A=__lsr(A); } void lsr_ () { A=__lsr(A); }
void jmp () { PC = _a (); } void jmp () { PC = _a (); }
void eor_a () { _eor (_memory[_a()]); } void eor_a () { _eor (_mem[_a()]); }
void lsr_a () { _lsr (_a()); } void lsr_a () { _lsr (_a()); }
// 50 // 50
void bvc () { if (!V) _bra(); PC++; } void bvc () { if (!V) _bra(); PC++; }
void eor_iy () { _eor (_memory[_iy()]); } void eor_iy () { _eor (_mem[_iy()]); }
void eor_zx () { _eor (_memory[_zx()]); } void eor_zx () { _eor (_mem[_zx()]); }
void lsr_zx () { _lsr (_zx()); } void lsr_zx () { _lsr (_zx()); }
void cli (); void cli ();
void eor_ay () { _eor (_memory[_ay()]); } void eor_ay () { _eor (_mem[_ay()]); }
void eor_ax () { _eor (_memory[_ax()]); } void eor_ax () { _eor (_mem[_ax()]); }
void lsr_ax () { _lsr (_ax()); } void lsr_ax () { _lsr (_ax()); }
// 60 // 60
void rts (); void rts ();
void adc_ix () { _adc (_memory[_ix()]); } void adc_ix () { _adc (_mem[_ix()]); }
void adc_z () { _adc (_memory[_z()]); } void adc_z () { _adc (_mem[_z()]); }
void ror_z () { _ror (_z()); } void ror_z () { _ror (_z()); }
void pla () { Z=N=A=popb (); } void pla () { Z=N=A=popb (); }
void adc_ () { _adc (_memory[PC++]); } void adc_ () { _adc (_mem[PC++]); }
void ror_ () { A=__ror (A); } void ror_ () { A=__ror (A); }
void jmp_i () { PC = _i(_a()); } void jmp_i () { PC = _i(_a()); }
void adc_a () { _adc (_memory[_a()]); } void adc_a () { _adc (_mem[_a()]); }
void ror_a () { _ror (_a()); } void ror_a () { _ror (_a()); }
// 70 // 70
void bvs () { if (V) _bra(); PC++; } void bvs () { if (V) _bra(); PC++; }
void adc_iy () { _adc (_memory[_iy()]); } void adc_iy () { _adc (_mem[_iy()]); }
void adc_zx () { _adc (_memory[_zx()]); } void adc_zx () { _adc (_mem[_zx()]); }
void ror_zx () { _ror (_zx ()); } void ror_zx () { _ror (_zx ()); }
void sei () { P.bits.I = 1; } void sei () { P.bits.I = 1; }
void adc_ay () { _adc (_memory[_ay()]); } void adc_ay () { _adc (_mem[_ay()]); }
void adc_ax () { _adc (_memory[_ax()]); } void adc_ax () { _adc (_mem[_ax()]); }
void ror_ax () { _ror (_ax ()); } void ror_ax () { _ror (_ax ()); }
// 80 // 80
void sta_ix () { _memory[_ix()] = A; } void sta_ix () { _mem[_ix()] = A; }
void sty_z () { _memory[_z()] = Y; } void sty_z () { _mem[_z()] = Y; }
void sta_z () { _memory[_z()] = A; } void sta_z () { _mem[_z()] = A; }
void stx_z () { _memory[_z()] = X; } void stx_z () { _mem[_z()] = X; }
void dey () { Z=N=--Y; } void dey () { Z=N=--Y; }
void txa () { Z=N=A=X; } void txa () { Z=N=A=X; }
void sty_a () { _memory[_a()] = Y; } void sty_a () { _mem[_a()] = Y; }
void sta_a () { _memory[_a()] = A; } void sta_a () { _mem[_a()] = A; }
void stx_a () { _memory[_a()] = X; } void stx_a () { _mem[_a()] = X; }
// 90 // 90
void bcc () { if (!C) _bra(); PC++; } void bcc () { if (!C) _bra(); PC++; }
void sta_iy () { _memory[_iy()] = A; } void sta_iy () { _mem[_iy()] = A; }
void sty_zx () { _memory[_zx()] = Y; } void sty_zx () { _mem[_zx()] = Y; }
void sta_zx () { _memory[_zx()] = A; } void sta_zx () { _mem[_zx()] = A; }
void stx_zy () { _memory[_zy()] = X; } void stx_zy () { _mem[_zy()] = X; }
void tya () { Z=N=A=Y; } void tya () { Z=N=A=Y; }
void sta_ay () { _memory[_ay()] = A; } void sta_ay () { _mem[_ay()] = A; }
void txs () { S=X; } void txs () { S=X; }
void sta_ax () { _memory[_ax()] = A; } void sta_ax () { _mem[_ax()] = A; }
// a0 // a0
void ldy_ () { _ldy (_memory[PC++]); } void ldy_ () { _ldy (_mem[PC++]); }
void lda_ix () { _lda (_memory[_ix()]); } void lda_ix () { _lda (_mem[_ix()]); }
void ldx_ () { _ldx (_memory[PC++]); } void ldx_ () { _ldx (_mem[PC++]); }
void lax_ix () { lda_ix (); X=A; } void lax_ix () { lda_ix (); X=A; }
void ldy_z () { _ldy (_memory[_z()]); } void ldy_z () { _ldy (_mem[_z()]); }
void lda_z () { _lda (_memory[_z()]); } void lda_z () { _lda (_mem[_z()]); }
void ldx_z () { _ldx (_memory[_z()]); } void ldx_z () { _ldx (_mem[_z()]); }
void lax_z () { lda_z (); X=A; } void lax_z () { lda_z (); X=A; }
void tay () { Z=N=Y=A; } void tay () { Z=N=Y=A; }
void lda_ () { _lda (_memory[PC++]); } void lda_ () { _lda (_mem[PC++]); }
void tax () { Z=N=X=A; } void tax () { Z=N=X=A; }
void ldy_a () { _ldy (_memory[_a()]); } void ldy_a () { _ldy (_mem[_a()]); }
void lda_a () { _lda (_memory[_a()]); } void lda_a () { _lda (_mem[_a()]); }
void ldx_a () { _ldx (_memory[_a()]); } void ldx_a () { _ldx (_mem[_a()]); }
void lax_a () { lda_a (); X=A; } void lax_a () { lda_a (); X=A; }
// b0 // b0
void bcs () { if (C) _bra(); PC++; } void bcs () { if (C) _bra(); PC++; }
void lda_iy () { _lda (_memory[_iy()]); } void lda_iy () { _lda (_mem[_iy()]); }
void lax_iy () { lda_iy (); X=A; } void lax_iy () { lda_iy (); X=A; }
void ldy_zx () { _ldy (_memory[_zx()]); } void ldy_zx () { _ldy (_mem[_zx()]); }
void lda_zx () { _lda (_memory[_zx()]); } void lda_zx () { _lda (_mem[_zx()]); }
void ldx_zy () { _ldx (_memory[_zy()]); } void ldx_zy () { _ldx (_mem[_zy()]); }
void lax_zy () { ldx_zy (); A=X; } void lax_zy () { ldx_zy (); A=X; }
void clv () { V=0; } void clv () { V=0; }
void lda_ay () { _lda (_memory[_ay()]); } void lda_ay () { _lda (_mem[_ay()]); }
void tsx () { Z=N=X=S; } void tsx () { Z=N=X=S; }
void ldy_ax () { _ldy (_memory[_ax()]); } void ldy_ax () { _ldy (_mem[_ax()]); }
void lda_ax () { _lda (_memory[_ax()]); } void lda_ax () { _lda (_mem[_ax()]); }
void ldx_ay () { _ldx (_memory[_ay()]); } void ldx_ay () { _ldx (_mem[_ay()]); }
void lax_ay () { ldx_ay (); A=X; } void lax_ay () { ldx_ay (); A=X; }
// c0 // c0
void cpy_ () { _cpy (_memory[PC++]); } void cpy_ () { _cpy (_mem[PC++]); }
void cmp_ix () { _cmp (_memory[_ix()]); } void cmp_ix () { _cmp (_mem[_ix()]); }
void cpy_z () { _cpy (_memory[_z()]); } void cpy_z () { _cpy (_mem[_z()]); }
void cmp_z () { _cmp (_memory[_z()]); } void cmp_z () { _cmp (_mem[_z()]); }
void dec_z () { _dec (_z()); } void dec_z () { _dec (_z()); }
void iny () { Z=N=++Y; } void iny () { Z=N=++Y; }
void cmp_ () { _cmp (_memory[PC++]); } void cmp_ () { _cmp (_mem[PC++]); }
void dex () { Z=N=--X; } void dex () { Z=N=--X; }
void cpy_a () { _cpy (_memory[_a()]); } void cpy_a () { _cpy (_mem[_a()]); }
void cmp_a () { _cmp (_memory[_a()]); } void cmp_a () { _cmp (_mem[_a()]); }
void dec_a () { _dec (_a()); } void dec_a () { _dec (_a()); }
// d0 // d0
void bne () { if (Z) _bra(); PC++; } void bne () { if (Z) _bra(); PC++; }
void cmp_iy () { _cmp (_memory[_iy()]); } void cmp_iy () { _cmp (_mem[_iy()]); }
void cmp_zx () { _cmp (_memory[_zx()]); } void cmp_zx () { _cmp (_mem[_zx()]); }
void dec_zx () { _dec (_zx()); } void dec_zx () { _dec (_zx()); }
void cld () { P.bits.D = 0; } void cld () { P.bits.D = 0; }
void cmp_ay () { _cmp (_memory[_ay()]); } void cmp_ay () { _cmp (_mem[_ay()]); }
void cmp_ax () { _cmp (_memory[_ax()]); } void cmp_ax () { _cmp (_mem[_ax()]); }
void dec_ax () { _dec (_ax()); } void dec_ax () { _dec (_ax()); }
// e0 // e0
void cpx_ () { _cpx (_memory[PC++]); } void cpx_ () { _cpx (_mem[PC++]); }
void sbc_ix () { _sbc (_memory[_ix()]); } void sbc_ix () { _sbc (_mem[_ix()]); }
void cpx_z () { _cpx (_memory[_z()]); } void cpx_z () { _cpx (_mem[_z()]); }
void sbc_z () { _sbc (_memory[_z()]); } void sbc_z () { _sbc (_mem[_z()]); }
void inc_z () { _inc (_z()); } void inc_z () { _inc (_z()); }
void inx () { Z=N=++X; } void inx () { Z=N=++X; }
void sbc_ () { _sbc (_memory[PC++]); } void sbc_ () { _sbc (_mem[PC++]); }
void cpx_a () { _cpx (_memory[_a()]); } void cpx_a () { _cpx (_mem[_a()]); }
void sbc_a () { _sbc (_memory[_a()]); } void sbc_a () { _sbc (_mem[_a()]); }
void inc_a () { _inc (_a()); } void inc_a () { _inc (_a()); }
// f0 // f0
void beq () { if (!Z) _bra(); PC++; } void beq () { if (!Z) _bra(); PC++; }
void sbc_iy () { _sbc (_memory[_iy()]); } void sbc_iy () { _sbc (_mem[_iy()]); }
void sbc_zx () { _sbc (_memory[_zx()]); } void sbc_zx () { _sbc (_mem[_zx()]); }
void inc_zx () { _inc (_zx()); } void inc_zx () { _inc (_zx()); }
void sed () { P.bits.D = 1; } void sed () { P.bits.D = 1; }
void sbc_ay () { _sbc (_memory[_ay()]); } void sbc_ay () { _sbc (_mem[_ay()]); }
void sbc_ax () { _sbc (_memory[_ax()]); } void sbc_ax () { _sbc (_mem[_ax()]); }
void inc_ax () { _inc (_ax()); } void inc_ax () { _inc (_ax()); }
}; };
#endif #endif