m6502ops.h

这个是延伸mame的在wince平台下的游戏模拟器的代码

		P &= ~(_fV | _fC);										\
		if ((A^tmp) & (A^sum) & _fN)							\
			P |= _fV;											\
		if (lo & 0xf0)											\
			lo -= 6;											\
		if (lo & 0x80)											\
			hi -= 0x10; 										\
		if (hi & 0x0f00)										\
			hi -= 0x60; 										\
		if ((sum & 0xff00) == 0)								\
			P |= _fC;											\
		A = (lo & 0x0f) + (hi & 0xf0);							\
	}															\
	else														\
	{															\
	int c = (P & _fC) ^ _fC;									\
	int sum = A - tmp - c;										\
		P &= ~(_fV | _fC);										\
		if ((A^tmp) & (A^sum) & _fN)							\
			P |= _fV;											\
		if ((sum & 0xff00) == 0)								\
			P |= _fC;											\
		A = (byte) sum; 										\
	}															\
	SET_NZ(A)

/* 6502 ********************************************************
 *	SEC Set carry flag
 ***************************************************************/
#define SEC 													\
	P |= _fC

/* 6502 ********************************************************
 *	SED Set decimal flag
 ***************************************************************/
#define SED 													\
	P |= _fD

/* 6502 ********************************************************
 *	SEI Set interrupt flag
 ***************************************************************/
#define SEI 													\
	P |= _fI

/* 6502 ********************************************************
 * STA	Store accumulator
 ***************************************************************/
#define STA 													\
	tmp = A

/* 6502 ********************************************************
 * STX	Store index X
 ***************************************************************/
#define STX 													\
	tmp = X

/* 6502 ********************************************************
 * STY	Store index Y
 ***************************************************************/
#define STY 													\
	tmp = Y

/* 6502 ********************************************************
 * TAX	Transfer accumulator to index X
 ***************************************************************/
#define TAX 													\
	X = A;														\
	SET_NZ(X)

/* 6502 ********************************************************
 * TAY	Transfer accumulator to index Y
 ***************************************************************/
#define TAY 													\
	Y = A;														\
	SET_NZ(Y)

/* 6502 ********************************************************
 * TSX	Transfer stack LSB to index X
 ***************************************************************/
#define TSX 													\
	X = S;														\
	SET_NZ(X)

/* 6502 ********************************************************
 * TXA	Transfer index X to accumulator
 ***************************************************************/
#define TXA 													\
	A = X;														\
	SET_NZ(A)

/* 6502 ********************************************************
 * TXS	Transfer index X to stack LSB
 * no flags changed (sic!)
 ***************************************************************/
#define TXS 													\
	S = X

/* 6502 ********************************************************
 * TYA	Transfer index Y to accumulator
 ***************************************************************/
#define TYA 													\
	A = Y;														\
	SET_NZ(A)

/***************************************************************
 ***************************************************************
 *			Macros to emulate the 65C02 opcodes
 ***************************************************************
 ***************************************************************/

/* 65C02 *******************************************************
 *	BBR Branch if bit is reset
 ***************************************************************/
#define BBR(bit)												\
	BRA(!(tmp & (1<<bit)))

/* 65C02 *******************************************************
 *	BBS Branch if bit is set
 ***************************************************************/
#define BBS(bit)												\
	BRA(tmp & (1<<bit))

/* 65C02 *******************************************************
 *	DEA Decrement accumulator
 ***************************************************************/
#define DEA 													\
	A = (byte)--A;												\
	SET_NZ(A)

/* 65C02 *******************************************************
 *	INA Increment accumulator
 ***************************************************************/
#define INA 													\
	A = (byte)++A;												\
	SET_NZ(A)

/* 65C02 *******************************************************
 *	PHX Push index X
 ***************************************************************/
#define PHX 													\
	PUSH(X)

/* 65C02 *******************************************************
 *	PHY Push index Y
 ***************************************************************/
#define PHY 													\
	PUSH(Y)

/* 65C02 *******************************************************
 *	PLX Pull index X
 ***************************************************************/
#define PLX 													\
	PULL(X)

/* 65C02 *******************************************************
 *	PLY Pull index Y
 ***************************************************************/
#define PLY 													\
	PULL(Y)

/* 65C02 *******************************************************
 *	RMB Reset memory bit
 ***************************************************************/
#define RMB(bit)												\
	tmp &= ~(1<<bit)

/* 65C02 *******************************************************
 *	SMB Set memory bit
 ***************************************************************/
#define SMB(bit)												\
	tmp |= (1<<bit)

/* 65C02 *******************************************************
 * STZ	Store zero
 ***************************************************************/
#define STZ                                                     \
    tmp = 0

/* 65C02 *******************************************************
 * TRB	Test and reset bits
 ***************************************************************/
#define TRB                                                     \
	SET_Z(tmp&A);												\
	tmp &= ~A

/* 65C02 *******************************************************
 * TSB	Test and set bits
 ***************************************************************/
#define TSB 													\
	SET_NZ(tmp&A);												\
	tmp |= A

/***************************************************************
 ***************************************************************
 *			Macros to emulate the 6510 opcodes
 ***************************************************************
 ***************************************************************/

/* 6510 ********************************************************
 *	ANC logical and, set carry from bit of A
 ***************************************************************/
#define ANC 													\
	P &= ~_fC;													\
	A = (byte)(A & tmp);										\
	if (A & 0x80)												\
		P |= _fC;												\
	SET_NZ(A)

/* 6510 ********************************************************
 *	ASR logical and, logical shift right
 ***************************************************************/
#define ASR 													\
	tmp = (byte)(A & tmp);										\
	LSR

/* 6510 ********************************************************
 * AST	and stack; transfer to accumulator and index X
 * logical and stack (LSB) with data, transfer result to S
 * transfer result to accumulator and index X also
 ***************************************************************/
#define AST 													\
	S &= tmp;													\
	A = X = S;													\
	SET_NZ(A)

/* 6510 ********************************************************
 *	ARR logical and, rotate right
 ***************************************************************/
#define ARR 													\
	tmp = (byte)(A & tmp);										\
	ROR

/* 6510 ********************************************************
 *	ASX logical and X w/ A, subtract data from X
 ***************************************************************/
#define ASX 													\
	P &= ~_fC;													\
	X &= A; 													\
	if (X >= tmp)												\
		P |= _fC;												\
	X = (byte)(X - tmp);										\
	SET_NZ(X)

/* 6510 ********************************************************
 *	AXA transfer index X to accumulator, logical and
 ***************************************************************/
#define AXA 													\
	tmp = (byte)(X & tmp);										\
	SET_NZ(tmp)

/* 6510 ********************************************************
 *	DCP decrement data and compare
 ***************************************************************/
#define DCP 													\
	tmp = (byte)--tmp;											\
	P &= ~_fC;													\
	if (A >= tmp)												\
		P |= _fC;												\
    SET_NZ((byte)(A - tmp))

/* 6502 ********************************************************
 *	DOP double no operation
 ***************************************************************/
#define DOP 													\
	PCW++

/* 6510 ********************************************************
 *	ISB increment and subtract with carry
 ***************************************************************/
#define ISB 													\
	tmp = (byte)++tmp;											\
    SBC

/* 6510 ********************************************************
 *  LAX load accumulator and index X
 ***************************************************************/
#define LAX 													\
	A = X = (byte)tmp;											\
	SET_NZ(A)

/* 6510 ********************************************************
 * RLA	rotate left and logical and accumulator
 *	new C <- [7][6][5][4][3][2][1][0] <- C
 ***************************************************************/
#define RLA 													\
	tmp = (tmp << 1) | (P & _fC);								\
	P = (P & ~_fC) | ((tmp >> 8) & _fC);						\
	tmp = (byte)tmp;											\
	A &= tmp;													\
    SET_NZ(A)

/* 6510 ********************************************************
 * RRA	rotate right and add with carry
 *  C -> [7][6][5][4][3][2][1][0] -> C
 ***************************************************************/
#define RRA 													\
	tmp |= (P & _fC) << 8;										\
	P = (P & ~_fC) | (tmp & _fC);								\
	tmp = (byte)(tmp >> 1); 									\
    ADC

/* 6510 ********************************************************
 * SAX	logical and accumulator with index X and store
 ***************************************************************/
#define SAX 													\
	tmp = A & X;												\
	SET_NZ(tmp)

/* 6510 ********************************************************
 *	SLO shift left and logical or
 ***************************************************************/
#define SLO 													\
	P = (P & ~_fC) | ((tmp >> 7) & _fC);						\
	tmp = (byte)(tmp << 1); 									\
	A |= tmp;													\
    SET_NZ(A)

/* 6510 ********************************************************
 *	SRE logical shift right and logical exclusive or
 *  0 -> [7][6][5][4][3][2][1][0] -> C
 ***************************************************************/
#define SRE 													\
	P = (P & ~_fC) | (tmp & _fC);								\
	tmp = (byte)tmp >> 1;										\
	A ^= tmp;													\
    SET_NZ(A)

/* 6510 ********************************************************
 * SAH	store accumulator and index X and high + 1
 * result = accumulator and index X and memory [PC+1] + 1
 ***************************************************************/
#define SAH 													\
	tmp = A & X;												\
	tmp &= (cpu_readop_arg((PCW + 1) & 0xffff) + 1)

/* 6510 ********************************************************
 * SSH	store stack high
 * logical and accumulator with index X, transfer result to S
 * logical and result with memory [PC+1] + 1
 ***************************************************************/
#define SSH 													\
	tmp = S = A & X;											\
	tmp &= (byte)(cpu_readop_arg((PCW + 1) & 0xffff) + 1)

/* 6510 ********************************************************
 * SXH	store index X high
 * logical and index X with memory[PC+1] and store the result
 ***************************************************************/
#define SXH 													\
	tmp = X & (byte)(cpu_readop_arg((PCW + 1) & 0xffff)

/* 6510 ********************************************************
 * SYH	store index Y and (high + 1)
 * logical and index Y with memory[PC+1] + 1 and store the result
 ***************************************************************/
#define SYH 													\
	tmp = Y & (byte)(cpu_readop_arg((PCW + 1) & 0xffff) + 1)

/* 6510 ********************************************************
 *	TOP triple no operation
 ***************************************************************/
#define TOP 													\
	PCW += 2