--- np2/i286c/i286c.mcr	2003/10/26 06:44:47	1.6
+++ np2/i286c/i286c.mcr	2003/11/29 03:38:26	1.10
@@ -6,27 +6,110 @@
 #define	WORD2LONG(src)	((short)(src))
 
 
-#define	SEGMENTPTR(s)	((UINT16 *)(&I286_SEGREG) + (s))
+#define	SEGMENTPTR(s)	(((UINT16 *)&I286_SEGREG) + (s))
 
 #define REAL_FLAGREG	(UINT16)((I286_FLAG & 0x7ff) | (I286_OV?O_FLAG:0))
 
 #define	STRING_DIR		((I286_FLAG & D_FLAG)?-1:1)
 #define	STRING_DIRx2	((I286_FLAG & D_FLAG)?-2:2)
 
-#if defined(CPUW2TEST)
-#define	WORDSZPF(a)		((szpcflag[(a) & 0xff] & P_FLAG) | \
-									(((a))?0:Z_FLAG) | (((a) >> 8) & S_FLAG))
+
+// ---- flags
+
+#if defined(I286C_TEST)
+
+extern BYTE BYTESZPF(UINT r);
+extern BYTE BYTESZPCF(UINT r);
+#define	BYTESZPCF2(a)	BYTESZPCF((a) & 0x1ff)
+extern BYTE WORDSZPF(UINT32 r);
+extern BYTE WORDSZPCF(UINT32 r);
+
+#elif !defined(MEMOPTIMIZE)
+
+extern	BYTE	_szpcflag8[0x200];
+extern	BYTE	_szpflag16[0x10000];
+#define	BYTESZPF(a)		(_szpcflag8[(a)])
+#define	BYTESZPCF(a)	(_szpcflag8[(a)])
+#define	BYTESZPCF2(a)	(_szpcflag8[(a) & 0x1ff])
+#define	WORDSZPF(a)		(_szpflag16[(a)])
+#define	WORDSZPCF(a)	(_szpflag16[LOW16(a)] + (((a) >> 16) & 1))
+
+#else
+
+extern	BYTE	_szpcflag8[0x200];
+
+#define	BYTESZPF(a)		(_szpcflag8[(a)])
+#define	BYTESZPCF(a)	(_szpcflag8[(a)])
+#define	BYTESZPCF2(a)	(_szpcflag8[(a) & 0x1ff])
+#define	WORDSZPF(a)		((_szpcflag8[(a) & 0xff] & P_FLAG) + \
+									(((a))?0:Z_FLAG) + (((a) >> 8) & S_FLAG))
+#define	WORDSZPCF(a)	((_szpcflag8[(a) & 0xff] & P_FLAG) + \
+							((LOW16(a))?0:Z_FLAG) + (((a) >> 8) & S_FLAG) + \
+							(((a) >> 16) & 1))
+
+#endif
+
+
+// ---- reg position
+
+#if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
+extern	BYTE	*_reg8_b53[256];
+extern	BYTE	*_reg8_b20[256];
+#define	REG8_B53(op)		_reg8_b53[(op)]
+#define	REG8_B20(op)		_reg8_b20[(op)]
+#else
+#if defined(BYTESEX_LITTLE)
+#define	REG8_B53(op)		\
+				(((BYTE *)&I286_REG) + (((op) >> 2) & 6) + (((op) >> 5) & 1))
+#define	REG8_B20(op)		\
+				(((BYTE *)&I286_REG) + (((op) & 3) * 2) + (((op) >> 2) & 1))
 #else
-#define	WORDSZPF(a)		szpflag_w[(a)]
+#define	REG8_B53(op)		(((BYTE *)&I286_REG) + (((op) >> 2) & 6) +	\
+													((((op) >> 5) & 1) ^ 1))
+#define	REG8_B20(op)		(((BYTE *)&I286_REG) + (((op) & 3) * 2) +	\
+													((((op) >> 2) & 1) ^ 1))
+#endif
+#endif
+
+#if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
+extern	UINT16	*_reg16_b53[256];
+extern	UINT16	*_reg16_b20[256];
+#define	REG16_B53(op)		_reg16_b53[(op)]
+#define	REG16_B20(op)		_reg16_b20[(op)]
+#else
+#define	REG16_B53(op)		(((UINT16 *)&I286_REG) + (((op) >> 3) & 7))
+#define	REG16_B20(op)		(((UINT16 *)&I286_REG) + ((op) & 7))
 #endif
 
+
+// ---- ea
+
+#if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
+typedef UINT32 (*CALCEA)(void);
+typedef UINT16 (*CALCLEA)(void);
+typedef UINT (*GETLEA)(UINT32 *seg);
+extern	CALCEA	_calc_ea_dst[];
+extern	CALCLEA	_calc_lea[];
+extern	GETLEA	_get_ea[];
+#define	CALC_EA(o)		(_calc_ea_dst[(o)]())
+#define	CALC_LEA(o)		(_calc_lea[(o)]())
+#define	GET_EA(o, s)	(_get_ea[(o)](s))
+#else
+extern UINT32 calc_ea_dst(UINT op);
+extern UINT16 calc_lea(UINT op);
+extern UINT calc_a(UINT op, UINT32 *seg);
+#define	CALC_EA(o)		(calc_ea_dst(o))
+#define	CALC_LEA(o)		(calc_lea(o))
+#define	GET_EA(o, s)	(calc_a(o, s))
+#endif
+
+
 #define	SWAPBYTE(p, q) {											\
 		BYTE tmp = (p);												\
 		(p) = (q);													\
 		(q) = tmp;													\
 	}
 
-
 #define	SWAPWORD(p, q) {											\
 		UINT16 tmp;													\
 		tmp = (p);													\
@@ -72,74 +155,68 @@
 
 #define	PREPART_EA_REG8(b, d_s)										\
 		GET_PCBYTE((b))												\
-		(d_s) = *(reg8_b53[(b)]);
+		(d_s) = *(REG8_B53(b));
 
 
 #define	PREPART_EA_REG8P(b, d_s)									\
 		GET_PCBYTE((b))												\
-		(d_s) = reg8_b53[(b)];
+		(d_s) = REG8_B53(b);
 
 
 #define	PREPART_EA_REG16(b, d_s)									\
 		GET_PCBYTE((b))												\
-		(d_s) = *(reg16_b53[(b)]);
+		(d_s) = *(REG16_B53(b));
 
 
 #define	PREPART_EA_REG16P(b, d_s)									\
 		GET_PCBYTE((b))												\
-		(d_s) = reg16_b53[(b)];
+		(d_s) = REG16_B53(b);
 
 
 #define PREPART_REG8_EA(b, s, d, regclk, memclk)					\
 		GET_PCBYTE((b))												\
 		if ((b) >= 0xc0) {											\
 			I286_WORKCLOCK(regclk);									\
-			(s) = *(reg8_b20[b]);									\
+			(s) = *(REG8_B20(b));									\
 		}															\
 		else {														\
 			I286_WORKCLOCK(memclk);									\
-			(s) = i286_memoryread(c_calc_ea_dst[(b)]());			\
+			(s) = i286_memoryread(CALC_EA(b));						\
 		}															\
-		(d) = reg8_b53[(b)];
+		(d) = REG8_B53(b);
 
 
 #define	PREPART_REG16_EA(b, s, d, regclk, memclk)					\
 		GET_PCBYTE(b)												\
 		if (b >= 0xc0) {											\
 			I286_WORKCLOCK(regclk);									\
-			s = *(reg16_b20[b]);									\
+			s = *(REG16_B20(b));									\
 		}															\
 		else {														\
 			I286_WORKCLOCK(memclk);									\
-			s = i286_memoryread_w(c_calc_ea_dst[b]());				\
+			s = i286_memoryread_w(CALC_EA(b));						\
 		}															\
-		d = reg16_b53[b];
+		d = REG16_B53(b);
 
 
 #define	ADDBYTE(r, d, s)											\
 		(r) = (s) + (d);											\
 		I286_OV = ((r) ^ (s)) & ((r) ^ (d)) & 0x80;					\
 		I286_FLAGL = (BYTE)(((r) ^ (d) ^ (s)) & A_FLAG);			\
-		I286_FLAGL |= szpcflag[(r)];
-
+		I286_FLAGL |= BYTESZPCF(r);
 
 #define	ADDWORD(r, d, s)											\
 		(r) = (s) + (d);											\
 		I286_OV = ((r) ^ (s)) & ((r) ^ (d)) & 0x8000;				\
 		I286_FLAGL = (BYTE)(((r) ^ (d) ^ (s)) & A_FLAG);			\
-		if ((r) & 0xffff0000) {										\
-			(r) &= 0x0000ffff;										\
-			I286_FLAGL |= C_FLAG;									\
-		}															\
-		I286_FLAGL |= WORDSZPF(r);
+		I286_FLAGL |= WORDSZPCF(r);
 
 
 // flag no check
 #define	ORBYTE(d, s)												\
 		(d) |= (s);													\
 		I286_OV = 0;												\
-		I286_FLAGL = szpcflag[(d)];
-
+		I286_FLAGL = BYTESZPF(d);
 
 #define	ORWORD(d, s)												\
 		(d) |= (s);													\
@@ -151,18 +228,13 @@
 		(r) = (I286_FLAGL & 1) + (s) + (d);							\
 		I286_OV = ((r) ^ (s)) & ((r) ^ (d)) & 0x80;					\
 		I286_FLAGL = (BYTE)(((r) ^ (d) ^ (s)) & A_FLAG);			\
-		I286_FLAGL |= szpcflag[(r)];
-
+		I286_FLAGL |= BYTESZPCF(r);
 
 #define	ADCWORD(r, d, s) 											\
 		(r) = (I286_FLAGL & 1) + (s) + (d);							\
 		I286_OV = ((r) ^ (s)) & ((r) ^ (d)) & 0x8000;				\
 		I286_FLAGL = (BYTE)(((r) ^ (d) ^ (s)) & A_FLAG);			\
-		if ((r) & 0xffff0000) {										\
-			(r) &= 0x0000ffff;										\
-			I286_FLAGL |= C_FLAG;									\
-		}															\
-		I286_FLAGL |= WORDSZPF(r);
+		I286_FLAGL |= WORDSZPCF(r);
 
 
 // flag no check
@@ -170,79 +242,64 @@
 		(r) = (d) - (s) - (I286_FLAGL & 1);							\
 		I286_OV = ((d) ^ (r)) & ((d) ^ (s)) & 0x80;					\
 		I286_FLAGL = (BYTE)(((r) ^ (d) ^ (s)) & A_FLAG);			\
-		I286_FLAGL |= szpcflag[(r) & 0x1ff];
+		I286_FLAGL |= BYTESZPCF2(r);
 
 #define	SBBWORD(r, d, s) 											\
 		(r) = (d) - (s) - (I286_FLAGL & 1);							\
 		I286_OV = ((d) ^ (r)) & ((d) ^ (s)) & 0x8000;				\
 		I286_FLAGL = (BYTE)(((r) ^ (d) ^ (s)) & A_FLAG);			\
-		if ((r) & 0xffff0000) {										\
-			(r) &= 0x0000ffff;										\
-			I286_FLAGL |= C_FLAG;									\
-		}															\
-		I286_FLAGL |= WORDSZPF(r);
+		I286_FLAGL |= WORDSZPCF(r);
 
 
 // flag no check
 #define	ANDBYTE(d, s)												\
 		(d) &= (s);													\
 		I286_OV = 0;												\
-		I286_FLAGL = szpcflag[(d)];
-
+		I286_FLAGL = BYTESZPF(d);
 
 #define	ANDWORD(d, s)												\
-		(d) &= s;													\
+		(d) &= (s);													\
 		I286_OV = 0;												\
 		I286_FLAGL = WORDSZPF(d);
 
 
 // flag no check
-#define	BYTE_SUB(r, d, s) 											\
+#define	SUBBYTE(r, d, s) 											\
 		(r) = (d) - (s);											\
 		I286_OV = ((d) ^ (r)) & ((d) ^ (s)) & 0x80;					\
 		I286_FLAGL = (BYTE)(((r) ^ (d) ^ (s)) & A_FLAG);			\
-		I286_FLAGL |= szpcflag[(r) & 0x1ff];
+		I286_FLAGL |= BYTESZPCF2(r);
 
-#define	WORD_SUB(r, d, s) 											\
+#define	SUBWORD(r, d, s) 											\
 		(r) = (d) - (s);											\
 		I286_OV = ((d) ^ (r)) & ((d) ^ (s)) & 0x8000;				\
-		I286_FLAGL = (BYTE)(((r) ^ (d) ^ (s)) & A_FLAG);			\
-		if ((r) & 0xffff0000) {										\
-			(r) &= 0x0000ffff;										\
-			I286_FLAGL |= C_FLAG;									\
-		}															\
-		I286_FLAGL |= WORDSZPF(r);
+		I286_FLAGL = ((r) ^ (d) ^ (s)) & A_FLAG;					\
+		I286_FLAGL |= WORDSZPCF(r);
 
 
 // flag no check
-#define	BYTE_XOR(d, s)												\
+#define	XORBYTE(d, s)												\
 		(d) ^= s;													\
 		I286_OV = 0;												\
-		I286_FLAGL = szpcflag[(d)];
-
+		I286_FLAGL = BYTESZPF(d);
 
-#define	WORD_XOR(d, s)												\
+#define	XORWORD(d, s)												\
 		(d) ^= (s);													\
 		I286_OV = 0;												\
 		I286_FLAGL = WORDSZPF(d);
 
 
-#define	BYTE_NEG(d, s) 												\
+#define	NEGBYTE(d, s) 												\
 		(d) = 0 - (s);												\
 		I286_OV = ((d) & (s)) & 0x80;								\
 		I286_FLAGL = (BYTE)(((d) ^ (s)) & A_FLAG);					\
-		I286_FLAGL |= szpcflag[(d) & 0x1ff];
+		I286_FLAGL |= BYTESZPCF2(d);
 
-
-#define	WORD_NEG(d, s) 												\
+#define	NEGWORD(d, s) 												\
 		(d) = 0 - (s);												\
 		I286_OV = ((d) & (s)) & 0x8000;								\
 		I286_FLAGL = (BYTE)(((d) ^ (s)) & A_FLAG);					\
-		if ((d) & 0xffff0000) {										\
-			(d) &= 0x0000ffff;										\
-			I286_FLAGL |= C_FLAG;									\
-		}															\
-		I286_FLAGL |= WORDSZPF(d);
+		I286_FLAGL |= WORDSZPCF(d);
 
 
 #define	BYTE_MUL(r, d, s)											\
@@ -253,7 +310,6 @@
 			I286_FLAGL |= C_FLAG;									\
 		}
 
-
 #define	WORD_MUL(r, d, s)											\
 		I286_FLAGL &= (Z_FLAG | S_FLAG | A_FLAG | P_FLAG);			\
 		(r) = (UINT16)(d) * (UINT16)(s);							\
@@ -271,7 +327,6 @@
 			I286_FLAGL |= C_FLAG;									\
 		}
 
-
 #define	WORD_IMUL(r, d, s)											\
 		I286_FLAGL &= (Z_FLAG | S_FLAG | A_FLAG | P_FLAG);			\
 		(r) = (short)(d) * (short)(s);								\
@@ -282,74 +337,69 @@
 
 
 // flag no check
-#define	BYTE_INC(s) {												\
-		BYTE	b;													\
-		b = (s);													\
-		b++;														\
-		I286_OV = b & (b ^ (s)) & 0x80;								\
+#define	INCBYTE(s) {												\
+		UINT b = (s);												\
+		(s)++;														\
+		I286_OV = (s) & (b ^ (s)) & 0x80;							\
 		I286_FLAGL &= C_FLAG;										\
 		I286_FLAGL |= (BYTE)((b ^ (s)) & A_FLAG);					\
-		I286_FLAGL |= szpcflag[b];									\
-		(s) = b;													\
+		I286_FLAGL |= BYTESZPF((BYTE)(s));							\
 	}
 
-
-#define	WORD_INC(s) {												\
-		UINT16 b;													\
-		b = (s);													\
-		b++;														\
-		I286_OV = b & (b ^ (s)) & 0x8000;							\
+#define	INCWORD(s) {												\
+		UINT32 b = (s);												\
+		(s)++;														\
+		I286_OV = (s) & (b ^ (s)) & 0x8000;							\
 		I286_FLAGL &= C_FLAG;										\
 		I286_FLAGL |= (BYTE)((b ^ (s)) & A_FLAG);					\
-		I286_FLAGL |= WORDSZPF(b);									\
-		(s) = b;													\
+		I286_FLAGL |= WORDSZPF((UINT16)(s));						\
 	}
 
 
 // flag no check
-#define	BYTE_DEC(s) {												\
-		BYTE b = (s);												\
+#define	DECBYTE(s) {												\
+		UINT b = (s);												\
 		b--;														\
 		I286_OV = (s) & (b ^ (s)) & 0x80;							\
 		I286_FLAGL &= C_FLAG;										\
 		I286_FLAGL |= (BYTE)((b ^ (s)) & A_FLAG);					\
-		I286_FLAGL |= szpcflag[b];									\
+		I286_FLAGL |= BYTESZPF((BYTE)b);							\
 		(s) = b;													\
 	}
 
-
-#define	WORD_DEC(s) {												\
-		UINT16 b = (s);												\
+#define	DECWORD(s) {												\
+		UINT32 b = (s);												\
 		b--;														\
 		I286_OV = (s) & (b ^ (s)) & 0x8000;							\
 		I286_FLAGL &= C_FLAG;										\
 		I286_FLAGL |= (BYTE)((b ^ (s)) & A_FLAG);					\
-		I286_FLAGL |= WORDSZPF(b);									\
+		I286_FLAGL |= WORDSZPF((UINT16)b);							\
 		(s) = b;													\
 	}
 
 
 // flag no check
-#define	INCWORD(w, clock) {											\
-		UINT16 bak;													\
-		bak = (w);													\
-		(w)++;														\
-		I286_OV = (w) & ((w) ^ bak) & 0x8000;						\
+#define	INCWORD2(r, clock) {										\
+		REG16 s = (r);												\
+		REG16 d = (r);												\
+		d++;														\
+		(r) = (UINT16)d;											\
+		I286_OV = d & (d ^ s) & 0x8000;								\
 		I286_FLAGL &= C_FLAG;										\
-		I286_FLAGL |= (BYTE)(((w) ^ bak) & A_FLAG);					\
-		I286_FLAGL |= WORDSZPF(w);									\
+		I286_FLAGL |= (BYTE)((d ^ s) & A_FLAG);						\
+		I286_FLAGL |= WORDSZPF((UINT16)d);							\
 		I286_WORKCLOCK(clock);										\
 	}
 
-
-#define	DECWORD(w, clock) {											\
-		UINT16 bak;													\
-		bak = (w);													\
-		w--;														\
-		I286_OV = bak & (w ^ bak) & 0x8000;							\
+#define	DECWORD2(r, clock) {										\
+		REG16 s = (r);												\
+		REG16 d = (r);												\
+		d--;														\
+		(r) = (UINT16)d;											\
+		I286_OV = s & (d ^ s) & 0x8000;								\
 		I286_FLAGL &= C_FLAG;										\
-		I286_FLAGL |= (BYTE)((w ^ bak) & A_FLAG);					\
-		I286_FLAGL |= WORDSZPF(w);									\
+		I286_FLAGL |= (BYTE)((d ^ s) & A_FLAG);						\
+		I286_FLAGL |= WORDSZPF((UINT16)d);							\
 		I286_WORKCLOCK(clock);										\
 	}
 
@@ -417,5 +467,5 @@
 	}
 
 
-#define	INT_NUM(a, b)		i286_intnum((a), (UINT16)(b))
+#define	INT_NUM(a, b)		i286_intnum(a, b)