np2/statsave.c - diff

Return to statsave.c CVS log

Up to [RetroPC.NET] / np2

Diff for /np2/statsave.c between versions 1.4 and 1.26

version 1.4, 2003/10/18 07:28:50	version 1.26, 2004/01/08 16:29:56
Line 4	Line 4
#include "scrnmng.h"	#include "scrnmng.h"
#include "soundmng.h"	#include "soundmng.h"
#include "timemng.h"	#include "timemng.h"
#include "i286.h"	#include "cpucore.h"
#include "memory.h"
#include "pccore.h"	#include "pccore.h"
#include "iocore.h"	#include "iocore.h"
#include "cbuscore.h"	#include "cbuscore.h"
#include "pc9861k.h"	#include "pc9861k.h"
#include "mpu98ii.h"	#include "mpu98ii.h"
#include "board14.h"	#include "board14.h"
	#include "amd98.h"
	#include "bios.h"
#include "vram.h"	#include "vram.h"
#include "maketext.h"
#include "palettes.h"	#include "palettes.h"
#include "font.h"	#include "maketext.h"
#include "sound.h"	#include "sound.h"
#include "bios.h"
#include "fmboard.h"	#include "fmboard.h"
#include "beep.h"	#include "beep.h"
	#include "font.h"
#include "fddfile.h"	#include "fddfile.h"
#include "fdd_mtr.h"	#include "fdd_mtr.h"
#include "sxsi.h"	#include "sxsi.h"
Line 28	Line 28
#include "keydisp.h"	#include "keydisp.h"


	#if defined(MACOS)
	#define CRLITERAL "\r"
	#define CRCONST str_cr
	#elif defined(WIN32) \|\| defined(X11) \|\| defined(SLZAURUS)
	#define CRLITERAL "\n"
	#define CRCONST str_lf
	#else
	#define CRLITERAL "\r\n"
	#define CRCONST str_crlf
	#endif


typedef struct {	typedef struct {
char name[16];	char name[16];
char vername[28];	char vername[28];
Line 38 typedef struct {	Line 50 typedef struct {
char index[10];	char index[10];
UINT16 ver;	UINT16 ver;
UINT32 size;	UINT32 size;
} NP2FLAGPART_T;	} NP2FENT;

enum {	enum {
NP2FLAG_BIN = 0,	NP2FLAG_BIN = 0,
NP2FLAG_TERM,	NP2FLAG_TERM,
NP2FLAG_CORE,	#if defined(CGWND_FONTPTR)
	NP2FLAG_CGW,
	#endif
	NP2FLAG_CLOCK,
	NP2FLAG_COM,
	NP2FLAG_DISK,
NP2FLAG_DMA,	NP2FLAG_DMA,
NP2FLAG_EGC,	NP2FLAG_EGC,
NP2FLAG_EXT,	NP2FLAG_EPSON,
NP2FLAG_EVT,	NP2FLAG_EVT,
NP2FLAG_GIJ,	NP2FLAG_EXT,
NP2FLAG_FM,	NP2FLAG_FM,
NP2FLAG_BEEP,	NP2FLAG_GIJ,
NP2FLAG_MIDI,	NP2FLAG_MEM
NP2FLAG_DISK
};	};

typedef struct {	typedef struct {
Line 73 typedef struct {	Line 89 typedef struct {
int num;	int num;
} ENUMTBL;	} ENUMTBL;

#define PROCID(a, b, c, d) (((d) << 24) \| ((c) << 16) \| ((b) << 8) \| (a))	#define PROCID(a, b, c, d) (((d) << 24) + ((c) << 16) + ((b) << 8) + (a))
#define PROC2NUM(a, b) proc2num(&(a), b, sizeof(b)/sizeof(PROCTBL))	#define PROC2NUM(a, b) proc2num(&(a), (b), sizeof(b)/sizeof(PROCTBL))
#define NUM2PROC(a, b) num2proc(&(a), b, sizeof(b)/sizeof(PROCTBL))	#define NUM2PROC(a, b) num2proc(&(a), (b), sizeof(b)/sizeof(PROCTBL))

#include "statsave.tbl"	#include "statsave.tbl"

Line 90 typedef struct {	Line 106 typedef struct {

static void err_append(ERR_BUF e, char buf) {	static void err_append(ERR_BUF e, char buf) {

	int len;

if ((e) && (buf)) {	if ((e) && (buf)) {
if (e->buf) {	if (e->buf) {
int len;
len = strlen(buf);	len = strlen(buf);
if (e->remain >= len) {	if (e->remain >= len) {
CopyMemory(e->buf, buf, len);	CopyMemory(e->buf, buf, len);
Line 139 static BOOL num2proc(void *func, const P	Line 156 static BOOL num2proc(void *func, const P
// ----	// ----

typedef struct {	typedef struct {
FILEH fh;	FILEH fh;
long pos;	long pos;
long bak;	long bak;
long next;	long next;
NP2FHDR f;	NP2FHDR f;
NP2FLAGPART_T p;	NP2FENT p;
} NP2FFILE;	} _NP2FFILE, *NP2FFILE;

static int flagopen(NP2FFILE f, const char filename, ERR_BUF *e) {	static int flagopen(NP2FFILE f, const char filename, ERR_BUF e) {

if (f) {	if (f) {
f->fh = file_open(filename);	f->fh = file_open(filename);
Line 186 static int flagopen(NP2FFILE *f, const c	Line 203 static int flagopen(NP2FFILE *f, const c
return(NP2FLAG_FAILURE);	return(NP2FLAG_FAILURE);
}	}

static int flagcreate(NP2FFILE f, const char filename) {	static int flagcreate(NP2FFILE f, const char *filename) {

if (f) {	if (f) {
f->fh = file_create(filename);	f->fh = file_create(filename);
Line 204 static int flagcreate(NP2FFILE *f, const	Line 221 static int flagcreate(NP2FFILE *f, const
return(NP2FLAG_FAILURE);	return(NP2FLAG_FAILURE);
}	}

static int flagload_create(NP2FFILE *f) {	static int flagload_create(NP2FFILE f) {

if (f) {	if (f) {
ZeroMemory(&f->p, sizeof(NP2FLAGPART_T));	ZeroMemory(&f->p, sizeof(NP2FENT));
if (f->pos & 15) {	if (f->pos & 15) {
f->pos += 15;	f->pos += 15;
f->pos &= ~0xf;	f->pos &= ~0xf;
Line 215 static int flagload_create(NP2FFILE *f)	Line 232 static int flagload_create(NP2FFILE *f)
return(NP2FLAG_FAILURE);	return(NP2FLAG_FAILURE);
}	}
}	}
if (file_read(f->fh, &f->p, sizeof(NP2FLAGPART_T))	if (file_read(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {
!= sizeof(NP2FLAGPART_T)) {
return(NP2FLAG_FAILURE);	return(NP2FLAG_FAILURE);
}	}
f->pos += sizeof(NP2FLAGPART_T);	f->pos += sizeof(NP2FENT);
f->next = f->pos + f->p.size;	f->next = f->pos + f->p.size;
return(NP2FLAG_SUCCESS);	return(NP2FLAG_SUCCESS);
}	}
return(NP2FLAG_FAILURE);	return(NP2FLAG_FAILURE);
}	}

static int flagload_load(NP2FFILE f, void buf, UINT size) {	static int flagload_load(NP2FFILE f, void *buf, UINT size) {

if (f && buf && size && (file_read(f->fh, buf, size) == size)) {	if (f && buf && size && (file_read(f->fh, buf, size) == size)) {
f->pos += size;	f->pos += size;
Line 235 static int flagload_load(NP2FFILE *f, vo	Line 251 static int flagload_load(NP2FFILE *f, vo
return(NP2FLAG_FAILURE);	return(NP2FLAG_FAILURE);
}	}

static int flagload_close(NP2FFILE *f) {	static int flagload_close(NP2FFILE f) {

if (file_seek(f->fh, f->next, 0) != f->next) {	if (file_seek(f->fh, f->next, 0) != f->next) {
return(NP2FLAG_FAILURE);	return(NP2FLAG_FAILURE);
Line 244 static int flagload_close(NP2FFILE *f) {	Line 260 static int flagload_close(NP2FFILE *f) {
return(NP2FLAG_SUCCESS);	return(NP2FLAG_SUCCESS);
}	}

static int flagsave_create(NP2FFILE f, const STENTRY t) {	static int flagsave_create(NP2FFILE f, const STENTRY *t) {

if (f && t) {	if (f && t) {
int len;	int len;
ZeroMemory(&f->p, sizeof(NP2FLAGPART_T));	ZeroMemory(&f->p, sizeof(NP2FENT));
if (f->pos & 15) {	if (f->pos & 15) {
UINT rem;	UINT rem;
rem = 16 - (f->pos & 15);	rem = 16 - (f->pos & 15);
Line 267 static int flagsave_create(NP2FFILE *f,	Line 283 static int flagsave_create(NP2FFILE *f,
CopyMemory(f->p.index, t->index, len);	CopyMemory(f->p.index, t->index, len);
}	}
f->p.ver = t->ver;	f->p.ver = t->ver;
if (file_write(f->fh, &f->p, sizeof(NP2FLAGPART_T))	if (file_write(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {
!= sizeof(NP2FLAGPART_T)) {
return(NP2FLAG_FAILURE);	return(NP2FLAG_FAILURE);
}	}
f->pos += sizeof(NP2FLAGPART_T);	f->pos += sizeof(NP2FENT);
return(NP2FLAG_SUCCESS);	return(NP2FLAG_SUCCESS);
}	}
return(NP2FLAG_FAILURE);	return(NP2FLAG_FAILURE);
}	}

static int flagsave_save(NP2FFILE f, void buf, UINT size) {	static int flagsave_save(NP2FFILE f, void *buf, UINT size) {

if (f && buf && size && (file_write(f->fh, buf, size) == size)) {	if (f && buf && size && (file_write(f->fh, buf, size) == size)) {
f->pos += size;	f->pos += size;
Line 287 static int flagsave_save(NP2FFILE *f, vo	Line 302 static int flagsave_save(NP2FFILE *f, vo
return(NP2FLAG_FAILURE);	return(NP2FLAG_FAILURE);
}	}

static int flagsave_close(NP2FFILE *f) {	static int flagsave_close(NP2FFILE f) {

if (!f) {	if (!f) {
goto fs_closeerr;	goto fs_closeerr;
Line 295 static int flagsave_close(NP2FFILE *f) {	Line 310 static int flagsave_close(NP2FFILE *f) {
if (file_seek(f->fh, f->bak, 0) != f->bak) {	if (file_seek(f->fh, f->bak, 0) != f->bak) {
goto fs_closeerr;	goto fs_closeerr;
}	}
if (file_write(f->fh, &f->p, sizeof(NP2FLAGPART_T))	if (file_write(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {
!= sizeof(NP2FLAGPART_T)) {
goto fs_closeerr;	goto fs_closeerr;
}	}
if (file_seek(f->fh, f->pos, 0) == f->pos) {	if (file_seek(f->fh, f->pos, 0) == f->pos) {
Line 307 fs_closeerr:	Line 321 fs_closeerr:
return(NP2FLAG_FAILURE);	return(NP2FLAG_FAILURE);
}	}

static void flagclose(NP2FFILE *f) {	static void flagclose(NP2FFILE f) {

if (f) {	if (f) {
file_close(f->fh);	file_close(f->fh);
Line 317 static void flagclose(NP2FFILE *f) {	Line 331 static void flagclose(NP2FFILE *f) {

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

static int flagsave_term(NP2FFILE f, const STENTRY t) {	static int flagsave_term(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;

Line 327 static int flagsave_term(NP2FFILE *f, co	Line 341 static int flagsave_term(NP2FFILE *f, co
}	}


// ----	// ---- common

static int flagsave_common(NP2FFILE f, const STENTRY t) {	static int flagsave_common(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;

Line 341 static int flagsave_common(NP2FFILE *f,	Line 355 static int flagsave_common(NP2FFILE *f,
return(ret);	return(ret);
}	}

static int flagload_common(NP2FFILE f, const STENTRY t) {	static int flagload_common(NP2FFILE f, const STENTRY *t) {

return(flagload_load(f, t->arg1, t->arg2));	return(flagload_load(f, t->arg1, t->arg2));
}	}


// -----	// ----- clock

static int flagload_core(NP2FFILE f, const STENTRY t) {	static int flagload_clock(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;

ret = flagload_common(f, t);	ret = flagload_common(f, t);
if (opna_rate) {	sound_changeclock();
pc.sampleclock = (pc.realclock / opna_rate) + 1;	beep_changeclock();
	return(ret);
	}


	// ---- memory

	static int flagsave_mem(NP2FFILE f, const STENTRY *t) {

	int ret;

	ret = flagsave_create(f, t);
	if (ret != NP2FLAG_FAILURE) {
	ret \|= flagsave_save(f, mem, 0x110000);
	ret \|= flagsave_save(f, mem + VRAM1_B, 0x18000);
	ret \|= flagsave_save(f, mem + VRAM1_E, 0x8000);
	ret \|= flagsave_close(f);
}	}
else {	return(ret);
pc.sampleclock = 0;	}

	static int flagload_mem(NP2FFILE f, const STENTRY *t) {

	int ret;

	ret = flagload_load(f, mem, 0x110000);
	ret \|= flagload_load(f, mem + VRAM1_B, 0x18000);
	ret \|= flagload_load(f, mem + VRAM1_E, 0x8000);
	(void)t;
	return(ret);
	}


	// ---- ext memory

	static int flagsave_ext(NP2FFILE f, const STENTRY *t) {

	int ret;

	ret = flagsave_create(f, t);
	if (ret != NP2FLAG_FAILURE) {
	ret \|= flagsave_save(f, &extmem, sizeof(extmem));
	if (CPU_EXTMEM) {
	ret \|= flagsave_save(f, CPU_EXTMEM, CPU_EXTMEMSIZE);
	}
	ret \|= flagsave_close(f);
	}
	return(ret);
	}

	static int flagload_ext(NP2FFILE f, const STENTRY *t) {

	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 (CPU_EXTMEM) {
	ret \|= flagload_load(f, CPU_EXTMEM, CPU_EXTMEMSIZE);
	}
	}
	else {
	extmem.maxmem = 0;
	}
}	}
	for (i=0; i<4; i++) {
	if (extmem.page[i] < pagemax) {
	extmem.pageptr[i] = CPU_EXTMEM + (extmem.page[i] << 12);
	}
	else {
	extmem.pageptr[i] = mem + 0xc0000 + (i << 14);
	}
	}
	(void)t;
return(ret);	return(ret);
}	}


// -----	// ---- cg window

static int flagsave_dma(NP2FFILE f, const STENTRY t) {	#if defined(CGWND_FONTPTR)
	static int flagsave_cgwnd(NP2FFILE f, const STENTRY *t) {

	int ret;
	_CGWINDOW cgwnd;

	cgwnd = cgwindow;
	cgwnd.fontlow -= (long)fontrom;
	cgwnd.fonthigh -= (long)fontrom;
	ret = flagsave_create(f, t);
	if (ret != NP2FLAG_FAILURE) {
	ret \|= flagsave_save(f, &cgwindow, sizeof(cgwindow));
	ret \|= flagsave_close(f);
	}
	return(ret);
	}

	static int flagload_cgwnd(NP2FFILE f, const STENTRY *t) {

	int ret;

	ret = flagload_load(f, &cgwindow, sizeof(cgwindow));
	cgwindow.fontlow += (long)fontrom;
	cgwindow.fonthigh += (long)fontrom;
	(void)t;
	return(ret);
	}
	#endif


	// ---- dma

	static int flagsave_dma(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;
int i;	int i;
Line 374 static int flagsave_dma(NP2FFILE *f, con	Line 495 static int flagsave_dma(NP2FFILE *f, con

dmabak = dmac;	dmabak = dmac;
for (i=0; i<4; i++) {	for (i=0; i<4; i++) {
if ((PROC2NUM(dmabak.dmach[i].outproc, dmaproc)) \|\|	if ((PROC2NUM(dmabak.dmach[i].proc.outproc, dmaproc)) \|\|
(PROC2NUM(dmabak.dmach[i].inproc, dmaproc)) \|\|	(PROC2NUM(dmabak.dmach[i].proc.inproc, dmaproc)) \|\|
(PROC2NUM(dmabak.dmach[i].extproc, dmaproc))) {	(PROC2NUM(dmabak.dmach[i].proc.extproc, dmaproc))) {
return(NP2FLAG_FAILURE);	return(NP2FLAG_FAILURE);
}	}
}	}
Line 388 static int flagsave_dma(NP2FFILE *f, con	Line 509 static int flagsave_dma(NP2FFILE *f, con
return(ret);	return(ret);
}	}

static int flagload_dma(NP2FFILE f, const STENTRY t) {	static int flagload_dma(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;
int i;	int i;
Line 396 static int flagload_dma(NP2FFILE *f, con	Line 517 static int flagload_dma(NP2FFILE *f, con
ret = flagload_load(f, &dmac, sizeof(dmac));	ret = flagload_load(f, &dmac, sizeof(dmac));

for (i=0; i<4; i++) {	for (i=0; i<4; i++) {
if (NUM2PROC(dmac.dmach[i].outproc, dmaproc)) {	if (NUM2PROC(dmac.dmach[i].proc.outproc, dmaproc)) {
dmac.dmach[i].outproc = dma_dummyout;	dmac.dmach[i].proc.outproc = dma_dummyout;
ret \|= NP2FLAG_WARNING;	ret \|= NP2FLAG_WARNING;
}	}
if (NUM2PROC(dmac.dmach[i].inproc, dmaproc)) {	if (NUM2PROC(dmac.dmach[i].proc.inproc, dmaproc)) {
dmac.dmach[i].inproc = dma_dummyin;	dmac.dmach[i].proc.inproc = dma_dummyin;
ret \|= NP2FLAG_WARNING;	ret \|= NP2FLAG_WARNING;
}	}
if (NUM2PROC(dmac.dmach[i].extproc, dmaproc)) {	if (NUM2PROC(dmac.dmach[i].proc.extproc, dmaproc)) {
dmac.dmach[i].extproc = dma_dummyproc;	dmac.dmach[i].proc.extproc = dma_dummyproc;
ret \|= NP2FLAG_WARNING;	ret \|= NP2FLAG_WARNING;
}	}
}	}
Line 414 static int flagload_dma(NP2FFILE *f, con	Line 535 static int flagload_dma(NP2FFILE *f, con
}	}


// -----	// ---- egc

static int flagsave_egc(NP2FFILE f, const STENTRY t) {	static int flagsave_egc(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;
_EGC egcbak;	_EGC egcbak;
Line 433 static int flagsave_egc(NP2FFILE *f, con	Line 554 static int flagsave_egc(NP2FFILE *f, con
return(ret);	return(ret);
}	}

static int flagload_egc(NP2FFILE f, const STENTRY t) {	static int flagload_egc(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;

Line 445 static int flagload_egc(NP2FFILE *f, con	Line 566 static int flagload_egc(NP2FFILE *f, con
}	}


// -----	// ---- epson

static int flagsave_ext(NP2FFILE f, const STENTRY t) {	static int flagsave_epson(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;

	if (!(pc.model & PCMODEL_EPSON)) {
	return(NP2FLAG_SUCCESS);
	}
ret = flagsave_create(f, t);	ret = flagsave_create(f, t);
if (ret != NP2FLAG_FAILURE) {	if (ret != NP2FLAG_FAILURE) {
ret \|= flagsave_save(f, &extmem, sizeof(extmem));	ret \|= flagsave_save(f, &epsonio, sizeof(epsonio));
if (extmemmng_size) {	ret \|= flagsave_save(f, mem + 0x1c0000, 0x8000);
ret \|= flagsave_save(f, extmemmng_ptr, extmemmng_size);	ret \|= flagsave_save(f, mem + 0x1e8000, 0x18000);
}
ret \|= flagsave_close(f);	ret \|= flagsave_close(f);
}	}
return(ret);	return(ret);
}	}

static int flagload_ext(NP2FFILE f, const STENTRY t) {	static int flagload_epson(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;
int i;
UINT pagemax = 0;

ret = flagload_load(f, &extmem, sizeof(extmem));	ret = flagload_load(f, &epsonio, sizeof(epsonio));
if (extmem.maxmem) {	ret \|= flagload_load(f, mem + 0x1c0000, 0x8000);
if (extmem.maxmem > (13+1)) {	ret \|= flagload_load(f, mem + 0x1e8000, 0x18000);
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;	(void)t;
return(ret);	return(ret);
}	}


// -----	// ---- event

typedef struct {	typedef struct {
SINT32 remainclock;
SINT32 baseclock;
UINT32 clock;
UINT readyevents;	UINT readyevents;
UINT waitevents;	UINT waitevents;
} NEVTSAVE;	} NEVTSAVE;
Line 513 typedef struct {	Line 611 typedef struct {
NEVENTCB proc;	NEVENTCB proc;
} NEVTITEM;	} NEVTITEM;

static int nevent_save(NP2FFILE *f, int num) {	static int nevent_save(NP2FFILE f, int num) {

NEVTITEM nit;	NEVTITEM nit;
UINT i;	UINT i;
Line 534 static int nevent_save(NP2FFILE *f, int	Line 632 static int nevent_save(NP2FFILE *f, int
return(flagsave_save(f, &nit, sizeof(nit)));	return(flagsave_save(f, &nit, sizeof(nit)));
}	}

static int flagsave_evt(NP2FFILE f, const STENTRY t) {	static int flagsave_evt(NP2FFILE f, const STENTRY *t) {

NEVTSAVE nevt;	NEVTSAVE nevt;
int ret;	int ret;
UINT i;	UINT i;

nevt.remainclock = nevent.remainclock;
nevt.baseclock = nevent.baseclock;
nevt.clock = nevent.clock;
nevt.readyevents = nevent.readyevents;	nevt.readyevents = nevent.readyevents;
nevt.waitevents = nevent.waitevents;	nevt.waitevents = nevent.waitevents;

Line 560 static int flagsave_evt(NP2FFILE *f, con	Line 655 static int flagsave_evt(NP2FFILE *f, con
return(ret);	return(ret);
}	}

static int nevent_load(NP2FFILE f, UINT tbl, UINT *pos) {	static int nevent_load(NP2FFILE f, UINT tbl, UINT pos) {

int ret;	int ret;
NEVTITEM nit;	NEVTITEM nit;
Line 593 static int nevent_load(NP2FFILE *f, UINT	Line 688 static int nevent_load(NP2FFILE *f, UINT
return(ret);	return(ret);
}	}

static int flagload_evt(NP2FFILE f, const STENTRY t) {	static int flagload_evt(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;
NEVTSAVE nevt;	NEVTSAVE nevt;
Line 601 static int flagload_evt(NP2FFILE *f, con	Line 696 static int flagload_evt(NP2FFILE *f, con

ret = flagload_load(f, &nevt, sizeof(nevt));	ret = flagload_load(f, &nevt, sizeof(nevt));

nevent.remainclock = nevt.remainclock;
nevent.baseclock = nevt.baseclock;
nevent.clock = nevt.clock;
nevent.readyevents = 0;	nevent.readyevents = 0;
nevent.waitevents = 0;	nevent.waitevents = 0;

Line 618 static int flagload_evt(NP2FFILE *f, con	Line 710 static int flagload_evt(NP2FFILE *f, con
}	}


// ----	// ---- gaiji

static int flagsave_gij(NP2FFILE f, const STENTRY t) {	static int flagsave_gij(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;
int i;	int i;
Line 630 static int flagsave_gij(NP2FFILE *f, con	Line 722 static int flagsave_gij(NP2FFILE *f, con
ret = flagsave_create(f, t);	ret = flagsave_create(f, t);
if (ret != NP2FLAG_FAILURE) {	if (ret != NP2FLAG_FAILURE) {
for (i=0; i<2; i++) {	for (i=0; i<2; i++) {
fnt = font + ((0x56 + (i << 7)) << 4);	fnt = fontrom + ((0x56 + (i << 7)) << 4);
for (j=0; j<0x80; j++) {	for (j=0; j<0x80; j++) {
ret \|= flagsave_save(f, fnt, 32);	ret \|= flagsave_save(f, fnt, 32);
fnt += 0x1000;	fnt += 0x1000;
Line 641 static int flagsave_gij(NP2FFILE *f, con	Line 733 static int flagsave_gij(NP2FFILE *f, con
return(ret);	return(ret);
}	}

static int flagload_gij(NP2FFILE f, const STENTRY t) {	static int flagload_gij(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;
int i;	int i;
Line 650 static int flagload_gij(NP2FFILE *f, con	Line 742 static int flagload_gij(NP2FFILE *f, con

ret = 0;	ret = 0;
for (i=0; i<2; i++) {	for (i=0; i<2; i++) {
fnt = font + ((0x56 + (i << 7)) << 4);	fnt = fontrom + ((0x56 + (i << 7)) << 4);
for (j=0; j<0x80; j++) {	for (j=0; j<0x80; j++) {
ret \|= flagload_load(f, fnt, 32);	ret \|= flagload_load(f, fnt, 32);
fnt += 0x1000;	fnt += 0x1000;
Line 661 static int flagload_gij(NP2FFILE *f, con	Line 753 static int flagload_gij(NP2FFILE *f, con
}	}


// -----	// ---- FM

enum {	enum {
FLAG_MG = 0x0001,	FLAG_MG = 0x0001,
Line 671 enum {	Line 763 enum {
FLAG_FM2B = 0x0010,	FLAG_FM2B = 0x0010,
FLAG_PSG1 = 0x0020,	FLAG_PSG1 = 0x0020,
FLAG_PSG2 = 0x0040,	FLAG_PSG2 = 0x0040,
FLAG_RHYTHM = 0x0080,	FLAG_PSG3 = 0x0080,
FLAG_ADPCM = 0x0100,	FLAG_RHYTHM = 0x0100,
FLAG_PCM86 = 0x0200,	FLAG_ADPCM = 0x0200,
FLAG_CS4231 = 0x0400	FLAG_PCM86 = 0x0400,
	FLAG_CS4231 = 0x0800
};	};

typedef struct {	typedef struct {
Line 682 typedef struct {	Line 775 typedef struct {
BYTE extop[4];	BYTE extop[4];
} OPNKEY;	} OPNKEY;

static int flagsave_fm(NP2FFILE f, const STENTRY t) {	static int flagsave_fm(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;
UINT saveflg;	UINT saveflg;
Line 727 static int flagsave_fm(NP2FFILE *f, cons	Line 820 static int flagsave_fm(NP2FFILE *f, cons
FLAG_PSG1 \| FLAG_RHYTHM \| FLAG_ADPCM;	FLAG_PSG1 \| FLAG_RHYTHM \| FLAG_ADPCM;
break;	break;

	case 0x80:
	saveflg = FLAG_PSG1 \| FLAG_PSG2 \| FLAG_PSG3;
	break;

default:	default:
saveflg = 0;	saveflg = 0;
break;	break;
Line 755 static int flagsave_fm(NP2FFILE *f, cons	Line 852 static int flagsave_fm(NP2FFILE *f, cons
if (saveflg & FLAG_PSG2) {	if (saveflg & FLAG_PSG2) {
ret \|= flagsave_save(f, &psg2.reg, sizeof(PSGREG));	ret \|= flagsave_save(f, &psg2.reg, sizeof(PSGREG));
}	}
	if (saveflg & FLAG_PSG3) {
	ret \|= flagsave_save(f, &psg3.reg, sizeof(PSGREG));
	}
if (saveflg & FLAG_ADPCM) {	if (saveflg & FLAG_ADPCM) {
ret \|= flagsave_save(f, &adpcm, sizeof(adpcm));	ret \|= flagsave_save(f, &adpcm, sizeof(adpcm));
}	}
Line 769 static int flagsave_fm(NP2FFILE *f, cons	Line 869 static int flagsave_fm(NP2FFILE *f, cons
return(ret);	return(ret);
}	}

static void play_fmreg(BYTE num) {	static void play_fmreg(BYTE num, UINT reg) {

UINT chbase;	UINT chbase;
UINT reg;
UINT i;	UINT i;

chbase = num * 3;	chbase = num * 3;
reg = num * 0x100;
for (i=0x30; i<0xa0; i++) {	for (i=0x30; i<0xa0; i++) {
opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);	opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);
}	}
Line 797 static void play_psgreg(PSGGEN psg) {	Line 895 static void play_psgreg(PSGGEN psg) {
}	}
}	}

static int flagload_fm(NP2FFILE f, const STENTRY t) {	static int flagload_fm(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;
UINT saveflg;	UINT saveflg;
OPNKEY opnkey;	OPNKEY opnkey;
	UINT fmreg1a;
	UINT fmreg1b;
	UINT fmreg2a;
	UINT fmreg2b;

opngen_reset();	opngen_reset();
psggen_reset(&psg1);	psggen_reset(&psg1);
Line 815 static int flagload_fm(NP2FFILE *f, cons	Line 917 static int flagload_fm(NP2FFILE *f, cons
ret = flagload_load(f, &usesound, sizeof(usesound));	ret = flagload_load(f, &usesound, sizeof(usesound));
fmboard_reset((BYTE)usesound);	fmboard_reset((BYTE)usesound);

	fmreg1a = 0x000;
	fmreg1b = 0x100;
	fmreg2a = 0x200;
	fmreg2b = 0x300;
switch(usesound) {	switch(usesound) {
case 0x01:	case 0x01:
saveflg = FLAG_MG;	saveflg = FLAG_MG;
Line 832 static int flagload_fm(NP2FFILE *f, cons	Line 938 static int flagload_fm(NP2FFILE *f, cons
case 0x06:	case 0x06:
saveflg = FLAG_FM1A \| FLAG_FM1B \| FLAG_FM2A \| FLAG_PSG1 \|	saveflg = FLAG_FM1A \| FLAG_FM1B \| FLAG_FM2A \| FLAG_PSG1 \|
FLAG_PSG2 \| FLAG_RHYTHM \| FLAG_PCM86;	FLAG_PSG2 \| FLAG_RHYTHM \| FLAG_PCM86;
	fmreg1a = 0x200; // ��ž��Ƥ�Τ��
	fmreg1b = 0x000;
	fmreg2a = 0x100;
break;	break;

case 0x08:	case 0x08:
Line 854 static int flagload_fm(NP2FFILE *f, cons	Line 963 static int flagload_fm(NP2FFILE *f, cons
FLAG_PSG1 \| FLAG_RHYTHM \| FLAG_ADPCM;	FLAG_PSG1 \| FLAG_RHYTHM \| FLAG_ADPCM;
break;	break;

	case 0x80:
	saveflg = FLAG_PSG1 \| FLAG_PSG2 \| FLAG_PSG3;
	break;

default:	default:
	saveflg = 0;
break;	break;
}	}

Line 879 static int flagload_fm(NP2FFILE *f, cons	Line 993 static int flagload_fm(NP2FFILE *f, cons
if (saveflg & FLAG_PSG2) {	if (saveflg & FLAG_PSG2) {
ret \|= flagload_load(f, &psg2.reg, sizeof(PSGREG));	ret \|= flagload_load(f, &psg2.reg, sizeof(PSGREG));
}	}
	if (saveflg & FLAG_PSG3) {
	ret \|= flagload_load(f, &psg3.reg, sizeof(PSGREG));
	}
if (saveflg & FLAG_ADPCM) {	if (saveflg & FLAG_ADPCM) {
ret \|= flagload_load(f, &adpcm, sizeof(adpcm));	ret \|= flagload_load(f, &adpcm, sizeof(adpcm));
}	}
Line 902 static int flagload_fm(NP2FFILE *f, cons	Line 1019 static int flagload_fm(NP2FFILE *f, cons
}	}

if (saveflg & FLAG_FM1A) {	if (saveflg & FLAG_FM1A) {
play_fmreg(0);	play_fmreg(0, fmreg1a);
}	}
if (saveflg & FLAG_FM1B) {	if (saveflg & FLAG_FM1B) {
play_fmreg(1);	play_fmreg(1, fmreg1b);
}	}
if (saveflg & FLAG_FM2A) {	if (saveflg & FLAG_FM2A) {
play_fmreg(2);	play_fmreg(2, fmreg2a);
}	}
if (saveflg & FLAG_FM2B) {	if (saveflg & FLAG_FM2B) {
play_fmreg(3);	play_fmreg(3, fmreg2b);
}	}
if (saveflg & FLAG_PSG1) {	if (saveflg & FLAG_PSG1) {
play_psgreg(&psg1);	play_psgreg(&psg1);
Line 919 static int flagload_fm(NP2FFILE *f, cons	Line 1036 static int flagload_fm(NP2FFILE *f, cons
if (saveflg & FLAG_PSG2) {	if (saveflg & FLAG_PSG2) {
play_psgreg(&psg2);	play_psgreg(&psg2);
}	}
	if (saveflg & FLAG_PSG3) {
	play_psgreg(&psg3);
	}
(void)t;	(void)t;
return(ret);	return(ret);
}	}
Line 933 typedef struct {	Line 1053 typedef struct {
DOSTIME time;	DOSTIME time;
} STATDISK;	} STATDISK;

static int disksave(NP2FFILE f, const char path, int readonly) {	static const char str_fddx[] = "FDD%u";
	static const char str_sasix[] = "SASI%u";
	static const char str_scsix[] = "SCSI%u";
	static const char str_updated[] = "%s: updated" CRLITERAL;
	static const char str_notfound[] = "%s: not found" CRLITERAL;

	static int disksave(NP2FFILE f, const char *path, int readonly) {

STATDISK st;	STATDISK st;
FILEH fh;	FILEH fh;
Line 951 static int disksave(NP2FFILE *f, const c	Line 1077 static int disksave(NP2FFILE *f, const c
return(flagsave_save(f, &st, sizeof(st)));	return(flagsave_save(f, &st, sizeof(st)));
}	}

static int flagsave_disk(NP2FFILE f, const STENTRY t) {	static int flagsave_disk(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;
BYTE i;	BYTE i;
Line 973 static int flagsave_disk(NP2FFILE *f, co	Line 1099 static int flagsave_disk(NP2FFILE *f, co
return(ret);	return(ret);
}	}

static int diskcheck(NP2FFILE f, const char name, ERR_BUF *e) {	static int diskcheck(NP2FFILE f, const char name, ERR_BUF e) {

int ret;	int ret;
FILEH fh;	FILEH fh;
Line 991 static int diskcheck(NP2FFILE *f, const	Line 1117 static int diskcheck(NP2FFILE *f, const
if ((memcmp(&st.date, &date, sizeof(date))) \|\|	if ((memcmp(&st.date, &date, sizeof(date))) \|\|
(memcmp(&st.time, &time, sizeof(time)))) {	(memcmp(&st.time, &time, sizeof(time)))) {
ret \|= NP2FLAG_DISKCHG;	ret \|= NP2FLAG_DISKCHG;
SPRINTF(buf, "%s: updated\n", name);	SPRINTF(buf, str_updated, name);
err_append(e, buf);	err_append(e, buf);
}	}
}	}
else {	else {
ret \|= NP2FLAG_DISKCHG;	ret \|= NP2FLAG_DISKCHG;
SPRINTF(buf, "%s: not found\n", name);	SPRINTF(buf, str_notfound, name);
err_append(e, buf);	err_append(e, buf);
}	}
}	}
return(ret);	return(ret);
}	}

static int flagcheck_disk(NP2FFILE f, const STENTRY t, ERR_BUF *e) {	static int flagcheck_disk(NP2FFILE f, const STENTRY t, ERR_BUF e) {

int ret;	int ret;
int i;	int i;
Line 1012 static int flagcheck_disk(NP2FFILE *f, c	Line 1138 static int flagcheck_disk(NP2FFILE *f, c

ret = 0;	ret = 0;
for (i=0; i<4; i++) {	for (i=0; i<4; i++) {
SPRINTF(buf, "FDD%d", i+1);	SPRINTF(buf, str_fddx, i+1);
ret \|= diskcheck(f, buf, e);	ret \|= diskcheck(f, buf, e);
}	}
sxsi_flash();	sxsi_flash();
for (i=0; i<2; i++) {	for (i=0; i<2; i++) {
SPRINTF(buf, "SASI%u", i+1);	SPRINTF(buf, str_sasix, i+1);
ret \|= diskcheck(f, buf, e);	ret \|= diskcheck(f, buf, e);
}	}
for (i=0; i<2; i++) {	for (i=0; i<2; i++) {
SPRINTF(buf, "SCSI%d", i+1);	SPRINTF(buf, str_scsix, i+1);
ret \|= diskcheck(f, buf, e);	ret \|= diskcheck(f, buf, e);
}	}
(void)t;	(void)t;
return(ret);	return(ret);
}	}

static int flagload_disk(NP2FFILE f, const STENTRY t) {	static int flagload_disk(NP2FFILE f, const STENTRY *t) {

int ret;	int ret;
BYTE i;	BYTE i;
Line 1061 static int flagload_disk(NP2FFILE *f, co	Line 1187 static int flagload_disk(NP2FFILE *f, co
}	}


// -----	// ---- com

#ifdef _MIDICH	static int flagsave_com(NP2FFILE f, const STENTRY *t) {
static int flagsave_midi(NP2FFILE f, const STENTRY t) {

UINT device;	UINT device;
COMMNG cm;	COMMNG cm;
int ret;	int ret;
_MIDICH mch[16];	COMFLAG flag;

device = (UINT)t->arg1;	device = (UINT)t->arg1;
switch(device) {	switch(device) {
Line 1086 static int flagsave_midi(NP2FFILE *f, co	Line 1211 static int flagsave_midi(NP2FFILE *f, co
break;	break;
}	}
ret = NP2FLAG_SUCCESS;	ret = NP2FLAG_SUCCESS;
if ((cm != NULL) && (cm->msg(cm, COMMSG_MIDISTATGET, (long)mch))) {	if (cm) {
ret = flagsave_create(f, t);	flag = (COMFLAG)cm->msg(cm, COMMSG_GETFLAG, 0);
if (ret != NP2FLAG_FAILURE) {	if (flag) {
ret \|= flagsave_save(f, mch, sizeof(mch));	ret = flagsave_create(f, t);
ret \|= flagsave_close(f);	if (ret != NP2FLAG_FAILURE) {
	ret \|= flagsave_save(f, flag, flag->size);
	ret \|= flagsave_close(f);
	}
	_MFREE(flag);
}	}
}	}
return(ret);	return(ret);
}	}

static int flagload_midi(NP2FFILE f, const STENTRY t) {	static int flagload_com(NP2FFILE f, const STENTRY *t) {

_MIDICH mch[16];	UINT device;
UINT device;	COMMNG cm;
COMMNG cm;	int ret;
int ret;	_COMFLAG fhdr;
	COMFLAG flag;

ret = flagload_load(f, mch, sizeof(mch));	ret = flagload_load(f, &fhdr, sizeof(fhdr));
if (ret != NP2FLAG_FAILURE) {	if (ret != NP2FLAG_SUCCESS) {
device = (UINT)t->arg1;	goto flcom_err1;
switch(device) {	}
case 0:	if (fhdr.size < sizeof(fhdr)) {
commng_destroy(cm_mpu98);	goto flcom_err1;
cm = commng_create(COMCREATE_MPU98II);	}
cm_mpu98 = cm;	flag = (COMFLAG)_MALLOC(fhdr.size, "com stat flag");
break;	if (flag == NULL) {
	goto flcom_err1;
	}
	CopyMemory(flag, &fhdr, sizeof(fhdr));
	ret \|= flagload_load(f, flag + 1, fhdr.size - sizeof(fhdr));
	if (ret != NP2FLAG_SUCCESS) {
	goto flcom_err2;
	}

case 1:	device = (UINT)t->arg1;
commng_destroy(cm_rs232c);	switch(device) {
cm = commng_create(COMCREATE_SERIAL);	case 0:
cm_rs232c = cm;	commng_destroy(cm_mpu98);
break;	cm = commng_create(COMCREATE_MPU98II);
	cm_mpu98 = cm;
	break;

default:	case 1:
cm = NULL;	commng_destroy(cm_rs232c);
break;	cm = commng_create(COMCREATE_SERIAL);
}	cm_rs232c = cm;
if (cm) {	break;
cm->msg(cm, COMMSG_MIDISTATSET, (long)mch);
}	default:
	cm = NULL;
	break;
}	}
	if (cm) {
	cm->msg(cm, COMMSG_SETFLAG, (long)flag);
	}

	flcom_err2:
	_MFREE(flag);

	flcom_err1:
return(ret);	return(ret);
}	}
#endif


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

static int flagcheck_versize(NP2FFILE f, const STENTRY t, ERR_BUF *e) {	static int flagcheck_versize(NP2FFILE f, const STENTRY t, ERR_BUF e) {

if ((f) && (t)) {	if ((f) && (t)) {
if ((f->p.ver == t->ver) && (f->p.size == t->arg2)) {	if ((f->p.ver == t->ver) && (f->p.size == t->arg2)) {
Line 1146 static int flagcheck_versize(NP2FFILE *f	Line 1294 static int flagcheck_versize(NP2FFILE *f
return(NP2FLAG_FAILURE);	return(NP2FLAG_FAILURE);
}	}

static int flagcheck_veronly(NP2FFILE f, const STENTRY t, ERR_BUF *e) {	static int flagcheck_veronly(NP2FFILE f, const STENTRY t, ERR_BUF e) {

if ((f) && (t)) {	if ((f) && (t)) {
if (f->p.ver == t->ver) {	if (f->p.ver == t->ver) {
Line 1163 static int flagcheck_veronly(NP2FFILE *f	Line 1311 static int flagcheck_veronly(NP2FFILE *f

int statsave_save(const char *filename) {	int statsave_save(const char *filename) {

NP2FFILE f;	_NP2FFILE f;
int ret;	int ret;
UINT i;	const STENTRY *tbl;
	const STENTRY *tblterm;

ret = flagcreate(&f, filename);	ret = flagcreate(&f, filename);
if (ret == NP2FLAG_FAILURE) {	if (ret == NP2FLAG_FAILURE) {
return(ret);	return(ret);
}	}
for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {	tbl = np2tbl;
switch(np2tbl[i].type) {	tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
	while(tbl < tblterm) {
	switch(tbl->type) {
case NP2FLAG_BIN:	case NP2FLAG_BIN:
case NP2FLAG_CORE:	case NP2FLAG_CLOCK:
case NP2FLAG_BEEP:	ret \|= flagsave_common(&f, tbl);
ret \|= flagsave_common(&f, &np2tbl[i]);
break;	break;

case NP2FLAG_TERM:	case NP2FLAG_TERM:
ret \|= flagsave_term(&f, &np2tbl[i]);	ret \|= flagsave_term(&f, tbl);
	break;

	#if defined(CGWND_FONTPTR)
	case NP2FLAG_CGW:
	ret \|= flagsave_cgwnd(&f, tbl);
	break;
	#endif

	case NP2FLAG_COM:
	ret \|= flagsave_com(&f, tbl);
	break;

	case NP2FLAG_DISK:
	ret \|= flagsave_disk(&f, tbl);
break;	break;

case NP2FLAG_DMA:	case NP2FLAG_DMA:
ret \|= flagsave_dma(&f, &np2tbl[i]);	ret \|= flagsave_dma(&f, tbl);
break;	break;

case NP2FLAG_EGC:	case NP2FLAG_EGC:
ret \|= flagsave_egc(&f, &np2tbl[i]);	ret \|= flagsave_egc(&f, tbl);
break;	break;

case NP2FLAG_EXT:	case NP2FLAG_EPSON:
ret \|= flagsave_ext(&f, &np2tbl[i]);	ret \|= flagsave_epson(&f, tbl);
break;	break;

case NP2FLAG_EVT:	case NP2FLAG_EVT:
ret \|= flagsave_evt(&f, &np2tbl[i]);	ret \|= flagsave_evt(&f, tbl);
break;	break;

case NP2FLAG_GIJ:	case NP2FLAG_EXT:
ret \|= flagsave_gij(&f, &np2tbl[i]);	ret \|= flagsave_ext(&f, tbl);
break;	break;

case NP2FLAG_FM:	case NP2FLAG_FM:
ret \|= flagsave_fm(&f, &np2tbl[i]);	ret \|= flagsave_fm(&f, tbl);
break;	break;

case NP2FLAG_DISK:	case NP2FLAG_GIJ:
ret \|= flagsave_disk(&f, &np2tbl[i]);	ret \|= flagsave_gij(&f, tbl);
break;	break;

#if defined(MIDICH)	case NP2FLAG_MEM:
case NP2FLAG_MIDI:	ret \|= flagsave_mem(&f, tbl);
ret \|= flagsave_midi(&f, &np2tbl[i]);
break;	break;
#endif
}	}
	tbl++;
}	}
flagclose(&f);	flagclose(&f);
return(ret);	return(ret);
Line 1224 int statsave_save(const char *filename)	Line 1387 int statsave_save(const char *filename)

int statsave_check(const char filename, char buf, int size) {	int statsave_check(const char filename, char buf, int size) {

NP2FFILE f;	ERR_BUF e;
	_NP2FFILE f;
int ret;	int ret;
UINT i;
BOOL done;	BOOL done;
ERR_BUF e;	const STENTRY *tbl;
	const STENTRY *tblterm;

e.buf = buf;	e.buf = buf;
e.remain = size;	e.remain = size;
Line 1250 int statsave_check(const char *filename,	Line 1414 int statsave_check(const char *filename,
ret \|= flagload_create(&f);	ret \|= flagload_create(&f);
CopyMemory(index, f.p.index, sizeof(f.p.index));	CopyMemory(index, f.p.index, sizeof(f.p.index));
index[10] = 0;	index[10] = 0;
for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {	tbl = np2tbl;
if (!strcmp(index, np2tbl[i].index)) {	tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
	while(tbl < tblterm) {
	if (!strcmp(index, tbl->index)) {
break;	break;
}	}
	tbl++;
}	}
if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {	if (tbl < tblterm) {
switch(np2tbl[i].type) {	switch(tbl->type) {
case NP2FLAG_BIN:	case NP2FLAG_BIN:
ret \|= flagcheck_versize(&f, &np2tbl[i], &e);	#if defined(CGWND_FONTPTR)
	case NP2FLAG_CGW:
	#endif
	case NP2FLAG_CLOCK:
	case NP2FLAG_MEM:
	ret \|= flagcheck_versize(&f, tbl, &e);
break;	break;

case NP2FLAG_TERM:	case NP2FLAG_TERM:
done = TRUE;	done = TRUE;
break;	break;

case NP2FLAG_CORE:	case NP2FLAG_COM:
case NP2FLAG_DMA:	case NP2FLAG_DMA:
case NP2FLAG_EGC:	case NP2FLAG_EGC:
case NP2FLAG_EXT:	case NP2FLAG_EPSON:
case NP2FLAG_EVT:	case NP2FLAG_EVT:
	case NP2FLAG_EXT:
case NP2FLAG_GIJ:	case NP2FLAG_GIJ:
case NP2FLAG_BEEP:	case NP2FLAG_FM:
#if defined(MIDICH)	ret \|= flagcheck_veronly(&f, tbl, &e);
case NP2FLAG_MIDI:
#endif
ret \|= flagcheck_veronly(&f, &np2tbl[i], &e);
break;	break;

case NP2FLAG_DISK:	case NP2FLAG_DISK:
ret \|= flagcheck_disk(&f, &np2tbl[i], &e);	ret \|= flagcheck_disk(&f, tbl, &e);
break;

case NP2FLAG_FM: // ver0.31
break;	break;

default:	default:
Line 1305 int statsave_check(const char *filename,	Line 1472 int statsave_check(const char *filename,

int statsave_load(const char *filename) {	int statsave_load(const char *filename) {

NP2FFILE f;	_NP2FFILE f;
int ret;	int ret;
UINT i;
BOOL done;	BOOL done;
	const STENTRY *tbl;
	const STENTRY *tblterm;

ret = flagopen(&f, filename, NULL);	ret = flagopen(&f, filename, NULL);
if (ret == NP2FLAG_FAILURE) {	if (ret == NP2FLAG_FAILURE) {
Line 1320 int statsave_load(const char *filename)	Line 1488 int statsave_load(const char *filename)
mpu98ii_midipanic();	mpu98ii_midipanic();
pc9861k_midipanic();	pc9861k_midipanic();
sound_reset();	sound_reset();
	#if defined(SUPPORT_WAVEMIX)
	wavemix_bind();
	#endif
fmboard_reset(0);	fmboard_reset(0);

done = FALSE;	done = FALSE;
Line 1328 int statsave_load(const char *filename)	Line 1499 int statsave_load(const char *filename)
ret \|= flagload_create(&f);	ret \|= flagload_create(&f);
CopyMemory(index, f.p.index, sizeof(f.p.index));	CopyMemory(index, f.p.index, sizeof(f.p.index));
index[10] = 0;	index[10] = 0;
for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {	tbl = np2tbl;
if (!strcmp(index, np2tbl[i].index)) {	tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
	while(tbl < tblterm) {
	if (!strcmp(index, tbl->index)) {
break;	break;
}	}
	tbl++;
}	}
if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {	if (tbl < tblterm) {
switch(np2tbl[i].type) {	switch(tbl->type) {
case NP2FLAG_BIN:	case NP2FLAG_BIN:
case NP2FLAG_BEEP:	ret \|= flagload_common(&f, tbl);
ret \|= flagload_common(&f, &np2tbl[i]);
break;	break;

case NP2FLAG_TERM:	case NP2FLAG_TERM:
done = TRUE;	done = TRUE;
break;	break;

case NP2FLAG_CORE:	#if defined(CGWND_FONTPTR)
ret \|= flagload_core(&f, &np2tbl[i]);	case NP2FLAG_CGW:
	ret \|= flagload_cgwnd(&f, tbl);
	break;
	#endif

	case NP2FLAG_CLOCK:
	ret \|= flagload_clock(&f, tbl);
	break;

	case NP2FLAG_COM:
	ret \|= flagload_com(&f, tbl);
	break;

	case NP2FLAG_DISK:
	ret \|= flagload_disk(&f, tbl);
break;	break;

case NP2FLAG_DMA:	case NP2FLAG_DMA:
ret \|= flagload_dma(&f, &np2tbl[i]);	ret \|= flagload_dma(&f, tbl);
break;	break;

case NP2FLAG_EGC:	case NP2FLAG_EGC:
ret \|= flagload_egc(&f, &np2tbl[i]);	ret \|= flagload_egc(&f, tbl);
break;	break;

case NP2FLAG_EXT:	case NP2FLAG_EPSON:
ret \|= flagload_ext(&f, &np2tbl[i]);	ret \|= flagload_epson(&f, tbl);
break;	break;

case NP2FLAG_EVT:	case NP2FLAG_EVT:
ret \|= flagload_evt(&f, &np2tbl[i]);	ret \|= flagload_evt(&f, tbl);
break;	break;

case NP2FLAG_GIJ:	case NP2FLAG_EXT:
ret \|= flagload_gij(&f, &np2tbl[i]);	ret \|= flagload_ext(&f, tbl);
break;	break;

case NP2FLAG_FM:	case NP2FLAG_FM:
ret \|= flagload_fm(&f, &np2tbl[i]);	ret \|= flagload_fm(&f, tbl);
break;	break;

case NP2FLAG_DISK:	case NP2FLAG_GIJ:
ret \|= flagload_disk(&f, &np2tbl[i]);	ret \|= flagload_gij(&f, tbl);
break;	break;

#if defined(MIDICH)	case NP2FLAG_MEM:
case NP2FLAG_MIDI:	ret \|= flagload_mem(&f, tbl);
ret \|= flagload_midi(&f, &np2tbl[i]);
break;	break;
#endif

default:	default:
ret \|= NP2FLAG_WARNING;	ret \|= NP2FLAG_WARNING;
Line 1395 int statsave_load(const char *filename)	Line 1580 int statsave_load(const char *filename)
flagclose(&f);	flagclose(&f);

// I/O��ľ��	// I/O��ľ��
	i286_memorymap((pc.model & PCMODEL_EPSON)?1:0);
iocore_build();	iocore_build();
iocore_bind();	iocore_bind();
cbuscore_bind();	cbuscore_bind();
Line 1407 int statsave_load(const char *filename)	Line 1593 int statsave_load(const char *filename)
gdcs.palchange = GDCSCRN_REDRAW;	gdcs.palchange = GDCSCRN_REDRAW;
tramflag.renewal = 1;	tramflag.renewal = 1;
cgwindow.writable \|= 0x80;	cgwindow.writable \|= 0x80;
	#if defined(CPUSTRUC_FONTPTR)
	FONTPTR_LOW = fontrom + cgwindow.low;
	FONTPTR_HIGH = fontrom + cgwindow.high;
	#endif
i286_vram_dispatch(vramop.operate);	i286_vram_dispatch(vramop.operate);
soundmng_play();	soundmng_play();

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

Removed from v.1.4
changed lines
	Added in v.1.26