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.1 and 1.8

version 1.1, 2003/10/16 17:57:49	version 1.8, 2004/01/30 14:33:27
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の回数を記録する	// C版EGCのみ ROPの回数を記録する
// #define LOG_EGCROP	// #define LOG_EGCROP


static QWORD_P egc_src;	enum {
static QWORD_P data;	EGCADDR_L = 0,
	EGCADDR_H = 1
	};
	#define EGCADDR(a) (a)



	static EGCQUAD egc_src;
	static EGCQUAD 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};

Line 53 void egcshift(void) {	Line 59 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 108 void egcshift(void) {	Line 114 void egcshift(void) {
}	}


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

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
egc.srcmask.b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
}	}
if (egc.dstbit) {	if (egc.dstbit) {
if ((egc.dstbit + egc.remain) >= 8) {	if ((egc.dstbit + egc.remain) >= 8) {
egc.srcmask.b[ext] = bytemask_u0[egc.dstbit + (7*8)];	egc.srcmask._b[ext] = bytemask_u0[egc.dstbit + (7*8)];
egc.remain -= (8 - egc.dstbit);	egc.remain -= (8 - egc.dstbit);
egc.dstbit = 0;	egc.dstbit = 0;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_u0[egc.dstbit + (egc.remain - 1)*8];	egc.srcmask._b[ext] = bytemask_u0[egc.dstbit +
	(egc.remain - 1) * 8];
egc.remain = 0;	egc.remain = 0;
egc.dstbit = 0;	egc.dstbit = 0;
}	}
Line 132 static void egcsftb_upn_sub(DWORD ext) {	Line 139 static void egcsftb_upn_sub(DWORD ext) {
egc.remain -= 8;	egc.remain -= 8;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_u1[egc.remain - 1];	egc.srcmask._b[ext] = bytemask_u1[egc.remain - 1];
egc.remain = 0;	egc.remain = 0;
}	}
}	}
egc_src.b[0][ext] = egc.outptr[0];	egc_src._b[0][ext] = egc.outptr[0];
egc_src.b[1][ext] = egc.outptr[4];	egc_src._b[1][ext] = egc.outptr[4];
egc_src.b[2][ext] = egc.outptr[8];	egc_src._b[2][ext] = egc.outptr[8];
egc_src.b[3][ext] = egc.outptr[12];	egc_src._b[3][ext] = egc.outptr[12];
egc.outptr++;	egc.outptr++;
}	}

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

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
egc.srcmask.b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
}	}
if (egc.dstbit) {	if (egc.dstbit) {
if ((egc.dstbit + egc.remain) >= 8) {	if ((egc.dstbit + egc.remain) >= 8) {
egc.srcmask.b[ext] = bytemask_d0[egc.dstbit + (7*8)];	egc.srcmask._b[ext] = bytemask_d0[egc.dstbit + (7*8)];
egc.remain -= (8 - egc.dstbit);	egc.remain -= (8 - egc.dstbit);
egc.dstbit = 0;	egc.dstbit = 0;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_d0[egc.dstbit + (egc.remain - 1)*8];	egc.srcmask._b[ext] = bytemask_d0[egc.dstbit +
	(egc.remain - 1) * 8];
egc.remain = 0;	egc.remain = 0;
egc.dstbit = 0;	egc.dstbit = 0;
}	}
Line 168 static void egcsftb_dnn_sub(DWORD ext) {	Line 175 static void egcsftb_dnn_sub(DWORD ext) {
egc.remain -= 8;	egc.remain -= 8;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_d1[egc.remain - 1];	egc.srcmask._b[ext] = bytemask_d1[egc.remain - 1];
egc.remain = 0;	egc.remain = 0;
}	}
}	}
egc_src.b[0][ext] = egc.outptr[0];	egc_src._b[0][ext] = egc.outptr[0];
egc_src.b[1][ext] = egc.outptr[4];	egc_src._b[1][ext] = egc.outptr[4];
egc_src.b[2][ext] = egc.outptr[8];	egc_src._b[2][ext] = egc.outptr[8];
egc_src.b[3][ext] = egc.outptr[12];	egc_src._b[3][ext] = egc.outptr[12];
egc.outptr--;	egc.outptr--;
}	}

Line 185 static void egcsftb_dnn_sub(DWORD ext) {	Line 192 static void egcsftb_dnn_sub(DWORD 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(DWORD ext) {	static void egcsftb_upr_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
egc.srcmask.b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
}	}
if (egc.dstbit) {	if (egc.dstbit) {
if ((egc.dstbit + egc.remain) >= 8) {	if ((egc.dstbit + egc.remain) >= 8) {
egc.srcmask.b[ext] = bytemask_u0[egc.dstbit + (7*8)];	egc.srcmask._b[ext] = bytemask_u0[egc.dstbit + (7*8)];
egc.remain -= (8 - egc.dstbit);	egc.remain -= (8 - egc.dstbit);
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_u0[egc.dstbit + (egc.remain - 1)*8];	egc.srcmask._b[ext] = bytemask_u0[egc.dstbit +
	(egc.remain - 1) * 8];
egc.remain = 0;	egc.remain = 0;
}	}
egc.dstbit = 0;	egc.dstbit = 0;
egc_src.b[0][ext] = (egc.outptr[0] >> egc.sft8bitr);	egc_src._b[0][ext] = (egc.outptr[0] >> egc.sft8bitr);
egc_src.b[1][ext] = (egc.outptr[4] >> egc.sft8bitr);	egc_src._b[1][ext] = (egc.outptr[4] >> egc.sft8bitr);
egc_src.b[2][ext] = (egc.outptr[8] >> egc.sft8bitr);	egc_src._b[2][ext] = (egc.outptr[8] >> egc.sft8bitr);
egc_src.b[3][ext] = (egc.outptr[12] >> egc.sft8bitr);	egc_src._b[3][ext] = (egc.outptr[12] >> egc.sft8bitr);
}	}
else {	else {
if (egc.remain >= 8) {	if (egc.remain >= 8) {
egc.remain -= 8;	egc.remain -= 8;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_u1[egc.remain - 1];	egc.srcmask._b[ext] = bytemask_u1[egc.remain - 1];
egc.remain = 0;	egc.remain = 0;
}	}
egc_src.b[0][ext] = (egc.outptr[0] << egc.sft8bitl) \|	egc_src._b[0][ext] = (egc.outptr[0] << egc.sft8bitl) \|
(egc.outptr[1] >> egc.sft8bitr);	(egc.outptr[1] >> egc.sft8bitr);
egc_src.b[1][ext] = (egc.outptr[4] << egc.sft8bitl) \|	egc_src._b[1][ext] = (egc.outptr[4] << egc.sft8bitl) \|
(egc.outptr[5] >> egc.sft8bitr);	(egc.outptr[5] >> egc.sft8bitr);
egc_src.b[2][ext] = (egc.outptr[8] << egc.sft8bitl) \|	egc_src._b[2][ext] = (egc.outptr[8] << egc.sft8bitl) \|
(egc.outptr[9] >> egc.sft8bitr);	(egc.outptr[9] >> egc.sft8bitr);
egc_src.b[3][ext] = (egc.outptr[12] << egc.sft8bitl) \|	egc_src._b[3][ext] = (egc.outptr[12] << egc.sft8bitl) \|
(egc.outptr[13] >> egc.sft8bitr);	(egc.outptr[13] >> egc.sft8bitr);
egc.outptr++;	egc.outptr++;
}	}
Line 233 static void egcsftb_upr_sub(DWORD ext) {	Line 241 static void egcsftb_upr_sub(DWORD 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(DWORD ext) {	static void egcsftb_dnr_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
egc.srcmask.b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
}	}
if (egc.dstbit) {	if (egc.dstbit) {
if ((egc.dstbit + egc.remain) >= 8) {	if ((egc.dstbit + egc.remain) >= 8) {
egc.srcmask.b[ext] = bytemask_d0[egc.dstbit + (7*8)];	egc.srcmask._b[ext] = bytemask_d0[egc.dstbit + (7*8)];
egc.remain -= (8 - egc.dstbit);	egc.remain -= (8 - egc.dstbit);
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_d0[egc.dstbit + (egc.remain - 1)*8];	egc.srcmask._b[ext] = bytemask_d0[egc.dstbit +
	(egc.remain - 1) * 8];
egc.remain = 0;	egc.remain = 0;
}	}
egc.dstbit = 0;	egc.dstbit = 0;
egc_src.b[0][ext] = (egc.outptr[0] << egc.sft8bitr);	egc_src._b[0][ext] = (egc.outptr[0] << egc.sft8bitr);
egc_src.b[1][ext] = (egc.outptr[4] << egc.sft8bitr);	egc_src._b[1][ext] = (egc.outptr[4] << egc.sft8bitr);
egc_src.b[2][ext] = (egc.outptr[8] << egc.sft8bitr);	egc_src._b[2][ext] = (egc.outptr[8] << egc.sft8bitr);
egc_src.b[3][ext] = (egc.outptr[12] << egc.sft8bitr);	egc_src._b[3][ext] = (egc.outptr[12] << egc.sft8bitr);
}	}
else {	else {
if (egc.remain >= 8) {	if (egc.remain >= 8) {
egc.remain -= 8;	egc.remain -= 8;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_d1[egc.remain - 1];	egc.srcmask._b[ext] = bytemask_d1[egc.remain - 1];
egc.remain = 0;	egc.remain = 0;
}	}
egc.outptr--;	egc.outptr--;
egc_src.b[0][ext] = (egc.outptr[1] >> egc.sft8bitl) \|	egc_src._b[0][ext] = (egc.outptr[1] >> egc.sft8bitl) \|
(egc.outptr[0] << egc.sft8bitr);	(egc.outptr[0] << egc.sft8bitr);
egc_src.b[1][ext] = (egc.outptr[5] >> egc.sft8bitl) \|	egc_src._b[1][ext] = (egc.outptr[5] >> egc.sft8bitl) \|
(egc.outptr[4] << egc.sft8bitr);	(egc.outptr[4] << egc.sft8bitr);
egc_src.b[2][ext] = (egc.outptr[9] >> egc.sft8bitl) \|	egc_src._b[2][ext] = (egc.outptr[9] >> egc.sft8bitl) \|
(egc.outptr[8] << egc.sft8bitr);	(egc.outptr[8] << egc.sft8bitr);
egc_src.b[3][ext] = (egc.outptr[13] >> egc.sft8bitl) \|	egc_src._b[3][ext] = (egc.outptr[13] >> egc.sft8bitl) \|
(egc.outptr[12] << egc.sft8bitr);	(egc.outptr[12] << egc.sft8bitr);
}	}
}	}
Line 281 static void egcsftb_dnr_sub(DWORD ext) {	Line 290 static void egcsftb_dnr_sub(DWORD 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(DWORD ext) {	static void egcsftb_upl_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
egc.srcmask.b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
}	}
if (egc.dstbit) {	if (egc.dstbit) {
if ((egc.dstbit + egc.remain) >= 8) {	if ((egc.dstbit + egc.remain) >= 8) {
egc.srcmask.b[ext] = bytemask_u0[egc.dstbit + (7*8)];	egc.srcmask._b[ext] = bytemask_u0[egc.dstbit + (7*8)];
egc.remain -= (8 - egc.dstbit);	egc.remain -= (8 - egc.dstbit);
egc.dstbit = 0;	egc.dstbit = 0;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_u0[egc.dstbit + (egc.remain - 1)*8];	egc.srcmask._b[ext] = bytemask_u0[egc.dstbit +
	(egc.remain - 1) * 8];
egc.remain = 0;	egc.remain = 0;
egc.dstbit = 0;	egc.dstbit = 0;
}	}
Line 305 static void egcsftb_upl_sub(DWORD ext) {	Line 315 static void egcsftb_upl_sub(DWORD ext) {
egc.remain -= 8;	egc.remain -= 8;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_u1[egc.remain - 1];	egc.srcmask._b[ext] = bytemask_u1[egc.remain - 1];
egc.remain = 0;	egc.remain = 0;
}	}
}	}
egc_src.b[0][ext] = (egc.outptr[0] << egc.sft8bitl) \|	egc_src._b[0][ext] = (egc.outptr[0] << egc.sft8bitl) \|
(egc.outptr[1] >> egc.sft8bitr);	(egc.outptr[1] >> egc.sft8bitr);
egc_src.b[1][ext] = (egc.outptr[4] << egc.sft8bitl) \|	egc_src._b[1][ext] = (egc.outptr[4] << egc.sft8bitl) \|
(egc.outptr[5] >> egc.sft8bitr);	(egc.outptr[5] >> egc.sft8bitr);
egc_src.b[2][ext] = (egc.outptr[8] << egc.sft8bitl) \|	egc_src._b[2][ext] = (egc.outptr[8] << egc.sft8bitl) \|
(egc.outptr[9] >> egc.sft8bitr);	(egc.outptr[9] >> egc.sft8bitr);
egc_src.b[3][ext] = (egc.outptr[12] << egc.sft8bitl) \|	egc_src._b[3][ext] = (egc.outptr[12] << egc.sft8bitl) \|
(egc.outptr[13] >> egc.sft8bitr);	(egc.outptr[13] >> egc.sft8bitr);
egc.outptr++;	egc.outptr++;
}	}
Line 326 static void egcsftb_upl_sub(DWORD ext) {	Line 336 static void egcsftb_upl_sub(DWORD 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(DWORD ext) {	static void egcsftb_dnl_sub(UINT ext) {

if (egc.dstbit >= 8) {	if (egc.dstbit >= 8) {
egc.dstbit -= 8;	egc.dstbit -= 8;
egc.srcmask.b[ext] = 0;	egc.srcmask._b[ext] = 0;
return;	return;
}	}
if (egc.dstbit) {	if (egc.dstbit) {
if ((egc.dstbit + egc.remain) >= 8) {	if ((egc.dstbit + egc.remain) >= 8) {
egc.srcmask.b[ext] = bytemask_d0[egc.dstbit + (7*8)];	egc.srcmask._b[ext] = bytemask_d0[egc.dstbit + (7*8)];
egc.remain -= (8 - egc.dstbit);	egc.remain -= (8 - egc.dstbit);
egc.dstbit = 0;	egc.dstbit = 0;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_d0[egc.dstbit + (egc.remain - 1)*8];	egc.srcmask._b[ext] = bytemask_d0[egc.dstbit +
	(egc.remain - 1) * 8];
egc.remain = 0;	egc.remain = 0;
egc.dstbit = 0;	egc.dstbit = 0;
}	}
Line 350 static void egcsftb_dnl_sub(DWORD ext) {	Line 361 static void egcsftb_dnl_sub(DWORD ext) {
egc.remain -= 8;	egc.remain -= 8;
}	}
else {	else {
egc.srcmask.b[ext] = bytemask_d1[egc.remain - 1];	egc.srcmask._b[ext] = bytemask_d1[egc.remain - 1];
egc.remain = 0;	egc.remain = 0;
}	}
}	}
egc.outptr--;	egc.outptr--;
egc_src.b[0][ext] = (egc.outptr[1] >> egc.sft8bitl) \|	egc_src._b[0][ext] = (egc.outptr[1] >> egc.sft8bitl) \|
(egc.outptr[0] << egc.sft8bitr);	(egc.outptr[0] << egc.sft8bitr);
egc_src.b[1][ext] = (egc.outptr[5] >> egc.sft8bitl) \|	egc_src._b[1][ext] = (egc.outptr[5] >> egc.sft8bitl) \|
(egc.outptr[4] << egc.sft8bitr);	(egc.outptr[4] << egc.sft8bitr);
egc_src.b[2][ext] = (egc.outptr[9] >> egc.sft8bitl) \|	egc_src._b[2][ext] = (egc.outptr[9] >> egc.sft8bitl) \|
(egc.outptr[8] << egc.sft8bitr);	(egc.outptr[8] << egc.sft8bitr);
egc_src.b[3][ext] = (egc.outptr[13] >> egc.sft8bitl) \|	egc_src._b[3][ext] = (egc.outptr[13] >> egc.sft8bitl) \|
(egc.outptr[12] << egc.sft8bitr);	(egc.outptr[12] << egc.sft8bitr);
}	}


static void egcsftb_upn0(DWORD adrs) {	static void egcsftb_upn0(UINT32 adrs) {

int ext;	UINT ext;

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

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

if (egc.stack < (DWORD)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
return;	return;
}	}
egc.stack -= (16 - egc.dstbit);	egc.stack -= (16 - egc.dstbit);
egcsftb_upn_sub(0);	egcsftb_upn_sub(EGCADDR_L);
if (egc.remain) {	if (egc.remain) {
egcsftb_upn_sub(1);	egcsftb_upn_sub(EGCADDR_H);
if (egc.remain) {	if (egc.remain) {
return;	return;
}	}
}	}
else {	else {
egc.srcmask.b[1] = 0;	egc.srcmask._b[EGCADDR_H] = 0;
}	}
egcshift();	egcshift();
(void)adrs;	(void)adrs;
}	}

	static void egcsftb_dnn0(UINT32 adrs) {

static void egcsftb_dnn0(DWORD adrs) {	UINT ext;

int ext;

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

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

if (egc.stack < (DWORD)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
return;	return;
}	}
egc.stack -= (16 - egc.dstbit);	egc.stack -= (16 - egc.dstbit);
egcsftb_dnn_sub(1);	egcsftb_dnn_sub(EGCADDR_H);
if (egc.remain) {	if (egc.remain) {
egcsftb_dnn_sub(0);	egcsftb_dnn_sub(EGCADDR_L);
if (egc.remain) {	if (egc.remain) {
return;	return;
}	}
}	}
else {	else {
egc.srcmask.b[0] = 0;	egc.srcmask._b[EGCADDR_L] = 0;
}	}
egcshift();	egcshift();
(void)adrs;	(void)adrs;
}	}


static void egcsftb_upr0(DWORD adrs) { // dir:up srcbit < dstbit	static void egcsftb_upr0(UINT32 adrs) { // dir:up srcbit < dstbit

int ext;	int ext;

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

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

if (egc.stack < (DWORD)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
return;	return;
}	}
egc.stack -= (16 - egc.dstbit);	egc.stack -= (16 - egc.dstbit);
egcsftb_upr_sub(0);	egcsftb_upr_sub(EGCADDR_L);
if (egc.remain) {	if (egc.remain) {
egcsftb_upr_sub(1);	egcsftb_upr_sub(EGCADDR_H);
if (egc.remain) {	if (egc.remain) {
return;	return;
}	}
}	}
else {	else {
egc.srcmask.b[1] = 0;	egc.srcmask._b[EGCADDR_H] = 0;
}	}
egcshift();	egcshift();
(void)adrs;	(void)adrs;
}	}

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

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

int ext;

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

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

if (egc.stack < (DWORD)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
return;	return;
}	}
egc.stack -= (16 - egc.dstbit);	egc.stack -= (16 - egc.dstbit);
egcsftb_dnr_sub(1);	egcsftb_dnr_sub(EGCADDR_H);
if (egc.remain) {	if (egc.remain) {
egcsftb_dnr_sub(0);	egcsftb_dnr_sub(EGCADDR_L);
if (egc.remain) {	if (egc.remain) {
return;	return;
}	}
}	}
else {	else {
egc.srcmask.b[0] = 0;	egc.srcmask._b[EGCADDR_L] = 0;
}	}
egcshift();	egcshift();
(void)adrs;	(void)adrs;
}	}


static void egcsftb_upl0(DWORD adrs) { // dir:up srcbit > dstbit	static void egcsftb_upl0(UINT32 adrs) { // dir:up srcbit > dstbit

int ext;	UINT ext;

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

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

if (egc.stack < (DWORD)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
return;	return;
}	}
egc.stack -= (16 - egc.dstbit);	egc.stack -= (16 - egc.dstbit);
egcsftb_upl_sub(0);	egcsftb_upl_sub(EGCADDR_L);
if (egc.remain) {	if (egc.remain) {
egcsftb_upl_sub(1);	egcsftb_upl_sub(EGCADDR_H);
if (egc.remain) {	if (egc.remain) {
return;	return;
}	}
}	}
else {	else {
egc.srcmask.b[1] = 0;	egc.srcmask._b[EGCADDR_H] = 0;
}	}
egcshift();	egcshift();
(void)adrs;	(void)adrs;
}	}

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

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

int ext;

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

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

if (egc.stack < (DWORD)(16 - egc.dstbit)) {	if (egc.stack < (UINT)(16 - egc.dstbit)) {
egc.srcmask.w = 0;	egc.srcmask.w = 0;
return;	return;
}	}
egc.stack -= (16 - egc.dstbit);	egc.stack -= (16 - egc.dstbit);
egcsftb_dnl_sub(1);	egcsftb_dnl_sub(EGCADDR_H);
if (egc.remain) {	if (egc.remain) {
egcsftb_dnl_sub(0);	egcsftb_dnl_sub(EGCADDR_L);
if (egc.remain) {	if (egc.remain) {
return;	return;
}	}
}	}
else {	else {
egc.srcmask.b[0] = 0;	egc.srcmask._b[EGCADDR_L] = 0;
}	}
egcshift();	egcshift();
(void)adrs;	(void)adrs;
}	}


static void (*egcsft_proc[])(DWORD adrs) = {	static void (*egcsft_proc[])(UINT32 adrs) = {
egcsftw_upn0, egcsftw_dnn0,	egcsftw_upn0, egcsftw_dnn0,
egcsftw_upr0, egcsftw_dnr0,	egcsftw_upr0, egcsftw_dnr0,
egcsftw_upl0, egcsftw_dnl0,	egcsftw_upl0, egcsftw_dnl0,
Line 603 static void (*egcsft_proc[])(DWORD adrs)	Line 611 static void (*egcsft_proc[])(DWORD adrs)
egcsftb_upr0, egcsftb_dnr0,	egcsftb_upr0, egcsftb_dnr0,
egcsftb_upl0, egcsftb_dnl0};	egcsftb_upl0, egcsftb_dnl0};


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

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

if (egc.stack <= 16) {	if (egc.stack <= 16) {
if (egc.srcbit >= 8) {	if (egc.srcbit >= 8) {
Line 622 static void shiftinput_byte(DWORD ext) {	Line 631 static void shiftinput_byte(DWORD ext) {
egc.inptr--;	egc.inptr--;
}	}
}	}
egc.srcmask.b[ext] = 0xff;	egc.srcmask._b[ext] = 0xff;
egcsft_proc[egc.func + 6](ext);	egcsft_proc[egc.func + 6](ext);
}	}

Line 659 static void shiftinput_decw(void) {	Line 668 static void shiftinput_decw(void) {
if (egc.ope & 0x400) { \	if (egc.ope & 0x400) { \
if (func < 6) { \	if (func < 6) { \
if (!(egc.sft & 0x1000)) { \	if (!(egc.sft & 0x1000)) { \
(WORD )(egc.inptr + 0) = value; \	egc.inptr[ 0] = (BYTE)value; \
(WORD )(egc.inptr + 4) = value; \	egc.inptr[ 1] = (BYTE)(value >> 8); \
(WORD )(egc.inptr + 8) = value; \	egc.inptr[ 4] = (BYTE)value; \
(WORD )(egc.inptr +12) = 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(); \	shiftinput_incw(); \
} \	} \
else { \	else { \
(WORD )(egc.inptr - 1) = value; \	egc.inptr[-1] = (BYTE)value; \
(WORD )(egc.inptr + 3) = value; \	egc.inptr[ 0] = (BYTE)(value >> 8); \
(WORD )(egc.inptr + 7) = value; \	egc.inptr[ 3] = (BYTE)value; \
(WORD )(egc.inptr +11) = 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(); \	shiftinput_decw(); \
} \	} \
} \	} \
else { \	else { \
*(egc.inptr + 0) = (BYTE)value; \	egc.inptr[ 0] = (BYTE)value; \
*(egc.inptr + 4) = (BYTE)value; \	egc.inptr[ 4] = (BYTE)value; \
*(egc.inptr + 8) = (BYTE)value; \	egc.inptr[ 8] = (BYTE)value; \
*(egc.inptr +12) = (BYTE)value; \	egc.inptr[12] = (BYTE)value; \
shiftinput_byte(ad & 1); \	shiftinput_byte(EGCADDR(ad & 1)); \
} \	} \
} \	} \
}	}


static void gdc_ope(DWORD ad, WORD value, int func) {	static void gdc_ope(UINT32 ad, REG16 value, int func) {

QWORD_P pat;	EGCQUAD pat;
QWORD_P dst;	EGCQUAD dst;

egc.mask2.w = egc.mask.w;	egc.mask2.w = egc.mask.w;

Line 704 static void gdc_ope(DWORD ad, WORD value	Line 721 static void gdc_ope(DWORD ad, WORD value
pat.d[1] = egc.fgc.d[1];	pat.d[1] = egc.fgc.d[1];
break;	break;
default:	default:
if ((egc.ope & 0x0300) == 0x0100) { // ver0.29	if ((egc.ope & 0x0300) == 0x0100) {
pat.d[0] = egc_src.d[0];	pat.d[0] = egc_src.d[0];
pat.d[1] = egc_src.d[1];	pat.d[1] = egc_src.d[1];
}	}
Line 715 static void gdc_ope(DWORD ad, WORD value	Line 732 static void gdc_ope(DWORD ad, WORD value
break;	break;
}	}
ad &= ~1;	ad &= ~1;
dst.w[0] = (WORD )(&mem[ad + VRAM_B]);	dst.w[0] = (UINT16 )(&mem[ad + VRAM_B]);
dst.w[1] = (WORD )(&mem[ad + VRAM_R]);	dst.w[1] = (UINT16 )(&mem[ad + VRAM_R]);
dst.w[2] = (WORD )(&mem[ad + VRAM_G]);	dst.w[2] = (UINT16 )(&mem[ad + VRAM_G]);
dst.w[3] = (WORD )(&mem[ad + VRAM_E]);	dst.w[3] = (UINT16 )(&mem[ad + VRAM_E]);

#ifdef LOG_EGCROP	#ifdef LOG_EGCROP
egcropcnt[egc.ope & 0xff]++;	egcropcnt[egc.ope & 0xff]++;
Line 783 static void gdc_ope(DWORD ad, WORD value	Line 800 static void gdc_ope(DWORD ad, WORD value
}	}
break;	break;
default:	default:
data.w[0] = value;	#if defined(BYTESEX_LITTLE)
data.w[1] = value;	data.w[0] = (UINT16)value;
data.w[2] = value;	data.w[1] = (UINT16)value;
data.w[3] = value;	data.w[2] = (UINT16)value;
	data.w[3] = (UINT16)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
break;	break;
}	}
}	}

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

DWORD ad;
DWORD ext;

// TRACE_("EGC read_byte", (WORD)(addr & 0x7fff));	UINT32 ad;
	UINT ext;

if (gdcs.access) {	if (gdcs.access) {
addr += VRAM_STEP;	addr += VRAM_STEP;
}	}
ad = VRAM_POS(addr);	ad = VRAMADDRMASKEX(addr);
ext = 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];
egc.lastvram.b[2][ext] = mem[ad + VRAM_G];	egc.lastvram._b[2][ext] = mem[ad + VRAM_G];
egc.lastvram.b[3][ext] = mem[ad + VRAM_E];	egc.lastvram._b[3][ext] = mem[ad + VRAM_E];

// shift input	// shift input
if (!(egc.ope & 0x400)) {	if (!(egc.ope & 0x400)) {
egc.inptr[0] = egc.lastvram.b[0][ext];	egc.inptr[0] = egc.lastvram._b[0][ext];
egc.inptr[4] = egc.lastvram.b[1][ext];	egc.inptr[4] = egc.lastvram._b[1][ext];
egc.inptr[8] = egc.lastvram.b[2][ext];	egc.inptr[8] = egc.lastvram._b[2][ext];
egc.inptr[12] = egc.lastvram.b[3][ext];	egc.inptr[12] = egc.lastvram._b[3][ext];
shiftinput_byte(ext);	shiftinput_byte(ext);
}	}

if ((egc.ope & 0x0300) == 0x0100) {	if ((egc.ope & 0x0300) == 0x0100) {
egc.patreg.b[0][ext] = mem[ad + VRAM_B];	egc.patreg._b[0][ext] = mem[ad + VRAM_B];
egc.patreg.b[1][ext] = mem[ad + VRAM_R];	egc.patreg._b[1][ext] = mem[ad + VRAM_R];
egc.patreg.b[2][ext] = mem[ad + VRAM_G];	egc.patreg._b[2][ext] = mem[ad + VRAM_G];
egc.patreg.b[3][ext] = mem[ad + VRAM_E];	egc.patreg._b[3][ext] = mem[ad + VRAM_E];
}	}
if (!(egc.ope & 0x2000)) {	if (!(egc.ope & 0x2000)) {
int pl = (egc.fgbg >> 8) & 3;	int pl = (egc.fgbg >> 8) & 3;
if (!(egc.ope & 0x400)) {	if (!(egc.ope & 0x400)) {
return(egc_src.b[pl][ext]);	return(egc_src._b[pl][ext]);
}	}
else {	else {
return(mem[ad + planead[pl]]);	return(mem[ad + planead[pl]]);
Line 836 BYTE MEMCALL egc_read(UINT32 addr) {	Line 859 BYTE MEMCALL egc_read(UINT32 addr) {
}	}


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

DWORD ext;
WORD wvalue;

// TRACE_("EGC write_byte", (WORD)(addr & 0x7fff));	UINT ext;
	REG16 wvalue;

addr &= 0x7fff;	addr = LOW15(addr);
ext = addr & 1;	ext = EGCADDR(addr & 1);
if (!gdcs.access) {	if (!gdcs.access) {
gdcs.grphdisp \|= 1;	gdcs.grphdisp \|= 1;
vramupdate[addr] \|= 0x01;	vramupdate[addr] \|= 0x01;
Line 855 void MEMCALL egc_write(UINT32 addr, BYTE	Line 876 void MEMCALL egc_write(UINT32 addr, BYTE
addr += VRAM_STEP;	addr += VRAM_STEP;
}	}
if ((egc.ope & 0x0300) == 0x0200) {	if ((egc.ope & 0x0300) == 0x0200) {
egc.patreg.b[0][ext] = mem[addr + VRAM_B];	egc.patreg._b[0][ext] = mem[addr + VRAM_B];
egc.patreg.b[1][ext] = mem[addr + VRAM_R];	egc.patreg._b[1][ext] = mem[addr + VRAM_R];
egc.patreg.b[2][ext] = mem[addr + VRAM_G];	egc.patreg._b[2][ext] = mem[addr + VRAM_G];
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	value = (BYTE)value;
	wvalue = (value << 8) + value;
if (!ext) {	if (!ext) {
gdc_ope(addr, wvalue, egc.func + 6);	gdc_ope(addr, wvalue, egc.func + 6);
}	}
else {	else {
gdc_ope(addr, wvalue, egc.func + 6);	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) {

DWORD ad;	UINT32 ad;

// TRACE_("EGC read_word", (WORD)(addr & 0x7fff));

if (!(addr & 1)) {	if (!(addr & 1)) {
if (gdcs.access) {	if (gdcs.access) {
addr += VRAM_STEP;	addr += VRAM_STEP;
}	}
ad = VRAM_POS(addr);	ad = VRAMADDRMASKEX(addr);
egc.lastvram.w[0] = (WORD )(&mem[ad + VRAM_B]);	egc.lastvram.w[0] = (UINT16 )(&mem[ad + VRAM_B]);
egc.lastvram.w[1] = (WORD )(&mem[ad + VRAM_R]);	egc.lastvram.w[1] = (UINT16 )(&mem[ad + VRAM_R]);
egc.lastvram.w[2] = (WORD )(&mem[ad + VRAM_G]);	egc.lastvram.w[2] = (UINT16 )(&mem[ad + VRAM_G]);
egc.lastvram.w[3] = (WORD )(&mem[ad + VRAM_E]);	egc.lastvram.w[3] = (UINT16 )(&mem[ad + VRAM_E]);

// shift input	// shift input
if (!(egc.ope & 0x400)) {	if (!(egc.ope & 0x400)) {
if (!(egc.sft & 0x1000)) {	if (!(egc.sft & 0x1000)) {
(WORD )(egc.inptr + 0) = egc.lastvram.w[0];	egc.inptr[ 0] = egc.lastvram._b[0][EGCADDR_L];
(WORD )(egc.inptr + 4) = egc.lastvram.w[1];	egc.inptr[ 1] = egc.lastvram._b[0][EGCADDR_H];
(WORD )(egc.inptr + 8) = egc.lastvram.w[2];	egc.inptr[ 4] = egc.lastvram._b[1][EGCADDR_L];
(WORD )(egc.inptr +12) = egc.lastvram.w[3];	egc.inptr[ 5] = egc.lastvram._b[1][EGCADDR_H];
	egc.inptr[ 8] = egc.lastvram._b[2][EGCADDR_L];
	egc.inptr[ 9] = egc.lastvram._b[2][EGCADDR_H];
	egc.inptr[12] = egc.lastvram._b[3][EGCADDR_L];
	egc.inptr[13] = egc.lastvram._b[3][EGCADDR_H];
shiftinput_incw();	shiftinput_incw();
}	}
else {	else {
(WORD )(egc.inptr - 1) = egc.lastvram.w[0];	egc.inptr[-1] = egc.lastvram._b[0][EGCADDR_L];
(WORD )(egc.inptr + 3) = egc.lastvram.w[1];	egc.inptr[ 0] = egc.lastvram._b[0][EGCADDR_H];
(WORD )(egc.inptr + 7) = egc.lastvram.w[2];	egc.inptr[ 3] = egc.lastvram._b[1][EGCADDR_L];
(WORD )(egc.inptr +11) = egc.lastvram.w[3];	egc.inptr[ 4] = egc.lastvram._b[1][EGCADDR_H];
	egc.inptr[ 7] = egc.lastvram._b[2][EGCADDR_L];
	egc.inptr[ 8] = egc.lastvram._b[2][EGCADDR_H];
	egc.inptr[11] = egc.lastvram._b[3][EGCADDR_L];
	egc.inptr[12] = egc.lastvram._b[3][EGCADDR_H];
shiftinput_decw();	shiftinput_decw();
}	}
}	}
Line 929 UINT16 MEMCALL egc_read_w(UINT32 addr) {	Line 957 UINT16 MEMCALL egc_read_w(UINT32 addr) {
if (!(egc.ope & 0x2000)) {	if (!(egc.ope & 0x2000)) {
int pl = (egc.fgbg >> 8) & 3;	int pl = (egc.fgbg >> 8) & 3;
if (!(egc.ope & 0x400)) {	if (!(egc.ope & 0x400)) {
return(egc_src.w[pl]);	return(LOADINTELWORD(egc_src._b[pl]));
}	}
else {	else {
return((WORD )(&mem[ad + planead[pl]]));	return(LOADINTELWORD(mem + ad + planead[pl]));
}	}
}	}
return((WORD )(&mem[addr]));	return(LOADINTELWORD(mem + addr));
}	}
else if (!(egc.sft & 0x1000)) {	else if (!(egc.sft & 0x1000)) {
WORD 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 {
WORD 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) {

// TRACE_("EGC write_word", (WORD)(addr & 0x7fff));

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;
(WORD )(&vramupdate[addr]) \|= 0x0101;	(UINT16 )(vramupdate + addr) \|= 0x0101;
}	}
else {	else {
gdcs.grphdisp \|= 2;	gdcs.grphdisp \|= 2;
(WORD )(&vramupdate[addr]) \|= 0x0202;	(UINT16 )(vramupdate + addr) \|= 0x0202;
addr += VRAM_STEP;	addr += VRAM_STEP;
}	}
if ((egc.ope & 0x0300) == 0x0200) {	if ((egc.ope & 0x0300) == 0x0200) {
egc.patreg.w[0] = (WORD )(&mem[addr + VRAM_B]);	egc.patreg.w[0] = (UINT16 )(&mem[addr + VRAM_B]);
egc.patreg.w[1] = (WORD )(&mem[addr + VRAM_R]);	egc.patreg.w[1] = (UINT16 )(&mem[addr + VRAM_R]);
egc.patreg.w[2] = (WORD )(&mem[addr + VRAM_G]);	egc.patreg.w[2] = (UINT16 )(&mem[addr + VRAM_G]);
egc.patreg.w[3] = (WORD )(&mem[addr + VRAM_E]);	egc.patreg.w[3] = (UINT16 )(&mem[addr + VRAM_E]);
}	}
gdc_ope(addr, value, egc.func);	gdc_ope(addr, value, egc.func);
if (egc.mask2.w) {	if (egc.mask2.w) {
if (!(egc.access & 1)) {	if (!(egc.access & 1)) {
(WORD )(&mem[addr + VRAM_B]) &= ~egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_B]) &= ~egc.mask2.w;
(WORD )(&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)) {
(WORD )(&mem[addr + VRAM_R]) &= ~egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_R]) &= ~egc.mask2.w;
(WORD )(&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)) {
(WORD )(&mem[addr + VRAM_G]) &= ~egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_G]) &= ~egc.mask2.w;
(WORD )(&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)) {
(WORD )(&mem[addr + VRAM_E]) &= ~egc.mask2.w;	(UINT16 )(&mem[addr + VRAM_E]) &= ~egc.mask2.w;
(WORD )(&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.1
changed lines
	Added in v.1.8