--- np2/i286c/memory.c	2003/11/28 08:01:32	1.4
+++ np2/i286c/memory.c	2003/12/08 00:55:31	1.10
@@ -1,5 +1,5 @@
 #include	"compiler.h"
-#include	"i286.h"
+#include	"cpucore.h"
 #include	"memory.h"
 #include	"egcmem.h"
 #include	"pccore.h"
@@ -9,25 +9,28 @@
 
 
 #define	USE_HIMEM
+#if defined(TRACE)
+#define	MEMORY_DEBUG
+#endif
 
 // ---- write byte
 
-static void MEMCALL i286_wt(UINT32 address, BYTE value) {
+static void MEMCALL i286_wt(UINT32 address, REG8 value) {
 
-	mem[address & extmem.adrsmask] = value;
+	mem[address & CPU_ADRSMASK] = (BYTE)value;
 }
 
-static void MEMCALL tram_wt(UINT32 address, BYTE value) {
+static void MEMCALL tram_wt(UINT32 address, REG8 value) {
 
-	I286_REMCLOCK -= vramop.tramwait;
+	CPU_REMCLOCK -= vramop.tramwait;
 	if (address < 0xa2000) {
-		mem[address] = value;
+		mem[address] = (BYTE)value;
 		tramupdate[LOW12(address >> 1)] = 1;
 		gdcs.textdisp |= 1;
 	}
 	else if (address < 0xa3fe0) {
 		if (!(address & 1)) {
-			mem[address] = value;
+			mem[address] = (BYTE)value;
 			tramupdate[LOW12(address >> 1)] = 1;
 			gdcs.textdisp |= 1;
 		}
@@ -35,7 +38,7 @@ static void MEMCALL tram_wt(UINT32 addre
 	else if (address < 0xa4000) {
 		if (!(address & 1)) {
 			if ((!(address & 2)) || (gdcs.msw_accessable)) {
-				mem[address] = value;
+				mem[address] = (BYTE)value;
 				tramupdate[LOW12(address >> 1)] = 1;
 				gdcs.textdisp |= 1;
 			}
@@ -44,33 +47,33 @@ static void MEMCALL tram_wt(UINT32 addre
 	else if (address < 0xa5000) {
 		if ((address & 1) && (cgwindow.writable & 1)) {
 			cgwindow.writable |= 0x80;
-			fontrom[cgwindow.high + ((address >> 1) & 0x0f)] = value;
+			fontrom[cgwindow.high + ((address >> 1) & 0x0f)] = (BYTE)value;
 		}
 	}
 }
 
-static void MEMCALL vram_w0(UINT32 address, BYTE value) {
+static void MEMCALL vram_w0(UINT32 address, REG8 value) {
 
-	I286_REMCLOCK -= vramop.vramwait;
-	mem[address] = value;
+	CPU_REMCLOCK -= vramop.vramwait;
+	mem[address] = (BYTE)value;
 	vramupdate[LOW15(address)] |= 1;
 	gdcs.grphdisp |= 1;
 }
 
-static void MEMCALL vram_w1(UINT32 address, BYTE value) {
+static void MEMCALL vram_w1(UINT32 address, REG8 value) {
 
-	I286_REMCLOCK -= vramop.vramwait;
-	mem[address + VRAM_STEP] = value;
+	CPU_REMCLOCK -= vramop.vramwait;
+	mem[address + VRAM_STEP] = (BYTE)value;
 	vramupdate[LOW15(address)] |= 2;
 	gdcs.grphdisp |= 2;
 }
 
-static void MEMCALL grcg_rmw0(UINT32 address, BYTE value) {
+static void MEMCALL grcg_rmw0(UINT32 address, REG8 value) {
 
-	BYTE	mask;
+	REG8	mask;
 	BYTE	*vram;
 
-	I286_REMCLOCK -= vramop.grcgwait;
+	CPU_REMCLOCK -= vramop.grcgwait;
 	mask = ~value;
 	address = LOW15(address);
 	vramupdate[address] |= 1;
@@ -94,12 +97,12 @@ static void MEMCALL grcg_rmw0(UINT32 add
 	}
 }
 
-static void MEMCALL grcg_rmw1(UINT32 address, BYTE value) {
+static void MEMCALL grcg_rmw1(UINT32 address, REG8 value) {
 
-	BYTE	mask;
+	REG8	mask;
 	BYTE	*vram;
 
-	I286_REMCLOCK -= vramop.grcgwait;
+	CPU_REMCLOCK -= vramop.grcgwait;
 	mask = ~value;
 	address = LOW15(address);
 	vramupdate[address] |= 2;
@@ -123,11 +126,11 @@ static void MEMCALL grcg_rmw1(UINT32 add
 	}
 }
 
-static void MEMCALL grcg_tdw0(UINT32 address, BYTE value) {
+static void MEMCALL grcg_tdw0(UINT32 address, REG8 value) {
 
 	BYTE	*vram;
 
-	I286_REMCLOCK -= vramop.grcgwait;
+	CPU_REMCLOCK -= vramop.grcgwait;
 	address = LOW15(address);
 	vramupdate[address] |= 1;
 	gdcs.grphdisp |= 1;
@@ -147,11 +150,11 @@ static void MEMCALL grcg_tdw0(UINT32 add
 	(void)value;
 }
 
-static void MEMCALL grcg_tdw1(UINT32 address, BYTE value) {
+static void MEMCALL grcg_tdw1(UINT32 address, REG8 value) {
 
 	BYTE	*vram;
 
-	I286_REMCLOCK -= vramop.grcgwait;
+	CPU_REMCLOCK -= vramop.grcgwait;
 	address = LOW15(address);
 	vramupdate[address] |= 2;
 	gdcs.grphdisp |= 2;
@@ -171,17 +174,17 @@ static void MEMCALL grcg_tdw1(UINT32 add
 	(void)value;
 }
 
-static void MEMCALL egc_wt(UINT32 address, BYTE value) {
+static void MEMCALL egc_wt(UINT32 address, REG8 value) {
 
 	egc_write(address, value);
 }
 
-static void MEMCALL emmc_wt(UINT32 address, BYTE value) {
+static void MEMCALL emmc_wt(UINT32 address, REG8 value) {
 
-	extmem.pageptr[(address >> 14) & 3][LOW14(address)] = value;
+	extmem.pageptr[(address >> 14) & 3][LOW14(address)] = (BYTE)value;
 }
 
-static void MEMCALL i286_wn(UINT32 address, BYTE value) {
+static void MEMCALL i286_wn(UINT32 address, REG8 value) {
 
 	(void)address;
 	(void)value;
@@ -190,14 +193,14 @@ static void MEMCALL i286_wn(UINT32 addre
 
 // ---- read byte
 
-static BYTE MEMCALL i286_rd(UINT32 address) {
+static REG8 MEMCALL i286_rd(UINT32 address) {
 
-	return(mem[address & extmem.adrsmask]);
+	return(mem[address & CPU_ADRSMASK]);
 }
 
-static BYTE MEMCALL tram_rd(UINT32 address) {
+static REG8 MEMCALL tram_rd(UINT32 address) {
 
-	I286_REMCLOCK -= vramop.tramwait;
+	CPU_REMCLOCK -= vramop.tramwait;
 	if (address < 0xa4000) {
 		return(mem[address]);
 	}
@@ -212,24 +215,24 @@ static BYTE MEMCALL tram_rd(UINT32 addre
 	return(mem[address]);
 }
 
-static BYTE MEMCALL vram_r0(UINT32 address) {
+static REG8 MEMCALL vram_r0(UINT32 address) {
 
-	I286_REMCLOCK -= vramop.vramwait;
+	CPU_REMCLOCK -= vramop.vramwait;
 	return(mem[address]);
 }
 
-static BYTE MEMCALL vram_r1(UINT32 address) {
+static REG8 MEMCALL vram_r1(UINT32 address) {
 
-	I286_REMCLOCK -= vramop.vramwait;
+	CPU_REMCLOCK -= vramop.vramwait;
 	return(mem[address + VRAM_STEP]);
 }
 
-static BYTE MEMCALL grcg_tcr0(UINT32 address) {
+static REG8 MEMCALL grcg_tcr0(UINT32 address) {
 
 const BYTE	*vram;
-	BYTE	ret;
+	REG8	ret;
 
-	I286_REMCLOCK -= vramop.grcgwait;
+	CPU_REMCLOCK -= vramop.grcgwait;
 	vram = mem + LOW15(address);
 	ret = 0;
 	if (!(grcg.modereg & 1)) {
@@ -244,15 +247,15 @@ const BYTE	*vram;
 	if (!(grcg.modereg & 8)) {
 		ret |= vram[VRAM0_E] ^ grcg.tile[3].b[0];
 	}
-	return(~ret);
+	return(ret ^ 0xff);
 }
 
-static BYTE MEMCALL grcg_tcr1(UINT32 address) {
+static REG8 MEMCALL grcg_tcr1(UINT32 address) {
 
-	BYTE	*vram;
-	BYTE	ret;
+const BYTE	*vram;
+	REG8	ret;
 
-	I286_REMCLOCK -= vramop.grcgwait;
+	CPU_REMCLOCK -= vramop.grcgwait;
 	ret = 0;
 	vram = mem + LOW15(address);
 	if (!(grcg.modereg & 1)) {
@@ -267,22 +270,22 @@ static BYTE MEMCALL grcg_tcr1(UINT32 add
 	if (!(grcg.modereg & 8)) {
 		ret |= vram[VRAM1_E] ^ grcg.tile[3].b[0];
 	}
-	return(~ret);
+	return(ret ^ 0xff);
 }
 
-static BYTE MEMCALL egc_rd(UINT32 address) {
+static REG8 MEMCALL egc_rd(UINT32 address) {
 
 	return(egc_read(address));
 }
 
-static BYTE MEMCALL emmc_rd(UINT32 address) {
+static REG8 MEMCALL emmc_rd(UINT32 address) {
 
 	return(extmem.pageptr[(address >> 14) & 3][LOW14(address)]);
 }
 
-static BYTE MEMCALL i286_itf(UINT32 address) {
+static REG8 MEMCALL i286_itf(UINT32 address) {
 
-	if (itf.bank) {
+	if (CPU_ITFBANK) {
 		address = ITF_ADRS + LOW15(address);
 	}
 	return(mem[address]);
@@ -291,15 +294,15 @@ static BYTE MEMCALL i286_itf(UINT32 addr
 
 // ---- write word
 
-static void MEMCALL i286w_wt(UINT32 address, UINT16 value) {
+static void MEMCALL i286w_wt(UINT32 address, REG16 value) {
 
 	BYTE	*ptr;
 
-	ptr = mem + (address & extmem.adrsmask);
+	ptr = mem + (address & CPU_ADRSMASK);
 	STOREINTELWORD(ptr, value);
 }
 
-static void MEMCALL tramw_wt(UINT32 address, UINT16 value) {
+static void MEMCALL tramw_wt(UINT32 address, REG16 value) {
 
 	if (address < 0xa1fff) {
 		STOREINTELWORD(mem + address, value);
@@ -346,7 +349,7 @@ static void MEMCALL tramw_wt(UINT32 addr
 
 
 #define GRCGW_NON(page) {											\
-	I286_REMCLOCK -= vramop.vramwait;								\
+	CPU_REMCLOCK -= vramop.vramwait;								\
 	STOREINTELWORD(mem + address + VRAM_STEP*(page), value);		\
 	vramupdate[LOW15(address)] |= (1 << page);						\
 	vramupdate[LOW15(address + 1)] |= (1 << page);					\
@@ -355,7 +358,7 @@ static void MEMCALL tramw_wt(UINT32 addr
 
 #define GRCGW_RMW(page) {											\
 	BYTE	*vram;													\
-	I286_REMCLOCK -= vramop.grcgwait;								\
+	CPU_REMCLOCK -= vramop.grcgwait;								\
 	address = LOW15(address);										\
 	vramupdate[address] |= (1 << page);								\
 	vramupdate[address + 1] |= (1 << page);							\
@@ -401,7 +404,7 @@ static void MEMCALL tramw_wt(UINT32 addr
 
 #define GRCGW_TDW(page) {											\
 	BYTE	*vram;													\
-	I286_REMCLOCK -= vramop.grcgwait;								\
+	CPU_REMCLOCK -= vramop.grcgwait;								\
 	address = LOW15(address);										\
 	vramupdate[address] |= (1 << page);								\
 	vramupdate[address + 1] |= (1 << page);							\
@@ -426,31 +429,31 @@ static void MEMCALL tramw_wt(UINT32 addr
 	(void)value;													\
 }
 
-static void MEMCALL vramw_w0(UINT32 address, UINT16 value) GRCGW_NON(0)
-static void MEMCALL vramw_w1(UINT32 address, UINT16 value) GRCGW_NON(1)
-static void MEMCALL grcgw_rmw0(UINT32 address, UINT16 value) GRCGW_RMW(0)
-static void MEMCALL grcgw_rmw1(UINT32 address, UINT16 value) GRCGW_RMW(1)
-static void MEMCALL grcgw_tdw0(UINT32 address, UINT16 value) GRCGW_TDW(0)
-static void MEMCALL grcgw_tdw1(UINT32 address, UINT16 value) GRCGW_TDW(1)
+static void MEMCALL vramw_w0(UINT32 address, REG16 value) GRCGW_NON(0)
+static void MEMCALL vramw_w1(UINT32 address, REG16 value) GRCGW_NON(1)
+static void MEMCALL grcgw_rmw0(UINT32 address, REG16 value) GRCGW_RMW(0)
+static void MEMCALL grcgw_rmw1(UINT32 address, REG16 value) GRCGW_RMW(1)
+static void MEMCALL grcgw_tdw0(UINT32 address, REG16 value) GRCGW_TDW(0)
+static void MEMCALL grcgw_tdw1(UINT32 address, REG16 value) GRCGW_TDW(1)
 
-static void MEMCALL egcw_wt(UINT32 address, UINT16 value) {
+static void MEMCALL egcw_wt(UINT32 address, REG16 value) {
 
 	if (!(address & 1)) {
 		egc_write_w(address, value);
 	}
 	else {
 		if (!(egc.sft & 0x1000)) {
-			egc_write(address, (BYTE)value);
-			egc_write(address + 1, (BYTE)(value >> 8));
+			egc_write(address, (REG8)value);
+			egc_write(address + 1, (REG8)(value >> 8));
 		}
 		else {
-			egc_write(address + 1, (BYTE)(value >> 8));
-			egc_write(address, (BYTE)value);
+			egc_write(address + 1, (REG8)(value >> 8));
+			egc_write(address, (REG8)value);
 		}
 	}
 }
 
-static void MEMCALL emmcw_wt(UINT32 address, UINT16 value) {
+static void MEMCALL emmcw_wt(UINT32 address, REG16 value) {
 
 	BYTE	*ptr;
 
@@ -460,11 +463,11 @@ static void MEMCALL emmcw_wt(UINT32 addr
 	}
 	else {
 		extmem.pageptr[(address >> 14) & 3][0x3fff] = (BYTE)value;
-		extmem.pageptr[((address + 1)>> 14) & 3][0] = (BYTE)(value >> 8);
+		extmem.pageptr[((address + 1) >> 14) & 3][0] = (BYTE)(value >> 8);
 	}
 }
 
-static void MEMCALL i286w_wn(UINT32 address, UINT16 value) {
+static void MEMCALL i286w_wn(UINT32 address, REG16 value) {
 
 	(void)address;
 	(void)value;
@@ -473,17 +476,17 @@ static void MEMCALL i286w_wn(UINT32 addr
 
 // ---- read word
 
-static UINT16 MEMCALL i286w_rd(UINT32 address) {
+static REG16 MEMCALL i286w_rd(UINT32 address) {
 
 	BYTE	*ptr;
 
-	ptr = mem + (address & extmem.adrsmask);
+	ptr = mem + (address & CPU_ADRSMASK);
 	return(LOADINTELWORD(ptr));
 }
 
-static UINT16 MEMCALL tramw_rd(UINT32 address) {
+static REG16 MEMCALL tramw_rd(UINT32 address) {
 
-	I286_REMCLOCK -= vramop.tramwait;
+	CPU_REMCLOCK -= vramop.tramwait;
 	if (address < (0xa4000 - 1)) {
 		return(LOADINTELWORD(mem + address));
 	}
@@ -492,13 +495,13 @@ static UINT16 MEMCALL tramw_rd(UINT32 ad
 	}
 	else if (address < 0xa4fff) {
 		if (address & 1) {
-			UINT16 ret;
+			REG16 ret;
 			ret = fontrom[cgwindow.high + ((address >> 1) & 0x0f)];
 			ret += fontrom[cgwindow.low + (((address + 1) >> 1) & 0x0f)] << 8;
 			return(ret);
 		}
 		else {
-			UINT16 ret;
+			REG16 ret;
 			ret = fontrom[cgwindow.low + ((address >> 1) & 0x0f)];
 			ret += fontrom[cgwindow.high + ((address >> 1) & 0x0f)] << 8;
 			return(ret);
@@ -510,24 +513,24 @@ static UINT16 MEMCALL tramw_rd(UINT32 ad
 	return(LOADINTELWORD(mem + address));
 }
 
-static UINT16 MEMCALL vramw_r0(UINT32 address) {
+static REG16 MEMCALL vramw_r0(UINT32 address) {
 
-	I286_REMCLOCK -= vramop.vramwait;
+	CPU_REMCLOCK -= vramop.vramwait;
 	return(LOADINTELWORD(mem + address));
 }
 
-static UINT16 MEMCALL vramw_r1(UINT32 address) {
+static REG16 MEMCALL vramw_r1(UINT32 address) {
 
-	I286_REMCLOCK -= vramop.vramwait;
+	CPU_REMCLOCK -= vramop.vramwait;
 	return(LOADINTELWORD(mem + address + VRAM_STEP));
 }
 
-static UINT16 MEMCALL grcgw_tcr0(UINT32 address) {
+static REG16 MEMCALL grcgw_tcr0(UINT32 address) {
 
 	BYTE	*vram;
-	UINT16	ret;
+	REG16	ret;
 
-	I286_REMCLOCK -= vramop.grcgwait;
+	CPU_REMCLOCK -= vramop.grcgwait;
 	ret = 0;
 	vram = mem + LOW15(address);
 	if (!(grcg.modereg & 1)) {
@@ -542,15 +545,15 @@ static UINT16 MEMCALL grcgw_tcr0(UINT32 
 	if (!(grcg.modereg & 8)) {
 		ret |= LOADINTELWORD(vram + VRAM0_E) ^ grcg.tile[3].w;
 	}
-	return(~ret);
+	return((UINT16)~ret);
 }
 
-static UINT16 MEMCALL grcgw_tcr1(UINT32 address) {
+static REG16 MEMCALL grcgw_tcr1(UINT32 address) {
 
 	BYTE	*vram;
-	UINT16	ret;
+	REG16	ret;
 
-	I286_REMCLOCK -= vramop.grcgwait;
+	CPU_REMCLOCK -= vramop.grcgwait;
 	ret = 0;
 	vram = mem + LOW15(address);
 	if (!(grcg.modereg & 1)) {
@@ -565,12 +568,12 @@ static UINT16 MEMCALL grcgw_tcr1(UINT32 
 	if (!(grcg.modereg & 8)) {
 		ret |= LOADINTELWORD(vram + VRAM1_E) ^ grcg.tile[3].w;
 	}
-	return(~ret);
+	return((UINT16)(~ret));
 }
 
-static UINT16 MEMCALL egcw_rd(UINT32 address) {
+static REG16 MEMCALL egcw_rd(UINT32 address) {
 
-	UINT16 ret;
+	REG16	ret;
 
 	if (!(address & 1)) {
 		return(egc_read_w(address));
@@ -578,29 +581,36 @@ static UINT16 MEMCALL egcw_rd(UINT32 add
 	else {
 		if (!(egc.sft & 0x1000)) {
 			ret = egc_read(address);
-			ret += (UINT16)egc_read(address + 1) << 8;
+			ret += egc_read(address + 1) << 8;
 			return(ret);
 		}
 		else {
-			UINT16 ret;
-			ret = (UINT16)egc_read(address + 1) << 8;
+			ret = egc_read(address + 1) << 8;
 			ret += egc_read(address);
 			return(ret);
 		}
 	}
 }
 
-static UINT16 MEMCALL emmcw_rd(UINT32 address) {
+static REG16 MEMCALL emmcw_rd(UINT32 address) {
 
-	BYTE	*ptr;
+const BYTE	*ptr;
+	REG16	ret;
 
-	ptr = extmem.pageptr[(address >> 14) & 3] + LOW14(address);
-	return(LOADINTELWORD(ptr));
+	if ((address & 0x3fff) != 0x3fff) {
+		ptr = extmem.pageptr[(address >> 14) & 3] + LOW14(address);
+		return(LOADINTELWORD(ptr));
+	}
+	else {
+		ret = extmem.pageptr[(address >> 14) & 3][0x3fff];
+		ret += extmem.pageptr[((address + 1) >> 14) & 3][0] << 8;
+		return(ret);
+	}
 }
 
-static UINT16 MEMCALL i286w_itf(UINT32 address) {
+static REG16 MEMCALL i286w_itf(UINT32 address) {
 
-	if (itf.bank) {
+	if (CPU_ITFBANK) {
 		address = ITF_ADRS + LOW15(address);
 	}
 	return(LOADINTELWORD(mem + address));
@@ -609,10 +619,10 @@ static UINT16 MEMCALL i286w_itf(UINT32 a
 
 // ---- table
 
-typedef void (MEMCALL * MEM8WRITE)(UINT32 address, BYTE value);
-typedef BYTE (MEMCALL * MEM8READ)(UINT32 address);
-typedef void (MEMCALL * MEM16WRITE)(UINT32 address, UINT16 value);
-typedef UINT16 (MEMCALL * MEM16READ)(UINT32 address);
+typedef void (MEMCALL * MEM8WRITE)(UINT32 address, REG8 value);
+typedef REG8 (MEMCALL * MEM8READ)(UINT32 address);
+typedef void (MEMCALL * MEM16WRITE)(UINT32 address, REG16 value);
+typedef REG16 (MEMCALL * MEM16READ)(UINT32 address);
 
 static MEM8WRITE memory_write[] = {
 			i286_wt,	i286_wt,	i286_wt,	i286_wt,		// 00
@@ -679,13 +689,13 @@ static const MEM16READ vramw_read[] = {
 			vramw_r0,	vramw_r1,	egcw_rd,	egcw_rd};		// c0 rmw
 
 
-static BYTE MEMCALL i286_nonram_r(UINT32 address) {
+static REG8 MEMCALL i286_nonram_r(UINT32 address) {
 
 	(void)address;
 	return(0xff);
 }
 
-static UINT16 MEMCALL i286_nonram_rw(UINT32 address) {
+static REG16 MEMCALL i286_nonram_rw(UINT32 address) {
 
 	(void)address;
 	return(0xffff);
@@ -724,7 +734,8 @@ void MEMCALL i286_vram_dispatch(UINT fun
 	}
 }
 
-BYTE MEMCALL i286_memoryread(UINT32 address) {
+#if defined(MEMORY_DEBUG)
+static REG8 MEMCALL _i286_memoryread(UINT32 address) {
 
 	if (address < I286_MEMREADMAX) {
 		return(mem[address]);
@@ -732,8 +743,8 @@ BYTE MEMCALL i286_memoryread(UINT32 addr
 #if defined(USE_HIMEM)
 	else if (address >= 0x10fff0) {
 		address -= 0x100000;
-		if (address < extmemmng_size) {
-			return(extmemmng_ptr[address]);
+		if (address < CPU_EXTMEMSIZE) {
+			return(CPU_EXTMEM[address]);
 		}
 		else {
 			return(0xff);
@@ -745,9 +756,9 @@ BYTE MEMCALL i286_memoryread(UINT32 addr
 	}
 }
 
-UINT16 MEMCALL i286_memoryread_w(UINT32 address) {
+static REG16 MEMCALL _i286_memoryread_w(UINT32 address) {
 
-	UINT16	ret;
+	REG16	ret;
 
 	if (address < (I286_MEMREADMAX - 1)) {
 		return(LOADINTELWORD(mem + address));
@@ -758,15 +769,15 @@ UINT16 MEMCALL i286_memoryread_w(UINT32 
 		if (address == (0x00fff0 - 1)) {
 			ret = mem[0x100000 + address];
 		}
-		else if (address < extmemmng_size) {
-			ret = extmemmng_ptr[address];
+		else if (address < CPU_EXTMEMSIZE) {
+			ret = CPU_EXTMEM[address];
 		}
 		else {
 			ret = 0xff;
 		}
 		address++;
-		if (address < extmemmng_size) {
-			ret += extmemmng_ptr[address] << 8;
+		if (address < CPU_EXTMEMSIZE) {
+			ret += CPU_EXTMEM[address] << 8;
 		}
 		else {
 			ret += 0xff00;
@@ -785,16 +796,100 @@ UINT16 MEMCALL i286_memoryread_w(UINT32 
 	}
 }
 
-void MEMCALL i286_memorywrite(UINT32 address, BYTE value) {
+REG8 MEMCALL i286_memoryread(UINT32 address) {
+
+	REG8	r;
+
+	r = _i286_memoryread(address);
+	if (r & 0xffffff00) {
+		TRACEOUT(("error i286_memoryread %x %x", address, r));
+	}
+	return(r);
+}
+
+REG16 MEMCALL i286_memoryread_w(UINT32 address) {
+
+	REG16	r;
+
+	r = _i286_memoryread_w(address);
+	if (r & 0xffff0000) {
+		TRACEOUT(("error i286_memoryread_w %x %x", address, r));
+	}
+	return(r);
+}
+#else
+REG8 MEMCALL i286_memoryread(UINT32 address) {
+
+	if (address < I286_MEMREADMAX) {
+		return(mem[address]);
+	}
+#if defined(USE_HIMEM)
+	else if (address >= 0x10fff0) {
+		address -= 0x100000;
+		if (address < CPU_EXTMEMSIZE) {
+			return(CPU_EXTMEM[address]);
+		}
+		else {
+			return(0xff);
+		}
+	}
+#endif
+	else {
+		return(memory_read[(address >> 15) & 0x1f](address));
+	}
+}
+
+REG16 MEMCALL i286_memoryread_w(UINT32 address) {
+
+	REG16	ret;
+
+	if (address < (I286_MEMREADMAX - 1)) {
+		return(LOADINTELWORD(mem + address));
+	}
+#if defined(USE_HIMEM)
+	else if (address >= (0x10fff0 - 1)) {
+		address -= 0x100000;
+		if (address == (0x00fff0 - 1)) {
+			ret = mem[0x100000 + address];
+		}
+		else if (address < CPU_EXTMEMSIZE) {
+			ret = CPU_EXTMEM[address];
+		}
+		else {
+			ret = 0xff;
+		}
+		address++;
+		if (address < CPU_EXTMEMSIZE) {
+			ret += CPU_EXTMEM[address] << 8;
+		}
+		else {
+			ret += 0xff00;
+		}
+		return(ret);
+	}
+#endif
+	else if ((address & 0x7fff) != 0x7fff) {
+		return(memword_read[(address >> 15) & 0x1f](address));
+	}
+	else {
+		ret = memory_read[(address >> 15) & 0x1f](address);
+		address++;
+		ret += memory_read[(address >> 15) & 0x1f](address) << 8;
+		return(ret);
+	}
+}
+#endif
+
+void MEMCALL i286_memorywrite(UINT32 address, REG8 value) {
 
 	if (address < I286_MEMWRITEMAX) {
-		mem[address] = value;
+		mem[address] = (BYTE)value;
 	}
 #if defined(USE_HIMEM)
 	else if (address >= 0x10fff0) {
 		address -= 0x100000;
-		if (address < extmemmng_size) {
-			extmemmng_ptr[address] = value;
+		if (address < CPU_EXTMEMSIZE) {
+			CPU_EXTMEM[address] = (BYTE)value;
 		}
 	}
 #endif
@@ -803,7 +898,7 @@ void MEMCALL i286_memorywrite(UINT32 add
 	}
 }
 
-void MEMCALL i286_memorywrite_w(UINT32 address, UINT16 value) {
+void MEMCALL i286_memorywrite_w(UINT32 address, REG16 value) {
 
 	if (address < (I286_MEMWRITEMAX - 1)) {
 		STOREINTELWORD(mem + address, value);
@@ -814,12 +909,12 @@ void MEMCALL i286_memorywrite_w(UINT32 a
 		if (address == (0x00fff0 - 1)) {
 			mem[address] = (BYTE)value;
 		}
-		else if (address < extmemmng_size) {
-			extmemmng_ptr[address] = (BYTE)value;
+		else if (address < CPU_EXTMEMSIZE) {
+			CPU_EXTMEM[address] = (BYTE)value;
 		}
 		address++;
-		if (address < extmemmng_size) {
-			extmemmng_ptr[address] = (BYTE)(value >> 8);
+		if (address < CPU_EXTMEMSIZE) {
+			CPU_EXTMEM[address] = (BYTE)(value >> 8);
 		}
 	}
 #endif
@@ -833,7 +928,7 @@ void MEMCALL i286_memorywrite_w(UINT32 a
 	}
 }
 
-BYTE MEMCALL i286_membyte_read(UINT seg, UINT off) {
+REG8 MEMCALL i286_membyte_read(UINT seg, UINT off) {
 
 	UINT32	address;
 
@@ -846,7 +941,7 @@ BYTE MEMCALL i286_membyte_read(UINT seg,
 	}
 }
 
-UINT16 MEMCALL i286_memword_read(UINT seg, UINT off) {
+REG16 MEMCALL i286_memword_read(UINT seg, UINT off) {
 
 	UINT32	address;
 
@@ -859,26 +954,26 @@ UINT16 MEMCALL i286_memword_read(UINT se
 	}
 }
 
-void MEMCALL i286_membyte_write(UINT seg, UINT off, BYTE value) {
+void MEMCALL i286_membyte_write(UINT seg, UINT off, REG8 value) {
 
 	UINT32	address;
 
 	address = (seg << 4) + off;
 	if (address < I286_MEMWRITEMAX) {
-		mem[address] = value;
+		mem[address] = (BYTE)value;
 	}
 	else {
 		i286_memorywrite(address, value);
 	}
 }
 
-void MEMCALL i286_memword_write(UINT seg, UINT off, UINT16 value) {
+void MEMCALL i286_memword_write(UINT seg, UINT off, REG16 value) {
 
 	UINT32	address;
 
 	address = (seg << 4) + off;
 	if (address < (I286_MEMWRITEMAX - 1)) {
-		STOREINTELWORD(mem + address,  value);
+		STOREINTELWORD(mem + address, value);
 	}
 	else {
 		i286_memorywrite_w(address, value);