--- np2/lio/gput1.c	2004/02/21 04:48:35	1.8
+++ np2/lio/gput1.c	2005/05/20 13:59:47	1.17
@@ -8,35 +8,35 @@
 
 
 typedef struct {
-	BYTE	x1[2];
-	BYTE	y1[2];
-	BYTE	x2[2];
-	BYTE	y2[2];
-	BYTE	off[2];
-	BYTE	seg[2];
-	BYTE	leng[2];
+	UINT8	x1[2];
+	UINT8	y1[2];
+	UINT8	x2[2];
+	UINT8	y2[2];
+	UINT8	off[2];
+	UINT8	seg[2];
+	UINT8	leng[2];
 } GGET;
 
 typedef struct {
-	BYTE	x[2];
-	BYTE	y[2];
-	BYTE	off[2];
-	BYTE	seg[2];
-	BYTE	leng[2];
-	BYTE	mode;
-	BYTE	colorsw;
-	BYTE	fg;
-	BYTE	bg;
+	UINT8	x[2];
+	UINT8	y[2];
+	UINT8	off[2];
+	UINT8	seg[2];
+	UINT8	leng[2];
+	UINT8	mode;
+	UINT8	colorsw;
+	UINT8	fg;
+	UINT8	bg;
 } GPUT1;
 
 typedef struct {
-	BYTE	x[2];
-	BYTE	y[2];
-	BYTE	chr[2];
-	BYTE	mode;
-	BYTE	colorsw;
-	BYTE	fg;
-	BYTE	bg;
+	UINT8	x[2];
+	UINT8	y[2];
+	UINT8	chr[2];
+	UINT8	mode;
+	UINT8	colorsw;
+	UINT8	fg;
+	UINT8	bg;
 } GPUT2;
 
 typedef struct {
@@ -53,7 +53,7 @@ typedef struct {
 } LIOPUT;
 
 typedef struct {
-	BYTE	*baseptr;
+	UINT8	*baseptr;
 	UINT	addr;
 	UINT	sft;
 	UINT	width;
@@ -61,7 +61,7 @@ typedef struct {
 } GETCNTX;
 
 typedef struct {
-	BYTE	*baseptr;
+	UINT8	*baseptr;
 	UINT	addr;
 	UINT	sft;
 	UINT	width;
@@ -69,13 +69,13 @@ typedef struct {
 	UINT8	maskr;
 	UINT8	masklr;
 	UINT8	mask;
-	BYTE	pat[84];
+	UINT8	pat[84];
 } PUTCNTX;
 
 
-static void getvram(const GETCNTX *gt, BYTE *dst) {
+static void getvram(const GETCNTX *gt, UINT8 *dst) {
 
-	BYTE	*baseptr;
+	UINT8	*baseptr;
 	UINT	addr;
 	UINT	width;
 	UINT	dat;
@@ -116,9 +116,9 @@ static void setdirty(UINT addr, UINT wid
 
 static void putor(const PUTCNTX *pt) {
 
-	BYTE	*baseptr;
+	UINT8	*baseptr;
 	UINT	addr;
-const BYTE	*src;
+const UINT8	*src;
 	UINT	width;
 	UINT	dat;
 
@@ -150,9 +150,9 @@ const BYTE	*src;
 
 static void putorn(const PUTCNTX *pt) {
 
-	BYTE	*baseptr;
+	UINT8	*baseptr;
 	UINT	addr;
-const BYTE	*src;
+const UINT8	*src;
 	UINT	width;
 	UINT	dat;
 
@@ -184,9 +184,9 @@ const BYTE	*src;
 
 static void putand(const PUTCNTX *pt) {
 
-	BYTE	*baseptr;
+	UINT8	*baseptr;
 	UINT	addr;
-const BYTE	*src;
+const UINT8	*src;
 	UINT	width;
 	UINT	dat;
 
@@ -218,9 +218,9 @@ const BYTE	*src;
 
 static void putandn(const PUTCNTX *pt) {
 
-	BYTE	*baseptr;
+	UINT8	*baseptr;
 	UINT	addr;
-const BYTE	*src;
+const UINT8	*src;
 	UINT	width;
 	UINT	dat;
 
@@ -252,9 +252,9 @@ const BYTE	*src;
 
 static void putxor(const PUTCNTX *pt) {
 
-	BYTE	*baseptr;
+	UINT8	*baseptr;
 	UINT	addr;
-const BYTE	*src;
+const UINT8	*src;
 	UINT	width;
 	UINT	dat;
 
@@ -286,9 +286,9 @@ const BYTE	*src;
 
 static void putxorn(const PUTCNTX *pt) {
 
-	BYTE	*baseptr;
+	UINT8	*baseptr;
 	UINT	addr;
-const BYTE	*src;
+const UINT8	*src;
 	UINT	width;
 	UINT	dat;
 
@@ -321,7 +321,7 @@ const BYTE	*src;
 
 // ----
 
-static REG8 putsub(LIOWORK lio, const LIOPUT *lput) {
+static REG8 putsub(GLIO lio, const LIOPUT *lput) {
 
 	UINT	addr;
 	PUTCNTX	pt;
@@ -334,8 +334,8 @@ static REG8 putsub(LIOWORK lio, const LI
 
 	if ((lput->x < lio->draw.x1) ||
 		(lput->y < lio->draw.y1) ||
-		((lput->x + lput->width) > lio->draw.x2) ||
-		((lput->y + lput->height) > lio->draw.y2)) {
+		((lput->x + lput->width - 1) > lio->draw.x2) ||
+		((lput->y + lput->height - 1) > lio->draw.y2)) {
 		return(LIO_ILLEGALFUNC);
 	}
 	if ((lput->width <= 0) || (lput->height <= 0)) {
@@ -348,6 +348,7 @@ static REG8 putsub(LIOWORK lio, const LI
 	}
 	setdirty(addr, (lput->x & 7) + lput->width, lput->height, lio->draw.sbit);
 
+	pt.addr = addr;
 	pt.sft = lput->x & 7;
 	pt.width = lput->width;
 	pt.maskl = (UINT8)(0xff >> pt.sft);
@@ -357,29 +358,32 @@ static REG8 putsub(LIOWORK lio, const LI
 	datacnt = (lput->width + 7) >> 3;
 	off = lput->off;
 
-	flag = (lio->palmode == 2)?0x0f:0x07;
+	flag = (lio->draw.flag & LIODRAW_4BPP)?0x0f:0x07;
 	flag |= (lput->fg & 15) << 4;
 	flag |= (lput->bg & 15) << 8;
 
 	// さて表示。
 	writecnt = 0;
-	for (pl=0; pl<4; pl++) {
-		if (flag & 1) {
-			pt.baseptr = mem + lio->draw.base + lioplaneadrs[pl];
-			pt.addr = addr;
-			height = lput->height;
-			do {
-				i286_memstr_read(lput->seg, off, pt.pat, datacnt);
-				off += datacnt;
+	height = lput->height;
+	do {
+		flag <<= 4;
+		for (pl=0; pl<4; pl++) {
+			flag >>= 1;
+			if (flag & 8) {
+				pt.baseptr = mem + lio->draw.base + lioplaneadrs[pl];
+				MEMR_READS(lput->seg, off, pt.pat, datacnt);
+				if (lput->sw) {
+					off += datacnt;
+				}
 				switch(lput->mode) {
 					case 0:		// PSET
-						if (flag & (1 << 4)) {
+						if (flag & (8 << 4)) {
 							putor(&pt);
 						}
 						else {
 							putandn(&pt);
 						}
-						if (flag & (1 << 8)) {
+						if (flag & (8 << 8)) {
 							putorn(&pt);
 						}
 						else {
@@ -389,13 +393,13 @@ static REG8 putsub(LIOWORK lio, const LI
 						break;
 
 					case 1:		// NOT
-						if (!(flag & (1 << 4))) {
+						if (!(flag & (8 << 4))) {
 							putor(&pt);
 						}
 						else {
 							putandn(&pt);
 						}
-						if (!(flag & (1 << 8))) {
+						if (!(flag & (8 << 8))) {
 							putorn(&pt);
 						}
 						else {
@@ -405,46 +409,45 @@ static REG8 putsub(LIOWORK lio, const LI
 						break;
 
 					case 2:		// OR
-						if (flag & (1 << 4)) {
+						if (flag & (8 << 4)) {
 							putor(&pt);
 							writecnt++;
 						}
-						if (flag & (1 << 8)) {
+						if (flag & (8 << 8)) {
 							putorn(&pt);
 							writecnt++;
 						}
 						break;
 
 					case 3:		// AND
-						if (!(flag & (1 << 4))) {
+						if (!(flag & (8 << 4))) {
 							putandn(&pt);
 							writecnt++;
 						}
-						if (!(flag & (1 << 8))) {
+						if (!(flag & (8 << 8))) {
 							putand(&pt);
 							writecnt++;
 						}
 						break;
 
 					case 4:		// XOR
-						if (flag & (1 << 4)) {
+						if (flag & (8 << 4)) {
 							putxor(&pt);
 							writecnt++;
 						}
-						if (flag & (1 << 8)) {
+						if (flag & (8 << 8)) {
 							putxorn(&pt);
 							writecnt++;
 						}
 						break;
 				}
-				pt.addr += 80;
-			} while(--height);
-			if (!lput->sw) {
-				off = lput->off;
 			}
 		}
-		flag >>= 1;
-	}
+		pt.addr += 80;
+		if (!lput->sw) {
+			off += datacnt;
+		}
+	} while(--height);
 	lio->wait += writecnt * datacnt * (10 + 10 + 10);
 	return(LIO_SUCCESS);
 }
@@ -452,7 +455,7 @@ static REG8 putsub(LIOWORK lio, const LI
 
 // ---- GGET
 
-REG8 lio_gget(LIOWORK lio) {
+REG8 lio_gget(GLIO lio) {
 
 	GGET	dat;
 	SINT32	x;
@@ -465,14 +468,12 @@ REG8 lio_gget(LIOWORK lio) {
 	UINT32	size;
 	UINT	datacnt;
 	UINT	mask;
-	UINT	addr;
 	GETCNTX	gt;
-	BYTE	pat[84];
+	UINT8	pat[84];
 	UINT	pl;
-	UINT	height;
 
 	lio_updatedraw(lio);
-	i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));
+	MEMR_READS(CPU_DS, CPU_BX, &dat, sizeof(dat));
 	x = (SINT16)LOADINTELWORD(dat.x1);
 	y = (SINT16)LOADINTELWORD(dat.y1);
 	x2 = (SINT16)LOADINTELWORD(dat.x2);
@@ -508,30 +509,29 @@ REG8 lio_gget(LIOWORK lio) {
 	if (leng < (size + 4)) {
 		return(LIO_ILLEGALFUNC);
 	}
-	i286_memword_write(seg, off, (REG16)x2);
-	i286_memword_write(seg, off+2, (REG16)y2);
+	MEMR_WRITE16(seg, off, (REG16)x2);
+	MEMR_WRITE16(seg, off+2, (REG16)y2);
 	off += 4;
-	addr = (x >> 3) + (y * 80);
+	gt.addr = (x >> 3) + (y * 80);
 	if (lio->draw.flag & LIODRAW_UPPER) {
-		addr += 16000;
+		gt.addr += 16000;
 	}
 	gt.sft = x & 7;
 	gt.width = x2;
 	gt.mask = (UINT8)((~0x7f) >> ((x2 - 1) & 7));
-	for (pl=0; pl<4; pl++) {
-		if (mask & 1) {
-			gt.baseptr = mem + lio->draw.base + lioplaneadrs[pl];
-			gt.addr = addr;
-			height = y2;
-			do {
+	do {
+		mask <<= 4;
+		for (pl=0; pl<4; pl++) {
+			mask >>= 1;
+			if (mask & 8) {
+				gt.baseptr = mem + lio->draw.base + lioplaneadrs[pl];
 				getvram(&gt, pat);
-				gt.addr += 80;
-				i286_memstr_write(seg, off, pat, datacnt);
+				MEMR_WRITES(seg, off, pat, datacnt);
 				off += datacnt;
-			} while(--height);
+			}
 		}
-		mask >>= 1;
-	}
+		gt.addr += 80;
+	} while(--y2);
 	lio->wait = size * 12;
 	return(LIO_SUCCESS);
 }
@@ -539,7 +539,7 @@ REG8 lio_gget(LIOWORK lio) {
 
 // ---- GPUT1
 
-REG8 lio_gput1(LIOWORK lio) {
+REG8 lio_gput1(GLIO lio) {
 
 	GPUT1	dat;
 	LIOPUT	lput;
@@ -547,15 +547,15 @@ REG8 lio_gput1(LIOWORK lio) {
 	UINT	size;
 
 	lio_updatedraw(lio);
-	i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));
+	MEMR_READS(CPU_DS, CPU_BX, &dat, sizeof(dat));
 	lput.x = (SINT16)LOADINTELWORD(dat.x);
 	lput.y = (SINT16)LOADINTELWORD(dat.y);
 	lput.off = (UINT16)(LOADINTELWORD(dat.off) + 4);
 	lput.seg = LOADINTELWORD(dat.seg);
 	lput.mode = dat.mode;
 	leng = LOADINTELWORD(dat.leng);
-	lput.width = i286_memword_read(lput.seg, lput.off - 4);
-	lput.height = i286_memword_read(lput.seg, lput.off - 2);
+	lput.width = MEMR_READ16(lput.seg, lput.off - 4);
+	lput.height = MEMR_READ16(lput.seg, lput.off - 2);
 	size = ((lput.width + 7) >> 3) * lput.height;
 	if (leng < (size + 4)) {
 		return(LIO_ILLEGALFUNC);
@@ -567,8 +567,8 @@ REG8 lio_gput1(LIOWORK lio) {
 			lput.bg = dat.bg;
 		}
 		else {
-			lput.fg = lio->mem.fgcolor;
-			lput.bg = lio->mem.bgcolor;
+			lput.fg = lio->work.fgcolor;
+			lput.bg = lio->work.bgcolor;
 		}
 	}
 	else {
@@ -589,31 +589,56 @@ REG8 lio_gput1(LIOWORK lio) {
 
 // ---- GPUT2
 
-REG8 lio_gput2(LIOWORK lio) {
+REG8 lio_gput2(GLIO lio) {
 
 	GPUT2	dat;
 	LIOPUT	lput;
 	UINT16	jis;
+	int		pat;
 	REG16	size;
 
 	lio_updatedraw(lio);
-	i286_memstr_read(CPU_DS, CPU_BX, &dat, sizeof(dat));
+	MEMR_READS(CPU_DS, CPU_BX, &dat, sizeof(dat));
 	lput.x = (SINT16)LOADINTELWORD(dat.x);
 	lput.y = (SINT16)LOADINTELWORD(dat.y);
+	lput.off = 0x104e;
+	lput.seg = CPU_DS;
 	jis = LOADINTELWORD(dat.chr);
-	if (jis & 0xff00) {
-		lput.off = 0x104e;
-		lput.seg = CPU_DS;
-		if (jis < 0x200) {			// 1/4ANK
+	pat = 0;
+	if (jis < 0x200) {
+		if (jis < 0x80) {
+			if (jis == 0x7c) {
+				pat = 1;
+			}
+			else if (jis == 0x7e) {
+				pat = 2;
+			}
+			else {
+				jis += 0x2900;
+			}
+		}
+		else if (jis < 0x100) {
+			if ((jis - 0x20) & 0x40) {
+				pat = (jis & 0x3f) + 3;
+			}
+			else {
+				jis += 0x2980;
+			}
+		}
+		else {
 			jis &= 0xff;
 		}
+	}
+	if (!pat) {
 		size = bios0x18_14(lput.seg, 0x104c, jis);
-		lput.width = (size & 0xff00) >> (8 - 3);
-		lput.height = (size & 0xff) << 3;
 	}
 	else {
-		return(0);
+		MEMR_WRITES(lput.seg, lput.off, mem + (LIO_SEGMENT << 4) +
+										LIO_FONT + ((pat - 1) << 4), 0x10);
+		size = 0x0102;
 	}
+	lput.width = (size & 0xff00) >> (8 - 3);
+	lput.height = (size & 0xff) << 3;
 	lput.mode = dat.mode;
 	lput.sw = 0;
 	if (dat.colorsw) {
@@ -621,8 +646,8 @@ REG8 lio_gput2(LIOWORK lio) {
 		lput.bg = dat.bg;
 	}
 	else {
-		lput.fg = lio->mem.fgcolor;
-		lput.bg = lio->mem.bgcolor;
+		lput.fg = lio->work.fgcolor;
+		lput.bg = lio->work.bgcolor;
 	}
 	return(putsub(lio, &lput));
 }