np2/statsave.c - diff

Return to statsave.c CVS log

Up to [RetroPC.NET] / np2

Diff for /np2/statsave.c between versions 1.33 and 1.49

version 1.33, 2004/01/26 14:57:20	version 1.49, 2005/05/15 18:48:36
Line 8	Line 8
#include "cpucore.h"	#include "cpucore.h"
#include "pccore.h"	#include "pccore.h"
#include "iocore.h"	#include "iocore.h"
	#include "gdc_sub.h"
#include "cbuscore.h"	#include "cbuscore.h"
	#include "ideio.h"
#include "sasiio.h"	#include "sasiio.h"
#include "scsiio.h"	#include "scsiio.h"
#include "pc9861k.h"	#include "pc9861k.h"
Line 29	Line 31
#include "keydisp.h"	#include "keydisp.h"
#include "hostdrv.h"	#include "hostdrv.h"
#include "calendar.h"	#include "calendar.h"
	#include "keystat.h"

#if defined(MACOS)	#if defined(MACOS)
#define CRCONST str_cr	#define CRCONST str_cr
Line 58 enum {	Line 61 enum {
STATFLAG_CGW,	STATFLAG_CGW,
#endif	#endif
STATFLAG_COM,	STATFLAG_COM,
STATFLAG_DISK,
STATFLAG_DMA,	STATFLAG_DMA,
STATFLAG_EGC,	STATFLAG_EGC,
STATFLAG_EPSON,	STATFLAG_EPSON,
STATFLAG_EVT,	STATFLAG_EVT,
STATFLAG_EXT,	STATFLAG_EXT,
	STATFLAG_FDD,
STATFLAG_FM,	STATFLAG_FM,
STATFLAG_GIJ,	STATFLAG_GIJ,
#if defined(SUPPORT_HOSTDRV)	#if defined(SUPPORT_HOSTDRV)
STATFLAG_HDRV,	STATFLAG_HDRV,
#endif	#endif
STATFLAG_MEM	STATFLAG_MEM,
	STATFLAG_SXSI
};	};

typedef struct {	typedef struct {
Line 93 extern COMMNG cm_mpu98;	Line 97 extern COMMNG cm_mpu98;
extern COMMNG cm_rs232c;	extern COMMNG cm_rs232c;

typedef struct {	typedef struct {
char *buf;	OEMCHAR *buf;
int remain;	int remain;
} ERR_BUF;	} ERR_BUF;


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

// 関数ポインタを intに変更。
static BOOL proc2num(void func, const PROCTBL tbl, int size) {

int i;

for (i=0; i<size; i++) {
if ((long )func == (long)tbl->proc) {
(long )func = (long)tbl->id;
return(SUCCESS);
}
tbl++;
}
return(FAILURE);
}

static BOOL num2proc(void func, const PROCTBL tbl, int size) {

int i;

for (i=0; i<size; i++) {
if ((long )func == (long)tbl->id) {
(long )func = (long)tbl->proc;
return(SUCCESS);
}
tbl++;
}
return(FAILURE);
}


// ----

enum {	enum {
SFFILEH_WRITE = 0x0001,	SFFILEH_WRITE = 0x0001,
SFFILEH_BLOCK = 0x0002,	SFFILEH_BLOCK = 0x0002,
Line 143 typedef struct {	Line 115 typedef struct {
UINT stat;	UINT stat;
FILEH fh;	FILEH fh;
UINT secpos;	UINT secpos;

// long pos;
// long bak;
// long next;
NP2FHDR f;	NP2FHDR f;
// NP2FENT p;	} _SFFILEH, *SFFILEH;
} _NP2FFILE, NP2FFILE, _SFFILEH, SFFILEH;

static SFFILEH statflag_open(const char filename, char err, int errlen) {	static SFFILEH statflag_open(const OEMCHAR filename, OEMCHAR err, int errlen) {

FILEH fh;	FILEH fh;
SFFILEH ret;	SFFILEH ret;
Line 188 sfo_err1:	Line 155 sfo_err1:
static int statflag_closesection(SFFILEH sffh) {	static int statflag_closesection(SFFILEH sffh) {

UINT leng;	UINT leng;
BYTE zero[16];	UINT8 zero[16];

if (sffh == NULL) {	if (sffh == NULL) {
goto sfcs_err1;	goto sfcs_err1;
Line 263 sfr_err:	Line 230 sfr_err:
return(STATFLAG_FAILURE);	return(STATFLAG_FAILURE);
}	}

static SFFILEH statflag_create(const char *filename) {	static SFFILEH statflag_create(const OEMCHAR *filename) {

SFFILEH ret;	SFFILEH ret;
FILEH fh;	FILEH fh;
Line 357 static void statflag_close(SFFILEH sffh)	Line 324 static void statflag_close(SFFILEH sffh)
}	}
}	}

void statflag_seterr(STFLAGH sfh, const char *str) {	void statflag_seterr(STFLAGH sfh, const OEMCHAR *str) {

if ((sfh) && (sfh->errlen)) {	if ((sfh) && (sfh->errlen)) {
milstr_ncat(sfh->err, str, sfh->errlen);	milstr_ncat(sfh->err, str, sfh->errlen);
Line 366 void statflag_seterr(STFLAGH sfh, const	Line 333 void statflag_seterr(STFLAGH sfh, const
}	}


	// ---- function

	// 関数ポインタを intに変更。
	static BRESULT proc2num(void func, const PROCTBL tbl, int size) {

#if 0	int i;
static int flagopen(NP2FFILE f, const char filename, ERR_BUF e) {

if (f) {	for (i=0; i<size; i++) {
f->fh = file_open(filename);	if ((long )func == (long)tbl->proc) {
if (f->fh == FILEH_INVALID) {	(long )func = (long)tbl->id;
return(STATFLAG_FAILURE);	return(SUCCESS);
}
if (file_read(f->fh, &f->f, sizeof(NP2FHDR))
!= sizeof(NP2FHDR)) {
file_close(f->fh);
return(STATFLAG_FAILURE);
}
f->pos = sizeof(NP2FHDR);
if (strcmp(f->f.name, np2flagdef.name)) {
file_close(f->fh);
return(STATFLAG_FAILURE);
}
if (strcmp(f->f.vername, np2flagdef.vername)) {
#if 1
file_close(f->fh);
return(STATFLAG_FAILURE);
#else
return(STATFLAG_VERSION); // 他形式を読むのであれば…
#endif
}
if (f->f.ver != np2flagdef.ver) {
#if 1
file_close(f->fh);
return(STATFLAG_FAILURE);
#else
return(STATFLAG_VERSION); // 他verを読むのであれば…
#endif
}	}
return(STATFLAG_SUCCESS);	tbl++;
}	}
(void)e;	return(FAILURE);
return(STATFLAG_FAILURE);
}	}

static int flagcreate(NP2FFILE f, const char *filename) {	static BRESULT num2proc(void func, const PROCTBL tbl, int size) {

if (f) {
f->fh = file_create(filename);
if (f->fh == FILEH_INVALID) {
return(STATFLAG_FAILURE);
}
if (file_write(f->fh, &np2flagdef, sizeof(NP2FHDR))
!= sizeof(NP2FHDR)) {
file_close(f->fh);
return(STATFLAG_FAILURE);
}
f->pos = sizeof(NP2FHDR);
return(STATFLAG_SUCCESS);
}
return(STATFLAG_FAILURE);
}

static int flagload_create(NP2FFILE f) {	int i;

if (f) {	for (i=0; i<size; i++) {
ZeroMemory(&f->p, sizeof(NP2FENT));	if ((long )func == (long)tbl->id) {
if (f->pos & 15) {	(long )func = (long)tbl->proc;
f->pos += 15;	return(SUCCESS);
f->pos &= ~0xf;
if (file_seek(f->fh, f->pos, 0) != f->pos) {
return(STATFLAG_FAILURE);
}
}
if (file_read(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {
return(STATFLAG_FAILURE);
}	}
f->pos += sizeof(NP2FENT);	tbl++;
f->next = f->pos + f->p.size;
return(STATFLAG_SUCCESS);
}	}
return(STATFLAG_FAILURE);	return(FAILURE);
}	}

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

if (f && buf && size && (file_read(f->fh, buf, size) == size)) {	// ---- file
f->pos += size;
return(STATFLAG_SUCCESS);
}
return(STATFLAG_FAILURE);
}

static int flagload_close(NP2FFILE f) {	typedef struct {
	OEMCHAR path[MAX_PATH];
	UINT ftype;
	int readonly;
	DOSDATE date;
	DOSTIME time;
	} STATPATH;

if (file_seek(f->fh, f->next, 0) != f->next) {	static const OEMCHAR str_updated[] = OEMTEXT("%s: updated");
return(STATFLAG_FAILURE);	static const OEMCHAR str_notfound[] = OEMTEXT("%s: not found");
}
f->pos = f->next;
return(STATFLAG_SUCCESS);
}

static int flagsave_create(NP2FFILE f, const SFENTRY *t) {	static int statflag_writepath(STFLAGH sfh, const OEMCHAR *path,
	UINT ftype, int readonly) {

if (f && t) {	STATPATH sp;
int len;	FILEH fh;
ZeroMemory(&f->p, sizeof(NP2FENT));
if (f->pos & 15) {
UINT rem;
rem = 16 - (f->pos & 15);
if (file_write(f->fh, &f->p, rem) != rem) {
return(STATFLAG_FAILURE);
}
f->pos += rem;
}
f->bak = f->pos;

len = strlen(t->index);	ZeroMemory(&sp, sizeof(sp));
if (len >= 10) {	if ((path) && (path[0])) {
len = 10;	file_cpyname(sp.path, path, NELEMENTS(sp.path));
}	sp.ftype = ftype;
if (len) {	sp.readonly = readonly;
CopyMemory(f->p.index, t->index, len);	fh = file_open_rb(path);
}	if (fh != FILEH_INVALID) {
f->p.ver = t->ver;	file_getdatetime(fh, &sp.date, &sp.time);
if (file_write(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {	file_close(fh);
return(STATFLAG_FAILURE);
}	}
f->pos += sizeof(NP2FENT);
return(STATFLAG_SUCCESS);
}
return(STATFLAG_FAILURE);
}

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

if (f && buf && size && (file_write(f->fh, buf, size) == size)) {
f->pos += size;
f->p.size += size;
return(STATFLAG_SUCCESS);
}	}
return(STATFLAG_FAILURE);	return(statflag_write(sfh, &sp, sizeof(sp)));
}	}

static int flagsave_close(NP2FFILE f) {	static int statflag_checkpath(STFLAGH sfh, const OEMCHAR *devname) {

if (!f) {	int ret;
goto fs_closeerr;	STATPATH sp;
}	FILEH fh;
if (file_seek(f->fh, f->bak, 0) != f->bak) {	OEMCHAR buf[256];
goto fs_closeerr;	DOSDATE date;
}	DOSTIME time;
if (file_write(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {
goto fs_closeerr;
}
if (file_seek(f->fh, f->pos, 0) == f->pos) {
return(STATFLAG_SUCCESS);
}

fs_closeerr:
return(STATFLAG_FAILURE);
}

static void flagclose(NP2FFILE f) {

if (f) {	ret = statflag_read(sfh, &sp, sizeof(sp));
file_close(f->fh);	if (sp.path[0]) {
	fh = file_open_rb(sp.path);
	if (fh != FILEH_INVALID) {
	file_getdatetime(fh, &date, &time);
	file_close(fh);
	if ((memcmp(&sp.date, &date, sizeof(date))) \|\|
	(memcmp(&sp.time, &time, sizeof(time)))) {
	ret \|= STATFLAG_DISKCHG;
	OEMSPRINTF(buf, str_updated, devname);
	statflag_seterr(sfh, buf);
	}
	}
	else {
	ret \|= STATFLAG_DISKCHG;
	OEMSPRINTF(buf, str_notfound, devname);
	statflag_seterr(sfh, buf);
	}
}	}
	return(ret);
}	}
#endif


// ---- common	// ---- common
Line 718 static int nevent_write(STFLAGH sfh, int	Line 613 static int nevent_write(STFLAGH sfh, int
UINT i;	UINT i;

ZeroMemory(&nit, sizeof(nit));	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) {	if (evtnum[i].num == num) {
nit.id = evtnum[i].id;	nit.id = evtnum[i].id;
break;	break;
Line 762 static int nevent_read(STFLAGH sfh, UINT	Line 657 static int nevent_read(STFLAGH sfh, UINT

ret = statflag_read(sfh, &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) {	if (nit.id == evtnum[i].id) {
break;	break;
}	}
}	}
if (i < (sizeof(evtnum)/sizeof(ENUMTBL))) {	if (i < NELEMENTS(evtnum)) {
num = evtnum[i].num;	num = evtnum[i].num;
nevent.item[num].clock = nit.clock;	nevent.item[num].clock = nit.clock;
nevent.item[num].flag = nit.flag;	nevent.item[num].flag = nit.flag;
Line 842 static int flagsave_gij(STFLAGH sfh, con	Line 737 static int flagsave_gij(STFLAGH sfh, con
int ret;	int ret;
int i;	int i;
int j;	int j;
const BYTE *fnt;	const UINT8 *fnt;

ret = STATFLAG_SUCCESS;	ret = STATFLAG_SUCCESS;
for (i=0; i<2; i++) {	for (i=0; i<2; i++) {
Line 861 static int flagload_gij(STFLAGH sfh, con	Line 756 static int flagload_gij(STFLAGH sfh, con
int ret;	int ret;
int i;	int i;
int j;	int j;
BYTE *fnt;	UINT8 *fnt;

ret = 0;	ret = 0;
for (i=0; i<2; i++) {	for (i=0; i<2; i++) {
Line 878 static int flagload_gij(STFLAGH sfh, con	Line 773 static int flagload_gij(STFLAGH sfh, con

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

	#if !defined(DISABLE_SOUND)

enum {	enum {
FLAG_MG = 0x0001,	FLAG_MG = 0x0001,
FLAG_FM1A = 0x0002,	FLAG_FM1A = 0x0002,
Line 894 enum {	Line 791 enum {
};	};

typedef struct {	typedef struct {
BYTE keyreg[OPNCH_MAX];	UINT8 keyreg[OPNCH_MAX];
BYTE extop[4];	UINT8 extop[4];
} OPNKEY;	} OPNKEY;

static int flagsave_fm(STFLAGH sfh, const SFENTRY *tbl) {	static int flagsave_fm(STFLAGH sfh, const SFENTRY *tbl) {
Line 988 static int flagsave_fm(STFLAGH sfh, cons	Line 885 static int flagsave_fm(STFLAGH sfh, cons
return(ret);	return(ret);
}	}

static void play_fmreg(BYTE num, UINT reg) {

UINT chbase;
UINT i;

chbase = num * 3;
for (i=0x30; i<0xa0; i++) {
opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);
}
for (i=0xb7; i>=0xa0; i--) {
opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);
}
for (i=0; i<3; i++) {
opngen_keyon(chbase + i, opngen.keyreg[chbase + i]);
}
}

static void play_psgreg(PSGGEN psg) {

BYTE i;

for (i=0; i<0x0e; i++) {
psggen_setreg(psg, i, ((BYTE *)&psg->reg)[i]);
}
}

static int flagload_fm(STFLAGH sfh, const SFENTRY *t) {	static int flagload_fm(STFLAGH sfh, const SFENTRY *t) {

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

opngen_reset();
psggen_reset(&psg1);
psggen_reset(&psg2);
psggen_reset(&psg3);
rhythm_reset(&rhythm);
adpcm_reset(&adpcm);
pcm86_reset();
cs4231_reset();

ret = statflag_read(sfh, &usesound, sizeof(usesound));	ret = statflag_read(sfh, &usesound, sizeof(usesound));
fmboard_reset(usesound);	fmboard_reset(usesound);

fmreg1a = 0x000;
fmreg1b = 0x100;
fmreg2a = 0x200;
fmreg2b = 0x300;
switch(usesound) {	switch(usesound) {
case 0x01:	case 0x01:
saveflg = FLAG_MG;	saveflg = FLAG_MG;
Line 1057 static int flagload_fm(STFLAGH sfh, cons	Line 911 static int flagload_fm(STFLAGH sfh, 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 1123 static int flagload_fm(STFLAGH sfh, cons	Line 974 static int flagload_fm(STFLAGH sfh, cons
}	}
if (saveflg & FLAG_CS4231) {	if (saveflg & FLAG_CS4231) {
ret \|= statflag_read(sfh, &cs4231, sizeof(cs4231));	ret \|= statflag_read(sfh, &cs4231, sizeof(cs4231));
cs4231.proc = cs4231dec[cs4231.reg.datafmt >> 4];
}	}

// 復元。	// 復元。これ移動すること！
rhythm_update(&rhythm);
adpcm_update(&adpcm);	adpcm_update(&adpcm);
pcm86gen_update();	pcm86gen_update();
if (saveflg & FLAG_PCM86) {	if (saveflg & FLAG_PCM86) {
fmboard_extenable((BYTE)(pcm86.extfunc & 1));	fmboard_extenable((REG8)(pcm86.extfunc & 1));
}	}
if (saveflg & FLAG_CS4231) {	if (saveflg & FLAG_CS4231) {
fmboard_extenable((BYTE)(cs4231.extfunc & 1));	fmboard_extenable((REG8)(cs4231.extfunc & 1));
}

if (saveflg & FLAG_FM1A) {
play_fmreg(0, fmreg1a);
}
if (saveflg & FLAG_FM1B) {
play_fmreg(1, fmreg1b);
}
if (saveflg & FLAG_FM2A) {
play_fmreg(2, fmreg2a);
}
if (saveflg & FLAG_FM2B) {
play_fmreg(3, fmreg2b);
}
if (saveflg & FLAG_PSG1) {
play_psgreg(&psg1);
}
if (saveflg & FLAG_PSG2) {
play_psgreg(&psg2);
}
if (saveflg & FLAG_PSG3) {
play_psgreg(&psg3);
}	}
(void)t;	(void)t;
return(ret);	return(ret);
}	}
	#endif


// ---- disk	// ---- fdd

typedef struct {
char path[MAX_PATH];
int readonly;
DOSDATE date;
DOSTIME time;
} STATDISK;

static const char str_fddx[] = "FDD%u";	static const OEMCHAR str_fddx[] = OEMTEXT("FDD%u");
static const char str_sasix[] = "SASI%u";
static const char str_scsix[] = "SCSI%u";
static const char str_updated[] = "%s: updated";
static const char str_notfound[] = "%s: not found";

static int disksave(STFLAGH sfh, const char *path, int readonly) {	static int flagsave_fdd(STFLAGH sfh, const SFENTRY *tbl) {

STATDISK st;	int ret;
FILEH fh;	UINT8 i;
	const OEMCHAR *path;
	UINT ftype;
	int ro;

ZeroMemory(&st, sizeof(st));	ret = STATFLAG_SUCCESS;
if ((path) && (path[0])) {	for (i=0; i<4; i++) {
file_cpyname(st.path, path, sizeof(st.path));	path = fdd_getfileex(i, &ftype, &ro);
st.readonly = readonly;	ret \|= statflag_writepath(sfh, path, ftype, ro);
fh = file_open_rb(path);
if (fh != FILEH_INVALID) {
file_getdatetime(fh, &st.date, &st.time);
file_close(fh);
}
}	}
return(statflag_write(sfh, &st, sizeof(st)));	(void)tbl;
	return(ret);
}	}

static int flagsave_disk(STFLAGH sfh, const SFENTRY *tbl) {	static int flagcheck_fdd(STFLAGH sfh, const SFENTRY *tbl) {

int ret;	int ret;
BYTE i;	int i;
	OEMCHAR buf[8];

sxsi_flash();
ret = STATFLAG_SUCCESS;	ret = STATFLAG_SUCCESS;
for (i=0; i<4; i++) {	for (i=0; i<4; i++) {
ret \|= disksave(sfh, fdd_diskname(i), fdd_diskprotect(i));	OEMSPRINTF(buf, str_fddx, i+1);
}	ret \|= statflag_checkpath(sfh, buf);
for (i=0x00; i<0x02; i++) {
ret \|= disksave(sfh, sxsi_getname(i), 0);
}
for (i=0x20; i<0x24; i++) {
ret \|= disksave(sfh, sxsi_getname(i), 0);
}	}
(void)tbl;	(void)tbl;
return(ret);	return(ret);
}	}

static int diskcheck(STFLAGH sfh, const char *name) {	static int flagload_fdd(STFLAGH sfh, const SFENTRY *tbl) {

int ret;	int ret;
FILEH fh;	UINT8 i;
STATDISK st;	STATPATH sp;
char buf[256];
DOSDATE date;
DOSTIME time;

ret = statflag_read(sfh, &st, sizeof(st));	ret = STATFLAG_SUCCESS;
if (st.path[0]) {	for (i=0; i<4; i++) {
fh = file_open_rb(st.path);	ret \|= statflag_read(sfh, &sp, sizeof(sp));
if (fh != FILEH_INVALID) {	if (sp.path[0]) {
file_getdatetime(fh, &date, &time);	fdd_set(i, sp.path, sp.ftype, sp.readonly);
file_close(fh);
if ((memcmp(&st.date, &date, sizeof(date))) \|\|
(memcmp(&st.time, &time, sizeof(time)))) {
ret \|= STATFLAG_DISKCHG;
SPRINTF(buf, str_updated, name);
statflag_seterr(sfh, buf);
}
}
else {
ret \|= STATFLAG_DISKCHG;
SPRINTF(buf, str_notfound, name);
statflag_seterr(sfh, buf);
}	}
}	}
	(void)tbl;
return(ret);	return(ret);
}	}

static int flagcheck_disk(STFLAGH sfh, const SFENTRY *tbl) {

int ret;	// ---- sxsi
int i;
char buf[8];

ret = 0;	typedef struct {
for (i=0; i<4; i++) {	UINT8 ide[4];
SPRINTF(buf, str_fddx, i+1);	UINT8 scsi[8];
ret \|= diskcheck(sfh, buf);	} SXSIDEVS;

	static const OEMCHAR str_sasix[] = OEMTEXT("SASI%u");
	static const OEMCHAR str_scsix[] = OEMTEXT("SCSI%u");

	static int flagsave_sxsi(STFLAGH sfh, const SFENTRY *tbl) {

	int ret;
	UINT i;
	SXSIDEVS sds;
	const OEMCHAR *path;

	sxsi_allflash();
	ret = STATFLAG_SUCCESS;
	for (i=0; i<NELEMENTS(sds.ide); i++) {
	sds.ide[i] = sxsi_getdevtype((REG8)i);
}	}
sxsi_flash();	for (i=0; i<NELEMENTS(sds.scsi); i++) {
for (i=0; i<2; i++) {	sds.scsi[i] = sxsi_getdevtype((REG8)(i + 0x20));
SPRINTF(buf, str_sasix, i+1);
ret \|= diskcheck(sfh, buf);
}	}
for (i=0; i<4; i++) {	ret = statflag_write(sfh, &sds, sizeof(sds));
SPRINTF(buf, str_scsix, i);	for (i=0; i<NELEMENTS(sds.ide); i++) {
ret \|= diskcheck(sfh, buf);	if (sds.ide[i] != SXSIDEV_NC) {
	path = sxsi_getfilename((REG8)i);
	ret \|= statflag_writepath(sfh, path, FTYPE_NONE, 0);
	}
	}
	for (i=0; i<NELEMENTS(sds.scsi); i++) {
	if (sds.scsi[i] != SXSIDEV_NC) {
	path = sxsi_getfilename((REG8)(i + 0x20));
	ret \|= statflag_writepath(sfh, path, FTYPE_NONE, 0);
	}
}	}
(void)tbl;	(void)tbl;
return(ret);	return(ret);
}	}

static int flagload_disk(STFLAGH sfh, const SFENTRY *tbl) {	static int flagcheck_sxsi(STFLAGH sfh, const SFENTRY *tbl) {

int ret;	int ret;
UINT8 i;	SXSIDEVS sds;
STATDISK st;	UINT i;
	OEMCHAR buf[8];

ret = 0;	sxsi_allflash();
for (i=0; i<4; i++) {	ret = statflag_read(sfh, &sds, sizeof(sds));
ret \|= statflag_read(sfh, &st, sizeof(st));	for (i=0; i<NELEMENTS(sds.ide); i++) {
if (st.path[0]) {	if (sds.ide[i] != SXSIDEV_NC) {
fdd_set(i, st.path, FTYPE_NONE, st.readonly);	OEMSPRINTF(buf, str_sasix, i+1);
}	ret \|= statflag_checkpath(sfh, buf);
}	}
sxsi_trash();	}
for (i=0x00; i<0x02; i++) {	for (i=0; i<NELEMENTS(sds.scsi); i++) {
ret \|= statflag_read(sfh, &st, sizeof(st));	if (sds.scsi[i] != SXSIDEV_NC) {
if (st.path[0]) {	OEMSPRINTF(buf, str_scsix, i);
sxsi_hddopen(i, st.path);	ret \|= statflag_checkpath(sfh, buf);
}	}
}	}
for (i=0x20; i<0x24; i++) {	(void)tbl;
ret \|= statflag_read(sfh, &st, sizeof(st));	return(ret);
if (st.path[0]) {	}
sxsi_hddopen(i, st.path);
	static int flagload_sxsi(STFLAGH sfh, const SFENTRY *tbl) {

	int ret;
	SXSIDEVS sds;
	UINT i;
	REG8 drv;
	STATPATH sp;

	ret = statflag_read(sfh, &sds, sizeof(sds));
	if (ret != STATFLAG_SUCCESS) {
	return(ret);
	}
	for (i=0; i<NELEMENTS(sds.ide); i++) {
	drv = (REG8)i;
	sxsi_setdevtype(drv, sds.ide[i]);
	if (sds.ide[i] != SXSIDEV_NC) {
	ret \|= statflag_read(sfh, &sp, sizeof(sp));
	sxsi_devopen(drv, sp.path);
	}
	}
	for (i=0; i<NELEMENTS(sds.scsi); i++) {
	drv = (REG8)(i + 0x20);
	sxsi_setdevtype(drv, sds.scsi[i]);
	if (sds.scsi[i] != SXSIDEV_NC) {
	ret \|= statflag_read(sfh, &sp, sizeof(sp));
	sxsi_devopen(drv, sp.path);
}	}
}	}
(void)tbl;	(void)tbl;
Line 1412 static int flagcheck_veronly(STFLAGH sfh	Line 1255 static int flagcheck_veronly(STFLAGH sfh

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

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

SFFILEH sffh;	SFFILEH sffh;
int ret;	int ret;
Line 1426 const SFENTRY *tblterm;	Line 1269 const SFENTRY *tblterm;

ret = STATFLAG_SUCCESS;	ret = STATFLAG_SUCCESS;
tbl = np2tbl;	tbl = np2tbl;
tblterm = tbl + (sizeof(np2tbl)/sizeof(SFENTRY));	tblterm = tbl + NELEMENTS(np2tbl);
while(tbl < tblterm) {	while(tbl < tblterm) {
ret \|= statflag_createsection(sffh, tbl);	ret \|= statflag_createsection(sffh, tbl);
switch(tbl->type) {	switch(tbl->type) {
Line 1445 const SFENTRY *tblterm;	Line 1288 const SFENTRY *tblterm;
ret \|= flagsave_com(&sffh->sfh, tbl);	ret \|= flagsave_com(&sffh->sfh, tbl);
break;	break;

case STATFLAG_DISK:
ret \|= flagsave_disk(&sffh->sfh, tbl);
break;

case STATFLAG_DMA:	case STATFLAG_DMA:
ret \|= flagsave_dma(&sffh->sfh, tbl);	ret \|= flagsave_dma(&sffh->sfh, tbl);
break;	break;
Line 1469 const SFENTRY *tblterm;	Line 1308 const SFENTRY *tblterm;
ret \|= flagsave_ext(&sffh->sfh, tbl);	ret \|= flagsave_ext(&sffh->sfh, tbl);
break;	break;

	case STATFLAG_FDD:
	ret \|= flagsave_fdd(&sffh->sfh, tbl);
	break;

	#if !defined(DISABLE_SOUND)
case STATFLAG_FM:	case STATFLAG_FM:
ret \|= flagsave_fm(&sffh->sfh, tbl);	ret \|= flagsave_fm(&sffh->sfh, tbl);
break;	break;
	#endif

case STATFLAG_GIJ:	case STATFLAG_GIJ:
ret \|= flagsave_gij(&sffh->sfh, tbl);	ret \|= flagsave_gij(&sffh->sfh, tbl);
Line 1486 const SFENTRY *tblterm;	Line 1331 const SFENTRY *tblterm;
case STATFLAG_MEM:	case STATFLAG_MEM:
ret \|= flagsave_mem(&sffh->sfh, tbl);	ret \|= flagsave_mem(&sffh->sfh, tbl);
break;	break;

	case STATFLAG_SXSI:
	ret \|= flagsave_sxsi(&sffh->sfh, tbl);
	break;
}	}
tbl++;	tbl++;
}	}
Line 1493 const SFENTRY *tblterm;	Line 1342 const SFENTRY *tblterm;
return(ret);	return(ret);
}	}

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

SFFILEH sffh;	SFFILEH sffh;
int ret;	int ret;
Line 1511 const SFENTRY *tblterm;	Line 1360 const SFENTRY *tblterm;
while((!done) && (ret != STATFLAG_FAILURE)) {	while((!done) && (ret != STATFLAG_FAILURE)) {
ret \|= statflag_readsection(sffh);	ret \|= statflag_readsection(sffh);
tbl = np2tbl;	tbl = np2tbl;
tblterm = tbl + (sizeof(np2tbl)/sizeof(SFENTRY));	tblterm = tbl + NELEMENTS(np2tbl);
while(tbl < tblterm) {	while(tbl < tblterm) {
if (!memcmp(sffh->sfh.hdr.index, tbl->index, 10)) {	if (!memcmp(sffh->sfh.hdr.index, tbl->index, 10)) {
break;	break;
Line 1539 const SFENTRY *tblterm;	Line 1388 const SFENTRY *tblterm;
case STATFLAG_EVT:	case STATFLAG_EVT:
case STATFLAG_EXT:	case STATFLAG_EXT:
case STATFLAG_GIJ:	case STATFLAG_GIJ:
	#if !defined(DISABLE_SOUND)
case STATFLAG_FM:	case STATFLAG_FM:
	#endif
#if defined(SUPPORT_HOSTDRV)	#if defined(SUPPORT_HOSTDRV)
case STATFLAG_HDRV:	case STATFLAG_HDRV:
#endif	#endif
ret \|= flagcheck_veronly(&sffh->sfh, tbl);	ret \|= flagcheck_veronly(&sffh->sfh, tbl);
break;	break;

case STATFLAG_DISK:	case STATFLAG_FDD:
ret \|= flagcheck_disk(&sffh->sfh, tbl);	ret \|= flagcheck_fdd(&sffh->sfh, tbl);
	break;

	case STATFLAG_SXSI:
	ret \|= flagcheck_sxsi(&sffh->sfh, tbl);
break;	break;

default:	default:
Line 1563 const SFENTRY *tblterm;	Line 1418 const SFENTRY *tblterm;
return(ret);	return(ret);
}	}

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

SFFILEH sffh;	SFFILEH sffh;
int ret;	int ret;
Line 1588 const SFENTRY *tblterm;	Line 1443 const SFENTRY *tblterm;
rs232c_midipanic();	rs232c_midipanic();
mpu98ii_midipanic();	mpu98ii_midipanic();
pc9861k_midipanic();	pc9861k_midipanic();
	sxsi_alltrash();

ret \|= flagload_common(&sffh->sfh, np2tbl);	ret \|= flagload_common(&sffh->sfh, np2tbl);
nevent_init();

CPU_RESET();	CPU_RESET();
CPU_SETEXTSIZE((UINT32)pccore.extmem);	CPU_SETEXTSIZE((UINT32)pccore.extmem);
	nevent_allreset();

sound_changeclock();	sound_changeclock();
beep_changeclock();	beep_changeclock();
sound_reset();	sound_reset();
#if defined(SUPPORT_WAVEMIX)	fddmtrsnd_bind();
wavemix_bind();
#endif

iocore_reset(); // サウンドでpicを呼ぶので…	iocore_reset(); // サウンドでpicを呼ぶので…
cbuscore_reset();	cbuscore_reset();
fmboard_reset(pccore.sound);	fmboard_reset(pccore.sound);


done = FALSE;	done = FALSE;
while((!done) && (ret != STATFLAG_FAILURE)) {	while((!done) && (ret != STATFLAG_FAILURE)) {
ret \|= statflag_readsection(sffh);	ret \|= statflag_readsection(sffh);
tbl = np2tbl + 1;	tbl = np2tbl + 1;
tblterm = np2tbl + (sizeof(np2tbl)/sizeof(SFENTRY));	tblterm = np2tbl + NELEMENTS(np2tbl);
while(tbl < tblterm) {	while(tbl < tblterm) {
if (!memcmp(sffh->sfh.hdr.index, tbl->index, 10)) {	if (!memcmp(sffh->sfh.hdr.index, tbl->index, 10)) {
break;	break;
Line 1638 const SFENTRY *tblterm;	Line 1491 const SFENTRY *tblterm;
ret \|= flagload_com(&sffh->sfh, tbl);	ret \|= flagload_com(&sffh->sfh, tbl);
break;	break;

case STATFLAG_DISK:
ret \|= flagload_disk(&sffh->sfh, tbl);
break;

case STATFLAG_DMA:	case STATFLAG_DMA:
ret \|= flagload_dma(&sffh->sfh, tbl);	ret \|= flagload_dma(&sffh->sfh, tbl);
break;	break;
Line 1662 const SFENTRY *tblterm;	Line 1511 const SFENTRY *tblterm;
ret \|= flagload_ext(&sffh->sfh, tbl);	ret \|= flagload_ext(&sffh->sfh, tbl);
break;	break;

	case STATFLAG_FDD:
	ret \|= flagload_fdd(&sffh->sfh, tbl);
	break;

	#if !defined(DISABLE_SOUND)
case STATFLAG_FM:	case STATFLAG_FM:
ret \|= flagload_fm(&sffh->sfh, tbl);	ret \|= flagload_fm(&sffh->sfh, tbl);
break;	break;
	#endif

case STATFLAG_GIJ:	case STATFLAG_GIJ:
ret \|= flagload_gij(&sffh->sfh, tbl);	ret \|= flagload_gij(&sffh->sfh, tbl);
Line 1680 const SFENTRY *tblterm;	Line 1535 const SFENTRY *tblterm;
ret \|= flagload_mem(&sffh->sfh, tbl);	ret \|= flagload_mem(&sffh->sfh, tbl);
break;	break;

	case STATFLAG_SXSI:
	ret \|= flagload_sxsi(&sffh->sfh, tbl);
	break;

default:	default:
ret \|= STATFLAG_WARNING;	ret \|= STATFLAG_WARNING;
break;	break;
Line 1710 const SFENTRY *tblterm;	Line 1569 const SFENTRY *tblterm;
FONTPTR_HIGH = fontrom + cgwindow.high;	FONTPTR_HIGH = fontrom + cgwindow.high;
#endif	#endif
i286_vram_dispatch(vramop.operate);	i286_vram_dispatch(vramop.operate);
	fddmtr_reset();
soundmng_play();	soundmng_play();

return(ret);	return(ret);

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

Removed from v.1.33
changed lines
	Added in v.1.49