#ifndef __R6502_H__
#define __R6502_H__

#undef PC
class Stream;

class r6502: public CPU {
public:
	void raise(int);
	void reset();
	void run(unsigned);
	char *status();
	void checkpoint(Stream &);
	void restore(Stream &);

	r6502 (Memory &, jmp_buf *, CPU::statfn);
private:
	/* registers */
	Memory::address PC;
	byte S, A, X, Y;
	byte N, V, B, D, I, Z, C;
	union {
		struct {
			unsigned C:1;
			unsigned Z:1;
			unsigned I:1;
			unsigned D:1;
			unsigned B:1;
			unsigned _:1;		// unused
			unsigned V:1;
			unsigned N:1;
		} bits;
		byte value;
	} P;
	byte _toBCD[256], _fromBCD[256];	// BCD maps
	bool _irq;				// interrupt pending?

	void step();
	void irq();
	void nmi();
	byte flags();

	/* stack */
	inline void pusha (Memory::address ret) {
		_memory[0x0100+S--] = ret >> 8;
		_memory[0x0100+S--] = ret & 0xff;
	}

	inline void pushb (byte b) {
		_memory[0x0100+S--] = b;
	}

	inline byte popb () {
		return _memory[++S+0x0100];
	}

	inline Memory::address popa () {
		byte b = popb ();
		return ((popb () << 8) | b);
	}

	static const Memory::address nmivec = 0xfffa;
	static const Memory::address resvec = 0xfffc;
	static const Memory::address ibvec = 0xfffe;
	
	inline Memory::address vector(Memory::address v) {
		return (_memory[v+1] << 8) | _memory[v];
	}

	/* operators */
	inline void _cmp (byte a) { Z=N=A-a; C=(A>=a); }
	inline void _cpx (byte a) { Z=N=X-a; C=(X>=a); }
	inline void _cpy (byte a) { Z=N=Y-a; C=(Y>=a); }
	inline void _and (byte a) { Z=N=A&=a; }
	inline void _eor (byte a) { Z=N=A^=a; }
	inline void _ora (byte a) { Z=N=A|=a; }
	inline void _lda (byte a) { Z=N=A=a; }
	inline void _ldx (byte a) { Z=N=X=a; }
	inline void _ldy (byte a) { Z=N=Y=a; }

	/* modes */
	inline Memory::address _a () { 
		Memory::address a = _memory[PC++];
		return a | (_memory[PC++] << 8);
	}
	inline Memory::address _ax () { return _a()+X; }
	inline Memory::address _ay () { return _a()+Y; }
	inline Memory::address _z () { return _memory[PC++]; }
	inline Memory::address _zx () { return (_z()+X) & 0xff; }
	inline Memory::address _zy () { return (_z()+Y) & 0xff; }
	inline Memory::address _i (Memory::address a) { 
		return (_memory[a+1]<<8)|_memory[a]; 
	}
	inline Memory::address _ix () { return _i(_zx()); }
	inline Memory::address _iy () { return _i(_memory[PC++])+Y; }

	void _adc (byte a);
	void _sbc (byte a) { if (P.bits.D) sbcd(a); else _adc(~a); }
	void sbcd (byte a);

	inline byte __ror (byte b) {
		N=b>>1; if (C) N|=0x80; C=b&1; return Z=N;
	}
	inline void _ror (Memory::address a) {
		_memory[a] = __ror(_memory[a]);
	}
	inline byte __rol (byte b) {
		N=b<<1; if (C) N|=1; C=(b&0x80)!=0; return Z=N;
	}
	inline void _rol (Memory::address a) {
		_memory[a] = __rol(_memory[a]);
	}
	inline byte __asl (byte b) { C=(b&0x80)!=0; return Z=N=b<<1; }
	inline void _asl (Memory::address a) {
		_memory[a] = __asl(_memory[a]);
	}
	inline byte __lsr (byte b) { C=b&1; Z=b>>1; N=0; return Z; }
	inline void _lsr (Memory::address a) {
		_memory[a] = __lsr(_memory[a]);
	}
	inline void _inc (Memory::address a) {
		Z=N=1+_memory[a]; _memory[a]=Z;
	}
	inline void _dec (Memory::address a) {
		Z=N=_memory[a]-1; _memory[a]=Z;
	}
	inline void _bit (byte z) { V=((z & 0x40)!=0); N=(z & 0x80); Z=(A & z); }
	inline void _bra() {
		byte b = _memory[PC];
		PC += b;
		if (b > 127) PC -= 0x0100;
	}

	/* dispatch table */
	typedef void (r6502::*OP)(); OP _ops[256];

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