np2/i286c/memory.c - diff

Return to memory.c CVS log

Up to [RetroPC.NET] / np2 / i286c

Diff for /np2/i286c/memory.c between versions 1.1 and 1.15

version 1.1, 2003/10/16 17:57:47	version 1.15, 2003/12/22 01:44:59
Line 1	Line 1
#include "compiler.h"	#include "compiler.h"
#include "i286.h"	#include "cpucore.h"
#include "memory.h"
#include "egcmem.h"	#include "egcmem.h"
#include "pccore.h"	#include "pccore.h"
#include "iocore.h"	#include "iocore.h"
Line 8	Line 7
#include "font.h"	#include "font.h"


#define USE_HIMEM	BYTE mem[0x200000];


	#define USE_HIMEM 0x10fff0

	#if defined(TRACE)
	#define MEMORY_DEBUG
	#endif

// ---- write byte	// ---- 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) {

nevent.remainclock -= vramop.tramwait;	CPU_REMCLOCK -= MEMWAIT_TRAM;
if (address < 0xa2000) {	if (address < 0xa2000) {
mem[address] = value;	mem[address] = (BYTE)value;
tramupdate[(address >> 1) & 0x0fff] = 1;	tramupdate[LOW12(address >> 1)] = 1;
gdcs.textdisp \|= 1;	gdcs.textdisp \|= 1;
}	}
else if (address < 0xa3fe0) {	else if (address < 0xa3fe0) {
if (!(address & 1)) {	if (!(address & 1)) {
mem[address] = value;	mem[address] = (BYTE)value;
tramupdate[(address >> 1) & 0x0fff] = 1;	tramupdate[LOW12(address >> 1)] = 1;
gdcs.textdisp \|= 1;	gdcs.textdisp \|= 1;
}	}
}	}
else if (address < 0xa4000) {	else if (address < 0xa4000) {
if (!(address & 1)) {	if (!(address & 1)) {
if ((!(address & 2)) \|\| (gdcs.msw_accessable)) {	if ((!(address & 2)) \|\| (gdcs.msw_accessable)) {
mem[address] = value;	mem[address] = (BYTE)value;
tramupdate[(address >> 1) & 0x0fff] = 1;	tramupdate[LOW12(address >> 1)] = 1;
gdcs.textdisp \|= 1;	gdcs.textdisp \|= 1;
}	}
}	}
Line 44 static void MEMCALL tram_wt(UINT32 addre	Line 50 static void MEMCALL tram_wt(UINT32 addre
else if (address < 0xa5000) {	else if (address < 0xa5000) {
if ((address & 1) && (cgwindow.writable & 1)) {	if ((address & 1) && (cgwindow.writable & 1)) {
cgwindow.writable \|= 0x80;	cgwindow.writable \|= 0x80;
font[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) {

nevent.remainclock -= vramop.vramwait;	CPU_REMCLOCK -= MEMWAIT_VRAM;
mem[address] = value;	mem[address] = (BYTE)value;
vramupdate[address & 0x7fff] \|= 1;	vramupdate[LOW15(address)] \|= 1;
gdcs.grphdisp \|= 1;	gdcs.grphdisp \|= 1;
}	}

static void MEMCALL vram_w1(UINT32 address, BYTE value) {	static void MEMCALL vram_w1(UINT32 address, REG8 value) {

nevent.remainclock -= vramop.vramwait;	CPU_REMCLOCK -= MEMWAIT_VRAM;
mem[address + VRAM_STEP] = value;	mem[address + VRAM_STEP] = (BYTE)value;
vramupdate[address & 0x7fff] \|= 2;	vramupdate[LOW15(address)] \|= 2;
gdcs.grphdisp \|= 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;	BYTE *vram;

nevent.remainclock -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
mask = ~value;	mask = ~value;
address &= 0x7fff;	address = LOW15(address);
vramupdate[address] \|= 1;	vramupdate[address] \|= 1;
gdcs.grphdisp \|= 1;	gdcs.grphdisp \|= 1;
vram = mem + address;	vram = mem + address;
Line 94 static void MEMCALL grcg_rmw0(UINT32 add	Line 100 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;	BYTE *vram;

nevent.remainclock -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
mask = ~value;	mask = ~value;
address &= 0x7fff;	address = LOW15(address);
vramupdate[address] \|= 2;	vramupdate[address] \|= 2;
gdcs.grphdisp \|= 2;	gdcs.grphdisp \|= 2;
vram = mem + address;	vram = mem + address;
Line 123 static void MEMCALL grcg_rmw1(UINT32 add	Line 129 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;	BYTE *vram;

nevent.remainclock -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
address &= 0x7fff;	address = LOW15(address);
vramupdate[address] \|= 1;	vramupdate[address] \|= 1;
gdcs.grphdisp \|= 1;	gdcs.grphdisp \|= 1;
vram = mem + address;	vram = mem + address;
Line 147 static void MEMCALL grcg_tdw0(UINT32 add	Line 153 static void MEMCALL grcg_tdw0(UINT32 add
(void)value;	(void)value;
}	}

static void MEMCALL grcg_tdw1(UINT32 address, BYTE value) {	static void MEMCALL grcg_tdw1(UINT32 address, REG8 value) {

BYTE *vram;	BYTE *vram;

nevent.remainclock -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
address &= 0x7fff;	address = LOW15(address);
vramupdate[address] \|= 2;	vramupdate[address] \|= 2;
gdcs.grphdisp \|= 2;	gdcs.grphdisp \|= 2;
vram = mem + address;	vram = mem + address;
Line 171 static void MEMCALL grcg_tdw1(UINT32 add	Line 177 static void MEMCALL grcg_tdw1(UINT32 add
(void)value;	(void)value;
}	}

static void MEMCALL egc_wt(UINT32 address, BYTE value) {	static void MEMCALL egc_wt(UINT32 address, REG8 value) {

	CPU_REMCLOCK -= MEMWAIT_GRCG;
egc_write(address, 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][address & 0x3fff] = 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)address;
(void)value;	(void)value;
Line 190 static void MEMCALL i286_wn(UINT32 addre	Line 197 static void MEMCALL i286_wn(UINT32 addre

// ---- read byte	// ---- 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) {

nevent.remainclock -= vramop.tramwait;	CPU_REMCLOCK -= MEMWAIT_TRAM;
if (address < 0xa4000) {	if (address < 0xa4000) {
return(mem[address]);	return(mem[address]);
}	}
else if (address < 0xa5000) {	else if (address < 0xa5000) {
if (address & 1) {	if (address & 1) {
return(font[cgwindow.high + ((address >> 1) & 0x0f)]);	return(fontrom[cgwindow.high + ((address >> 1) & 0x0f)]);
}	}
else {	else {
return(font[cgwindow.low + ((address >> 1) & 0x0f)]);	return(fontrom[cgwindow.low + ((address >> 1) & 0x0f)]);
}	}
}	}
return(mem[address]);	return(mem[address]);
}	}

static BYTE MEMCALL vram_r0(UINT32 address) {	static REG8 MEMCALL vram_r0(UINT32 address) {

nevent.remainclock -= vramop.vramwait;	CPU_REMCLOCK -= MEMWAIT_VRAM;
return(mem[address]);	return(mem[address]);
}	}

static BYTE MEMCALL vram_r1(UINT32 address) {	static REG8 MEMCALL vram_r1(UINT32 address) {

nevent.remainclock -= vramop.vramwait;	CPU_REMCLOCK -= MEMWAIT_VRAM;
return(mem[address + VRAM_STEP]);	return(mem[address + VRAM_STEP]);
}	}

static BYTE MEMCALL grcg_tcr0(UINT32 address) {	static REG8 MEMCALL grcg_tcr0(UINT32 address) {

const BYTE *vram;	const BYTE *vram;
BYTE ret;	REG8 ret;

nevent.remainclock -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
vram = mem + (address & 0x7fff);	vram = mem + LOW15(address);
ret = 0;	ret = 0;
if (!(grcg.modereg & 1)) {	if (!(grcg.modereg & 1)) {
ret \|= vram[VRAM0_B] ^ grcg.tile[0].b[0];	ret \|= vram[VRAM0_B] ^ grcg.tile[0].b[0];
Line 244 const BYTE *vram;	Line 251 const BYTE *vram;
if (!(grcg.modereg & 8)) {	if (!(grcg.modereg & 8)) {
ret \|= vram[VRAM0_E] ^ grcg.tile[3].b[0];	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;	const BYTE *vram;
BYTE ret;	REG8 ret;

nevent.remainclock -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
ret = 0;	ret = 0;
vram = mem + (address & 0x7fff);	vram = mem + LOW15(address);
if (!(grcg.modereg & 1)) {	if (!(grcg.modereg & 1)) {
ret \|= vram[VRAM1_B] ^ grcg.tile[0].b[0];	ret \|= vram[VRAM1_B] ^ grcg.tile[0].b[0];
}	}
Line 267 static BYTE MEMCALL grcg_tcr1(UINT32 add	Line 274 static BYTE MEMCALL grcg_tcr1(UINT32 add
if (!(grcg.modereg & 8)) {	if (!(grcg.modereg & 8)) {
ret \|= vram[VRAM1_E] ^ grcg.tile[3].b[0];	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) {

	CPU_REMCLOCK -= MEMWAIT_GRCG;
return(egc_read(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][address & 0x3fff]);	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 + (address & 0x7fff);	address = ITF_ADRS + LOW15(address);
}	}
return(mem[address]);	return(mem[address]);
}	}
Line 291 static BYTE MEMCALL i286_itf(UINT32 addr	Line 299 static BYTE MEMCALL i286_itf(UINT32 addr

// ---- write word	// ---- write word

static void MEMCALL i286w_wt(UINT32 address, UINT16 value) {	static void MEMCALL i286w_wt(UINT32 address, REG16 value) {

BYTE *ptr;	BYTE *ptr;

ptr = mem + (address & extmem.adrsmask);	ptr = mem + (address & CPU_ADRSMASK);
STOREINTELWORD(ptr, value);	STOREINTELWORD(ptr, value);
}	}

static void MEMCALL tramw_wt(UINT32 address, UINT16 value) {	static void MEMCALL tramw_wt(UINT32 address, REG16 value) {

	CPU_REMCLOCK -= MEMWAIT_TRAM;
if (address < 0xa1fff) {	if (address < 0xa1fff) {
STOREINTELWORD(mem + address, value);	STOREINTELWORD(mem + address, value);
tramupdate[(address >> 1) & 0x0fff] = 1;	tramupdate[LOW12(address >> 1)] = 1;
tramupdate[((address + 1) >> 1) & 0x0fff] = 1;	tramupdate[LOW12((address + 1) >> 1)] = 1;
gdcs.textdisp \|= 1;	gdcs.textdisp \|= 1;
}	}
else if (address == 0xa1fff) {	else if (address == 0xa1fff) {
Line 319 static void MEMCALL tramw_wt(UINT32 addr	Line 328 static void MEMCALL tramw_wt(UINT32 addr
value >>= 8;	value >>= 8;
}	}
mem[address] = (BYTE)value;	mem[address] = (BYTE)value;
tramupdate[(address >> 1) & 0x0fff] = 1;	tramupdate[LOW12(address >> 1)] = 1;
gdcs.textdisp \|= 1;	gdcs.textdisp \|= 1;
}	}
else if (address < 0xa3fff) {	else if (address < 0xa3fff) {
Line 329 static void MEMCALL tramw_wt(UINT32 addr	Line 338 static void MEMCALL tramw_wt(UINT32 addr
}	}
if ((!(address & 2)) \|\| (gdcs.msw_accessable)) {	if ((!(address & 2)) \|\| (gdcs.msw_accessable)) {
mem[address] = (BYTE)value;	mem[address] = (BYTE)value;
tramupdate[(address >> 1) & 0x0fff] = 1;	tramupdate[LOW12(address >> 1)] = 1;
gdcs.textdisp \|= 1;	gdcs.textdisp \|= 1;
}	}
}	}
Line 339 static void MEMCALL tramw_wt(UINT32 addr	Line 348 static void MEMCALL tramw_wt(UINT32 addr
}	}
if (cgwindow.writable & 1) {	if (cgwindow.writable & 1) {
cgwindow.writable \|= 0x80;	cgwindow.writable \|= 0x80;
font[cgwindow.high + ((address >> 1) & 0x0f)] = (BYTE)value;	fontrom[cgwindow.high + ((address >> 1) & 0x0f)] = (BYTE)value;
}	}
}	}
}	}


#define GRCGW_NON(page) { \	#define GRCGW_NON(page) { \
nevent.remainclock -= vramop.vramwait; \	CPU_REMCLOCK -= MEMWAIT_VRAM; \
STOREINTELWORD(mem + address + VRAM_STEP*(page), value); \	STOREINTELWORD(mem + address + VRAM_STEP*(page), value); \
vramupdate[address & 0x7fff] \|= (1 << page); \	vramupdate[LOW15(address)] \|= (1 << page); \
vramupdate[(address + 1) & 0x7fff] \|= (1 << page); \	vramupdate[LOW15(address + 1)] \|= (1 << page); \
gdcs.grphdisp \|= (1 << page); \	gdcs.grphdisp \|= (1 << page); \
}	}

#define GRCGW_RMW(page) { \	#define GRCGW_RMW(page) { \
BYTE *vram; \	BYTE *vram; \
nevent.remainclock -= vramop.grcgwait; \	CPU_REMCLOCK -= MEMWAIT_GRCG; \
address &= 0x7fff; \	address = LOW15(address); \
vramupdate[address] \|= (1 << page); \	vramupdate[address] \|= (1 << page); \
vramupdate[address + 1] \|= (1 << page); \	vramupdate[address + 1] \|= (1 << page); \
gdcs.grphdisp \|= (1 << page); \	gdcs.grphdisp \|= (1 << page); \
Line 401 static void MEMCALL tramw_wt(UINT32 addr	Line 410 static void MEMCALL tramw_wt(UINT32 addr

#define GRCGW_TDW(page) { \	#define GRCGW_TDW(page) { \
BYTE *vram; \	BYTE *vram; \
nevent.remainclock -= vramop.grcgwait; \	CPU_REMCLOCK -= MEMWAIT_GRCG; \
address &= 0x7fff; \	address = LOW15(address); \
vramupdate[address] \|= (1 << page); \	vramupdate[address] \|= (1 << page); \
vramupdate[address + 1] \|= (1 << page); \	vramupdate[address + 1] \|= (1 << page); \
gdcs.grphdisp \|= (1 << page); \	gdcs.grphdisp \|= (1 << page); \
Line 426 static void MEMCALL tramw_wt(UINT32 addr	Line 435 static void MEMCALL tramw_wt(UINT32 addr
(void)value; \	(void)value; \
}	}

static void MEMCALL vramw_w0(UINT32 address, UINT16 value) GRCGW_NON(0)	static void MEMCALL vramw_w0(UINT32 address, REG16 value) GRCGW_NON(0)
static void MEMCALL vramw_w1(UINT32 address, UINT16 value) GRCGW_NON(1)	static void MEMCALL vramw_w1(UINT32 address, REG16 value) GRCGW_NON(1)
static void MEMCALL grcgw_rmw0(UINT32 address, UINT16 value) GRCGW_RMW(0)	static void MEMCALL grcgw_rmw0(UINT32 address, REG16 value) GRCGW_RMW(0)
static void MEMCALL grcgw_rmw1(UINT32 address, UINT16 value) GRCGW_RMW(1)	static void MEMCALL grcgw_rmw1(UINT32 address, REG16 value) GRCGW_RMW(1)
static void MEMCALL grcgw_tdw0(UINT32 address, UINT16 value) GRCGW_TDW(0)	static void MEMCALL grcgw_tdw0(UINT32 address, REG16 value) GRCGW_TDW(0)
static void MEMCALL grcgw_tdw1(UINT32 address, UINT16 value) GRCGW_TDW(1)	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) {

	CPU_REMCLOCK -= MEMWAIT_GRCG;
if (!(address & 1)) {	if (!(address & 1)) {
egc_write_w(address, value);	egc_write_w(address, value);
}	}
else {	else {
if (!(egc.sft & 0x1000)) {	if (!(egc.sft & 0x1000)) {
egc_write(address, (BYTE)value);	egc_write(address, (REG8)value);
egc_write(address + 1, (BYTE)(value >> 8));	egc_write(address + 1, (REG8)(value >> 8));
}	}
else {	else {
egc_write(address + 1, (BYTE)(value >> 8));	egc_write(address + 1, (REG8)(value >> 8));
egc_write(address, (BYTE)value);	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;	BYTE *ptr;

if ((address & 0x3fff) != 0x3fff) {	if ((address & 0x3fff) != 0x3fff) {
ptr = extmem.pageptr[(address >> 14) & 3] + (address & 0x3fff);	ptr = extmem.pageptr[(address >> 14) & 3] + LOW14(address);
STOREINTELWORD(ptr, value);	STOREINTELWORD(ptr, value);
}	}
else {	else {
extmem.pageptr[(address >> 14) & 3][0x3fff] = (BYTE)value;	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)address;
(void)value;	(void)value;
Line 473 static void MEMCALL i286w_wn(UINT32 addr	Line 483 static void MEMCALL i286w_wn(UINT32 addr

// ---- read word	// ---- read word

static UINT16 MEMCALL i286w_rd(UINT32 address) {	static REG16 MEMCALL i286w_rd(UINT32 address) {

BYTE *ptr;	BYTE *ptr;

ptr = mem + (address & extmem.adrsmask);	ptr = mem + (address & CPU_ADRSMASK);
return(LOADINTELWORD(ptr));	return(LOADINTELWORD(ptr));
}	}

static UINT16 MEMCALL tramw_rd(UINT32 address) {	static REG16 MEMCALL tramw_rd(UINT32 address) {

nevent.remainclock -= vramop.tramwait;	CPU_REMCLOCK -= MEMWAIT_TRAM;
if (address < (0xa4000 - 1)) {	if (address < (0xa4000 - 1)) {
return(LOADINTELWORD(mem + address));	return(LOADINTELWORD(mem + address));
}	}
else if (address == 0xa3fff) {	else if (address == 0xa3fff) {
return(mem[address] + (font[cgwindow.low] << 8));	return(mem[address] + (fontrom[cgwindow.low] << 8));
}	}
else if (address < 0xa4fff) {	else if (address < 0xa4fff) {
if (address & 1) {	if (address & 1) {
UINT16 ret;	REG16 ret;
ret = font[cgwindow.high + ((address >> 1) & 0x0f)];	ret = fontrom[cgwindow.high + ((address >> 1) & 0x0f)];
ret += font[cgwindow.low + (((address + 1) >> 1) & 0x0f)] << 8;	ret += fontrom[cgwindow.low + (((address + 1) >> 1) & 0x0f)] << 8;
return(ret);	return(ret);
}	}
else {	else {
UINT16 ret;	REG16 ret;
ret = font[cgwindow.low + ((address >> 1) & 0x0f)];	ret = fontrom[cgwindow.low + ((address >> 1) & 0x0f)];
ret += font[cgwindow.high + ((address >> 1) & 0x0f)] << 8;	ret += fontrom[cgwindow.high + ((address >> 1) & 0x0f)] << 8;
return(ret);	return(ret);
}	}
}	}
else if (address == 0xa4fff) {	else if (address == 0xa4fff) {
return((mem[0xa5000] << 8) \| font[cgwindow.high + 15]);	return((mem[0xa5000] << 8) \| fontrom[cgwindow.high + 15]);
}	}
return(LOADINTELWORD(mem + address));	return(LOADINTELWORD(mem + address));
}	}

static UINT16 MEMCALL vramw_r0(UINT32 address) {	static REG16 MEMCALL vramw_r0(UINT32 address) {

nevent.remainclock -= vramop.vramwait;	CPU_REMCLOCK -= MEMWAIT_VRAM;
return(LOADINTELWORD(mem + address));	return(LOADINTELWORD(mem + address));
}	}

static UINT16 MEMCALL vramw_r1(UINT32 address) {	static REG16 MEMCALL vramw_r1(UINT32 address) {

nevent.remainclock -= vramop.vramwait;	CPU_REMCLOCK -= MEMWAIT_VRAM;
return(LOADINTELWORD(mem + address + VRAM_STEP));	return(LOADINTELWORD(mem + address + VRAM_STEP));
}	}

static UINT16 MEMCALL grcgw_tcr0(UINT32 address) {	static REG16 MEMCALL grcgw_tcr0(UINT32 address) {

BYTE *vram;	BYTE *vram;
UINT16 ret;	REG16 ret;

nevent.remainclock -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
ret = 0;	ret = 0;
vram = mem + (address & 0x7fff);	vram = mem + LOW15(address);
if (!(grcg.modereg & 1)) {	if (!(grcg.modereg & 1)) {
ret \|= LOADINTELWORD(vram + VRAM0_B) ^ grcg.tile[0].w;	ret \|= LOADINTELWORD(vram + VRAM0_B) ^ grcg.tile[0].w;
}	}
Line 542 static UINT16 MEMCALL grcgw_tcr0(UINT32	Line 552 static UINT16 MEMCALL grcgw_tcr0(UINT32
if (!(grcg.modereg & 8)) {	if (!(grcg.modereg & 8)) {
ret \|= LOADINTELWORD(vram + VRAM0_E) ^ grcg.tile[3].w;	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;	BYTE *vram;
UINT16 ret;	REG16 ret;

nevent.remainclock -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
ret = 0;	ret = 0;
vram = mem + (address & 0x7fff);	vram = mem + LOW15(address);
if (!(grcg.modereg & 1)) {	if (!(grcg.modereg & 1)) {
ret \|= LOADINTELWORD(vram + VRAM1_B) ^ grcg.tile[0].w;	ret \|= LOADINTELWORD(vram + VRAM1_B) ^ grcg.tile[0].w;
}	}
Line 565 static UINT16 MEMCALL grcgw_tcr1(UINT32	Line 575 static UINT16 MEMCALL grcgw_tcr1(UINT32
if (!(grcg.modereg & 8)) {	if (!(grcg.modereg & 8)) {
ret \|= LOADINTELWORD(vram + VRAM1_E) ^ grcg.tile[3].w;	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;

	CPU_REMCLOCK -= MEMWAIT_GRCG;
if (!(address & 1)) {	if (!(address & 1)) {
return(egc_read_w(address));	return(egc_read_w(address));
}	}
else {	else {
if (!(egc.sft & 0x1000)) {	if (!(egc.sft & 0x1000)) {
ret = egc_read(address);	ret = egc_read(address);
ret += (UINT16)egc_read(address + 1) << 8;	ret += egc_read(address + 1) << 8;
return(ret);	return(ret);
}	}
else {	else {
UINT16 ret;	ret = egc_read(address + 1) << 8;
ret = (UINT16)egc_read(address + 1) << 8;
ret += egc_read(address);	ret += egc_read(address);
return(ret);	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] + (address & 0x3fff);	if ((address & 0x3fff) != 0x3fff) {
return(LOADINTELWORD(ptr));	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 + (address & 0x7fff);	address = ITF_ADRS + LOW15(address);
}	}
return(LOADINTELWORD(mem + address));	return(LOADINTELWORD(mem + address));
}	}
Line 609 static UINT16 MEMCALL i286w_itf(UINT32 a	Line 627 static UINT16 MEMCALL i286w_itf(UINT32 a

// ---- table	// ---- table

typedef void (MEMCALL * MEM8WRITE)(UINT32 address, BYTE value);	typedef void (MEMCALL * MEM8WRITE)(UINT32 address, REG8 value);
typedef BYTE (MEMCALL * MEM8READ)(UINT32 address);	typedef REG8 (MEMCALL * MEM8READ)(UINT32 address);
typedef void (MEMCALL * MEM16WRITE)(UINT32 address, UINT16 value);	typedef void (MEMCALL * MEM16WRITE)(UINT32 address, REG16 value);
typedef UINT16 (MEMCALL * MEM16READ)(UINT32 address);	typedef REG16 (MEMCALL * MEM16READ)(UINT32 address);

static MEM8WRITE memory_write[] = {	typedef struct {
i286_wt, i286_wt, i286_wt, i286_wt, // 00	MEM8READ rd8[0x20];
i286_wt, i286_wt, i286_wt, i286_wt, // 20	MEM8WRITE wr8[0x20];
i286_wt, i286_wt, i286_wt, i286_wt, // 40	MEM16READ rd16[0x20];
i286_wt, i286_wt, i286_wt, i286_wt, // 60	MEM16WRITE wr16[0x20];
i286_wt, i286_wt, i286_wt, i286_wt, // 80	} MEMFN;
tram_wt, vram_w0, vram_w0, vram_w0, // a0
emmc_wt, emmc_wt, i286_wn, i286_wn, // c0	typedef struct {
vram_w0, i286_wn, i286_wn, i286_wn}; // e0	MEM8READ rd8;
	MEM8WRITE wr8;
	MEM16READ rd16;
	MEM16WRITE wr16;
	} VACCTBL;

static MEM8READ memory_read[] = {	static MEMFN memfn = {
i286_rd, i286_rd, i286_rd, i286_rd, // 00	{i286_rd, i286_rd, i286_rd, i286_rd, // 00
i286_rd, i286_rd, i286_rd, i286_rd, // 20	i286_rd, i286_rd, i286_rd, i286_rd, // 20
i286_rd, i286_rd, i286_rd, i286_rd, // 40	i286_rd, i286_rd, i286_rd, i286_rd, // 40
i286_rd, i286_rd, i286_rd, i286_rd, // 60	i286_rd, i286_rd, i286_rd, i286_rd, // 60
i286_rd, i286_rd, i286_rd, i286_rd, // 80	i286_rd, i286_rd, i286_rd, i286_rd, // 80
tram_rd, vram_r0, vram_r0, vram_r0, // a0	tram_rd, vram_r0, vram_r0, vram_r0, // a0
emmc_rd, emmc_rd, i286_rd, i286_rd, // c0	emmc_rd, emmc_rd, i286_rd, i286_rd, // c0
vram_r0, i286_rd, i286_rd, i286_itf}; // f0	vram_r0, i286_rd, i286_rd, i286_itf}, // f0

static MEM16WRITE memword_write[] = {	{i286_wt, i286_wt, i286_wt, i286_wt, // 00
i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 00	i286_wt, i286_wt, i286_wt, i286_wt, // 20
i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 20	i286_wt, i286_wt, i286_wt, i286_wt, // 40
i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 40	i286_wt, i286_wt, i286_wt, i286_wt, // 60
i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 60	i286_wt, i286_wt, i286_wt, i286_wt, // 80
i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 80	tram_wt, vram_w0, vram_w0, vram_w0, // a0
tramw_wt, vramw_w0, vramw_w0, vramw_w0, // a0	emmc_wt, emmc_wt, i286_wn, i286_wn, // c0
emmcw_wt, emmcw_wt, i286w_wn, i286w_wn, // c0	vram_w0, i286_wn, i286_wn, i286_wn}, // e0
vramw_w0, i286w_wn, i286w_wn, i286w_wn}; // e0

static MEM16READ memword_read[] = {	{i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 00
i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 00
i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 20	i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 20
i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 40	i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 40
i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 60	i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 60
i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 80	i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 80
tramw_rd, vramw_r0, vramw_r0, vramw_r0, // a0	tramw_rd, vramw_r0, vramw_r0, vramw_r0, // a0
emmcw_rd, emmcw_rd, i286w_rd, i286w_rd, // c0	emmcw_rd, emmcw_rd, i286w_rd, i286w_rd, // c0
vramw_r0, i286w_rd, i286w_rd, i286w_itf}; // e0	vramw_r0, i286w_rd, i286w_rd, i286w_itf}, // e0

static const MEM8WRITE vram_write[] = {	{i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 00
vram_w0, vram_w1, vram_w0, vram_w1, // 00	i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 20
vram_w0, vram_w1, vram_w0, vram_w1, // 40	i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 40
grcg_tdw0, grcg_tdw1, egc_wt, egc_wt, // 80 tdw/tcr	i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 60
grcg_rmw0, grcg_rmw1, egc_wt, egc_wt}; // c0 rmw	i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 80
	tramw_wt, vramw_w0, vramw_w0, vramw_w0, // a0
static const MEM8READ vram_read[] = {	emmcw_wt, emmcw_wt, i286w_wn, i286w_wn, // c0
vram_r0, vram_r1, vram_r0, vram_r1, // 00	vramw_w0, i286w_wn, i286w_wn, i286w_wn}}; // e0
vram_r0, vram_r1, vram_r0, vram_r1, // 40
grcg_tcr0, grcg_tcr1, egc_rd, egc_rd, // 80 tdw/tcr	static const VACCTBL vacctbl[0x10] = {
vram_r0, vram_r1, egc_rd, egc_rd}; // c0 rmw	{vram_r0, vram_w0, vramw_r0, vramw_w0}, // 00
	{vram_r1, vram_w1, vramw_r1, vramw_w1},
static const MEM16WRITE vramw_write[] = {	{vram_r0, vram_w0, vramw_r0, vramw_w0},
vramw_w0, vramw_w1, vramw_w0, vramw_w1, // 00	{vram_r1, vram_w1, vramw_r1, vramw_w1},
vramw_w0, vramw_w1, vramw_w0, vramw_w1, // 40	{vram_r0, vram_w0, vramw_r0, vramw_w0}, // 40
grcgw_tdw0, grcgw_tdw1, egcw_wt, egcw_wt, // 80 tdw/tcr	{vram_r1, vram_w1, vramw_r1, vramw_w1},
grcgw_rmw0, grcgw_rmw1, egcw_wt, egcw_wt}; // c0 rmw	{vram_r0, vram_w0, vramw_r0, vramw_w0},
	{vram_r1, vram_w1, vramw_r1, vramw_w1},
static const MEM16READ vramw_read[] = {	{grcg_tcr0, grcg_tdw0, grcgw_tcr0, grcgw_tdw0}, // 80 tdw/tcr
vramw_r0, vramw_r1, vramw_r0, vramw_r1, // 00	{grcg_tcr1, grcg_tdw1, grcgw_tcr1, grcgw_tdw1},
vramw_r0, vramw_r1, vramw_r0, vramw_r1, // 40	{egc_rd, egc_wt, egcw_rd, egcw_wt},
grcgw_tcr0, grcgw_tcr1, egcw_rd, egcw_rd, // 80 tdw/tcr	{egc_rd, egc_wt, egcw_rd, egcw_wt},
vramw_r0, vramw_r1, egcw_rd, egcw_rd}; // c0 rmw	{vram_r0, grcg_rmw0, vramw_r0, grcgw_rmw0}, // c0 rmw
	{vram_r1, grcg_rmw1, vramw_r1, grcgw_rmw1},
	{egc_rd, egc_wt, egcw_rd, egcw_wt},
	{egc_rd, egc_wt, egcw_rd, egcw_wt}};


static BYTE MEMCALL i286_nonram_r(UINT32 address) {	static REG8 MEMCALL i286_nonram_r(UINT32 address) {

(void)address;	(void)address;
return(0xff);	return(0xff);
}	}

static UINT16 MEMCALL i286_nonram_rw(UINT32 address) {	static REG16 MEMCALL i286_nonram_rw(UINT32 address) {

(void)address;	(void)address;
return(0xffff);	return(0xffff);
Line 693 static UINT16 MEMCALL i286_nonram_rw(UIN	Line 716 static UINT16 MEMCALL i286_nonram_rw(UIN

void MEMCALL i286_vram_dispatch(UINT func) {	void MEMCALL i286_vram_dispatch(UINT func) {

UINT proc;	const VACCTBL *vacc;

proc = func & 0x0f;	vacc = vacctbl + (func & 0x0f);
memory_write[0xa8000 >> 15] = vram_write[proc];
memory_write[0xb0000 >> 15] = vram_write[proc];	memfn.rd8[0xa8000 >> 15] = vacc->rd8;
memory_write[0xb8000 >> 15] = vram_write[proc];	memfn.rd8[0xb0000 >> 15] = vacc->rd8;
memory_write[0xe0000 >> 15] = vram_write[proc];	memfn.rd8[0xb8000 >> 15] = vacc->rd8;
	memfn.rd8[0xe0000 >> 15] = vacc->rd8;
memory_read[0xa8000 >> 15] = vram_read[proc];
memory_read[0xb0000 >> 15] = vram_read[proc];	memfn.wr8[0xa8000 >> 15] = vacc->wr8;
memory_read[0xb8000 >> 15] = vram_read[proc];	memfn.wr8[0xb0000 >> 15] = vacc->wr8;
memory_read[0xe0000 >> 15] = vram_read[proc];	memfn.wr8[0xb8000 >> 15] = vacc->wr8;
	memfn.wr8[0xe0000 >> 15] = vacc->wr8;
memword_write[0xa8000 >> 15] = vramw_write[proc];
memword_write[0xb0000 >> 15] = vramw_write[proc];	memfn.rd16[0xa8000 >> 15] = vacc->rd16;
memword_write[0xb8000 >> 15] = vramw_write[proc];	memfn.rd16[0xb0000 >> 15] = vacc->rd16;
memword_write[0xe0000 >> 15] = vramw_write[proc];	memfn.rd16[0xb8000 >> 15] = vacc->rd16;
	memfn.rd16[0xe0000 >> 15] = vacc->rd16;
memword_read[0xa8000 >> 15] = vramw_read[proc];
memword_read[0xb0000 >> 15] = vramw_read[proc];	memfn.wr16[0xa8000 >> 15] = vacc->wr16;
memword_read[0xb8000 >> 15] = vramw_read[proc];	memfn.wr16[0xb0000 >> 15] = vacc->wr16;
memword_read[0xe0000 >> 15] = vramw_read[proc];	memfn.wr16[0xb8000 >> 15] = vacc->wr16;
	memfn.wr16[0xe0000 >> 15] = vacc->wr16;

if (!(func & 0x10)) { // degital	if (!(func & 0x10)) { // degital
memory_write[0xe0000 >> 15] = i286_wn;	memfn.wr8[0xe0000 >> 15] = i286_wn;
memword_write[0xe0000 >> 15] = i286w_wn;	memfn.wr16[0xe0000 >> 15] = i286w_wn;
memory_read[0xe0000 >> 15] = i286_nonram_r;	memfn.rd8[0xe0000 >> 15] = i286_nonram_r;
memword_read[0xe0000 >> 15] = i286_nonram_rw;	memfn.rd16[0xe0000 >> 15] = i286_nonram_rw;
	}
	}

	#if defined(MEMORY_DEBUG)
	static REG8 MEMCALL _i286_memoryread(UINT32 address) {

	if (address < I286_MEMREADMAX) {
	return(mem[address]);
	}
	#if defined(USE_HIMEM)
	else if (address >= USE_HIMEM) {
	address -= 0x100000;
	if (address < CPU_EXTMEMSIZE) {
	return(CPU_EXTMEM[address]);
	}
	else {
	return(0xff);
	}
	}
	#endif
	else {
	return(memfn.rd8[(address >> 15) & 0x1f](address));
	}
	}

	static 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 >= (USE_HIMEM - 1)) {
	address -= 0x100000;
	if (address == (USE_HIMEM - 0x100000 - 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(memfn.rd16[(address >> 15) & 0x1f](address));
	}
	else {
	ret = memfn.rd8[(address >> 15) & 0x1f](address);
	address++;
	ret += memfn.rd8[(address >> 15) & 0x1f](address) << 8;
	return(ret);
}	}
}	}

BYTE MEMCALL i286_memoryread(UINT32 address) {	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) {	if (address < I286_MEMREADMAX) {
return(mem[address]);	return(mem[address]);
}	}
#if defined(USE_HIMEM)	#if defined(USE_HIMEM)
else if (address >= 0x10fff0) {	else if (address >= USE_HIMEM) {
address -= 0x100000;	address -= 0x100000;
if (address < extmemmng_size) {	if (address < CPU_EXTMEMSIZE) {
return(extmemmng_ptr[address]);	return(CPU_EXTMEM[address]);
}	}
else {	else {
return(0xff);	return(0xff);
Line 741 BYTE MEMCALL i286_memoryread(UINT32 addr	Line 849 BYTE MEMCALL i286_memoryread(UINT32 addr
}	}
#endif	#endif
else {	else {
return(memory_read[(address >> 15) & 0x1f](address));	return(memfn.rd8[(address >> 15) & 0x1f](address));
}	}
}	}

UINT16 MEMCALL i286_memoryread_w(UINT32 address) {	REG16 MEMCALL i286_memoryread_w(UINT32 address) {

UINT16 ret;	REG16 ret;

if (address < (I286_MEMREADMAX - 1)) {	if (address < (I286_MEMREADMAX - 1)) {
return(LOADINTELWORD(mem + address));	return(LOADINTELWORD(mem + address));
}	}
#if defined(USE_HIMEM)	#if defined(USE_HIMEM)
else if (address >= (0x10fff0 - 1)) {	else if (address >= (USE_HIMEM - 1)) {
address -= 0x100000;	address -= 0x100000;
if (address == (0x00fff0 - 1)) {	if (address == (USE_HIMEM - 0x100000 - 1)) {
ret = mem[0x100000 + address];	ret = mem[0x100000 + address];
}	}
else if (address < extmemmng_size) {	else if (address < CPU_EXTMEMSIZE) {
ret = extmemmng_ptr[address];	ret = CPU_EXTMEM[address];
}	}
else {	else {
ret = 0xff;	ret = 0xff;
}	}
address++;	address++;
if (address < extmemmng_size) {	if (address < CPU_EXTMEMSIZE) {
ret += extmemmng_ptr[address] << 8;	ret += CPU_EXTMEM[address] << 8;
}	}
else {	else {
ret += 0xff00;	ret += 0xff00;
Line 775 UINT16 MEMCALL i286_memoryread_w(UINT32	Line 883 UINT16 MEMCALL i286_memoryread_w(UINT32
}	}
#endif	#endif
else if ((address & 0x7fff) != 0x7fff) {	else if ((address & 0x7fff) != 0x7fff) {
return(memword_read[(address >> 15) & 0x1f](address));	return(memfn.rd16[(address >> 15) & 0x1f](address));
}	}
else {	else {
ret = memory_read[(address >> 15) & 0x1f](address);	ret = memfn.rd8[(address >> 15) & 0x1f](address);
address++;	address++;
ret += memory_read[(address >> 15) & 0x1f](address) << 8;	ret += memfn.rd8[(address >> 15) & 0x1f](address) << 8;
return(ret);	return(ret);
}	}
}	}
	#endif

void MEMCALL i286_memorywrite(UINT32 address, BYTE value) {	void MEMCALL i286_memorywrite(UINT32 address, REG8 value) {

if (address < I286_MEMWRITEMAX) {	if (address < I286_MEMWRITEMAX) {
mem[address] = value;	mem[address] = (BYTE)value;
}	}
#if defined(USE_HIMEM)	#if defined(USE_HIMEM)
else if (address >= 0x10fff0) {	else if (address >= USE_HIMEM) {
address -= 0x100000;	address -= 0x100000;
if (address < extmemmng_size) {	if (address < CPU_EXTMEMSIZE) {
extmemmng_ptr[address] = value;	CPU_EXTMEM[address] = (BYTE)value;
}	}
}	}
#endif	#endif
else {	else {
memory_write[(address >> 15) & 0x1f](address, value);	memfn.wr8[(address >> 15) & 0x1f](address, value);
}	}
}	}

void MEMCALL i286_memorywrite_w(UINT32 address, UINT16 value) {	void MEMCALL i286_memorywrite_w(UINT32 address, REG16 value) {

if (address < (I286_MEMWRITEMAX - 1)) {	if (address < (I286_MEMWRITEMAX - 1)) {
STOREINTELWORD(mem + address, value);	STOREINTELWORD(mem + address, value);
}	}
#if defined(USE_HIMEM)	#if defined(USE_HIMEM)
else if (address >= (0x10fff0 - 1)) {	else if (address >= (USE_HIMEM - 1)) {
address -= 0x100000;	address -= 0x100000;
if (address == (0x00fff0 - 1)) {	if (address == (USE_HIMEM - 0x100000 - 1)) {
mem[address] = (BYTE)value;	mem[address] = (BYTE)value;
}	}
else if (address < extmemmng_size) {	else if (address < CPU_EXTMEMSIZE) {
extmemmng_ptr[address] = (BYTE)value;	CPU_EXTMEM[address] = (BYTE)value;
}	}
address++;	address++;
if (address < extmemmng_size) {	if (address < CPU_EXTMEMSIZE) {
extmemmng_ptr[address] = (BYTE)(value >> 8);	CPU_EXTMEM[address] = (BYTE)(value >> 8);
}	}
}	}
#endif	#endif
else if ((address & 0x7fff) != 0x7fff) {	else if ((address & 0x7fff) != 0x7fff) {
memword_write[(address >> 15) & 0x1f](address, value);	memfn.wr16[(address >> 15) & 0x1f](address, value);
}	}
else {	else {
memory_write[(address >> 15) & 0x1f](address, (BYTE)value);	memfn.wr8[(address >> 15) & 0x1f](address, (BYTE)value);
address++;	address++;
memory_write[(address >> 15) & 0x1f](address, (BYTE)(value >> 8));	memfn.wr8[(address >> 15) & 0x1f](address, (BYTE)(value >> 8));
}	}
}	}

BYTE MEMCALL i286_membyte_read(UINT seg, UINT off) {	REG8 MEMCALL i286_membyte_read(UINT seg, UINT off) {

UINT32 address;	UINT32 address;

address = (seg << 4) + off;	address = (seg << 4) + LOW16(off);
if (address < I286_MEMREADMAX) {	if (address < I286_MEMREADMAX) {
return(mem[address]);	return(mem[address]);
}	}
Line 846 BYTE MEMCALL i286_membyte_read(UINT seg,	Line 955 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;	UINT32 address;

address = (seg << 4) + off;	address = (seg << 4) + LOW16(off);
if (address < (I286_MEMREADMAX - 1)) {	if (address < (I286_MEMREADMAX - 1)) {
return(LOADINTELWORD(mem + address));	return(LOADINTELWORD(mem + address));
}	}
Line 859 UINT16 MEMCALL i286_memword_read(UINT se	Line 968 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;	UINT32 address;

address = (seg << 4) + off;	address = (seg << 4) + LOW16(off);
if (address < I286_MEMWRITEMAX) {	if (address < I286_MEMWRITEMAX) {
mem[address] = value;	mem[address] = (BYTE)value;
}	}
else {	else {
i286_memorywrite(address, value);	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;	UINT32 address;

address = (seg << 4) + off;	address = (seg << 4) + LOW16(off);
if (address < (I286_MEMWRITEMAX - 1)) {	if (address < (I286_MEMWRITEMAX - 1)) {
STOREINTELWORD(mem + address, value);	STOREINTELWORD(mem + address, value);
}	}
else {	else {
i286_memorywrite_w(address, value);	i286_memorywrite_w(address, value);
Line 893 void MEMCALL i286_memstr_read(UINT seg,	Line 1002 void MEMCALL i286_memstr_read(UINT seg,

out = (BYTE *)dat;	out = (BYTE *)dat;
adrs = seg << 4;	adrs = seg << 4;
	off = LOW16(off);
if ((I286_MEMREADMAX >= 0x10000) &&	if ((I286_MEMREADMAX >= 0x10000) &&
(adrs < (I286_MEMREADMAX - 0x10000))) {	(adrs < (I286_MEMREADMAX - 0x10000))) {
if (leng) {	if (leng) {
Line 917 void MEMCALL i286_memstr_read(UINT seg,	Line 1027 void MEMCALL i286_memstr_read(UINT seg,
else {	else {
while(leng--) {	while(leng--) {
*out++ = i286_memoryread(adrs + off);	*out++ = i286_memoryread(adrs + off);
off = (off + 1) & 0xffff;	off = LOW16(off + 1);
}	}
}	}
}	}
Line 931 void MEMCALL i286_memstr_write(UINT seg,	Line 1041 void MEMCALL i286_memstr_write(UINT seg,

out = (BYTE *)dat;	out = (BYTE *)dat;
adrs = seg << 4;	adrs = seg << 4;
	off = LOW16(off);
if ((I286_MEMWRITEMAX >= 0x10000) &&	if ((I286_MEMWRITEMAX >= 0x10000) &&
(adrs < (I286_MEMWRITEMAX - 0x10000))) {	(adrs < (I286_MEMWRITEMAX - 0x10000))) {
if (leng) {	if (leng) {
Line 955 void MEMCALL i286_memstr_write(UINT seg,	Line 1066 void MEMCALL i286_memstr_write(UINT seg,
else {	else {
while(leng--) {	while(leng--) {
i286_memorywrite(adrs + off, *out++);	i286_memorywrite(adrs + off, *out++);
off = (off + 1) & 0xffff;	off = LOW16(off + 1);
}	}
}	}
}	}

RetroPC.NET-CVS <cvs@retropc.net>

Removed from v.1.1
changed lines
	Added in v.1.15