--- np2/i286c/i286c.c	2003/10/26 07:50:36	1.6
+++ np2/i286c/i286c.c	2005/02/07 14:46:10	1.25
@@ -1,17 +1,16 @@
 #include	"compiler.h"
-#include	"i286.h"
+#include	"cpucore.h"
 #include	"i286c.h"
 #include	"v30patch.h"
-#include	"memory.h"
 #include	"pccore.h"
 #include	"iocore.h"
 #include	"dmap.h"
 #include	"i286c.mcr"
 
 
-	I286REG		i286reg;
+	I286CORE	i286core;
 
-const BYTE iflags[256] = {					// Z_FLAG, S_FLAG, P_FLAG
+const UINT8 iflags[512] = {					// Z_FLAG, S_FLAG, P_FLAG
 			0x44, 0x00, 0x00, 0x04, 0x00, 0x04, 0x04, 0x00,
 			0x00, 0x04, 0x04, 0x00, 0x04, 0x00, 0x00, 0x04,
 			0x00, 0x04, 0x04, 0x00, 0x04, 0x00, 0x00, 0x04,
@@ -43,86 +42,90 @@ const BYTE iflags[256] = {					// Z_FLAG
 			0x80, 0x84, 0x84, 0x80, 0x84, 0x80, 0x80, 0x84,
 			0x84, 0x80, 0x80, 0x84, 0x80, 0x84, 0x84, 0x80,
 			0x84, 0x80, 0x80, 0x84, 0x80, 0x84, 0x84, 0x80,
-			0x80, 0x84, 0x84, 0x80, 0x84, 0x80, 0x80, 0x84};
+			0x80, 0x84, 0x84, 0x80, 0x84, 0x80, 0x80, 0x84,
+			0x45, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
+			0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
+			0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
+			0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
+			0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
+			0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
+			0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
+			0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
+			0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
+			0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
+			0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
+			0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
+			0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
+			0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
+			0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
+			0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
+			0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
+			0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
+			0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
+			0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
+			0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
+			0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
+			0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
+			0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
+			0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
+			0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
+			0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
+			0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
+			0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
+			0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
+			0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
+			0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85};
 
 
 // ----
 
-	UINT32	EA_FIX;
-	BYTE	*reg8_b53[256];
-	BYTE	*reg8_b20[256];
-	UINT16	*reg16_b53[256];
-	UINT16	*reg16_b20[256];
-	BYTE	szpcflag[0x200];
-	CALCEA	c_calc_ea_dst[256];
-	CALCLEA	c_calc_lea[192];
-	GETLEA	c_get_ea[192];
-
-#if !defined(CPUW2TEST)
-	BYTE	szpflag_w[0x10000];
+#if !defined(MEMOPTIMIZE)
+	UINT8	_szpflag16[0x10000];
 #endif
 
+#if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
+	UINT8	*_reg8_b53[256];
+	UINT8	*_reg8_b20[256];
+#endif
+#if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
+	UINT16	*_reg16_b53[256];
+	UINT16	*_reg16_b20[256];
+#endif
 
-static UINT32 ea_nop(void) {
-
-	return(0);
-}
-
-void i286_initialize(void) {
+void i286c_initialize(void) {
 
+#if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
 	UINT	i;
-	UINT	bit;
-	BYTE	f;
-	int		pos;
-
-	for (i=0; i<0x100; i++) {
-		f = P_FLAG;
-		for (bit=0x80; bit; bit>>=1) {
-			if (i & bit) {
-				f ^= P_FLAG;
-			}
-		}
-		if (!(i & 0xff)) {
-			f |= Z_FLAG;
-		}
-		if (i & 0x80) {
-			f |= S_FLAG;
-		}
-		szpcflag[i+0x000] = f;
-		szpcflag[i+0x100] = f | C_FLAG;
-	}
+#endif
 
+#if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
 	for (i=0; i<0x100; i++) {
+		int pos;
 #if defined(BYTESEX_LITTLE)
 		pos = ((i & 0x20)?1:0);
 #else
 		pos = ((i & 0x20)?0:1);
 #endif
 		pos += ((i >> 3) & 3) * 2;
-		reg8_b53[i] = ((BYTE *)&I286_REG) + pos;
+		_reg8_b53[i] = ((UINT8 *)&I286_REG) + pos;
 #if defined(BYTESEX_LITTLE)
 		pos = ((i & 0x4)?1:0);
 #else
 		pos = ((i & 0x4)?0:1);
 #endif
 		pos += (i & 3) * 2;
-		reg8_b20[i] = ((BYTE *)&I286_REG) + pos;
-		reg16_b53[i] = ((UINT16 *)&I286_REG) + ((i >> 3) & 7);
-		reg16_b20[i] = ((UINT16 *)&I286_REG) + (i & 7);
-	}
-
-	for (i=0; i<0xc0; i++) {
-		pos = ((i >> 3) & 0x18) + (i & 0x07);
-		c_calc_ea_dst[i] = i286c_ea_dst_tbl[pos];
-		c_calc_lea[i] = i286c_lea_tbl[pos];
-		c_get_ea[i] = i286c_ea_tbl[pos];
-	}
-	for (; i<0x100; i++) {
-		c_calc_ea_dst[i] = ea_nop;
+		_reg8_b20[i] = ((UINT8 *)&I286_REG) + pos;
+#if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
+		_reg16_b53[i] = ((UINT16 *)&I286_REG) + ((i >> 3) & 7);
+		_reg16_b20[i] = ((UINT16 *)&I286_REG) + (i & 7);
+#endif
 	}
+#endif
 
-#if !defined(CPUW2TEST)
+#if !defined(MEMOPTIMIZE)
 	for (i=0; i<0x10000; i++) {
+		REG8 f;
+		UINT bit;
 		f = P_FLAG;
 		for (bit=0x80; bit; bit>>=1) {
 			if (i & bit) {
@@ -135,26 +138,87 @@ void i286_initialize(void) {
 		if (i & 0x8000) {
 			f |= S_FLAG;
 		}
-		szpflag_w[i] = f;
+		_szpflag16[i] = f;
 	}
 #endif
-	v30init();
+#if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
+	i286cea_initialize();
+#endif
+	v30cinit();
+	ZeroMemory(&i286core, sizeof(i286core));
+}
+
+void i286c_deinitialize(void) {
+
+	if (CPU_EXTMEM) {
+		_MFREE(CPU_EXTMEM);
+		CPU_EXTMEM = NULL;
+		CPU_EXTMEMSIZE = 0;
+	}
+}
+
+static void i286c_initreg(void) {
+
+	I286_CS = 0xf000;
+	CS_BASE = 0xf0000;
+	I286_IP = 0xfff0;
+	I286_ADRSMASK = 0xfffff;
+}
+
+void i286c_reset(void) {
+
+	ZeroMemory(&i286core.s, sizeof(i286core.s));
+	i286c_initreg();
+}
+
+void i286c_shut(void) {
+
+	ZeroMemory(&i286core.s, offsetof(I286STAT, cpu_type));
+	i286c_initreg();
 }
 
-void i286_reset(void) {
+void i286c_setextsize(UINT32 size) {
 
-	i286_initialize();
-	ZeroMemory(&i286reg, sizeof(i286reg));
-	I286_CS = 0x1fc0;
-	CS_BASE = 0x1fc00;
+	if (CPU_EXTMEMSIZE != size) {
+		if (CPU_EXTMEM) {
+			_MFREE(CPU_EXTMEM);
+			CPU_EXTMEM = NULL;
+		}
+		if (size) {
+			CPU_EXTMEM = (UINT8 *)_MALLOC(size + 16, "EXTMEM");
+			if (CPU_EXTMEM == NULL) {
+				size = 0;
+			}
+		}
+		CPU_EXTMEMSIZE = size;
+	}
+	i286core.e.ems[0] = mem + 0xc0000;
+	i286core.e.ems[1] = mem + 0xc4000;
+	i286core.e.ems[2] = mem + 0xc8000;
+	i286core.e.ems[3] = mem + 0xcc000;
 }
 
-void i286_resetprefetch(void) {
+void i286c_setemm(UINT frame, UINT32 addr) {
+
+	UINT8	*ptr;
+
+	frame &= 3;
+	if (addr < USE_HIMEM) {
+		ptr = mem + addr;
+	}
+	else if ((addr - 0x100000 + 0x4000) <= CPU_EXTMEMSIZE) {
+		ptr = CPU_EXTMEM + (addr - 0x100000);
+	}
+	else {
+		ptr = mem + 0xc0000 + (frame << 14);
+	}
+	i286core.e.ems[frame] = ptr;
 }
 
-void CPUCALL i286_intnum(UINT vect, UINT16 IP) {
 
-const BYTE	*ptr;
+void CPUCALL i286c_intnum(UINT vect, REG16 IP) {
+
+const UINT8	*ptr;
 
 	REGPUSH0(REAL_FLAGREG)
 	REGPUSH0(I286_CS)
@@ -163,17 +227,17 @@ const BYTE	*ptr;
 	I286_FLAG &= ~(T_FLAG | I_FLAG);
 	I286_TRAP = 0;
 
-	ptr = I286_MEM + (vect * 4);
+	ptr = mem + (vect * 4);
 	I286_IP = LOADINTELWORD(ptr+0);				// real mode!
 	I286_CS = LOADINTELWORD(ptr+2);				// real mode!
 	CS_BASE = I286_CS << 4;
 	I286_WORKCLOCK(20);
 }
 
-void CPUCALL i286_interrupt(BYTE vect) {
+void CPUCALL i286c_interrupt(REG8 vect) {
 
 	UINT	op;
-const BYTE	*ptr;
+const UINT8	*ptr;
 
 	op = i286_memoryread(I286_IP + CS_BASE);
 	if (op == 0xf4) {							// hlt
@@ -186,14 +250,14 @@ const BYTE	*ptr;
 	I286_FLAG &= ~(T_FLAG | I_FLAG);
 	I286_TRAP = 0;
 
-	ptr = I286_MEM + (vect * 4);
-	I286_IP = LOADINTELWORD(ptr+0);				// real mode!
-	I286_CS = LOADINTELWORD(ptr+2);				// real mode!
+	ptr = mem + (vect * 4);
+	I286_IP = LOADINTELWORD(ptr + 0);			// real mode!
+	I286_CS = LOADINTELWORD(ptr + 2);			// real mode!
 	CS_BASE = I286_CS << 4;
 	I286_WORKCLOCK(20);
 }
 
-void i286(void) {
+void i286c(void) {
 
 	UINT	opcode;
 
@@ -202,7 +266,7 @@ void i286(void) {
 			GET_PCBYTE(opcode);
 			i286op[opcode]();
 			if (I286_TRAP) {
-				i286_interrupt(1);
+				i286c_interrupt(1);
 			}
 			dmap_i286();
 		} while(I286_REMCLOCK > 0);
@@ -222,7 +286,7 @@ void i286(void) {
 	}
 }
 
-void i286_step(void) {
+void i286c_step(void) {
 
 	UINT	opcode;
 
@@ -239,3 +303,64 @@ void i286_step(void) {
 	dmap_i286();
 }
 
+
+// ---- test
+
+#if defined(I286C_TEST)
+UINT8 BYTESZPF(UINT r) {
+
+	if (r & (~0xff)) {
+		TRACEOUT(("BYTESZPF bound error: %x", r));
+	}
+	return(iflags[r & 0xff]);
+}
+
+UINT8 BYTESZPCF(UINT r) {
+
+	if (r & (~0x1ff)) {
+		TRACEOUT(("BYTESZPCF bound error: %x", r));
+	}
+	return(iflags[r & 0x1ff]);
+}
+
+UINT8 WORDSZPF(UINT32 r) {
+
+	UINT8	f1;
+	UINT8	f2;
+
+	if (r & (~0xffff)) {
+		TRACEOUT(("WORDSZPF bound error: %x", r));
+	}
+	f1 = _szpflag16[r & 0xffff];
+	f2 = iflags[r & 0xff] & P_FLAG;
+	f2 += (r)?0:Z_FLAG;
+	f2 += (r >> 8) & S_FLAG;
+	if (f1 != f2) {
+		TRACEOUT(("word flag error: %.2x %.2x", f1, f2));
+	}
+	return(f1);
+}
+
+UINT8 WORDSZPCF(UINT32 r) {
+
+	UINT8	f1;
+	UINT8	f2;
+
+	if ((r & 0xffff0000) && (!(r & 0x00010000))) {
+		TRACEOUT(("WORDSZPCF bound error: %x", r));
+	}
+	f1 = (r >> 16) & 1;
+	f1 += _szpflag16[LOW16(r)];
+
+	f2 = iflags[r & 0xff] & P_FLAG;
+	f2 += (LOW16(r))?0:Z_FLAG;
+	f2 += (r >> 8) & S_FLAG;
+	f2 += (r >> 16) & 1;
+
+	if (f1 != f2) {
+		TRACEOUT(("word flag error: %.2x %.2x", f1, f2));
+	}
+	return(f1);
+}
+#endif
+