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;
return(ret);
}
static int flagload_epson(STFLAGH sfh, const SFENTRY *tbl) {
int ret;
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);
}
static int flagload_mem(STFLAGH sfh, const SFENTRY *tbl) {
int ret;
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);
}
/**
* Load
* @param[in] opna The instance
* @param[in] sfh The handle of statsave
* @param[in] tbl The item of statsave
* @return Error
*/
int opna_sfload(POPNA opna, STFLAGH sfh, const SFENTRY *tbl)
{
int ret = statflag_read(sfh, &opna->s, sizeof(opna->s));
if (opna->s.cCaps & OPNA_HAS_ADPCM)
{
ret |= statflag_read(sfh, &opna->adpcm, sizeof(opna->adpcm));
adpcm_update(&opna->adpcm);
}
return ret;
}
static int flagload_com(STFLAGH sfh, const SFENTRY *tbl) {
UINT device;
COMMNG cm;
int ret;
_COMFLAG fhdr;
COMFLAG flag;
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;
}
device = (UINT)(INTPTR)tbl->arg1;
switch(device) {
case 0:
commng_destroy(cm_mpu98);
cm = commng_create(COMCREATE_MPU98II);
cm_mpu98 = cm;
break;
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, (INTPTR)flag);
}
flcom_err2:
_MFREE(flag);
flcom_err1:
return(ret);
}
static int nevent_read(STFLAGH sfh, UINT *tbl, UINT *pos) {
int ret;
NEVTITEM nit;
UINT i;
UINT num;
ret = statflag_read(sfh, &nit, sizeof(nit));
for (i=0; i<NELEMENTS(evtnum); i++) {
if (nit.id == evtnum[i].id) {
break;
}
}
if (i < NELEMENTS(evtnum)) {
num = evtnum[i].num;
g_nevent.item[num].clock = nit.clock;
g_nevent.item[num].flag = nit.flag;
g_nevent.item[num].proc = nit.proc;
if (NUM2PROC(g_nevent.item[num].proc, evtproc)) {
ret |= STATFLAG_WARNING;
}
else {
tbl[*pos] = num;
(*pos)++;
}
}
else {
ret |= STATFLAG_WARNING;
}
return(ret);
}
static int statflag_checkpath(STFLAGH sfh, const OEMCHAR *dvname) {
int ret;
STATPATH sp;
FILEH fh;
OEMCHAR buf[256];
DOSDATE dosdate;
DOSTIME dostime;
ret = statflag_read(sfh, &sp, sizeof(sp));
if (sp.path[0]) {
fh = file_open_rb(sp.path);
if (fh != FILEH_INVALID) {
file_getdatetime(fh, &dosdate, &dostime);
file_close(fh);
if ((memcmp(&sp.date, &dosdate, sizeof(dosdate))) ||
(memcmp(&sp.time, &dostime, sizeof(dostime)))) {
ret |= STATFLAG_DISKCHG;
OEMSPRINTF(buf, str_updated, dvname);
statflag_seterr(sfh, buf);
}
}
else {
ret |= STATFLAG_DISKCHG;
OEMSPRINTF(buf, str_notfound, dvname);
statflag_seterr(sfh, buf);
}
}
return(ret);
}
static int flagload_egc(STFLAGH sfh, const SFENTRY *tbl) {
int ret;
ret = statflag_read(sfh, &egc, sizeof(egc));
egc.inptr += (INTPTR)egc.buf;
egc.outptr += (INTPTR)egc.buf;
(void)tbl;
return(ret);
}
static int flagload_cgwnd(STFLAGH sfh, const SFENTRY *tbl) {
int ret;
ret = statflag_read(sfh, &cgwindow, sizeof(cgwindow));
cgwindow.fontlow += (long)fontrom;
cgwindow.fonthigh += (long)fontrom;
(void)tbl;
return(ret);
}
static int flagload_ext(STFLAGH sfh, const SFENTRY *tbl) {
int ret;
ret = STATFLAG_SUCCESS;
if (CPU_EXTMEM) {
ret = statflag_read(sfh, CPU_EXTMEM, CPU_EXTMEMSIZE);
}
(void)tbl;
return(ret);
}
static int flagload_fdd(STFLAGH sfh, const SFENTRY *tbl) {
int ret;
UINT8 i;
STATPATH sp;
ret = STATFLAG_SUCCESS;
for (i=0; i<4; i++) {
ret |= statflag_read(sfh, &sp, sizeof(sp));
if (sp.path[0]) {
fdd_set(i, sp.path, sp.ftype, sp.readonly);
}
}
(void)tbl;
return(ret);
}
static int flagload_gij(STFLAGH sfh, const SFENTRY *tbl) {
int ret;
int i;
int j;
UINT8 *fnt;
ret = 0;
for (i=0; i<2; i++) {
fnt = fontrom + ((0x56 + (i << 7)) << 4);
for (j=0; j<0x80; j++) {
ret |= statflag_read(sfh, fnt, 32);
fnt += 0x1000;
}
}
(void)tbl;
return(ret);
}
static int flagload_evt(STFLAGH sfh, const SFENTRY *tbl) {
int ret;
NEVTSAVE nevt;
UINT i;
ret = statflag_read(sfh, &nevt, sizeof(nevt));
g_nevent.readyevents = 0;
g_nevent.waitevents = 0;
for (i=0; i<nevt.readyevents; i++) {
ret |= nevent_read(sfh, g_nevent.level, &g_nevent.readyevents);
}
for (i=0; i<nevt.waitevents; i++) {
ret |= nevent_read(sfh, g_nevent.waitevent, &g_nevent.waitevents);
}
(void)tbl;
return(ret);
}
static int flagload_dma(STFLAGH sfh, const SFENTRY *tbl) {
int ret;
int i;
ret = statflag_read(sfh, &dmac, sizeof(dmac));
for (i=0; i<4; i++) {
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)tbl;
return(ret);
}
static int flagcheck_sxsi(STFLAGH sfh, const SFENTRY *tbl) {
int ret;
SXSIDEVS sds;
UINT i;
OEMCHAR buf[8];
sxsi_allflash();
ret = statflag_read(sfh, &sds, sizeof(sds));
for (i=0; i<NELEMENTS(sds.ide); i++) {
if (sds.ide[i] != SXSIDEV_NC) {
OEMSPRINTF(buf, str_sasix, i+1);
ret |= statflag_checkpath(sfh, buf);
}
}
for (i=0; i<NELEMENTS(sds.scsi); i++) {
if (sds.scsi[i] != SXSIDEV_NC) {
OEMSPRINTF(buf, str_scsix, i);
ret |= statflag_checkpath(sfh, buf);
}
}
(void)tbl;
return(ret);
}
static int flagload_fm(STFLAGH sfh, const SFENTRY *t) {
int ret;
UINT saveflg;
OPNKEY opnkey;
UINT i;
ret = statflag_read(sfh, &g_usesound, sizeof(g_usesound));
fmboard_reset(&np2cfg, g_usesound);
switch(g_usesound) {
case 0x01:
saveflg = FLAG_MG;
break;
case 0x02:
saveflg = FLAG_FM1A;
break;
case 0x04:
saveflg = FLAG_FM1A | FLAG_FM1B | FLAG_RHYTHM | FLAG_PCM86;
break;
case 0x06:
saveflg = FLAG_FM1A | FLAG_FM1B | FLAG_FM2A | FLAG_RHYTHM | FLAG_PCM86;
break;
case 0x08:
saveflg = FLAG_FM1A | FLAG_FM1B | FLAG_RHYTHM | FLAG_CS4231;
break;
case 0x14:
saveflg = FLAG_FM1A | FLAG_FM1B | FLAG_RHYTHM | FLAG_ADPCM | FLAG_PCM86;
break;
case 0x20:
saveflg = FLAG_FM1A | FLAG_FM1B | FLAG_RHYTHM | FLAG_ADPCM;
break;
case 0x40:
saveflg = FLAG_FM1A | FLAG_FM1B | FLAG_FM2A | FLAG_FM2B | FLAG_RHYTHM | FLAG_ADPCM;
break;
case 0x80:
saveflg = FLAG_PSG1 | FLAG_PSG2 | FLAG_PSG3;
break;
default:
saveflg = 0;
break;
}
if (saveflg & FLAG_MG) {
ret |= statflag_read(sfh, &g_musicgen, sizeof(g_musicgen));
board14_allkeymake();
}
if (saveflg & FLAG_FM1A) {
ret |= statflag_read(sfh, &g_fmtimer, sizeof(g_fmtimer));
ret |= statflag_read(sfh, &g_opn, sizeof(g_opn));
ret |= statflag_read(sfh, &opnkey, sizeof(opnkey));
for (i = 0; i < OPNCH_MAX; i++)
{
g_opngen.opnch[i].keyreg = opnkey.keyreg[i];
}
g_opngen.opnch[2].extop = opnkey.extop[0];
g_opngen.opnch[5].extop = opnkey.extop[1];
g_opngen.opnch[8].extop = opnkey.extop[2];
g_opngen.opnch[11].extop = opnkey.extop[3];
}
if (saveflg & FLAG_PSG1) {
ret |= statflag_read(sfh, &g_psg1.reg, sizeof(PSGREG));
}
if (saveflg & FLAG_PSG2) {
ret |= statflag_read(sfh, &g_psg2.reg, sizeof(PSGREG));
}
if (saveflg & FLAG_PSG3) {
ret |= statflag_read(sfh, &g_psg3.reg, sizeof(PSGREG));
}
if (saveflg & FLAG_ADPCM) {
ret |= statflag_read(sfh, &g_adpcm, sizeof(g_adpcm));
}
if (saveflg & FLAG_PCM86) {
ret |= statflag_read(sfh, &pcm86, sizeof(pcm86));
}
if (saveflg & FLAG_CS4231) {
ret |= statflag_read(sfh, &cs4231, sizeof(cs4231));
}
// 復元。 これ移動すること！
adpcm_update(&g_adpcm);
pcm86gen_update();
if (saveflg & FLAG_PCM86) {
fmboard_extenable((REG8)(pcm86.extfunc & 1));
}
if (saveflg & FLAG_CS4231) {
fmboard_extenable((REG8)(cs4231.extfunc & 1));
}
(void)t;
return(ret);
}
static int flagload_common(STFLAGH sfh, const SFENTRY *tbl) {
return(statflag_read(sfh, tbl->arg1, tbl->arg2));
}
