--- np2/statsave.c	2003/10/24 08:07:33	1.11
+++ np2/statsave.c	2005/03/05 06:02:28	1.46
@@ -1,17 +1,22 @@
 #include	"compiler.h"
+#include	"strres.h"
 #include	"dosio.h"
 #include	"commng.h"
 #include	"scrnmng.h"
 #include	"soundmng.h"
 #include	"timemng.h"
-#include	"i286.h"
-#include	"memory.h"
+#include	"cpucore.h"
 #include	"pccore.h"
 #include	"iocore.h"
+#include	"gdc_sub.h"
 #include	"cbuscore.h"
+#include	"ideio.h"
+#include	"sasiio.h"
+#include	"scsiio.h"
 #include	"pc9861k.h"
 #include	"mpu98ii.h"
 #include	"board14.h"
+#include	"amd98.h"
 #include	"bios.h"
 #include	"vram.h"
 #include	"palettes.h"
@@ -23,9 +28,18 @@
 #include	"fddfile.h"
 #include	"fdd_mtr.h"
 #include	"sxsi.h"
-#include	"calendar.h"
-#include	"statsave.h"
 #include	"keydisp.h"
+#include	"hostdrv.h"
+#include	"calendar.h"
+#include	"keystat.h"
+
+#if defined(MACOS)
+#define	CRCONST		str_cr
+#elif defined(WIN32) || defined(X11) || defined(SLZAURUS)
+#define	CRCONST		str_lf
+#else
+#define	CRCONST		str_crlf
+#endif
 
 
 typedef struct {
@@ -38,31 +52,30 @@ typedef struct {
 	char	index[10];
 	UINT16	ver;
 	UINT32	size;
-} NP2FLAGPART_T;
+} NP2FENT;
 
 enum {
-	NP2FLAG_BIN			= 0,
-	NP2FLAG_TERM,
-	NP2FLAG_CLOCK,
-	NP2FLAG_DMA,
-	NP2FLAG_EGC,
-	NP2FLAG_EXT,
-	NP2FLAG_EVT,
-	NP2FLAG_GIJ,
-	NP2FLAG_FM,
-	NP2FLAG_MIDI,
-	NP2FLAG_DISK
+	STATFLAG_BIN			= 0,
+	STATFLAG_TERM,
+#if defined(CGWND_FONTPTR)
+	STATFLAG_CGW,
+#endif
+	STATFLAG_COM,
+	STATFLAG_DISK,
+	STATFLAG_DMA,
+	STATFLAG_EGC,
+	STATFLAG_EPSON,
+	STATFLAG_EVT,
+	STATFLAG_EXT,
+	STATFLAG_FM,
+	STATFLAG_GIJ,
+#if defined(SUPPORT_HOSTDRV)
+	STATFLAG_HDRV,
+#endif
+	STATFLAG_MEM
 };
 
 typedef struct {
-const char	*index;
-	UINT16	ver;
-	UINT16	type;
-	void	*arg1;
-	UINT	arg2;
-} STENTRY;
-
-typedef struct {
 	UINT32	id;
 	void	*proc;
 } PROCTBL;
@@ -83,30 +96,15 @@ extern	COMMNG	cm_mpu98;
 extern	COMMNG	cm_rs232c;
 
 typedef struct {
-	char	*buf;
+	OEMCHAR	*buf;
 	int		remain;
 } ERR_BUF;
 
-static void err_append(ERR_BUF *e, char *buf) {
-
-	if ((e) && (buf)) {
-		if (e->buf) {
-			int len;
-			len = strlen(buf);
-			if (e->remain >= len) {
-				CopyMemory(e->buf, buf, len);
-				e->buf += len;
-				e->remain -= len;
-			}
-		}
-	}
-}
-
 
 // ----
 
 // 関数ポインタを intに変更。
-static BOOL proc2num(void *func, const PROCTBL *tbl, int size) {
+static BRESULT proc2num(void *func, const PROCTBL *tbl, int size) {
 
 	int		i;
 
@@ -120,7 +118,7 @@ static BOOL proc2num(void *func, const P
 	return(FAILURE);
 }
 
-static BOOL num2proc(void *func, const PROCTBL *tbl, int size) {
+static BRESULT num2proc(void *func, const PROCTBL *tbl, int size) {
 
 	int		i;
 
@@ -137,361 +135,399 @@ static BOOL num2proc(void *func, const P
 
 // ----
 
+enum {
+	SFFILEH_WRITE	= 0x0001,
+	SFFILEH_BLOCK	= 0x0002,
+	SFFILEH_ERROR	= 0x0004
+};
+
 typedef struct {
+	_STFLAGH	sfh;
+	UINT		stat;
 	FILEH		fh;
-	long		pos;
-	long		bak;
-	long		next;
+	UINT		secpos;
 	NP2FHDR		f;
-	NP2FLAGPART_T	p;
-} NP2FFILE;
+} _SFFILEH, *SFFILEH;
 
-static int flagopen(NP2FFILE *f, const char *filename, ERR_BUF *e) {
+static SFFILEH statflag_open(const OEMCHAR *filename, OEMCHAR *err, int errlen) {
 
-	if (f) {
-		f->fh = file_open(filename);
-		if (f->fh == FILEH_INVALID) {
-			return(NP2FLAG_FAILURE);
-		}
-		if (file_read(f->fh, &f->f, sizeof(NP2FHDR))
-												!= sizeof(NP2FHDR)) {
-			file_close(f->fh);
-			return(NP2FLAG_FAILURE);
-		}
-		f->pos = sizeof(NP2FHDR);
-		if (strcmp(f->f.name, np2flagdef.name)) {
-			file_close(f->fh);
-			return(NP2FLAG_FAILURE);
-		}
-		if (strcmp(f->f.vername, np2flagdef.vername)) {
-#if 1
-			file_close(f->fh);
-			return(NP2FLAG_FAILURE);
-#else
-			return(NP2FLAG_VERSION);			// 他形式を読むのであれば…
-#endif
-		}
-		if (f->f.ver != np2flagdef.ver) {
-#if 1
-			file_close(f->fh);
-			return(NP2FLAG_FAILURE);
-#else
-			return(NP2FLAG_VERSION);			// 他verを読むのであれば…
-#endif
+	FILEH	fh;
+	SFFILEH	ret;
+
+	fh = file_open_rb(filename);
+	if (fh == FILEH_INVALID) {
+		goto sfo_err1;
+	}
+	ret = (SFFILEH)_MALLOC(sizeof(_SFFILEH), filename);
+	if (ret == NULL) {
+		goto sfo_err2;
+	}
+	if ((file_read(fh, &ret->f, sizeof(NP2FHDR)) == sizeof(NP2FHDR)) &&
+		(!memcmp(&ret->f, &np2flagdef, sizeof(np2flagdef)))) {
+		ZeroMemory(ret, sizeof(_SFFILEH));
+		ret->fh = fh;
+		ret->secpos = sizeof(NP2FHDR);
+		if ((err) && (errlen > 0)) {
+			err[0] = '\0';
+			ret->sfh.err = err;
+			ret->sfh.errlen = errlen;
 		}
-		return(NP2FLAG_SUCCESS);
+		return(ret);
 	}
-	(void)e;
-	return(NP2FLAG_FAILURE);
-}
+	_MFREE(ret);
 
-static int flagcreate(NP2FFILE *f, const char *filename) {
+sfo_err2:
+	file_close(fh);
 
-	if (f) {
-		f->fh = file_create(filename);
-		if (f->fh == FILEH_INVALID) {
-			return(NP2FLAG_FAILURE);
-		}
-		if (file_write(f->fh, &np2flagdef, sizeof(NP2FHDR))
-														!= sizeof(NP2FHDR)) {
-			file_close(f->fh);
-			return(NP2FLAG_FAILURE);
-		}
-		f->pos = sizeof(NP2FHDR);
-		return(NP2FLAG_SUCCESS);
-	}
-	return(NP2FLAG_FAILURE);
+sfo_err1:
+	return(NULL);
 }
 
-static int flagload_create(NP2FFILE *f) {
+static int statflag_closesection(SFFILEH sffh) {
+
+	UINT	leng;
+	UINT8	zero[16];
 
-	if (f) {
-		ZeroMemory(&f->p, sizeof(NP2FLAGPART_T));
-		if (f->pos & 15) {
-			f->pos += 15;
-			f->pos &= ~0xf;
-			if (file_seek(f->fh, f->pos, 0) != f->pos) {
-				return(NP2FLAG_FAILURE);
+	if (sffh == NULL) {
+		goto sfcs_err1;
+	}
+	if (sffh->stat == (SFFILEH_BLOCK | SFFILEH_WRITE)) {
+		leng = (0 - sffh->sfh.hdr.size) & 15;
+		if (leng) {
+			ZeroMemory(zero, sizeof(zero));
+			if (file_write(sffh->fh, zero, leng) != leng) {
+				goto sfcs_err2;
 			}
 		}
-		if (file_read(f->fh, &f->p, sizeof(NP2FLAGPART_T))
-												!= sizeof(NP2FLAGPART_T)) {
-			return(NP2FLAG_FAILURE);
+		if ((file_seek(sffh->fh, (long)sffh->secpos, FSEEK_SET)
+												!= (long)sffh->secpos) ||
+			(file_write(sffh->fh, &sffh->sfh.hdr, sizeof(sffh->sfh.hdr))
+												!= sizeof(sffh->sfh.hdr))) {
+			goto sfcs_err2;
+		}
+	}
+	if (sffh->stat & SFFILEH_BLOCK) {
+		sffh->stat &= ~SFFILEH_BLOCK;
+		sffh->secpos += sizeof(sffh->sfh.hdr) +
+									((sffh->sfh.hdr.size + 15) & (~15));
+		if (file_seek(sffh->fh, (long)sffh->secpos, FSEEK_SET)
+												!= (long)sffh->secpos) {
+			goto sfcs_err2;
 		}
-		f->pos += sizeof(NP2FLAGPART_T);
-		f->next = f->pos + f->p.size;
-		return(NP2FLAG_SUCCESS);
 	}
-	return(NP2FLAG_FAILURE);
+	return(STATFLAG_SUCCESS);
+
+sfcs_err2:
+	sffh->stat = SFFILEH_ERROR;
+
+sfcs_err1:
+	return(STATFLAG_FAILURE);
 }
 
-static int flagload_load(NP2FFILE *f, void *buf, UINT size) {
+static int statflag_readsection(SFFILEH sffh) {
+
+	int		ret;
 
-	if (f && buf && size && (file_read(f->fh, buf, size) == size)) {
-		f->pos += size;
-		return(NP2FLAG_SUCCESS);
+	ret = statflag_closesection(sffh);
+	if (ret != STATFLAG_SUCCESS) {
+		return(ret);
+	}
+	if ((sffh->stat == 0) &&
+		(file_read(sffh->fh, &sffh->sfh.hdr, sizeof(sffh->sfh.hdr))
+												== sizeof(sffh->sfh.hdr))) {
+		sffh->stat = SFFILEH_BLOCK;
+		sffh->sfh.pos = 0;
+		return(STATFLAG_SUCCESS);
 	}
-	return(NP2FLAG_FAILURE);
+	sffh->stat = SFFILEH_ERROR;
+	return(STATFLAG_FAILURE);
 }
 
-static int flagload_close(NP2FFILE *f) {
+int statflag_read(STFLAGH sfh, void *buf, UINT size) {
 
-	if (file_seek(f->fh, f->next, 0) != f->next) {
-		return(NP2FLAG_FAILURE);
+	if ((sfh == NULL) || (buf == NULL) ||
+		((sfh->pos + size) > sfh->hdr.size)) {
+		goto sfr_err;
 	}
-	f->pos = f->next;
-	return(NP2FLAG_SUCCESS);
+	if (size) {
+		if (file_read(((SFFILEH)sfh)->fh, buf, size) != size) {
+			goto sfr_err;
+		}
+		sfh->pos += size;
+	}
+	return(STATFLAG_SUCCESS);
+
+sfr_err:
+	return(STATFLAG_FAILURE);
 }
 
-static int flagsave_create(NP2FFILE *f, const STENTRY *t) {
+static SFFILEH statflag_create(const OEMCHAR *filename) {
 
-	if (f && t) {
-		int		len;
-		ZeroMemory(&f->p, sizeof(NP2FLAGPART_T));
-		if (f->pos & 15) {
-			UINT rem;
-			rem = 16 - (f->pos & 15);
-			if (file_write(f->fh, &f->p, rem) != rem) {
-				return(NP2FLAG_FAILURE);
-			}
-			f->pos += rem;
-		}
-		f->bak = f->pos;
+	SFFILEH	ret;
+	FILEH	fh;
 
-		len = strlen(t->index);
-		if (len >= 10) {
-			len = 10;
-		}
-		if (len) {
-			CopyMemory(f->p.index, t->index, len);
-		}
-		f->p.ver = t->ver;
-		if (file_write(f->fh, &f->p, sizeof(NP2FLAGPART_T))
-												!= sizeof(NP2FLAGPART_T)) {
-			return(NP2FLAG_FAILURE);
-		}
-		f->pos += sizeof(NP2FLAGPART_T);
-		return(NP2FLAG_SUCCESS);
+	ret = (SFFILEH)_MALLOC(sizeof(_SFFILEH), filename);
+	if (ret == NULL) {
+		goto sfc_err1;
+	}
+	fh = file_create(filename);
+	if (fh == FILEH_INVALID) {
+		goto sfc_err2;
 	}
-	return(NP2FLAG_FAILURE);
+	if (file_write(fh, &np2flagdef, sizeof(NP2FHDR)) == sizeof(NP2FHDR)) {
+		ZeroMemory(ret, sizeof(_SFFILEH));
+		ret->stat = SFFILEH_WRITE;
+		ret->fh = fh;
+		ret->secpos = sizeof(NP2FHDR);
+		return(ret);
+	}
+	file_close(fh);
+	file_delete(filename);
+
+sfc_err2:
+	_MFREE(ret);
+
+sfc_err1:
+	return(NULL);
 }
 
-static int flagsave_save(NP2FFILE *f, void *buf, UINT size) {
+static int statflag_createsection(SFFILEH sffh, const SFENTRY *tbl) {
 
-	if (f && buf && size && (file_write(f->fh, buf, size) == size)) {
-		f->pos += size;
-		f->p.size += size;
-		return(NP2FLAG_SUCCESS);
+	int		ret;
+
+	ret = statflag_closesection(sffh);
+	if (ret != STATFLAG_SUCCESS) {
+		return(ret);
 	}
-	return(NP2FLAG_FAILURE);
+	if (sffh->stat != SFFILEH_WRITE) {
+		sffh->stat = SFFILEH_ERROR;
+		return(STATFLAG_FAILURE);
+	}
+	CopyMemory(sffh->sfh.hdr.index, tbl->index, sizeof(sffh->sfh.hdr.index));
+	sffh->sfh.hdr.ver = tbl->ver;
+	sffh->sfh.hdr.size = 0;
+	return(STATFLAG_SUCCESS);
 }
 
-static int flagsave_close(NP2FFILE *f) {
+int statflag_write(STFLAGH sfh, const void *buf, UINT size) {
+
+	SFFILEH	sffh;
 
-	if (!f) {
-		goto fs_closeerr;
+	if (sfh == NULL) {
+		goto sfw_err1;
 	}
-	if (file_seek(f->fh, f->bak, 0) != f->bak) {
-		goto fs_closeerr;
+	sffh = (SFFILEH)sfh;
+	if (!(sffh->stat & SFFILEH_WRITE)) {
+		goto sfw_err2;
 	}
-	if (file_write(f->fh, &f->p, sizeof(NP2FLAGPART_T))
-												!= sizeof(NP2FLAGPART_T)) {
-		goto fs_closeerr;
+	if (!(sffh->stat & SFFILEH_BLOCK)) {
+		sffh->stat |= SFFILEH_BLOCK;
+		sfh->pos = 0;
+		if (file_write(sffh->fh, &sfh->hdr, sizeof(sfh->hdr))
+														!= sizeof(sfh->hdr)) {
+			goto sfw_err2;
+		}
 	}
-	if (file_seek(f->fh, f->pos, 0) == f->pos) {
-		return(NP2FLAG_SUCCESS);
+	if (size) {
+		if ((buf == NULL) || (file_write(sffh->fh, buf, size) != size)) {
+			goto sfw_err2;
+		}
+		sfh->pos += size;
+		if (sfh->hdr.size < sfh->pos) {
+			sfh->hdr.size = sfh->pos;
+		}
 	}
+	return(STATFLAG_SUCCESS);
+
+sfw_err2:
+	sffh->stat = SFFILEH_ERROR;
 
-fs_closeerr:
-	return(NP2FLAG_FAILURE);
+sfw_err1:
+	return(STATFLAG_FAILURE);
 }
 
-static void flagclose(NP2FFILE *f) {
+static void statflag_close(SFFILEH sffh) {
 
-	if (f) {
-		file_close(f->fh);
+	if (sffh) {
+		statflag_closesection(sffh);
+		file_close(sffh->fh);
+		_MFREE(sffh);
 	}
 }
 
+void statflag_seterr(STFLAGH sfh, const OEMCHAR *str) {
 
-// ----
+	if ((sfh) && (sfh->errlen)) {
+		milstr_ncat(sfh->err, str, sfh->errlen);
+		milstr_ncat(sfh->err, CRCONST, sfh->errlen);
+	}
+}
 
-static int flagsave_term(NP2FFILE *f, const STENTRY *t) {
 
-	int		ret;
+// ---- common
 
-	ret = flagsave_create(f, t);
-	ret |= flagsave_close(f);
-	return(ret);
+static int flagsave_common(STFLAGH sfh, const SFENTRY *tbl) {
+
+	return(statflag_write(sfh, tbl->arg1, tbl->arg2));
 }
 
+static int flagload_common(STFLAGH sfh, const SFENTRY *tbl) {
 
-// ----
+	return(statflag_read(sfh, tbl->arg1, tbl->arg2));
+}
 
-static int flagsave_common(NP2FFILE *f, const STENTRY *t) {
+
+// ---- memory
+
+static int flagsave_mem(STFLAGH sfh, const SFENTRY *tbl) {
 
 	int		ret;
 
-	ret = flagsave_create(f, t);
-	if (ret != NP2FLAG_FAILURE) {
-		ret |= flagsave_save(f, t->arg1, t->arg2);
-		ret |= flagsave_close(f);
-	}
+	ret = statflag_write(sfh, mem, 0x110000);
+	ret |= statflag_write(sfh, mem + VRAM1_B, 0x18000);
+	ret |= statflag_write(sfh, mem + VRAM1_E, 0x8000);
+	(void)tbl;
 	return(ret);
 }
 
-static int flagload_common(NP2FFILE *f, const STENTRY *t) {
+static int flagload_mem(STFLAGH sfh, const SFENTRY *tbl) {
+
+	int		ret;
 
-	return(flagload_load(f, t->arg1, t->arg2));
+	ret = statflag_read(sfh, mem, 0x110000);
+	ret |= statflag_read(sfh, mem + VRAM1_B, 0x18000);
+	ret |= statflag_read(sfh, mem + VRAM1_E, 0x8000);
+	(void)tbl;
+	return(ret);
 }
 
 
-// -----
+// ---- cg window
+
+#if defined(CGWND_FONTPTR)
+static int flagsave_cgwnd(STFLAGH sfh, const SFENTRY *tbl) {
+
+	_CGWINDOW	cgwnd;
+
+	cgwnd = cgwindow;
+	cgwnd.fontlow -= (long)fontrom;
+	cgwnd.fonthigh -= (long)fontrom;
+	(void)tbl;
+	return(statflag_write(sfh, &cgwindow, sizeof(cgwindow)));
+}
 
-static int flagload_clock(NP2FFILE *f, const STENTRY *t) {
+static int flagload_cgwnd(STFLAGH sfh, const SFENTRY *tbl) {
 
 	int		ret;
 
-	ret = flagload_common(f, t);
-	sound_changeclock();
-	beep_changeclock();
+	ret = statflag_read(sfh, &cgwindow, sizeof(cgwindow));
+	cgwindow.fontlow += (long)fontrom;
+	cgwindow.fonthigh += (long)fontrom;
+	(void)tbl;
 	return(ret);
 }
+#endif
 
 
-// -----
+// ---- dma
 
-static int flagsave_dma(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_dma(STFLAGH sfh, const SFENTRY *tbl) {
 
-	int			ret;
 	int			i;
 	_DMAC		dmabak;
 
 	dmabak = dmac;
 	for (i=0; i<4; i++) {
-		if ((PROC2NUM(dmabak.dmach[i].outproc, dmaproc)) ||
-			(PROC2NUM(dmabak.dmach[i].inproc, dmaproc)) ||
-			(PROC2NUM(dmabak.dmach[i].extproc, dmaproc))) {
-			return(NP2FLAG_FAILURE);
+		if ((PROC2NUM(dmabak.dmach[i].proc.outproc, dmaproc)) ||
+			(PROC2NUM(dmabak.dmach[i].proc.inproc, dmaproc)) ||
+			(PROC2NUM(dmabak.dmach[i].proc.extproc, dmaproc))) {
+			return(STATFLAG_FAILURE);
 		}
 	}
-	ret = flagsave_create(f, t);
-	if (ret != NP2FLAG_FAILURE) {
-		ret |= flagsave_save(f, &dmabak, sizeof(dmabak));
-		ret |= flagsave_close(f);
-	}
-	return(ret);
+	(void)tbl;
+	return(statflag_write(sfh, &dmabak, sizeof(dmabak)));
 }
 
-static int flagload_dma(NP2FFILE *f, const STENTRY *t) {
+static int flagload_dma(STFLAGH sfh, const SFENTRY *tbl) {
 
 	int		ret;
 	int		i;
 
-	ret = flagload_load(f, &dmac, sizeof(dmac));
+	ret = statflag_read(sfh, &dmac, sizeof(dmac));
 
 	for (i=0; i<4; i++) {
-		if (NUM2PROC(dmac.dmach[i].outproc, dmaproc)) {
-			dmac.dmach[i].outproc = dma_dummyout;
-			ret |= NP2FLAG_WARNING;
-		}
-		if (NUM2PROC(dmac.dmach[i].inproc, dmaproc)) {
-			dmac.dmach[i].inproc = dma_dummyin;
-			ret |= NP2FLAG_WARNING;
-		}
-		if (NUM2PROC(dmac.dmach[i].extproc, dmaproc)) {
-			dmac.dmach[i].extproc = dma_dummyproc;
-			ret |= NP2FLAG_WARNING;
+		if (NUM2PROC(dmac.dmach[i].proc.outproc, dmaproc)) {
+			dmac.dmach[i].proc.outproc = dma_dummyout;
+			ret |= STATFLAG_WARNING;
+		}
+		if (NUM2PROC(dmac.dmach[i].proc.inproc, dmaproc)) {
+			dmac.dmach[i].proc.inproc = dma_dummyin;
+			ret |= STATFLAG_WARNING;
+		}
+		if (NUM2PROC(dmac.dmach[i].proc.extproc, dmaproc)) {
+			dmac.dmach[i].proc.extproc = dma_dummyproc;
+			ret |= STATFLAG_WARNING;
 		}
 	}
-	(void)t;
+	(void)tbl;
 	return(ret);
 }
 
 
-// -----
+// ---- egc
 
-static int flagsave_egc(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_egc(STFLAGH sfh, const SFENTRY *tbl) {
 
-	int		ret;
 	_EGC	egcbak;
 
 	egcbak = egc;
 	egcbak.inptr -= (long)egc.buf;
 	egcbak.outptr -= (long)egc.buf;
-
-	ret = flagsave_create(f, t);
-	if (ret != NP2FLAG_FAILURE) {
-		ret |= flagsave_save(f, &egcbak, sizeof(egcbak));
-		ret |= flagsave_close(f);
-	}
-	return(ret);
+	(void)tbl;
+	return(statflag_write(sfh, &egcbak, sizeof(egcbak)));
 }
 
-static int flagload_egc(NP2FFILE *f, const STENTRY *t) {
+static int flagload_egc(STFLAGH sfh, const SFENTRY *tbl) {
 
 	int		ret;
 
-	ret = flagload_load(f, &egc, sizeof(egc));
+	ret = statflag_read(sfh, &egc, sizeof(egc));
 	egc.inptr += (long)egc.buf;
 	egc.outptr += (long)egc.buf;
-	(void)t;
+	(void)tbl;
 	return(ret);
 }
 
 
-// -----
+// ---- epson
 
-static int flagsave_ext(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_epson(STFLAGH sfh, const SFENTRY *tbl) {
 
 	int		ret;
 
-	ret = flagsave_create(f, t);
-	if (ret != NP2FLAG_FAILURE) {
-		ret |= flagsave_save(f, &extmem, sizeof(extmem));
-		if (extmemmng_size) {
-			ret |= flagsave_save(f, extmemmng_ptr, extmemmng_size);
-		}
-		ret |= flagsave_close(f);
+	if (!(pccore.model & PCMODEL_EPSON)) {
+		return(STATFLAG_SUCCESS);
 	}
+	ret = statflag_write(sfh, &epsonio, sizeof(epsonio));
+	ret |= statflag_write(sfh, mem + 0x1c0000, 0x8000);
+	ret |= statflag_write(sfh, mem + 0x1e8000, 0x18000);
+	(void)tbl;
 	return(ret);
 }
 
-static int flagload_ext(NP2FFILE *f, const STENTRY *t) {
+static int flagload_epson(STFLAGH sfh, const SFENTRY *tbl) {
 
 	int		ret;
-	int		i;
-	UINT	pagemax = 0;
 
-	ret = flagload_load(f, &extmem, sizeof(extmem));
-	if (extmem.maxmem) {
-		if (extmem.maxmem > (13+1)) {
-			extmem.maxmem = (13+1);
-		}
-		if (!extmemmng_realloc(extmem.maxmem - 1)) {
-			pagemax = (extmem.maxmem - 1) << 8;
-			if (extmemmng_size) {
-				ret |= flagload_load(f, extmemmng_ptr, extmemmng_size);
-			}
-		}
-		else {
-			extmem.maxmem = 0;
-		}
-	}
-	for (i=0; i<4; i++) {
-		if (extmem.page[i] < pagemax) {
-			extmem.pageptr[i] = extmemmng_ptr + (extmem.page[i] << 12);
-		}
-		else {
-			extmem.pageptr[i] = mem + 0xc0000 + (i << 14);
-		}
-	}
-	(void)t;
+	ret = statflag_read(sfh, &epsonio, sizeof(epsonio));
+	ret |= statflag_read(sfh, mem + 0x1c0000, 0x8000);
+	ret |= statflag_read(sfh, mem + 0x1e8000, 0x18000);
+	(void)tbl;
 	return(ret);
 }
 
 
-// -----
+// ---- event
 
 typedef struct {
 	UINT		readyevents;
@@ -505,13 +541,13 @@ typedef struct {
 	NEVENTCB	proc;
 } NEVTITEM;
 
-static int nevent_save(NP2FFILE *f, int num) {
+static int nevent_write(STFLAGH sfh, int num) {
 
 	NEVTITEM	nit;
 	UINT		i;
 
 	ZeroMemory(&nit, sizeof(nit));
-	for (i=0; i<sizeof(evtnum)/sizeof(ENUMTBL); i++) {
+	for (i=0; i<NELEMENTS(evtnum); i++) {
 		if (evtnum[i].num == num) {
 			nit.id = evtnum[i].id;
 			break;
@@ -523,10 +559,10 @@ static int nevent_save(NP2FFILE *f, int 
 	if (PROC2NUM(nit.proc, evtproc)) {
 		nit.proc = NULL;
 	}
-	return(flagsave_save(f, &nit, sizeof(nit)));
+	return(statflag_write(sfh, &nit, sizeof(nit)));
 }
 
-static int flagsave_evt(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_evt(STFLAGH sfh, const SFENTRY *tbl) {
 
 	NEVTSAVE	nevt;
 	int			ret;
@@ -535,41 +571,38 @@ static int flagsave_evt(NP2FFILE *f, con
 	nevt.readyevents = nevent.readyevents;
 	nevt.waitevents = nevent.waitevents;
 
-	ret = flagsave_create(f, t);
-	if (ret != NP2FLAG_FAILURE) {
-		ret |= flagsave_save(f, &nevt, sizeof(nevt));
-		for (i=0; i<nevt.readyevents; i++) {
-			ret |= nevent_save(f, nevent.level[i]);
-		}
-		for (i=0; i<nevt.waitevents; i++) {
-			ret |= nevent_save(f, nevent.waitevent[i]);
-		}
-		ret |= flagsave_close(f);
+	ret = statflag_write(sfh, &nevt, sizeof(nevt));
+	for (i=0; i<nevt.readyevents; i++) {
+		ret |= nevent_write(sfh, nevent.level[i]);
 	}
+	for (i=0; i<nevt.waitevents; i++) {
+		ret |= nevent_write(sfh, nevent.waitevent[i]);
+	}
+	(void)tbl;
 	return(ret);
 }
 
-static int nevent_load(NP2FFILE *f, UINT *tbl, UINT *pos) {
+static int nevent_read(STFLAGH sfh, UINT *tbl, UINT *pos) {
 
 	int			ret;
 	NEVTITEM	nit;
 	UINT		i;
 	UINT		num;
 
-	ret = flagload_load(f, &nit, sizeof(nit));
+	ret = statflag_read(sfh, &nit, sizeof(nit));
 
-	for (i=0; i<sizeof(evtnum)/sizeof(ENUMTBL); i++) {
+	for (i=0; i<NELEMENTS(evtnum); i++) {
 		if (nit.id == evtnum[i].id) {
 			break;
 		}
 	}
-	if (i < (sizeof(evtnum)/sizeof(ENUMTBL))) {
+	if (i < NELEMENTS(evtnum)) {
 		num = evtnum[i].num;
 		nevent.item[num].clock = nit.clock;
 		nevent.item[num].flag = nit.flag;
 		nevent.item[num].proc = nit.proc;
 		if (NUM2PROC(nevent.item[num].proc, evtproc)) {
-			ret |= NP2FLAG_WARNING;
+			ret |= STATFLAG_WARNING;
 		}
 		else {
 			tbl[*pos] = num;
@@ -577,77 +610,104 @@ static int nevent_load(NP2FFILE *f, UINT
 		}
 	}
 	else {
-		ret |= NP2FLAG_WARNING;
+		ret |= STATFLAG_WARNING;
 	}
 	return(ret);
 }
 
-static int flagload_evt(NP2FFILE *f, const STENTRY *t) {
+static int flagload_evt(STFLAGH sfh, const SFENTRY *tbl) {
 
 	int			ret;
 	NEVTSAVE	nevt;
 	UINT		i;
 
-	ret = flagload_load(f, &nevt, sizeof(nevt));
+	ret = statflag_read(sfh, &nevt, sizeof(nevt));
 
 	nevent.readyevents = 0;
 	nevent.waitevents = 0;
 
 	for (i=0; i<nevt.readyevents; i++) {
-		ret |= nevent_load(f, nevent.level, &nevent.readyevents);
+		ret |= nevent_read(sfh, nevent.level, &nevent.readyevents);
 	}
 	for (i=0; i<nevt.waitevents; i++) {
-		ret |= nevent_load(f, nevent.waitevent, &nevent.waitevents);
+		ret |= nevent_read(sfh, nevent.waitevent, &nevent.waitevents);
 	}
-	(void)t;
+	(void)tbl;
 	return(ret);
 }
 
 
-// ----
+// ---- extmem
+
+static int flagsave_ext(STFLAGH sfh, const SFENTRY *tbl) {
+
+	int		ret;
+
+	ret = STATFLAG_SUCCESS;
+	if (CPU_EXTMEM) {
+		ret = statflag_write(sfh, CPU_EXTMEM, CPU_EXTMEMSIZE);
+	}
+	(void)tbl;
+	return(ret);
+}
+
+static int flagload_ext(STFLAGH sfh, const SFENTRY *tbl) {
 
-static int flagsave_gij(NP2FFILE *f, const STENTRY *t) {
+	int		ret;
+
+	ret = STATFLAG_SUCCESS;
+	if (CPU_EXTMEM) {
+		ret = statflag_read(sfh, CPU_EXTMEM, CPU_EXTMEMSIZE);
+	}
+	(void)tbl;
+	return(ret);
+}
+
+
+// ---- gaiji
+
+static int flagsave_gij(STFLAGH sfh, const SFENTRY *tbl) {
 
 	int		ret;
 	int		i;
 	int		j;
-	BYTE	*fnt;
+const UINT8	*fnt;
 
-	ret = flagsave_create(f, t);
-	if (ret != NP2FLAG_FAILURE) {
-		for (i=0; i<2; i++) {
-			fnt = font + ((0x56 + (i << 7)) << 4);
-			for (j=0; j<0x80; j++) {
-				ret |= flagsave_save(f, fnt, 32);
-				fnt += 0x1000;
-			}
+	ret = STATFLAG_SUCCESS;
+	for (i=0; i<2; i++) {
+		fnt = fontrom + ((0x56 + (i << 7)) << 4);
+		for (j=0; j<0x80; j++) {
+			ret |= statflag_write(sfh, fnt, 32);
+			fnt += 0x1000;
 		}
-		ret |= flagsave_close(f);
 	}
+	(void)tbl;
 	return(ret);
 }
 
-static int flagload_gij(NP2FFILE *f, const STENTRY *t) {
+static int flagload_gij(STFLAGH sfh, const SFENTRY *tbl) {
 
 	int		ret;
 	int		i;
 	int		j;
-	BYTE	*fnt;
+	UINT8	*fnt;
 
 	ret = 0;
 	for (i=0; i<2; i++) {
-		fnt = font + ((0x56 + (i << 7)) << 4);
+		fnt = fontrom + ((0x56 + (i << 7)) << 4);
 		for (j=0; j<0x80; j++) {
-			ret |= flagload_load(f, fnt, 32);
+			ret |= statflag_read(sfh, fnt, 32);
 			fnt += 0x1000;
 		}
 	}
-	(void)t;
+	(void)tbl;
 	return(ret);
 }
 
 
-// -----
+// ---- FM
+
+#if !defined(DISABLE_SOUND)
 
 enum {
 	FLAG_MG			= 0x0001,
@@ -657,18 +717,19 @@ enum {
 	FLAG_FM2B		= 0x0010,
 	FLAG_PSG1		= 0x0020,
 	FLAG_PSG2		= 0x0040,
-	FLAG_RHYTHM		= 0x0080,
-	FLAG_ADPCM		= 0x0100,
-	FLAG_PCM86		= 0x0200,
-	FLAG_CS4231		= 0x0400
+	FLAG_PSG3		= 0x0080,
+	FLAG_RHYTHM		= 0x0100,
+	FLAG_ADPCM		= 0x0200,
+	FLAG_PCM86		= 0x0400,
+	FLAG_CS4231		= 0x0800
 };
 
 typedef struct {
-	BYTE	keyreg[OPNCH_MAX];
-	BYTE	extop[4];
+	UINT8	keyreg[OPNCH_MAX];
+	UINT8	extop[4];
 } OPNKEY;
 
-static int flagsave_fm(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_fm(STFLAGH sfh, const SFENTRY *tbl) {
 
 	int		ret;
 	UINT	saveflg;
@@ -713,93 +774,59 @@ static int flagsave_fm(NP2FFILE *f, cons
 										FLAG_PSG1 | FLAG_RHYTHM | FLAG_ADPCM;
 			break;
 
+		case 0x80:
+			saveflg = FLAG_PSG1 | FLAG_PSG2 | FLAG_PSG3;
+			break;
+
 		default:
 			saveflg = 0;
 			break;
 	}
 
-	ret = flagsave_create(f, t);
-	if (ret != NP2FLAG_FAILURE) {
-		ret |= flagsave_save(f, &usesound, sizeof(usesound));
-
-		if (saveflg & FLAG_MG) {
-			ret |= flagsave_save(f, &musicgen, sizeof(musicgen));
-		}
-		if (saveflg & FLAG_FM1A) {
-			ret |= flagsave_save(f, &fmtimer, sizeof(fmtimer));
-			ret |= flagsave_save(f, &opn, sizeof(opn));
-			CopyMemory(opnkey.keyreg, opngen.keyreg, sizeof(opngen.keyreg));
-			opnkey.extop[0] = opnch[2].extop;
-			opnkey.extop[1] = opnch[5].extop;
-			opnkey.extop[2] = opnch[8].extop;
-			opnkey.extop[3] = opnch[11].extop;
-			ret |= flagsave_save(f, &opnkey, sizeof(opnkey));
-		}
-		if (saveflg & FLAG_PSG1) {
-			ret |= flagsave_save(f, &psg1.reg, sizeof(PSGREG));
-		}
-		if (saveflg & FLAG_PSG2) {
-			ret |= flagsave_save(f, &psg2.reg, sizeof(PSGREG));
-		}
-		if (saveflg & FLAG_ADPCM) {
-			ret |= flagsave_save(f, &adpcm, sizeof(adpcm));
-		}
-		if (saveflg & FLAG_PCM86) {
-			ret |= flagsave_save(f, &pcm86, sizeof(pcm86));
-		}
-		if (saveflg & FLAG_CS4231) {
-			ret |= flagsave_save(f, &cs4231, sizeof(cs4231));
-		}
-		ret |= flagsave_close(f);
+	ret = statflag_write(sfh, &usesound, sizeof(usesound));
+	if (saveflg & FLAG_MG) {
+		ret |= statflag_write(sfh, &musicgen, sizeof(musicgen));
 	}
-	return(ret);
-}
-
-static void play_fmreg(BYTE num) {
-
-	UINT	chbase;
-	UINT	reg;
-	UINT	i;
-
-	chbase = num * 3;
-	reg = num * 0x100;
-	for (i=0x30; i<0xa0; i++) {
-		opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);
+	if (saveflg & FLAG_FM1A) {
+		ret |= statflag_write(sfh, &fmtimer, sizeof(fmtimer));
+		ret |= statflag_write(sfh, &opn, sizeof(opn));
+		CopyMemory(opnkey.keyreg, opngen.keyreg, sizeof(opngen.keyreg));
+		opnkey.extop[0] = opnch[2].extop;
+		opnkey.extop[1] = opnch[5].extop;
+		opnkey.extop[2] = opnch[8].extop;
+		opnkey.extop[3] = opnch[11].extop;
+		ret |= statflag_write(sfh, &opnkey, sizeof(opnkey));
 	}
-	for (i=0xb7; i>=0xa0; i--) {
-		opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);
+	if (saveflg & FLAG_PSG1) {
+		ret |= statflag_write(sfh, &psg1.reg, sizeof(PSGREG));
 	}
-	for (i=0; i<3; i++) {
-		opngen_keyon(chbase + i, opngen.keyreg[chbase + i]);
+	if (saveflg & FLAG_PSG2) {
+		ret |= statflag_write(sfh, &psg2.reg, sizeof(PSGREG));
 	}
-}
-
-static void play_psgreg(PSGGEN psg) {
-
-	BYTE	i;
-
-	for (i=0; i<0x0e; i++) {
-		psggen_setreg(psg, i, ((BYTE *)&psg->reg)[i]);
+	if (saveflg & FLAG_PSG3) {
+		ret |= statflag_write(sfh, &psg3.reg, sizeof(PSGREG));
+	}
+	if (saveflg & FLAG_ADPCM) {
+		ret |= statflag_write(sfh, &adpcm, sizeof(adpcm));
+	}
+	if (saveflg & FLAG_PCM86) {
+		ret |= statflag_write(sfh, &pcm86, sizeof(pcm86));
 	}
+	if (saveflg & FLAG_CS4231) {
+		ret |= statflag_write(sfh, &cs4231, sizeof(cs4231));
+	}
+	(void)tbl;
+	return(ret);
 }
 
-static int flagload_fm(NP2FFILE *f, const STENTRY *t) {
+static int flagload_fm(STFLAGH sfh, const SFENTRY *t) {
 
 	int		ret;
 	UINT	saveflg;
 	OPNKEY	opnkey;
 
-	opngen_reset();
-	psggen_reset(&psg1);
-	psggen_reset(&psg2);
-	psggen_reset(&psg3);
-	rhythm_reset(&rhythm);
-	adpcm_reset(&adpcm);
-	pcm86_reset();
-	cs4231_reset();
-
-	ret = flagload_load(f, &usesound, sizeof(usesound));
-	fmboard_reset((BYTE)usesound);
+	ret = statflag_read(sfh, &usesound, sizeof(usesound));
+	fmboard_reset(usesound);
 
 	switch(usesound) {
 		case 0x01:
@@ -840,20 +867,24 @@ static int flagload_fm(NP2FFILE *f, cons
 										FLAG_PSG1 | FLAG_RHYTHM | FLAG_ADPCM;
 			break;
 
+		case 0x80:
+			saveflg = FLAG_PSG1 | FLAG_PSG2 | FLAG_PSG3;
+			break;
+
 		default:
 			saveflg = 0;
 			break;
 	}
 
-	if ((saveflg & FLAG_MG) && (f->p.ver != 0)) {
-		ret |= flagload_load(f, &musicgen, sizeof(musicgen));
+	if (saveflg & FLAG_MG) {
+		ret |= statflag_read(sfh, &musicgen, sizeof(musicgen));
 		board14_allkeymake();
 	}
 
 	if (saveflg & FLAG_FM1A) {
-		ret |= flagload_load(f, &fmtimer, sizeof(fmtimer));
-		ret |= flagload_load(f, &opn, sizeof(opn));
-		ret |= flagload_load(f, &opnkey, sizeof(opnkey));
+		ret |= statflag_read(sfh, &fmtimer, sizeof(fmtimer));
+		ret |= statflag_read(sfh, &opn, sizeof(opn));
+		ret |= statflag_read(sfh, &opnkey, sizeof(opnkey));
 		CopyMemory(opngen.keyreg, &opnkey.keyreg, sizeof(opngen.keyreg));
 		opnch[2].extop = opnkey.extop[0];
 		opnch[5].extop = opnkey.extop[1];
@@ -861,66 +892,55 @@ static int flagload_fm(NP2FFILE *f, cons
 		opnch[11].extop = opnkey.extop[3];
 	}
 	if (saveflg & FLAG_PSG1) {
-		ret |= flagload_load(f, &psg1.reg, sizeof(PSGREG));
+		ret |= statflag_read(sfh, &psg1.reg, sizeof(PSGREG));
 	}
 	if (saveflg & FLAG_PSG2) {
-		ret |= flagload_load(f, &psg2.reg, sizeof(PSGREG));
+		ret |= statflag_read(sfh, &psg2.reg, sizeof(PSGREG));
+	}
+	if (saveflg & FLAG_PSG3) {
+		ret |= statflag_read(sfh, &psg3.reg, sizeof(PSGREG));
 	}
 	if (saveflg & FLAG_ADPCM) {
-		ret |= flagload_load(f, &adpcm, sizeof(adpcm));
+		ret |= statflag_read(sfh, &adpcm, sizeof(adpcm));
 	}
 	if (saveflg & FLAG_PCM86) {
-		ret |= flagload_load(f, &pcm86, sizeof(pcm86));
+		ret |= statflag_read(sfh, &pcm86, sizeof(pcm86));
 	}
 	if (saveflg & FLAG_CS4231) {
-		ret |= flagload_load(f, &cs4231, sizeof(cs4231));
-		cs4231.proc = cs4231dec[cs4231.reg.datafmt >> 4];
+		ret |= statflag_read(sfh, &cs4231, sizeof(cs4231));
 	}
 
-	// 復元。
-	rhythm_update(&rhythm);
+	// 復元。 これ移動すること！
 	adpcm_update(&adpcm);
 	pcm86gen_update();
 	if (saveflg & FLAG_PCM86) {
-		fmboard_extenable((BYTE)(pcm86.extfunc & 1));
+		fmboard_extenable((REG8)(pcm86.extfunc & 1));
 	}
 	if (saveflg & FLAG_CS4231) {
-		fmboard_extenable((BYTE)(cs4231.extfunc & 1));
-	}
-
-	if (saveflg & FLAG_FM1A) {
-		play_fmreg(0);
-	}
-	if (saveflg & FLAG_FM1B) {
-		play_fmreg(1);
-	}
-	if (saveflg & FLAG_FM2A) {
-		play_fmreg(2);
-	}
-	if (saveflg & FLAG_FM2B) {
-		play_fmreg(3);
-	}
-	if (saveflg & FLAG_PSG1) {
-		play_psgreg(&psg1);
-	}
-	if (saveflg & FLAG_PSG2) {
-		play_psgreg(&psg2);
+		fmboard_extenable((REG8)(cs4231.extfunc & 1));
 	}
 	(void)t;
 	return(ret);
 }
+#endif
 
 
 // ---- disk
 
 typedef struct {
-	char	path[MAX_PATH];
+	OEMCHAR	path[MAX_PATH];
 	int		readonly;
 	DOSDATE	date;
 	DOSTIME	time;
 } STATDISK;
 
-static int disksave(NP2FFILE *f, const char *path, int readonly) {
+static const OEMCHAR str_fddx[] = OEMTEXT("FDD%u");
+static const OEMCHAR str_sasix[] = OEMTEXT("SASI%u");
+static const OEMCHAR str_scsix[] = OEMTEXT("SCSI%u");
+static const OEMCHAR str_updated[] = OEMTEXT("%s: updated");
+static const OEMCHAR str_notfound[] = OEMTEXT("%s: not found");
+
+static int disksave(STFLAGH sfh, const OEMCHAR *path, int readonly) {
 
 	STATDISK	st;
 	FILEH		fh;
@@ -935,41 +955,39 @@ static int disksave(NP2FFILE *f, const c
 			file_close(fh);
 		}
 	}
-	return(flagsave_save(f, &st, sizeof(st)));
+	return(statflag_write(sfh, &st, sizeof(st)));
 }
 
-static int flagsave_disk(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_disk(STFLAGH sfh, const SFENTRY *tbl) {
 
 	int		ret;
-	BYTE	i;
+	UINT8	i;
 
-	sxsi_flash();
-	ret = flagsave_create(f, t);
-	if (ret != NP2FLAG_FAILURE) {
-		for (i=0; i<4; i++) {
-			ret |= disksave(f, fdd_diskname(i), fdd_diskprotect(i));
-		}
-		for (i=0x00; i<0x02; i++) {
-			ret |= disksave(f, sxsi_getname(i), 0);
-		}
-		for (i=0x20; i<0x22; i++) {
-			ret |= disksave(f, sxsi_getname(i), 0);
-		}
-		ret |= flagsave_close(f);
+	sxsi_allflash();
+	ret = STATFLAG_SUCCESS;
+	for (i=0; i<4; i++) {
+		ret |= disksave(sfh, fdd_diskname(i), fdd_diskprotect(i));
+	}
+	for (i=0x00; i<0x02; i++) {
+		ret |= disksave(sfh, sxsi_getfilename(i), 0);
 	}
+	for (i=0x20; i<0x24; i++) {
+		ret |= disksave(sfh, sxsi_getfilename(i), 0);
+	}
+	(void)tbl;
 	return(ret);
 }
 
-static int diskcheck(NP2FFILE *f, const char *name, ERR_BUF *e) {
+static int diskcheck(STFLAGH sfh, const OEMCHAR *name) {
 
 	int			ret;
 	FILEH		fh;
 	STATDISK	st;
-	char		buf[256];
+	OEMCHAR		buf[256];
 	DOSDATE		date;
 	DOSTIME		time;
 
-	ret = flagload_load(f, &st, sizeof(st));
+	ret = statflag_read(sfh, &st, sizeof(st));
 	if (st.path[0]) {
 		fh = file_open_rb(st.path);
 		if (fh != FILEH_INVALID) {
@@ -977,88 +995,84 @@ static int diskcheck(NP2FFILE *f, const 
 			file_close(fh);
 			if ((memcmp(&st.date, &date, sizeof(date))) ||
 				(memcmp(&st.time, &time, sizeof(time)))) {
-				ret |= NP2FLAG_DISKCHG;
-				SPRINTF(buf, "%s: updated\n", name);
-				err_append(e, buf);
+				ret |= STATFLAG_DISKCHG;
+				OEMSPRINTF(buf, str_updated, name);
+				statflag_seterr(sfh, buf);
 			}
 		}
 		else {
-			ret |= NP2FLAG_DISKCHG;
-			SPRINTF(buf, "%s: not found\n", name);
-			err_append(e, buf);
+			ret |= STATFLAG_DISKCHG;
+			OEMSPRINTF(buf, str_notfound, name);
+			statflag_seterr(sfh, buf);
 		}
 	}
 	return(ret);
 }
 
-static int flagcheck_disk(NP2FFILE *f, const STENTRY *t, ERR_BUF *e) {
+static int flagcheck_disk(STFLAGH sfh, const SFENTRY *tbl) {
 
 	int		ret;
 	int		i;
-	char	buf[8];
+	OEMCHAR	buf[8];
 
 	ret = 0;
 	for (i=0; i<4; i++) {
-		SPRINTF(buf, "FDD%d", i+1);
-		ret |= diskcheck(f, buf, e);
+		OEMSPRINTF(buf, str_fddx, i+1);
+		ret |= diskcheck(sfh, buf);
 	}
-	sxsi_flash();
+	sxsi_allflash();
 	for (i=0; i<2; i++) {
-		SPRINTF(buf, "SASI%u", i+1);
-		ret |= diskcheck(f, buf, e);
+		OEMSPRINTF(buf, str_sasix, i+1);
+		ret |= diskcheck(sfh, buf);
 	}
-	for (i=0; i<2; i++) {
-		SPRINTF(buf, "SCSI%d", i+1);
-		ret |= diskcheck(f, buf, e);
+	for (i=0; i<4; i++) {
+		OEMSPRINTF(buf, str_scsix, i);
+		ret |= diskcheck(sfh, buf);
 	}
-	(void)t;
+	(void)tbl;
 	return(ret);
 }
 
-static int flagload_disk(NP2FFILE *f, const STENTRY *t) {
+static int flagload_disk(STFLAGH sfh, const SFENTRY *tbl) {
 
 	int			ret;
-	BYTE		i;
+	UINT8		i;
 	STATDISK	st;
 
 	ret = 0;
 	for (i=0; i<4; i++) {
-		ret |= flagload_load(f, &st, sizeof(st));
+		ret |= statflag_read(sfh, &st, sizeof(st));
 		if (st.path[0]) {
 			fdd_set(i, st.path, FTYPE_NONE, st.readonly);
 		}
 	}
-	sxsi_trash();
 	for (i=0x00; i<0x02; i++) {
-		ret |= flagload_load(f, &st, sizeof(st));
+		ret |= statflag_read(sfh, &st, sizeof(st));
 		if (st.path[0]) {
-			sxsi_hddopen(i, st.path);
+			sxsi_devopen(i, st.path);
 		}
 	}
-	for (i=0x20; i<0x22; i++) {
-		ret |= flagload_load(f, &st, sizeof(st));
-#if 0
-		if (file[0]) {
-			bios0x1b_scsiopen(i, file);
+	for (i=0x20; i<0x24; i++) {
+		ret |= statflag_read(sfh, &st, sizeof(st));
+		if (st.path[0]) {
+			sxsi_devopen(i, st.path);
 		}
-#endif
 	}
-	(void)t;
+	(void)tbl;
 	return(ret);
 }
 
 
-// -----
+// ---- com
 
-#ifdef _MIDICH
-static int flagsave_midi(NP2FFILE *f, const STENTRY *t) {
+static int flagsave_com(STFLAGH sfh, const SFENTRY *tbl) {
 
 	UINT	device;
 	COMMNG	cm;
 	int		ret;
-	_MIDICH	mch[16];
+	COMFLAG	flag;
 
-	device = (UINT)t->arg1;
+	device = (UINT)(long)tbl->arg1;
 	switch(device) {
 		case 0:
 			cm = cm_mpu98;
@@ -1072,313 +1086,378 @@ static int flagsave_midi(NP2FFILE *f, co
 			cm = NULL;
 			break;
 	}
-	ret = NP2FLAG_SUCCESS;
-	if ((cm != NULL) && (cm->msg(cm, COMMSG_MIDISTATGET, (long)mch))) {
-		ret = flagsave_create(f, t);
-		if (ret != NP2FLAG_FAILURE) {
-			ret |= flagsave_save(f, mch, sizeof(mch));
-			ret |= flagsave_close(f);
+	ret = STATFLAG_SUCCESS;
+	if (cm) {
+		flag = (COMFLAG)cm->msg(cm, COMMSG_GETFLAG, 0);
+		if (flag) {
+			ret |= statflag_write(sfh, flag, flag->size);
+			_MFREE(flag);
 		}
 	}
 	return(ret);
 }
 
-static int flagload_midi(NP2FFILE *f, const STENTRY *t) {
+static int flagload_com(STFLAGH sfh, const SFENTRY *tbl) {
 
-	_MIDICH	mch[16];
-	UINT	device;
-	COMMNG	cm;
-	int		ret;
+	UINT		device;
+	COMMNG		cm;
+	int			ret;
+	_COMFLAG	fhdr;
+	COMFLAG		flag;
 
-	ret = flagload_load(f, mch, sizeof(mch));
-	if (ret != NP2FLAG_FAILURE) {
-		device = (UINT)t->arg1;
-		switch(device) {
-			case 0:
-				commng_destroy(cm_mpu98);
-				cm = commng_create(COMCREATE_MPU98II);
-				cm_mpu98 = cm;
-				break;
+	ret = statflag_read(sfh, &fhdr, sizeof(fhdr));
+	if (ret != STATFLAG_SUCCESS) {
+		goto flcom_err1;
+	}
+	if (fhdr.size < sizeof(fhdr)) {
+		goto flcom_err1;
+	}
+	flag = (COMFLAG)_MALLOC(fhdr.size, "com stat flag");
+	if (flag == NULL) {
+		goto flcom_err1;
+	}
+	CopyMemory(flag, &fhdr, sizeof(fhdr));
+	ret |= statflag_read(sfh, flag + 1, fhdr.size - sizeof(fhdr));
+	if (ret != STATFLAG_SUCCESS) {
+		goto flcom_err2;
+	}
 
-			case 1:
-				commng_destroy(cm_rs232c);
-				cm = commng_create(COMCREATE_SERIAL);
-				cm_rs232c = cm;
-				break;
+	device = (UINT)(long)tbl->arg1;
+	switch(device) {
+		case 0:
+			commng_destroy(cm_mpu98);
+			cm = commng_create(COMCREATE_MPU98II);
+			cm_mpu98 = cm;
+			break;
 
-			default:
-				cm = NULL;
-				break;
-		}
-		if (cm) {
-			cm->msg(cm, COMMSG_MIDISTATSET, (long)mch);
-		}
+		case 1:
+			commng_destroy(cm_rs232c);
+			cm = commng_create(COMCREATE_SERIAL);
+			cm_rs232c = cm;
+			break;
+
+		default:
+			cm = NULL;
+			break;
+	}
+	if (cm) {
+		cm->msg(cm, COMMSG_SETFLAG, (long)flag);
 	}
+
+flcom_err2:
+	_MFREE(flag);
+
+flcom_err1:
 	return(ret);
 }
-#endif
 
 
 // ----
 
-static int flagcheck_versize(NP2FFILE *f, const STENTRY *t, ERR_BUF *e) {
+static int flagcheck_versize(STFLAGH sfh, const SFENTRY *tbl) {
 
-	if ((f) && (t)) {
-		if ((f->p.ver == t->ver) && (f->p.size == t->arg2)) {
-			return(NP2FLAG_SUCCESS);
-		}
-		return(NP2FLAG_VERSION);
+	if ((sfh->hdr.ver == tbl->ver) && (sfh->hdr.size == tbl->arg2)) {
+		return(STATFLAG_SUCCESS);
 	}
-	(void)e;
-	return(NP2FLAG_FAILURE);
+	return(STATFLAG_FAILURE);
 }
 
-static int flagcheck_veronly(NP2FFILE *f, const STENTRY *t, ERR_BUF *e) {
+static int flagcheck_veronly(STFLAGH sfh, const SFENTRY *tbl) {
 
-	if ((f) && (t)) {
-		if (f->p.ver == t->ver) {
-			return(NP2FLAG_SUCCESS);
-		}
-		return(NP2FLAG_VERSION);
+	if (sfh->hdr.ver == tbl->ver) {
+		return(STATFLAG_SUCCESS);
 	}
-	(void)e;
-	return(NP2FLAG_FAILURE);
+	return(STATFLAG_FAILURE);
 }
 
 
 // ----
 
-int statsave_save(const char *filename) {
+int statsave_save(const OEMCHAR *filename) {
 
-	NP2FFILE	f;
+	SFFILEH		sffh;
 	int			ret;
-	UINT		i;
+const SFENTRY	*tbl;
+const SFENTRY	*tblterm;
 
-	ret = flagcreate(&f, filename);
-	if (ret == NP2FLAG_FAILURE) {
-		return(ret);
-	}
-	for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {
-		switch(np2tbl[i].type) {
-			case NP2FLAG_BIN:
-			case NP2FLAG_CLOCK:
-				ret |= flagsave_common(&f, &np2tbl[i]);
+	sffh = statflag_create(filename);
+	if (sffh == NULL) {
+		return(STATFLAG_FAILURE);
+	}
+
+	ret = STATFLAG_SUCCESS;
+	tbl = np2tbl;
+	tblterm = tbl + NELEMENTS(np2tbl);
+	while(tbl < tblterm) {
+		ret |= statflag_createsection(sffh, tbl);
+		switch(tbl->type) {
+			case STATFLAG_BIN:
+			case STATFLAG_TERM:
+				ret |= flagsave_common(&sffh->sfh, tbl);
 				break;
 
-			case NP2FLAG_TERM:
-				ret |= flagsave_term(&f, &np2tbl[i]);
+#if defined(CGWND_FONTPTR)
+			case STATFLAG_CGW:
+				ret |= flagsave_cgwnd(&sffh->sfh, tbl);
 				break;
+#endif
 
-			case NP2FLAG_DMA:
-				ret |= flagsave_dma(&f, &np2tbl[i]);
+			case STATFLAG_COM:
+				ret |= flagsave_com(&sffh->sfh, tbl);
 				break;
 
-			case NP2FLAG_EGC:
-				ret |= flagsave_egc(&f, &np2tbl[i]);
+			case STATFLAG_DISK:
+				ret |= flagsave_disk(&sffh->sfh, tbl);
 				break;
 
-			case NP2FLAG_EXT:
-				ret |= flagsave_ext(&f, &np2tbl[i]);
+			case STATFLAG_DMA:
+				ret |= flagsave_dma(&sffh->sfh, tbl);
 				break;
 
-			case NP2FLAG_EVT:
-				ret |= flagsave_evt(&f, &np2tbl[i]);
+			case STATFLAG_EGC:
+				ret |= flagsave_egc(&sffh->sfh, tbl);
 				break;
 
-			case NP2FLAG_GIJ:
-				ret |= flagsave_gij(&f, &np2tbl[i]);
+			case STATFLAG_EPSON:
+				ret |= flagsave_epson(&sffh->sfh, tbl);
 				break;
 
-			case NP2FLAG_FM:
-				ret |= flagsave_fm(&f, &np2tbl[i]);
+			case STATFLAG_EVT:
+				ret |= flagsave_evt(&sffh->sfh, tbl);
 				break;
 
-			case NP2FLAG_DISK:
-				ret |= flagsave_disk(&f, &np2tbl[i]);
+			case STATFLAG_EXT:
+				ret |= flagsave_ext(&sffh->sfh, tbl);
 				break;
 
-#if defined(MIDICH)
-			case NP2FLAG_MIDI:
-				ret |= flagsave_midi(&f, &np2tbl[i]);
+#if !defined(DISABLE_SOUND)
+			case STATFLAG_FM:
+				ret |= flagsave_fm(&sffh->sfh, tbl);
 				break;
 #endif
+
+			case STATFLAG_GIJ:
+				ret |= flagsave_gij(&sffh->sfh, tbl);
+				break;
+
+#if defined(SUPPORT_HOSTDRV)
+				case STATFLAG_HDRV:
+				ret |= hostdrv_sfsave(&sffh->sfh, tbl);
+				break;
+#endif
+
+			case STATFLAG_MEM:
+				ret |= flagsave_mem(&sffh->sfh, tbl);
+				break;
 		}
+		tbl++;
 	}
-	flagclose(&f);
+	statflag_close(sffh);
 	return(ret);
 }
 
-int statsave_check(const char *filename, char *buf, int size) {
+int statsave_check(const OEMCHAR *filename, OEMCHAR *buf, int size) {
 
-	NP2FFILE	f;
+	SFFILEH		sffh;
 	int			ret;
-	UINT		i;
 	BOOL		done;
-	ERR_BUF		e;
+const SFENTRY	*tbl;
+const SFENTRY	*tblterm;
 
-	e.buf = buf;
-	e.remain = size;
-	if (e.remain) {
-		e.remain--;
-		if (buf) {
-			*buf = '\0';
-		}
-	}
-	else {
-		e.buf = NULL;
+	sffh = statflag_open(filename, buf, size);
+	if (sffh == NULL) {
+		return(STATFLAG_FAILURE);
 	}
 
-	ret = flagopen(&f, filename, &e);
-	if (ret != NP2FLAG_FAILURE) {
-		done = FALSE;
-		while((!done) && (ret != NP2FLAG_FAILURE)) {
-			char index[11];
-			ret |= flagload_create(&f);
-			CopyMemory(index, f.p.index, sizeof(f.p.index));
-			index[10] = 0;
-			for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {
-				if (!strcmp(index, np2tbl[i].index)) {
-					break;
-				}
+	done = FALSE;
+	ret = STATFLAG_SUCCESS;
+	while((!done) && (ret != STATFLAG_FAILURE)) {
+		ret |= statflag_readsection(sffh);
+		tbl = np2tbl;
+		tblterm = tbl + NELEMENTS(np2tbl);
+		while(tbl < tblterm) {
+			if (!memcmp(sffh->sfh.hdr.index, tbl->index, 10)) {
+				break;
 			}
-			if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {
-				switch(np2tbl[i].type) {
-					case NP2FLAG_BIN:
-					case NP2FLAG_CLOCK:
-						ret |= flagcheck_versize(&f, &np2tbl[i], &e);
-						break;
-
-					case NP2FLAG_TERM:
-						done = TRUE;
-						break;
-
-					case NP2FLAG_DMA:
-					case NP2FLAG_EGC:
-					case NP2FLAG_EXT:
-					case NP2FLAG_EVT:
-					case NP2FLAG_GIJ:
-#if defined(MIDICH)
-					case NP2FLAG_MIDI:
+			tbl++;
+		}
+		if (tbl < tblterm) {
+			switch(tbl->type) {
+				case STATFLAG_BIN:
+#if defined(CGWND_FONTPTR)
+				case STATFLAG_CGW:
 #endif
-						ret |= flagcheck_veronly(&f, &np2tbl[i], &e);
-						break;
+				case STATFLAG_MEM:
+					ret |= flagcheck_versize(&sffh->sfh, tbl);
+					break;
 
-					case NP2FLAG_DISK:
-						ret |= flagcheck_disk(&f, &np2tbl[i], &e);
-						break;
-
-					case NP2FLAG_FM:							// ver0.31
-						break;
-
-					default:
-						ret |= NP2FLAG_WARNING;
-						break;
-				}
-			}
-			else {
-				ret |= NP2FLAG_WARNING;
+				case STATFLAG_TERM:
+					done = TRUE;
+					break;
+
+				case STATFLAG_COM:
+				case STATFLAG_DMA:
+				case STATFLAG_EGC:
+				case STATFLAG_EPSON:
+				case STATFLAG_EVT:
+				case STATFLAG_EXT:
+				case STATFLAG_GIJ:
+#if !defined(DISABLE_SOUND)
+				case STATFLAG_FM:
+#endif
+#if defined(SUPPORT_HOSTDRV)
+				case STATFLAG_HDRV:
+#endif
+					ret |= flagcheck_veronly(&sffh->sfh, tbl);
+					break;
+
+				case STATFLAG_DISK:
+					ret |= flagcheck_disk(&sffh->sfh, tbl);
+					break;
+
+				default:
+					ret |= STATFLAG_WARNING;
+					break;
 			}
-			ret |= flagload_close(&f);
 		}
-		flagclose(&f);
-	}
-	if (e.buf) {
-		*e.buf = '\0';
+		else {
+			ret |= STATFLAG_WARNING;
+		}
 	}
+	statflag_close(sffh);
 	return(ret);
 }
 
-int statsave_load(const char *filename) {
+int statsave_load(const OEMCHAR *filename) {
 
-	NP2FFILE	f;
+	SFFILEH		sffh;
 	int			ret;
-	UINT		i;
 	BOOL		done;
+const SFENTRY	*tbl;
+const SFENTRY	*tblterm;
 
-	ret = flagopen(&f, filename, NULL);
-	if (ret == NP2FLAG_FAILURE) {
-		return(ret);
+	sffh = statflag_open(filename, NULL, 0);
+	if (sffh == NULL) {
+		return(STATFLAG_FAILURE);
+	}
+
+	// PCCORE read!
+	ret = statflag_readsection(sffh);
+	if ((ret != STATFLAG_SUCCESS) ||
+		(memcmp(sffh->sfh.hdr.index, np2tbl[0].index, 10))) {
+		statflag_close(sffh);
+		return(STATFLAG_FAILURE);
 	}
 
 	soundmng_stop();
 	rs232c_midipanic();
 	mpu98ii_midipanic();
 	pc9861k_midipanic();
+	sxsi_alltrash();
+
+	ret |= flagload_common(&sffh->sfh, np2tbl);
+
+	CPU_RESET();
+	CPU_SETEXTSIZE((UINT32)pccore.extmem);
+	nevent_allreset();
+
+	sound_changeclock();
+	beep_changeclock();
 	sound_reset();
-	fmboard_reset(0);
+	fddmtrsnd_bind();
+
+	iocore_reset();								// サウンドでpicを呼ぶので…
+	cbuscore_reset();
+	fmboard_reset(pccore.sound);
 
 	done = FALSE;
-	while((!done) && (ret != NP2FLAG_FAILURE)) {
-		char index[11];
-		ret |= flagload_create(&f);
-		CopyMemory(index, f.p.index, sizeof(f.p.index));
-		index[10] = 0;
-		for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {
-			if (!strcmp(index, np2tbl[i].index)) {
+	while((!done) && (ret != STATFLAG_FAILURE)) {
+		ret |= statflag_readsection(sffh);
+		tbl = np2tbl + 1;
+		tblterm = np2tbl + NELEMENTS(np2tbl);
+		while(tbl < tblterm) {
+			if (!memcmp(sffh->sfh.hdr.index, tbl->index, 10)) {
 				break;
 			}
+			tbl++;
 		}
-		if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {
-			switch(np2tbl[i].type) {
-				case NP2FLAG_BIN:
-					ret |= flagload_common(&f, &np2tbl[i]);
+		if (tbl < tblterm) {
+			switch(tbl->type) {
+				case STATFLAG_BIN:
+					ret |= flagload_common(&sffh->sfh, tbl);
 					break;
 
-				case NP2FLAG_TERM:
+				case STATFLAG_TERM:
 					done = TRUE;
 					break;
 
-				case NP2FLAG_CLOCK:
-					ret |= flagload_clock(&f, &np2tbl[i]);
+#if defined(CGWND_FONTPTR)
+				case STATFLAG_CGW:
+					ret |= flagload_cgwnd(&sffh->sfh, tbl);
 					break;
+#endif
 
-				case NP2FLAG_DMA:
-					ret |= flagload_dma(&f, &np2tbl[i]);
+				case STATFLAG_COM:
+					ret |= flagload_com(&sffh->sfh, tbl);
 					break;
 
-				case NP2FLAG_EGC:
-					ret |= flagload_egc(&f, &np2tbl[i]);
+				case STATFLAG_DISK:
+					ret |= flagload_disk(&sffh->sfh, tbl);
 					break;
 
-				case NP2FLAG_EXT:
-					ret |= flagload_ext(&f, &np2tbl[i]);
+				case STATFLAG_DMA:
+					ret |= flagload_dma(&sffh->sfh, tbl);
 					break;
 
-				case NP2FLAG_EVT:
-					ret |= flagload_evt(&f, &np2tbl[i]);
+				case STATFLAG_EGC:
+					ret |= flagload_egc(&sffh->sfh, tbl);
 					break;
 
-				case NP2FLAG_GIJ:
-					ret |= flagload_gij(&f, &np2tbl[i]);
+				case STATFLAG_EPSON:
+					ret |= flagload_epson(&sffh->sfh, tbl);
 					break;
 
-				case NP2FLAG_FM:
-					ret |= flagload_fm(&f, &np2tbl[i]);
+				case STATFLAG_EVT:
+					ret |= flagload_evt(&sffh->sfh, tbl);
 					break;
 
-				case NP2FLAG_DISK:
-					ret |= flagload_disk(&f, &np2tbl[i]);
+				case STATFLAG_EXT:
+					ret |= flagload_ext(&sffh->sfh, tbl);
 					break;
 
-#if defined(MIDICH)
-				case NP2FLAG_MIDI:
-					ret |= flagload_midi(&f, &np2tbl[i]);
+#if !defined(DISABLE_SOUND)
+				case STATFLAG_FM:
+					ret |= flagload_fm(&sffh->sfh, tbl);
 					break;
 #endif
 
+				case STATFLAG_GIJ:
+					ret |= flagload_gij(&sffh->sfh, tbl);
+					break;
+
+#if defined(SUPPORT_HOSTDRV)
+				case STATFLAG_HDRV:
+					ret |= hostdrv_sfload(&sffh->sfh, tbl);
+					break;
+#endif
+
+				case STATFLAG_MEM:
+					ret |= flagload_mem(&sffh->sfh, tbl);
+					break;
+
 				default:
-					ret |= NP2FLAG_WARNING;
+					ret |= STATFLAG_WARNING;
 					break;
 			}
 		}
 		else {
-			ret |= NP2FLAG_WARNING;
+			ret |= STATFLAG_WARNING;
 		}
-		ret |= flagload_close(&f);
 	}
-	flagclose(&f);
+	statflag_close(sffh);
 
 	// I/O作り直し
+	i286_memorymap((pccore.model & PCMODEL_EPSON)?1:0);
 	iocore_build();
 	iocore_bind();
 	cbuscore_bind();
@@ -1391,6 +1470,10 @@ int statsave_load(const char *filename) 
 	gdcs.palchange = GDCSCRN_REDRAW;
 	tramflag.renewal = 1;
 	cgwindow.writable |= 0x80;
+#if defined(CPUSTRUC_FONTPTR)
+	FONTPTR_LOW = fontrom + cgwindow.low;
+	FONTPTR_HIGH = fontrom + cgwindow.high;
+#endif
 	i286_vram_dispatch(vramop.operate);
 	soundmng_play();