--- np2/i286c/i286c.mcr	2003/11/28 08:01:32	1.9
+++ np2/i286c/i286c.mcr	2005/02/07 14:46:10	1.20
@@ -1,9 +1,15 @@
 
+#if defined(X11) && (defined(i386) || defined(__i386__))
+#define	INHIBIT_WORDP(m)	((m) >= (I286_MEMWRITEMAX - 1))
+#elif (defined(ARM) || defined(X11)) && defined(BYTESEX_LITTLE)
+#define	INHIBIT_WORDP(m)	(((m) & 1) || ((m) >= I286_MEMWRITEMAX))
+#else
 #define	INHIBIT_WORDP(m)	(1)
+#endif
 
-#define	__CBW(src)		(UINT16)((char)(src))
-#define	__CBD(src)		((char)(src))
-#define	WORD2LONG(src)	((short)(src))
+#define	__CBW(src)		(UINT16)((SINT8)(src))
+#define	__CBD(src)		((SINT8)(src))
+#define	WORD2LONG(src)	((SINT16)(src))
 
 
 #define	SEGMENTPTR(s)	(((UINT16 *)&I286_SEGREG) + (s))
@@ -18,32 +24,29 @@
 
 #if defined(I286C_TEST)
 
-extern BYTE BYTESZPF(UINT r);
-extern BYTE BYTESZPCF(UINT r);
+extern UINT8 BYTESZPF(UINT r);
+extern UINT8 BYTESZPCF(UINT r);
 #define	BYTESZPCF2(a)	BYTESZPCF((a) & 0x1ff)
-extern BYTE WORDSZPF(UINT32 r);
-extern BYTE WORDSZPCF(UINT32 r);
+extern UINT8 WORDSZPF(UINT32 r);
+extern UINT8 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])
+extern	UINT8	_szpflag16[0x10000];
+#define	BYTESZPF(a)		(iflags[(a)])
+#define	BYTESZPCF(a)	(iflags[(a)])
+#define	BYTESZPCF2(a)	(iflags[(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) + \
+#define	BYTESZPF(a)		(iflags[(a)])
+#define	BYTESZPCF(a)	(iflags[(a)])
+#define	BYTESZPCF2(a)	(iflags[(a) & 0x1ff])
+#define	WORDSZPF(a)		((iflags[(a) & 0xff] & P_FLAG) + \
 									(((a))?0:Z_FLAG) + (((a) >> 8) & S_FLAG))
-#define	WORDSZPCF(a)	((_szpcflag8[(a) & 0xff] & P_FLAG) + \
+#define	WORDSZPCF(a)	((iflags[(a) & 0xff] & P_FLAG) + \
 							((LOW16(a))?0:Z_FLAG) + (((a) >> 8) & S_FLAG) + \
 							(((a) >> 16) & 1))
 
@@ -53,20 +56,20 @@ extern	BYTE	_szpcflag8[0x200];
 // ---- reg position
 
 #if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
-extern	BYTE	*_reg8_b53[256];
-extern	BYTE	*_reg8_b20[256];
+extern	UINT8	*_reg8_b53[256];
+extern	UINT8	*_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))
+				(((UINT8 *)&I286_REG) + (((op) >> 2) & 6) + (((op) >> 5) & 1))
 #define	REG8_B20(op)		\
-				(((BYTE *)&I286_REG) + (((op) & 3) * 2) + (((op) >> 2) & 1))
+				(((UINT8 *)&I286_REG) + (((op) & 3) * 2) + (((op) >> 2) & 1))
 #else
-#define	REG8_B53(op)		(((BYTE *)&I286_REG) + (((op) >> 2) & 6) +	\
+#define	REG8_B53(op)		(((UINT8 *)&I286_REG) + (((op) >> 2) & 6) +	\
 													((((op) >> 5) & 1) ^ 1))
-#define	REG8_B20(op)		(((BYTE *)&I286_REG) + (((op) & 3) * 2) +	\
+#define	REG8_B20(op)		(((UINT8 *)&I286_REG) + (((op) & 3) * 2) +	\
 													((((op) >> 2) & 1) ^ 1))
 #endif
 #endif
@@ -105,13 +108,14 @@ extern UINT calc_a(UINT op, UINT32 *seg)
 
 
 #define	SWAPBYTE(p, q) {											\
-		BYTE tmp = (p);												\
+		REG8 tmp;													\
+		tmp = (p);													\
 		(p) = (q);													\
 		(q) = tmp;													\
 	}
 
 #define	SWAPWORD(p, q) {											\
-		UINT16 tmp;													\
+		REG16 tmp;													\
 		tmp = (p);													\
 		(p) = (q);													\
 		(q) = tmp;													\
@@ -202,14 +206,13 @@ extern UINT calc_a(UINT op, UINT32 *seg)
 #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 = (UINT8)(((r) ^ (d) ^ (s)) & A_FLAG);			\
 		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);			\
+		I286_FLAGL = (UINT8)(((r) ^ (d) ^ (s)) & A_FLAG);			\
 		I286_FLAGL |= WORDSZPCF(r);
 
 
@@ -219,7 +222,6 @@ extern UINT calc_a(UINT op, UINT32 *seg)
 		I286_OV = 0;												\
 		I286_FLAGL = BYTESZPF(d);
 
-
 #define	ORWORD(d, s)												\
 		(d) |= (s);													\
 		I286_OV = 0;												\
@@ -229,14 +231,13 @@ extern UINT calc_a(UINT op, UINT32 *seg)
 #define	ADCBYTE(r, d, s) 											\
 		(r) = (I286_FLAGL & 1) + (s) + (d);							\
 		I286_OV = ((r) ^ (s)) & ((r) ^ (d)) & 0x80;					\
-		I286_FLAGL = (BYTE)(((r) ^ (d) ^ (s)) & A_FLAG);			\
+		I286_FLAGL = (UINT8)(((r) ^ (d) ^ (s)) & A_FLAG);			\
 		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);			\
+		I286_FLAGL = (UINT8)(((r) ^ (d) ^ (s)) & A_FLAG);			\
 		I286_FLAGL |= WORDSZPCF(r);
 
 
@@ -244,13 +245,13 @@ extern UINT calc_a(UINT op, UINT32 *seg)
 #define	SBBBYTE(r, d, s) 											\
 		(r) = (d) - (s) - (I286_FLAGL & 1);							\
 		I286_OV = ((d) ^ (r)) & ((d) ^ (s)) & 0x80;					\
-		I286_FLAGL = (BYTE)(((r) ^ (d) ^ (s)) & A_FLAG);			\
+		I286_FLAGL = (UINT8)(((r) ^ (d) ^ (s)) & A_FLAG);			\
 		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);			\
+		I286_FLAGL = (UINT8)(((r) ^ (d) ^ (s)) & A_FLAG);			\
 		I286_FLAGL |= WORDSZPCF(r);
 
 
@@ -260,63 +261,59 @@ extern UINT calc_a(UINT op, UINT32 *seg)
 		I286_OV = 0;												\
 		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 = (UINT8)(((r) ^ (d) ^ (s)) & A_FLAG);			\
 		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);			\
+		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 = 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 = (UINT8)(((d) ^ (s)) & A_FLAG);					\
 		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);					\
+		I286_FLAGL = (UINT8)(((d) ^ (s)) & A_FLAG);					\
 		I286_FLAGL |= WORDSZPCF(d);
 
 
 #define	BYTE_MUL(r, d, s)											\
 		I286_FLAGL &= (Z_FLAG | S_FLAG | A_FLAG | P_FLAG);			\
-		(r) = (BYTE)(d) * (BYTE)(s);								\
+		(r) = (UINT8)(d) * (UINT8)(s);								\
 		I286_OV = (r) >> 8;											\
 		if (I286_OV) {												\
 			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);							\
@@ -328,16 +325,15 @@ extern UINT calc_a(UINT op, UINT32 *seg)
 
 #define	BYTE_IMUL(r, d, s)											\
 		I286_FLAGL &= (Z_FLAG | S_FLAG | A_FLAG | P_FLAG);			\
-		(r) = (char)(d) * (char)(s);								\
+		(r) = (SINT8)(d) * (SINT8)(s);								\
 		I286_OV = ((r) + 0x80) & 0xffffff00;						\
 		if (I286_OV) {												\
 			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);								\
+		(r) = (SINT16)(d) * (SINT16)(s);							\
 		I286_OV = ((r) + 0x8000) & 0xffff0000;						\
 		if (I286_OV) {												\
 			I286_FLAGL |= C_FLAG;									\
@@ -345,97 +341,118 @@ extern UINT calc_a(UINT op, UINT32 *seg)
 
 
 // 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 |= BYTESZPF(b);									\
-		(s) = b;													\
+		I286_FLAGL |= (UINT8)((b ^ (s)) & A_FLAG);					\
+		I286_FLAGL |= BYTESZPF((UINT8)(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 |= (UINT8)((b ^ (s)) & A_FLAG);					\
+		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 |= BYTESZPF(b);									\
+		I286_FLAGL |= (UINT8)((b ^ (s)) & A_FLAG);					\
+		I286_FLAGL |= BYTESZPF((UINT8)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 |= (UINT8)((b ^ (s)) & A_FLAG);					\
+		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 |= (UINT8)((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 |= (UINT8)((d ^ s) & A_FLAG);					\
+		I286_FLAGL |= WORDSZPF((UINT16)d);							\
 		I286_WORKCLOCK(clock);										\
 	}
 
 
-#define	REGPUSH(reg, clock)	{										\
-		I286_WORKCLOCK(clock);										\
-		I286_SP -= 2;												\
-		i286_memorywrite_w(I286_SP + SS_BASE, reg);					\
-	}
-
+// ---- stack
 
 #define	REGPUSH0(reg)												\
 		I286_SP -= 2;												\
 		i286_memorywrite_w(I286_SP + SS_BASE, reg);
 
+#define	REGPOP0(reg) 												\
+		reg = i286_memoryread_w(I286_SP + SS_BASE);					\
+		I286_SP += 2;
+
+#if (defined(ARM) || defined(X11)) && defined(BYTESEX_LITTLE)
 
-#define	SP_PUSH(reg, clock)	{										\
-		UINT16 sp = reg;											\
+#define	REGPUSH(reg, clock)	{										\
+		UINT32 addr;												\
+		I286_WORKCLOCK(clock);										\
 		I286_SP -= 2;												\
-		i286_memorywrite_w(I286_SP + SS_BASE, sp);					\
+		addr = I286_SP + SS_BASE;									\
+		if (INHIBIT_WORDP(addr)) {									\
+			i286_memorywrite_w(addr, reg);							\
+		}															\
+		else {														\
+			*(UINT16 *)(mem + addr) = (reg);						\
+		}															\
+	}
+
+#define	REGPOP(reg, clock) {										\
+		UINT32 addr;												\
 		I286_WORKCLOCK(clock);										\
+		addr = I286_SP + SS_BASE;									\
+		if (INHIBIT_WORDP(addr)) {									\
+			(reg) = i286_memoryread_w(addr);						\
+		}															\
+		else {														\
+			(reg) = *(UINT16 *)(mem + addr);						\
+		}															\
+		I286_SP += 2;												\
 	}
 
+#else
+
+#define	REGPUSH(reg, clock)	{										\
+		I286_WORKCLOCK(clock);										\
+		I286_SP -= 2;												\
+		i286_memorywrite_w(I286_SP + SS_BASE, reg);					\
+	}
 
 #define	REGPOP(reg, clock) {										\
 		I286_WORKCLOCK(clock);										\
@@ -443,16 +460,19 @@ extern UINT calc_a(UINT op, UINT32 *seg)
 		I286_SP += 2;												\
 	}
 
-#define	SP_POP(reg, clock) {										\
+#endif
+
+#define	SP_PUSH(reg, clock)	{										\
+		REG16 sp = (reg);											\
+		I286_SP -= 2;												\
+		i286_memorywrite_w(I286_SP + SS_BASE, sp);					\
 		I286_WORKCLOCK(clock);										\
-		reg = i286_memoryread_w(I286_SP + SS_BASE);					\
 	}
 
-
-#define	REGPOP0(reg) 												\
+#define	SP_POP(reg, clock) {										\
+		I286_WORKCLOCK(clock);										\
 		reg = i286_memoryread_w(I286_SP + SS_BASE);					\
-		I286_SP += 2;
-
+	}
 
 
 #define	JMPSHORT(clock) {											\
@@ -480,5 +500,7 @@ extern UINT calc_a(UINT op, UINT32 *seg)
 	}
 
 
-#define	INT_NUM(a, b)		i286_intnum(a, b)
+#define	SEGSELECT(c)	((I286_MSW & MSW_PE)?i286c_selector(c):((c) << 4))
+
+#define	INT_NUM(a, b)	i286c_intnum((a), (REG16)(b))