np2/i286c/egcmem.c - diff

Return to egcmem.c CVS log

Up to [RetroPC.NET] / np2 / i286c

Diff for /np2/i286c/Attic/egcmem.c between versions 1.3 and 1.9

version 1.3, 2003/10/25 10:19:57	version 1.9, 2004/02/18 02:03:36
Line 1	Line 1
#include "compiler.h"	#include "compiler.h"
#include "memory.h"	#include "cpucore.h"
#include "egcmem.h"	#include "egcmem.h"
#include "pccore.h"	#include "pccore.h"
#include "iocore.h"	#include "iocore.h"
#include "vram.h"	#include "vram.h"


// C版EGCのみ ROPの回数を記録する
// #define LOG_EGCROP


enum {	enum {
EGCADDR_L = 0,	EGCADDR_L = 0,
EGCADDR_H = 1	EGCADDR_H = 1
Line 19 enum {	Line 15 enum {


static EGCQUAD egc_src;	static EGCQUAD egc_src;
static EGCQUAD data;	static EGCQUAD egc_data;

static const UINT planead[4] = {VRAM_B, VRAM_R, VRAM_G, VRAM_E};	static const UINT planead[4] = {VRAM_B, VRAM_R, VRAM_G, VRAM_E};


static const BYTE bytemask_u0[64] = // dir:right by startbit + (len-1)*8	static const UINT8 bytemask_u0[64] = // dir:right by startbit + (len-1)*8
{0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01,	{0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01,
0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x03, 0x01,	0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x03, 0x01,
0xe0, 0x70, 0x38, 0x1c, 0x0e, 0x07, 0x03, 0x01,	0xe0, 0x70, 0x38, 0x1c, 0x0e, 0x07, 0x03, 0x01,
Line 34 static const BYTE bytemask_u0[64] = //	Line 30 static const BYTE bytemask_u0[64] = //
0xfe, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01,	0xfe, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01,
0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01};	0xff, 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01};

static const BYTE bytemask_u1[8] = // dir:right by length	static const UINT8 bytemask_u1[8] = // dir:right by length
{0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff};	{0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff};

static const BYTE bytemask_d0[64] = // dir:left by startbit + (len-1)*8	static const UINT8 bytemask_d0[64] = // dir:left by startbit + (len-1)*8
{0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,	{0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x80,	0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x80,
0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0, 0xc0, 0x80,	0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0, 0xc0, 0x80,
Line 47 static const BYTE bytemask_d0[64] = //	Line 43 static const BYTE bytemask_d0[64] = //
0x7f, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80,	0x7f, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80,
0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80};	0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80};

static const BYTE bytemask_d1[8] = // dir:left by length	static const UINT8 bytemask_d1[8] = // dir:left by length
{0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};	{0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};

#ifdef LOG_EGCROP
static int egcropcnt[256];
#endif


void egcshift(void) {	void egcshift(void) {

BYTE src8, dst8;	BYTE src8, dst8;

egc.remain = (egc.leng & 0xfff) + 1;	egc.remain = LOW12(egc.leng) + 1;
egc.func = (egc.sft >> 12) & 1;	egc.func = (egc.sft >> 12) & 1;
if (!egc.func) {	if (!egc.func) {
egc.inptr = egc.buf;	egc.inptr = egc.buf;
Line 114 void egcshift(void) {	Line 106 void egcshift(void) {
}	}


static void egcsftb_upn_sub(UINT ext) {	static void MEMCALL egcsftb_upn_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
Line 150 static void egcsftb_upn_sub(UINT ext) {	Line 142 static void egcsftb_upn_sub(UINT ext) {
egc.outptr++;	egc.outptr++;
}	}

static void egcsftb_dnn_sub(UINT ext) {	static void MEMCALL egcsftb_dnn_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
Line 192 static void egcsftb_dnn_sub(UINT ext) {	Line 184 static void egcsftb_dnn_sub(UINT ext) {
// 1st -> data[0] >> (dst - src)	// 1st -> data[0] >> (dst - src)
// 2nd -> (data[0] << (8 - (dst - src))) \| (data[1] >> (dst - src))	// 2nd -> (data[0] << (8 - (dst - src))) \| (data[1] >> (dst - src))

static void egcsftb_upr_sub(UINT ext) {	static void MEMCALL egcsftb_upr_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
Line 241 static void egcsftb_upr_sub(UINT ext) {	Line 233 static void egcsftb_upr_sub(UINT ext) {
// 1st -> data[0] << (dst - src)	// 1st -> data[0] << (dst - src)
// 2nd -> (data[0] >> (8 - (dst - src))) \| (data[-1] << (dst - src))	// 2nd -> (data[0] >> (8 - (dst - src))) \| (data[-1] << (dst - src))

static void egcsftb_dnr_sub(UINT ext) {	static void MEMCALL egcsftb_dnr_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
Line 290 static void egcsftb_dnr_sub(UINT ext) {	Line 282 static void egcsftb_dnr_sub(UINT ext) {
// 1st -> (data[0] << (src - dst)) \| (data[1] >> (8 - (src - dst))	// 1st -> (data[0] << (src - dst)) \| (data[1] >> (8 - (src - dst))
// 2nd -> (data[0] << (src - dst)) \| (data[1] >> (8 - (src - dst))	// 2nd -> (data[0] << (src - dst)) \| (data[1] >> (8 - (src - dst))

static void egcsftb_upl_sub(UINT ext) {	static void MEMCALL egcsftb_upl_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
Line 336 static void egcsftb_upl_sub(UINT ext) {	Line 328 static void egcsftb_upl_sub(UINT ext) {
// 1st -> (data[0] >> (dst - src)) \| (data[-1] << (8 - (src - dst))	// 1st -> (data[0] >> (dst - src)) \| (data[-1] << (8 - (src - dst))
// 2nd -> (data[0] >> (dst - src)) \| (data[-1] << (8 - (src - dst))	// 2nd -> (data[0] >> (dst - src)) \| (data[-1] << (8 - (src - dst))

static void egcsftb_dnl_sub(UINT ext) {	static void MEMCALL egcsftb_dnl_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
Line 377 static void egcsftb_dnl_sub(UINT ext) {	Line 369 static void egcsftb_dnl_sub(UINT ext) {
}	}


static void egcsftb_upn0(UINT32 adrs) {	static void MEMCALL egcsftb_upn0(UINT ext) {

UINT ext;

ext = EGCADDR(adrs & 1);
if (egc.stack < (UINT)(8 - egc.dstbit)) {	if (egc.stack < (UINT)(8 - egc.dstbit)) {
egc.srcmask._b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
Line 393 static void egcsftb_upn0(UINT32 adrs) {	Line 382 static void egcsftb_upn0(UINT32 adrs) {
}	}
}	}

static void egcsftw_upn0(UINT32 adrs) {	static void MEMCALL egcsftw_upn0(void) {

if (egc.stack < (UINT)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
Line 411 static void egcsftw_upn0(UINT32 adrs) {	Line 400 static void egcsftw_upn0(UINT32 adrs) {
egc.srcmask._b[EGCADDR_H] = 0;	egc.srcmask._b[EGCADDR_H] = 0;
}	}
egcshift();	egcshift();
(void)adrs;
}	}

static void egcsftb_dnn0(UINT32 adrs) {	static void MEMCALL egcsftb_dnn0(UINT ext) {

UINT ext;

ext = EGCADDR(adrs & 1);
if (egc.stack < (UINT)(8 - egc.dstbit)) {	if (egc.stack < (UINT)(8 - egc.dstbit)) {
egc.srcmask._b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
Line 430 static void egcsftb_dnn0(UINT32 adrs) {	Line 415 static void egcsftb_dnn0(UINT32 adrs) {
}	}
}	}

static void egcsftw_dnn0(UINT32 adrs) {	static void MEMCALL egcsftw_dnn0(void) {

if (egc.stack < (UINT)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
Line 448 static void egcsftw_dnn0(UINT32 adrs) {	Line 433 static void egcsftw_dnn0(UINT32 adrs) {
egc.srcmask._b[EGCADDR_L] = 0;	egc.srcmask._b[EGCADDR_L] = 0;
}	}
egcshift();	egcshift();
(void)adrs;
}	}


static void egcsftb_upr0(UINT32 adrs) { // dir:up srcbit < dstbit	static void MEMCALL egcsftb_upr0(UINT ext) { // dir:up srcbit < dstbit

int ext;

ext = EGCADDR(adrs & 1);
if (egc.stack < (UINT)(8 - egc.dstbit)) {	if (egc.stack < (UINT)(8 - egc.dstbit)) {
egc.srcmask._b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
Line 468 static void egcsftb_upr0(UINT32 adrs) {	Line 449 static void egcsftb_upr0(UINT32 adrs) {
}	}
}	}

static void egcsftw_upr0(UINT32 adrs) { // dir:up srcbit < dstbit	static void MEMCALL egcsftw_upr0(void) { // dir:up srcbit < dstbit

if (egc.stack < (UINT)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
Line 486 static void egcsftw_upr0(UINT32 adrs) {	Line 467 static void egcsftw_upr0(UINT32 adrs) {
egc.srcmask._b[EGCADDR_H] = 0;	egc.srcmask._b[EGCADDR_H] = 0;
}	}
egcshift();	egcshift();
(void)adrs;
}	}

static void egcsftb_dnr0(UINT32 adrs) { // dir:up srcbit < dstbit	static void MEMCALL egcsftb_dnr0(UINT ext) { // dir:up srcbit < dstbit

UINT ext;

ext = EGCADDR(adrs & 1);
if (egc.stack < (UINT)(8 - egc.dstbit)) {	if (egc.stack < (UINT)(8 - egc.dstbit)) {
egc.srcmask._b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
Line 505 static void egcsftb_dnr0(UINT32 adrs) {	Line 482 static void egcsftb_dnr0(UINT32 adrs) {
}	}
}	}

static void egcsftw_dnr0(UINT32 adrs) { // dir:up srcbit < dstbit	static void MEMCALL egcsftw_dnr0(void) { // dir:up srcbit < dstbit

if (egc.stack < (UINT)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
Line 523 static void egcsftw_dnr0(UINT32 adrs) {	Line 500 static void egcsftw_dnr0(UINT32 adrs) {
egc.srcmask._b[EGCADDR_L] = 0;	egc.srcmask._b[EGCADDR_L] = 0;
}	}
egcshift();	egcshift();
(void)adrs;
}	}


static void egcsftb_upl0(UINT32 adrs) { // dir:up srcbit > dstbit	static void MEMCALL egcsftb_upl0(UINT ext) { // dir:up srcbit > dstbit

UINT ext;

ext = EGCADDR(adrs & 1);
if (egc.stack < (UINT)(8 - egc.dstbit)) {	if (egc.stack < (UINT)(8 - egc.dstbit)) {
egc.srcmask._b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
Line 543 static void egcsftb_upl0(UINT32 adrs) {	Line 516 static void egcsftb_upl0(UINT32 adrs) {
}	}
}	}

static void egcsftw_upl0(UINT32 adrs) { // dir:up srcbit > dstbit	static void MEMCALL egcsftw_upl0(void) { // dir:up srcbit > dstbit

if (egc.stack < (UINT)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
Line 561 static void egcsftw_upl0(UINT32 adrs) {	Line 534 static void egcsftw_upl0(UINT32 adrs) {
egc.srcmask._b[EGCADDR_H] = 0;	egc.srcmask._b[EGCADDR_H] = 0;
}	}
egcshift();	egcshift();
(void)adrs;
}	}

static void egcsftb_dnl0(UINT32 adrs) { // dir:up srcbit > dstbit	static void MEMCALL egcsftb_dnl0(UINT ext) { // dir:up srcbit > dstbit

UINT ext;

ext = EGCADDR(adrs & 1);
if (egc.stack < (UINT)(8 - egc.dstbit)) {	if (egc.stack < (UINT)(8 - egc.dstbit)) {
egc.srcmask._b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
Line 580 static void egcsftb_dnl0(UINT32 adrs) {	Line 549 static void egcsftb_dnl0(UINT32 adrs) {
}	}
}	}

static void egcsftw_dnl0(UINT32 adrs) { // dir:up srcbit > dstbit	static void MEMCALL egcsftw_dnl0(void) { // dir:up srcbit > dstbit

if (egc.stack < (UINT)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
Line 598 static void egcsftw_dnl0(UINT32 adrs) {	Line 567 static void egcsftw_dnl0(UINT32 adrs) {
egc.srcmask._b[EGCADDR_L] = 0;	egc.srcmask._b[EGCADDR_L] = 0;
}	}
egcshift();	egcshift();
(void)adrs;
}	}


static void (*egcsft_proc[])(UINT32 adrs) = {	typedef void (MEMCALL * EGCSFTB)(UINT ext);
egcsftw_upn0, egcsftw_dnn0,	typedef void (MEMCALL * EGCSFTW)(void);
egcsftw_upr0, egcsftw_dnr0,
egcsftw_upl0, egcsftw_dnl0,

	static const EGCSFTB egcsftb[6] = {
egcsftb_upn0, egcsftb_dnn0,	egcsftb_upn0, egcsftb_dnn0,
egcsftb_upr0, egcsftb_dnr0,	egcsftb_upr0, egcsftb_dnr0,
egcsftb_upl0, egcsftb_dnl0};	egcsftb_upl0, egcsftb_dnl0};

	static const EGCSFTW egcsftw[6] = {
	egcsftw_upn0, egcsftw_dnn0,
	egcsftw_upr0, egcsftw_dnr0,
	egcsftw_upl0, egcsftw_dnl0};



// ---------------------------------------------------------------------------	// ---------------------------------------------------------------------------

static void shiftinput_byte(UINT ext) {	static void MEMCALL shiftinput_byte(UINT ext) {

if (egc.stack <= 16) {	if (egc.stack <= 16) {
if (egc.srcbit >= 8) {	if (egc.srcbit >= 8) {
Line 632 static void shiftinput_byte(UINT ext) {	Line 605 static void shiftinput_byte(UINT ext) {
}	}
}	}
egc.srcmask._b[ext] = 0xff;	egc.srcmask._b[ext] = 0xff;
egcsft_proc[egc.func + 6](ext);	(*egcsftb[egc.func])(ext);
}	}

static void shiftinput_incw(void) {	static void MEMCALL shiftinput_incw(void) {

if (egc.stack <= 16) {	if (egc.stack <= 16) {
egc.inptr += 2;	egc.inptr += 2;
Line 646 static void shiftinput_incw(void) {	Line 619 static void shiftinput_incw(void) {
egc.srcbit = 0;	egc.srcbit = 0;
}	}
egc.srcmask.w = 0xffff;	egc.srcmask.w = 0xffff;
egcsft_proc[egc.func](0);	(*egcsftw[egc.func])();
}	}

static void shiftinput_decw(void) {	static void MEMCALL shiftinput_decw(void) {

if (egc.stack <= 16) {	if (egc.stack <= 16) {
egc.inptr -= 2;	egc.inptr -= 2;
Line 660 static void shiftinput_decw(void) {	Line 633 static void shiftinput_decw(void) {
egc.srcbit = 0;	egc.srcbit = 0;
}	}
egc.srcmask.w = 0xffff;	egc.srcmask.w = 0xffff;
egcsft_proc[egc.func](0);	(*egcsftw[egc.func])();
	}

	#define EGCOPE_SHIFTB \
	if (egc.ope & 0x400) { \
	egc.inptr[ 0] = (BYTE)value; \
	egc.inptr[ 4] = (BYTE)value; \
	egc.inptr[ 8] = (BYTE)value; \
	egc.inptr[12] = (BYTE)value; \
	shiftinput_byte(EGCADDR(ad & 1)); \
	} \

	#define EGCOPE_SHIFTW \
	if (egc.ope & 0x400) { \
	if (!(egc.sft & 0x1000)) { \
	egc.inptr[ 0] = (BYTE)value; \
	egc.inptr[ 1] = (BYTE)(value >> 8); \
	egc.inptr[ 4] = (BYTE)value; \
	egc.inptr[ 5] = (BYTE)(value >> 8); \
	egc.inptr[ 8] = (BYTE)value; \
	egc.inptr[ 9] = (BYTE)(value >> 8); \
	egc.inptr[12] = (BYTE)value; \
	egc.inptr[13] = (BYTE)(value >> 8); \
	shiftinput_incw(); \
	} \
	else { \
	egc.inptr[-1] = (BYTE)value; \
	egc.inptr[ 0] = (BYTE)(value >> 8); \
	egc.inptr[ 3] = (BYTE)value; \
	egc.inptr[ 4] = (BYTE)(value >> 8); \
	egc.inptr[ 7] = (BYTE)value; \
	egc.inptr[ 8] = (BYTE)(value >> 8); \
	egc.inptr[11] = (BYTE)value; \
	egc.inptr[12] = (BYTE)(value >> 8); \
	shiftinput_decw(); \
	} \
	}


	// ----

	static const UINT8 data_00[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
	static const UINT8 data_ff[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};

	static const EGCQUAD * MEMCALL ope_00(REG8 ope, UINT32 ad) {

	(void)ope;
	(void)ad;
	return((EGCQUAD *)data_00);
	}

	static const EGCQUAD * MEMCALL ope_0f(REG8 ope, UINT32 ad) {

	egc_data.d[0] = ~egc_src.d[0];
	egc_data.d[1] = ~egc_src.d[1];

	(void)ope;
	(void)ad;
	return(&egc_data);
}	}

	static const EGCQUAD * MEMCALL ope_c0(REG8 ope, UINT32 ad) {

	EGCQUAD dst;

	dst.w[0] = (UINT16 )(&mem[ad + VRAM_B]);
	dst.w[1] = (UINT16 )(&mem[ad + VRAM_R]);
	dst.w[2] = (UINT16 )(&mem[ad + VRAM_G]);
	dst.w[3] = (UINT16 )(&mem[ad + VRAM_E]);
	egc_data.d[0] = (egc_src.d[0] & dst.d[0]);
	egc_data.d[1] = (egc_src.d[1] & dst.d[1]);

#define EGCOPE_SHIFT { \	(void)ope;
if (egc.ope & 0x400) { \	(void)ad;
if (func < 6) { \	return(&egc_data);
if (!(egc.sft & 0x1000)) { \
egc.inptr[ 0] = (BYTE)value; \
egc.inptr[ 1] = (BYTE)(value >> 8); \
egc.inptr[ 4] = (BYTE)value; \
egc.inptr[ 5] = (BYTE)(value >> 8); \
egc.inptr[ 8] = (BYTE)value; \
egc.inptr[ 9] = (BYTE)(value >> 8); \
egc.inptr[12] = (BYTE)value; \
egc.inptr[13] = (BYTE)(value >> 8); \
shiftinput_incw(); \
} \
else { \
egc.inptr[-1] = (BYTE)value; \
egc.inptr[ 0] = (BYTE)(value >> 8); \
egc.inptr[ 3] = (BYTE)value; \
egc.inptr[ 4] = (BYTE)(value >> 8); \
egc.inptr[ 7] = (BYTE)value; \
egc.inptr[ 8] = (BYTE)(value >> 8); \
egc.inptr[11] = (BYTE)value; \
egc.inptr[12] = (BYTE)(value >> 8); \
shiftinput_decw(); \
} \
} \
else { \
egc.inptr[ 0] = (BYTE)value; \
egc.inptr[ 4] = (BYTE)value; \
egc.inptr[ 8] = (BYTE)value; \
egc.inptr[12] = (BYTE)value; \
shiftinput_byte(EGCADDR(ad & 1)); \
} \
} \
}	}

	static const EGCQUAD * MEMCALL ope_f0(REG8 ope, UINT32 ad) {

	(void)ope;
	(void)ad;
	return(&egc_src);
	}

static void gdc_ope(UINT32 ad, UINT16 value, int func) {	static const EGCQUAD * MEMCALL ope_fc(REG8 ope, UINT32 ad) {

	EGCQUAD dst;

	dst.w[0] = (UINT16 )(&mem[ad + VRAM_B]);
	dst.w[1] = (UINT16 )(&mem[ad + VRAM_R]);
	dst.w[2] = (UINT16 )(&mem[ad + VRAM_G]);
	dst.w[3] = (UINT16 )(&mem[ad + VRAM_E]);
	egc_data.d[0] = egc_src.d[0];
	egc_data.d[0] \|= ((~egc_src.d[0]) & dst.d[0]);
	egc_data.d[1] = egc_src.d[1];
	egc_data.d[1] \|= ((~egc_src.d[1]) & dst.d[1]);

	(void)ope;
	(void)ad;
	return(&egc_data);
	}

	static const EGCQUAD * MEMCALL ope_ff(REG8 ope, UINT32 ad) {

	(void)ope;
	(void)ad;
	return((EGCQUAD *)data_ff);
	}

	static const EGCQUAD * MEMCALL ope_nd(REG8 ope, UINT32 ad) {

EGCQUAD pat;	EGCQUAD pat;

	switch(egc.fgbg & 0x6000) {
	case 0x2000:
	pat.d[0] = egc.bgc.d[0];
	pat.d[1] = egc.bgc.d[1];
	break;

	case 0x4000:
	pat.d[0] = egc.fgc.d[0];
	pat.d[1] = egc.fgc.d[1];
	break;

	default:
	if ((egc.ope & 0x0300) == 0x0100) {
	pat.d[0] = egc_src.d[0];
	pat.d[1] = egc_src.d[1];
	}
	else {
	pat.d[0] = egc.patreg.d[0];
	pat.d[1] = egc.patreg.d[1];
	}
	break;
	}

	egc_data.d[0] = 0;
	egc_data.d[1] = 0;
	if (ope & 0x80) {
	egc_data.d[0] \|= (pat.d[0] & egc_src.d[0]);
	egc_data.d[1] \|= (pat.d[1] & egc_src.d[1]);
	}
	if (ope & 0x40) {
	egc_data.d[0] \|= ((~pat.d[0]) & egc_src.d[0]);
	egc_data.d[1] \|= ((~pat.d[1]) & egc_src.d[1]);
	}
	if (ope & 0x08) {
	egc_data.d[0] \|= (pat.d[0] & (~egc_src.d[0]));
	egc_data.d[1] \|= (pat.d[1] & (~egc_src.d[1]));
	}
	if (ope & 0x04) {
	egc_data.d[0] \|= ((~pat.d[0]) & (~egc_src.d[0]));
	egc_data.d[1] \|= ((~pat.d[1]) & (~egc_src.d[1]));
	}
	(void)ad;
	return(&egc_data);
	}

	static const EGCQUAD * MEMCALL ope_np(REG8 ope, UINT32 ad) {

EGCQUAD dst;	EGCQUAD dst;

egc.mask2.w = egc.mask.w;	dst.w[0] = (UINT16 )(&mem[ad + VRAM_B]);
	dst.w[1] = (UINT16 )(&mem[ad + VRAM_R]);
	dst.w[2] = (UINT16 )(&mem[ad + VRAM_G]);
	dst.w[3] = (UINT16 )(&mem[ad + VRAM_E]);

	egc_data.d[0] = 0;
	egc_data.d[1] = 0;
	if (ope & 0x80) {
	egc_data.d[0] \|= (egc_src.d[0] & dst.d[0]);
	egc_data.d[1] \|= (egc_src.d[1] & dst.d[1]);
	}
	if (ope & 0x20) {
	egc_data.d[0] \|= (egc_src.d[0] & (~dst.d[0]));
	egc_data.d[1] \|= (egc_src.d[1] & (~dst.d[1]));
	}
	if (ope & 0x08) {
	egc_data.d[0] \|= ((~egc_src.d[0]) & dst.d[0]);
	egc_data.d[1] \|= ((~egc_src.d[1]) & dst.d[1]);
	}
	if (ope & 0x02) {
	egc_data.d[0] \|= ((~egc_src.d[0]) & (~dst.d[0]));
	egc_data.d[1] \|= ((~egc_src.d[1]) & (~dst.d[1]));
	}
	return(&egc_data);
	}

	static const EGCQUAD * MEMCALL ope_xx(REG8 ope, UINT32 ad) {

	EGCQUAD pat;
	EGCQUAD dst;

	switch(egc.fgbg & 0x6000) {
	case 0x2000:
	pat.d[0] = egc.bgc.d[0];
	pat.d[1] = egc.bgc.d[1];
	break;

	case 0x4000:
	pat.d[0] = egc.fgc.d[0];
	pat.d[1] = egc.fgc.d[1];
	break;

	default:
	if ((egc.ope & 0x0300) == 0x0100) {
	pat.d[0] = egc_src.d[0];
	pat.d[1] = egc_src.d[1];
	}
	else {
	pat.d[0] = egc.patreg.d[0];
	pat.d[1] = egc.patreg.d[1];
	}
	break;
	}
	dst.w[0] = (UINT16 )(&mem[ad + VRAM_B]);
	dst.w[1] = (UINT16 )(&mem[ad + VRAM_R]);
	dst.w[2] = (UINT16 )(&mem[ad + VRAM_G]);
	dst.w[3] = (UINT16 )(&mem[ad + VRAM_E]);

	egc_data.d[0] = 0;
	egc_data.d[1] = 0;
	if (ope & 0x80) {
	egc_data.d[0] \|= (pat.d[0] & egc_src.d[0] & dst.d[0]);
	egc_data.d[1] \|= (pat.d[1] & egc_src.d[1] & dst.d[1]);
	}
	if (ope & 0x40) {
	egc_data.d[0] \|= ((~pat.d[0]) & egc_src.d[0] & dst.d[0]);
	egc_data.d[1] \|= ((~pat.d[1]) & egc_src.d[1] & dst.d[1]);
	}
	if (ope & 0x20) {
	egc_data.d[0] \|= (pat.d[0] & egc_src.d[0] & (~dst.d[0]));
	egc_data.d[1] \|= (pat.d[1] & egc_src.d[1] & (~dst.d[1]));
	}
	if (ope & 0x10) {
	egc_data.d[0] \|= ((~pat.d[0]) & egc_src.d[0] & (~dst.d[0]));
	egc_data.d[1] \|= ((~pat.d[1]) & egc_src.d[1] & (~dst.d[1]));
	}
	if (ope & 0x08) {
	egc_data.d[0] \|= (pat.d[0] & (~egc_src.d[0]) & dst.d[0]);
	egc_data.d[1] \|= (pat.d[1] & (~egc_src.d[1]) & dst.d[1]);
	}
	if (ope & 0x04) {
	egc_data.d[0] \|= ((~pat.d[0]) & (~egc_src.d[0]) & dst.d[0]);
	egc_data.d[1] \|= ((~pat.d[1]) & (~egc_src.d[1]) & dst.d[1]);
	}
	if (ope & 0x02) {
	egc_data.d[0] \|= (pat.d[0] & (~egc_src.d[0]) & (~dst.d[0]));
	egc_data.d[1] \|= (pat.d[1] & (~egc_src.d[1]) & (~dst.d[1]));
	}
	if (ope & 0x01) {
	egc_data.d[0] \|= ((~pat.d[0]) & (~egc_src.d[0]) & (~dst.d[0]));
	egc_data.d[1] \|= ((~pat.d[1]) & (~egc_src.d[1]) & (~dst.d[1]));
	}
	return(&egc_data);
	}

	typedef const EGCQUAD * (MEMCALL * OPEFN)(REG8 ope, UINT32 ad);

	static const OPEFN opefn[256] = {
	ope_00, ope_xx, ope_xx, ope_np, ope_xx, ope_nd, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_nd, ope_xx, ope_np, ope_xx, ope_xx, ope_0f,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_np, ope_xx, ope_xx, ope_np, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_np, ope_xx, ope_xx, ope_np,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_nd, ope_xx, ope_xx, ope_xx, ope_xx, ope_nd, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_nd, ope_xx, ope_xx, ope_xx, ope_xx, ope_nd,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_nd, ope_xx, ope_xx, ope_xx, ope_xx, ope_nd, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_nd, ope_xx, ope_xx, ope_xx, ope_xx, ope_nd,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_c0, ope_xx, ope_xx, ope_np, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_np, ope_xx, ope_xx, ope_np,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx, ope_xx,
	ope_f0, ope_xx, ope_xx, ope_np, ope_xx, ope_nd, ope_xx, ope_xx,
	ope_xx, ope_xx, ope_nd, ope_xx, ope_fc, ope_xx, ope_xx, ope_ff};


	// ----

	static const EGCQUAD * MEMCALL egc_opeb(UINT32 ad, REG8 value) {

	UINT tmp;

	egc.mask2.w = egc.mask.w;
switch(egc.ope & 0x1800) {	switch(egc.ope & 0x1800) {
case 0x0800:	case 0x0800:
EGCOPE_SHIFT;	EGCOPE_SHIFTB;
	egc.mask2.w &= egc.srcmask.w;
	tmp = egc.ope & 0xff;
	return((*opefn[tmp])(tmp, ad & (~1)));

	case 0x1000:
switch(egc.fgbg & 0x6000) {	switch(egc.fgbg & 0x6000) {
case 0x2000:	case 0x2000:
pat.d[0] = egc.bgc.d[0];	return(&egc.bgc);
pat.d[1] = egc.bgc.d[1];
break;
case 0x4000:	case 0x4000:
pat.d[0] = egc.fgc.d[0];	return(&egc.fgc);
pat.d[1] = egc.fgc.d[1];
break;
default:	default:
if ((egc.ope & 0x0300) == 0x0100) { // ver0.29	EGCOPE_SHIFTB;
pat.d[0] = egc_src.d[0];	egc.mask2.w &= egc.srcmask.w;
pat.d[1] = egc_src.d[1];	return(&egc_src);
}
else {
pat.d[0] = egc.patreg.d[0];
pat.d[1] = egc.patreg.d[1];
}
break;
}	}
ad &= ~1;	break;
dst.w[0] = (UINT16 )(&mem[ad + VRAM_B]);
dst.w[1] = (UINT16 )(&mem[ad + VRAM_R]);
dst.w[2] = (UINT16 )(&mem[ad + VRAM_G]);
dst.w[3] = (UINT16 )(&mem[ad + VRAM_E]);

#ifdef LOG_EGCROP	default:
egcropcnt[egc.ope & 0xff]++;	tmp = value & 0xff;
#endif	tmp = tmp \| (tmp << 8);
data.d[0] = 0;	egc_data.w[0] = (UINT16)tmp;
data.d[1] = 0;	egc_data.w[1] = (UINT16)tmp;
if (egc.ope & 0x80) {	egc_data.w[2] = (UINT16)tmp;
data.d[0] \|= (pat.d[0] & egc_src.d[0] & dst.d[0]);	egc_data.w[3] = (UINT16)tmp;
data.d[1] \|= (pat.d[1] & egc_src.d[1] & dst.d[1]);	return(&egc_data);
}	}
if (egc.ope & 0x40) {	}
data.d[0] \|= ((~pat.d[0]) & egc_src.d[0] & dst.d[0]);
data.d[1] \|= ((~pat.d[1]) & egc_src.d[1] & dst.d[1]);	static const EGCQUAD * MEMCALL egc_opew(UINT32 ad, REG16 value) {
}
if (egc.ope & 0x20) {	UINT tmp;
data.d[0] \|= (pat.d[0] & egc_src.d[0] & (~dst.d[0]));
data.d[1] \|= (pat.d[1] & egc_src.d[1] & (~dst.d[1]));	egc.mask2.w = egc.mask.w;
}	switch(egc.ope & 0x1800) {
if (egc.ope & 0x10) {	case 0x0800:
data.d[0] \|= ((~pat.d[0]) & egc_src.d[0] & (~dst.d[0]));	EGCOPE_SHIFTW;
data.d[1] \|= ((~pat.d[1]) & egc_src.d[1] & (~dst.d[1]));
}
if (egc.ope & 0x08) {
data.d[0] \|= (pat.d[0] & (~egc_src.d[0]) & dst.d[0]);
data.d[1] \|= (pat.d[1] & (~egc_src.d[1]) & dst.d[1]);
}
if (egc.ope & 0x04) {
data.d[0] \|= ((~pat.d[0]) & (~egc_src.d[0]) & dst.d[0]);
data.d[1] \|= ((~pat.d[1]) & (~egc_src.d[1]) & dst.d[1]);
}
if (egc.ope & 0x02) {
data.d[0] \|= (pat.d[0] & (~egc_src.d[0]) & (~dst.d[0]));
data.d[1] \|= (pat.d[1] & (~egc_src.d[1]) & (~dst.d[1]));
}
if (egc.ope & 0x01) {
data.d[0] \|= ((~pat.d[0]) & (~egc_src.d[0]) & (~dst.d[0]));
data.d[1] \|= ((~pat.d[1]) & (~egc_src.d[1]) & (~dst.d[1]));
}
egc.mask2.w &= egc.srcmask.w;	egc.mask2.w &= egc.srcmask.w;
break;	tmp = egc.ope & 0xff;
	return((*opefn[tmp])(tmp, ad));

case 0x1000:	case 0x1000:
switch(egc.fgbg & 0x6000) {	switch(egc.fgbg & 0x6000) {
case 0x2000: // ver0.29	case 0x2000:
data.d[0] = egc.bgc.d[0];	return(&egc.bgc);
data.d[1] = egc.bgc.d[1];
break;	case 0x4000:
case 0x4000: // ver0.29	return(&egc.fgc);
data.d[0] = egc.fgc.d[0];
data.d[1] = egc.fgc.d[1];
break;
default:	default:
#if 0	EGCOPE_SHIFTW;
data.d[0] = egc.patreg.d[0];
data.d[1] = egc.patreg.d[1];
#else
EGCOPE_SHIFT;
data.d[0] = egc_src.d[0];
data.d[1] = egc_src.d[1];
egc.mask2.w &= egc.srcmask.w;	egc.mask2.w &= egc.srcmask.w;
#endif	return(&egc_src);
break;
}	}
break;	break;

default:	default:
#if defined(BYTESEX_LITTLE)	#if defined(BYTESEX_BIG)
data.w[0] = value;	value = ((value >> 8) & 0xff) \| ((value & 0xff) << 8);
data.w[1] = value;
data.w[2] = value;
data.w[3] = value;
#else
data._b[0][0] = (BYTE)value;
data._b[0][1] = (BYTE)(value >> 8);
data.w[1] = data.w[0];
data.w[2] = data.w[0];
data.w[3] = data.w[0];
#endif	#endif
break;	egc_data.w[0] = (UINT16)value;
	egc_data.w[1] = (UINT16)value;
	egc_data.w[2] = (UINT16)value;
	egc_data.w[3] = (UINT16)value;
	return(&egc_data);
}	}
}	}

BYTE MEMCALL egc_read(UINT32 addr) {	REG8 MEMCALL egc_read(UINT32 addr) {

UINT32 ad;	UINT32 ad;
UINT ext;	UINT ext;
Line 824 BYTE MEMCALL egc_read(UINT32 addr) {	Line 1014 BYTE MEMCALL egc_read(UINT32 addr) {
if (gdcs.access) {	if (gdcs.access) {
addr += VRAM_STEP;	addr += VRAM_STEP;
}	}
ad = VRAM_POS(addr);	ad = VRAMADDRMASKEX(addr);
ext = EGCADDR(addr & 1);	ext = EGCADDR(addr & 1);
egc.lastvram._b[0][ext] = mem[ad + VRAM_B];	egc.lastvram._b[0][ext] = mem[ad + VRAM_B];
egc.lastvram._b[1][ext] = mem[ad + VRAM_R];	egc.lastvram._b[1][ext] = mem[ad + VRAM_R];
Line 859 BYTE MEMCALL egc_read(UINT32 addr) {	Line 1049 BYTE MEMCALL egc_read(UINT32 addr) {
}	}


void MEMCALL egc_write(UINT32 addr, BYTE value) {	void MEMCALL egc_write(UINT32 addr, REG8 value) {

UINT ext;	UINT ext;
UINT16 wvalue;	const EGCQUAD *data;

addr &= 0x7fff;	addr = LOW15(addr);
ext = EGCADDR(addr & 1);	ext = EGCADDR(addr & 1);
if (!gdcs.access) {	if (!gdcs.access) {
gdcs.grphdisp \|= 1;	gdcs.grphdisp \|= 1;
Line 882 void MEMCALL egc_write(UINT32 addr, BYTE	Line 1072 void MEMCALL egc_write(UINT32 addr, BYTE
egc.patreg._b[3][ext] = mem[addr + VRAM_E];	egc.patreg._b[3][ext] = mem[addr + VRAM_E];
}	}

wvalue = (value << 8) \| (value); // ver0.28/pr4	data = egc_opeb(addr, value);
if (!ext) {
gdc_ope(addr, wvalue, egc.func + 6);
}
else {
gdc_ope(addr, wvalue, egc.func + 6);
}
if (egc.mask2._b[ext]) {	if (egc.mask2._b[ext]) {
if (!(egc.access & 1)) {	if (!(egc.access & 1)) {
mem[addr + VRAM_B] &= ~egc.mask2._b[ext];	mem[addr + VRAM_B] &= ~egc.mask2._b[ext];
mem[addr + VRAM_B] \|= data._b[0][ext] & egc.mask2._b[ext];	mem[addr + VRAM_B] \|= data->_b[0][ext] & egc.mask2._b[ext];
}	}
if (!(egc.access & 2)) {	if (!(egc.access & 2)) {
mem[addr + VRAM_R] &= ~egc.mask2._b[ext];	mem[addr + VRAM_R] &= ~egc.mask2._b[ext];
mem[addr + VRAM_R] \|= data._b[1][ext] & egc.mask2._b[ext];	mem[addr + VRAM_R] \|= data->_b[1][ext] & egc.mask2._b[ext];
}	}
if (!(egc.access & 4)) {	if (!(egc.access & 4)) {
mem[addr + VRAM_G] &= ~egc.mask2._b[ext];	mem[addr + VRAM_G] &= ~egc.mask2._b[ext];
mem[addr + VRAM_G] \|= data._b[2][ext] & egc.mask2._b[ext];	mem[addr + VRAM_G] \|= data->_b[2][ext] & egc.mask2._b[ext];
}	}
if (!(egc.access & 8)) {	if (!(egc.access & 8)) {
mem[addr + VRAM_E] &= ~egc.mask2._b[ext];	mem[addr + VRAM_E] &= ~egc.mask2._b[ext];
mem[addr + VRAM_E] \|= data._b[3][ext] & egc.mask2._b[ext];	mem[addr + VRAM_E] \|= data->_b[3][ext] & egc.mask2._b[ext];
}	}
}	}
}	}

UINT16 MEMCALL egc_read_w(UINT32 addr) {	REG16 MEMCALL egc_read_w(UINT32 addr) {

UINT32 ad;	UINT32 ad;

Line 917 UINT16 MEMCALL egc_read_w(UINT32 addr) {	Line 1101 UINT16 MEMCALL egc_read_w(UINT32 addr) {
if (gdcs.access) {	if (gdcs.access) {
addr += VRAM_STEP;	addr += VRAM_STEP;
}	}
ad = VRAM_POS(addr);	ad = VRAMADDRMASKEX(addr);
egc.lastvram.w[0] = (UINT16 )(&mem[ad + VRAM_B]);	egc.lastvram.w[0] = (UINT16 )(&mem[ad + VRAM_B]);
egc.lastvram.w[1] = (UINT16 )(&mem[ad + VRAM_R]);	egc.lastvram.w[1] = (UINT16 )(&mem[ad + VRAM_R]);
egc.lastvram.w[2] = (UINT16 )(&mem[ad + VRAM_G]);	egc.lastvram.w[2] = (UINT16 )(&mem[ad + VRAM_G]);
Line 965 UINT16 MEMCALL egc_read_w(UINT32 addr) {	Line 1149 UINT16 MEMCALL egc_read_w(UINT32 addr) {
return(LOADINTELWORD(mem + addr));	return(LOADINTELWORD(mem + addr));
}	}
else if (!(egc.sft & 0x1000)) {	else if (!(egc.sft & 0x1000)) {
UINT16 ret;	REG16 ret;
ret = egc_read(addr);	ret = egc_read(addr);
ret \|= egc_read(addr+1) << 8;	ret \|= egc_read(addr+1) << 8;
return(ret);	return(ret);
}	}
else {	else {
UINT16 ret;	REG16 ret;
ret = egc_read(addr+1) << 8;	ret = egc_read(addr+1) << 8;
ret \|= egc_read(addr);	ret \|= egc_read(addr);
return(ret);	return(ret);
}	}
}	}

void MEMCALL egc_write_w(UINT32 addr, UINT16 value) {	void MEMCALL egc_write_w(UINT32 addr, REG16 value) {

	const EGCQUAD *data;

if (!(addr & 1)) { // word access	if (!(addr & 1)) { // word access
addr &= 0x7ffe;	addr = LOW15(addr);
if (!gdcs.access) {	if (!gdcs.access) {
gdcs.grphdisp \|= 1;	gdcs.grphdisp \|= 1;
(UINT16 )(vramupdate + addr) \|= 0x0101;	(UINT16 )(vramupdate + addr) \|= 0x0101;
Line 997 void MEMCALL egc_write_w(UINT32 addr, UI	Line 1183 void MEMCALL egc_write_w(UINT32 addr, UI
egc.patreg.w[2] = (UINT16 )(&mem[addr + VRAM_G]);	egc.patreg.w[2] = (UINT16 )(&mem[addr + VRAM_G]);
egc.patreg.w[3] = (UINT16 )(&mem[addr + VRAM_E]);	egc.patreg.w[3] = (UINT16 )(&mem[addr + VRAM_E]);
}	}
gdc_ope(addr, value, egc.func);	data = egc_opew(addr, value);
if (egc.mask2.w) {	if (egc.mask2.w) {
if (!(egc.access & 1)) {	if (!(egc.access & 1)) {
(UINT16 )(&mem[addr + VRAM_B]) &= ~egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_B]) &= ~egc.mask2.w;
(UINT16 )(&mem[addr + VRAM_B]) \|= data.w[0] & egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_B]) \|= data->w[0] & egc.mask2.w;
}	}
if (!(egc.access & 2)) {	if (!(egc.access & 2)) {
(UINT16 )(&mem[addr + VRAM_R]) &= ~egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_R]) &= ~egc.mask2.w;
(UINT16 )(&mem[addr + VRAM_R]) \|= data.w[1] & egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_R]) \|= data->w[1] & egc.mask2.w;
}	}
if (!(egc.access & 4)) {	if (!(egc.access & 4)) {
(UINT16 )(&mem[addr + VRAM_G]) &= ~egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_G]) &= ~egc.mask2.w;
(UINT16 )(&mem[addr + VRAM_G]) \|= data.w[2] & egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_G]) \|= data->w[2] & egc.mask2.w;
}	}
if (!(egc.access & 8)) {	if (!(egc.access & 8)) {
(UINT16 )(&mem[addr + VRAM_E]) &= ~egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_E]) &= ~egc.mask2.w;
(UINT16 )(&mem[addr + VRAM_E]) \|= data.w[3] & egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_E]) \|= data->w[3] & egc.mask2.w;
}	}
}	}
}	}
else if (!(egc.sft & 0x1000)) {	else if (!(egc.sft & 0x1000)) {
egc_write(addr, (BYTE)value);	egc_write(addr, (REG8)value);
egc_write(addr+1, (BYTE)(value >> 8));	egc_write(addr+1, (REG8)(value >> 8));
}	}
else {	else {
egc_write(addr+1, (BYTE)(value >> 8));	egc_write(addr+1, (REG8)(value >> 8));
egc_write(addr, (BYTE)value);	egc_write(addr, (REG8)value);
}	}
}	}

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

Removed from v.1.3
changed lines
	Added in v.1.9