[BACK]Return to statsave.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2

Diff for /np2/statsave.c between versions 1.24 and 1.48

version 1.24, 2004/01/05 07:48:22 version 1.48, 2005/03/22 04:39:07
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
   #include        "strres.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "commng.h"  #include        "commng.h"
 #include        "scrnmng.h"  #include        "scrnmng.h"
Line 7 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        "scsiio.h"
 #include        "pc9861k.h"  #include        "pc9861k.h"
 #include        "mpu98ii.h"  #include        "mpu98ii.h"
 #include        "board14.h"  #include        "board14.h"
Line 23 Line 28
 #include        "fddfile.h"  #include        "fddfile.h"
 #include        "fdd_mtr.h"  #include        "fdd_mtr.h"
 #include        "sxsi.h"  #include        "sxsi.h"
 #include        "calendar.h"  
 #include        "statsave.h"  
 #include        "keydisp.h"  #include        "keydisp.h"
   #include        "hostdrv.h"
   #include        "calendar.h"
   #include        "keystat.h"
   
 #if defined(MACOS)  #if defined(MACOS)
 #define CRLITERAL       "\r"  
 #define CRCONST         str_cr  #define CRCONST         str_cr
 #elif defined(WIN32) || defined(X11) || defined(SLZAURUS)  #elif defined(WIN32) || defined(X11) || defined(SLZAURUS)
 #define CRLITERAL       "\n"  
 #define CRCONST         str_lf  #define CRCONST         str_lf
 #else  #else
 #define CRLITERAL       "\r\n"  
 #define CRCONST         str_crlf  #define CRCONST         str_crlf
 #endif  #endif
   
Line 53  typedef struct { Line 55  typedef struct {
 } NP2FENT;  } NP2FENT;
   
 enum {  enum {
         NP2FLAG_BIN                     = 0,          STATFLAG_BIN                    = 0,
         NP2FLAG_TERM,          STATFLAG_TERM,
 #if defined(CGWND_FONTPTR)  #if defined(CGWND_FONTPTR)
         NP2FLAG_CGW,          STATFLAG_CGW,
 #endif  #endif
         NP2FLAG_CLOCK,          STATFLAG_COM,
         NP2FLAG_COM,          STATFLAG_DMA,
         NP2FLAG_DISK,          STATFLAG_EGC,
         NP2FLAG_DMA,          STATFLAG_EPSON,
         NP2FLAG_EGC,          STATFLAG_EVT,
         NP2FLAG_EPSON,          STATFLAG_EXT,
         NP2FLAG_EVT,          STATFLAG_FDD,
         NP2FLAG_EXT,          STATFLAG_FM,
         NP2FLAG_FM,          STATFLAG_GIJ,
         NP2FLAG_GIJ,  #if defined(SUPPORT_HOSTDRV)
         NP2FLAG_MEM          STATFLAG_HDRV,
   #endif
           STATFLAG_MEM,
           STATFLAG_SXSI
 };  };
   
 typedef struct {  typedef struct {
 const char      *index;  
         UINT16  ver;  
         UINT16  type;  
         void    *arg1;  
         UINT    arg2;  
 } STENTRY;  
   
 typedef struct {  
         UINT32  id;          UINT32  id;
         void    *proc;          void    *proc;
 } PROCTBL;  } PROCTBL;
Line 100  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;
   
 static void err_append(ERR_BUF *e, char *buf) {  
   
         int             len;  
   
         if ((e) && (buf)) {  // ----
                 if (e->buf) {  
                         len = strlen(buf);  
                         if (e->remain >= len) {  
                                 CopyMemory(e->buf, buf, len);  
                                 e->buf += len;  
                                 e->remain -= len;  
                         }  
                 }  
         }  
 }  
   
   enum {
           SFFILEH_WRITE   = 0x0001,
           SFFILEH_BLOCK   = 0x0002,
           SFFILEH_ERROR   = 0x0004
   };
   
 // ----  typedef struct {
           _STFLAGH        sfh;
           UINT            stat;
           FILEH           fh;
           UINT            secpos;
           NP2FHDR         f;
   } _SFFILEH, *SFFILEH;
   
 // 関数ポインタを intに変更。  static SFFILEH statflag_open(const OEMCHAR *filename, OEMCHAR *err, int errlen) {
 static BOOL proc2num(void *func, const PROCTBL *tbl, int size) {  
   
         int             i;          FILEH   fh;
           SFFILEH ret;
   
         for (i=0; i<size; i++) {          fh = file_open_rb(filename);
                 if (*(long *)func == (long)tbl->proc) {          if (fh == FILEH_INVALID) {
                         *(long *)func = (long)tbl->id;                  goto sfo_err1;
                         return(SUCCESS);          }
           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;
                 }                  }
                 tbl++;                  return(ret);
         }          }
         return(FAILURE);          _MFREE(ret);
 }  
   
 static BOOL num2proc(void *func, const PROCTBL *tbl, int size) {  
   
         int             i;  sfo_err2:
           file_close(fh);
   
         for (i=0; i<size; i++) {  sfo_err1:
                 if (*(long *)func == (long)tbl->id) {          return(NULL);
                         *(long *)func = (long)tbl->proc;  
                         return(SUCCESS);  
                 }  
                 tbl++;  
         }  
         return(FAILURE);  
 }  }
   
   static int statflag_closesection(SFFILEH sffh) {
   
 // ----          UINT    leng;
           UINT8   zero[16];
   
 typedef struct {          if (sffh == NULL) {
         FILEH   fh;                  goto sfcs_err1;
         long    pos;          }
         long    bak;          if (sffh->stat == (SFFILEH_BLOCK | SFFILEH_WRITE)) {
         long    next;                  leng = (0 - sffh->sfh.hdr.size) & 15;
         NP2FHDR f;                  if (leng) {
         NP2FENT p;                          ZeroMemory(zero, sizeof(zero));
 } _NP2FFILE, *NP2FFILE;                          if (file_write(sffh->fh, zero, leng) != leng) {
                                   goto sfcs_err2;
 static int flagopen(NP2FFILE f, const char *filename, ERR_BUF *e) {                          }
   
         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 ((file_seek(sffh->fh, (long)sffh->secpos, FSEEK_SET)
 #if 1                                                                                                  != (long)sffh->secpos) ||
                         file_close(f->fh);                          (file_write(sffh->fh, &sffh->sfh.hdr, sizeof(sffh->sfh.hdr))
                         return(NP2FLAG_FAILURE);                                                                                                  != sizeof(sffh->sfh.hdr))) {
 #else                          goto sfcs_err2;
                         return(NP2FLAG_VERSION);                        // 他verを読むのであれば…                  }
 #endif          }
           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;
                 }                  }
                 return(NP2FLAG_SUCCESS);  
         }          }
         (void)e;          return(STATFLAG_SUCCESS);
         return(NP2FLAG_FAILURE);  
   sfcs_err2:
           sffh->stat = SFFILEH_ERROR;
   
   sfcs_err1:
           return(STATFLAG_FAILURE);
 }  }
   
 static int flagcreate(NP2FFILE f, const char *filename) {  static int statflag_readsection(SFFILEH sffh) {
   
         if (f) {          int             ret;
                 f->fh = file_create(filename);  
                 if (f->fh == FILEH_INVALID) {          ret = statflag_closesection(sffh);
                         return(NP2FLAG_FAILURE);          if (ret != STATFLAG_SUCCESS) {
                 }                  return(ret);
                 if (file_write(f->fh, &np2flagdef, sizeof(NP2FHDR))          }
                                                                                                                 != sizeof(NP2FHDR)) {          if ((sffh->stat == 0) &&
                         file_close(f->fh);                  (file_read(sffh->fh, &sffh->sfh.hdr, sizeof(sffh->sfh.hdr))
                         return(NP2FLAG_FAILURE);                                                                                                  == sizeof(sffh->sfh.hdr))) {
                 }                  sffh->stat = SFFILEH_BLOCK;
                 f->pos = sizeof(NP2FHDR);                  sffh->sfh.pos = 0;
                 return(NP2FLAG_SUCCESS);                  return(STATFLAG_SUCCESS);
         }          }
         return(NP2FLAG_FAILURE);          sffh->stat = SFFILEH_ERROR;
           return(STATFLAG_FAILURE);
 }  }
   
 static int flagload_create(NP2FFILE f) {  int statflag_read(STFLAGH sfh, void *buf, UINT size) {
   
         if (f) {          if ((sfh == NULL) || (buf == NULL) ||
                 ZeroMemory(&f->p, sizeof(NP2FENT));                  ((sfh->pos + size) > sfh->hdr.size)) {
                 if (f->pos & 15) {                  goto sfr_err;
                         f->pos += 15;          }
                         f->pos &= ~0xf;          if (size) {
                         if (file_seek(f->fh, f->pos, 0) != f->pos) {                  if (file_read(((SFFILEH)sfh)->fh, buf, size) != size) {
                                 return(NP2FLAG_FAILURE);                          goto sfr_err;
                         }  
                 }  
                 if (file_read(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {  
                         return(NP2FLAG_FAILURE);  
                 }                  }
                 f->pos += sizeof(NP2FENT);                  sfh->pos += size;
                 f->next = f->pos + f->p.size;  
                 return(NP2FLAG_SUCCESS);  
         }          }
         return(NP2FLAG_FAILURE);          return(STATFLAG_SUCCESS);
   
   sfr_err:
           return(STATFLAG_FAILURE);
 }  }
   
 static int flagload_load(NP2FFILE f, void *buf, UINT size) {  static SFFILEH statflag_create(const OEMCHAR *filename) {
   
         if (f && buf && size && (file_read(f->fh, buf, size) == size)) {          SFFILEH ret;
                 f->pos += size;          FILEH   fh;
                 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;
           }
           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);
         }          }
         return(NP2FLAG_FAILURE);          file_close(fh);
           file_delete(filename);
   
   sfc_err2:
           _MFREE(ret);
   
   sfc_err1:
           return(NULL);
 }  }
   
 static int flagload_close(NP2FFILE f) {  static int statflag_createsection(SFFILEH sffh, const SFENTRY *tbl) {
   
         if (file_seek(f->fh, f->next, 0) != f->next) {          int             ret;
                 return(NP2FLAG_FAILURE);  
           ret = statflag_closesection(sffh);
           if (ret != STATFLAG_SUCCESS) {
                   return(ret);
         }          }
         f->pos = f->next;          if (sffh->stat != SFFILEH_WRITE) {
         return(NP2FLAG_SUCCESS);                  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_create(NP2FFILE f, const STENTRY *t) {  int statflag_write(STFLAGH sfh, const void *buf, UINT size) {
   
         if (f && t) {          SFFILEH sffh;
                 int             len;  
                 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(NP2FLAG_FAILURE);  
                         }  
                         f->pos += rem;  
                 }  
                 f->bak = f->pos;  
   
                 len = strlen(t->index);          if (sfh == NULL) {
                 if (len >= 10) {                  goto sfw_err1;
                         len = 10;          }
           sffh = (SFFILEH)sfh;
           if (!(sffh->stat & SFFILEH_WRITE)) {
                   goto sfw_err2;
           }
           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 (len) {          }
                         CopyMemory(f->p.index, t->index, len);          if (size) {
                   if ((buf == NULL) || (file_write(sffh->fh, buf, size) != size)) {
                           goto sfw_err2;
                 }                  }
                 f->p.ver = t->ver;                  sfh->pos += size;
                 if (file_write(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {                  if (sfh->hdr.size < sfh->pos) {
                         return(NP2FLAG_FAILURE);                          sfh->hdr.size = sfh->pos;
                 }                  }
                 f->pos += sizeof(NP2FENT);  
                 return(NP2FLAG_SUCCESS);  
         }          }
         return(NP2FLAG_FAILURE);          return(STATFLAG_SUCCESS);
 }  
   
 static int flagsave_save(NP2FFILE f, void *buf, UINT size) {  sfw_err2:
           sffh->stat = SFFILEH_ERROR;
   
         if (f && buf && size && (file_write(f->fh, buf, size) == size)) {  sfw_err1:
                 f->pos += size;          return(STATFLAG_FAILURE);
                 f->p.size += size;  
                 return(NP2FLAG_SUCCESS);  
         }  
         return(NP2FLAG_FAILURE);  
 }  }
   
 static int flagsave_close(NP2FFILE f) {  static void statflag_close(SFFILEH sffh) {
   
         if (!f) {          if (sffh) {
                 goto fs_closeerr;                  statflag_closesection(sffh);
         }                  file_close(sffh->fh);
         if (file_seek(f->fh, f->bak, 0) != f->bak) {                  _MFREE(sffh);
                 goto fs_closeerr;  
         }          }
         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(NP2FLAG_SUCCESS);  
         }  
   
 fs_closeerr:  
         return(NP2FLAG_FAILURE);  
 }  }
   
 static void flagclose(NP2FFILE f) {  void statflag_seterr(STFLAGH sfh, const OEMCHAR *str) {
   
         if (f) {          if ((sfh) && (sfh->errlen)) {
                 file_close(f->fh);                  milstr_ncat(sfh->err, str, sfh->errlen);
                   milstr_ncat(sfh->err, CRCONST, sfh->errlen);
         }          }
 }  }
   
   
 // ----  // ---- function
   
 static int flagsave_term(NP2FFILE f, const STENTRY *t) {  // 関数ポインタを intに変更。
   static BRESULT proc2num(void *func, const PROCTBL *tbl, int size) {
   
         int             ret;          int             i;
   
         ret = flagsave_create(f, t);          for (i=0; i<size; i++) {
         ret |= flagsave_close(f);                  if (*(long *)func == (long)tbl->proc) {
         return(ret);                          *(long *)func = (long)tbl->id;
                           return(SUCCESS);
                   }
                   tbl++;
           }
           return(FAILURE);
 }  }
   
   static BRESULT num2proc(void *func, const PROCTBL *tbl, int size) {
   
 // ---- common          int             i;
   
 static int flagsave_common(NP2FFILE f, const STENTRY *t) {  
   
         int             ret;  
   
         ret = flagsave_create(f, t);          for (i=0; i<size; i++) {
         if (ret != NP2FLAG_FAILURE) {                  if (*(long *)func == (long)tbl->id) {
                 ret |= flagsave_save(f, t->arg1, t->arg2);                          *(long *)func = (long)tbl->proc;
                 ret |= flagsave_close(f);                          return(SUCCESS);
                   }
                   tbl++;
         }          }
         return(ret);          return(FAILURE);
 }  }
   
 static int flagload_common(NP2FFILE f, const STENTRY *t) {  
   
         return(flagload_load(f, t->arg1, t->arg2));  // ---- file
 }  
   
   typedef struct {
           OEMCHAR path[MAX_PATH];
           UINT    ftype;
           int             readonly;
           DOSDATE date;
           DOSTIME time;
   } STATPATH;
   
 // ----- clock  static const OEMCHAR str_updated[] = OEMTEXT("%s: updated");
   static const OEMCHAR str_notfound[] = OEMTEXT("%s: not found");
   
 static int flagload_clock(NP2FFILE f, const STENTRY *t) {  static int statflag_writepath(STFLAGH sfh, const OEMCHAR *path,
                                                                                                   UINT ftype, int readonly) {
   
         int             ret;          STATPATH        sp;
           FILEH           fh;
   
         ret = flagload_common(f, t);          ZeroMemory(&sp, sizeof(sp));
         sound_changeclock();          if ((path) && (path[0])) {
         beep_changeclock();                  file_cpyname(sp.path, path, NELEMENTS(sp.path));
         return(ret);                  sp.ftype = ftype;
                   sp.readonly = readonly;
                   fh = file_open_rb(path);
                   if (fh != FILEH_INVALID) {
                           file_getdatetime(fh, &sp.date, &sp.time);
                           file_close(fh);
                   }
           }
           return(statflag_write(sfh, &sp, sizeof(sp)));
 }  }
   
   static int statflag_checkpath(STFLAGH sfh, const OEMCHAR *devname) {
   
 // ---- memory          int                     ret;
           STATPATH        sp;
 static int flagsave_mem(NP2FFILE f, const STENTRY *t) {          FILEH           fh;
           OEMCHAR         buf[256];
         int             ret;          DOSDATE         date;
           DOSTIME         time;
   
         ret = flagsave_create(f, t);          ret = statflag_read(sfh, &sp, sizeof(sp));
         if (ret != NP2FLAG_FAILURE) {          if (sp.path[0]) {
                 ret |= flagsave_save(f, mem, 0x110000);                  fh = file_open_rb(sp.path);
                 ret |= flagsave_save(f, mem + VRAM1_B, 0x18000);                  if (fh != FILEH_INVALID) {
                 ret |= flagsave_save(f, mem + VRAM1_E, 0x8000);                          file_getdatetime(fh, &date, &time);
                 ret |= flagsave_close(f);                          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);          return(ret);
 }  }
   
 static int flagload_mem(NP2FFILE f, const STENTRY *t) {  
   
         int             ret;  // ---- common
   
         ret = flagload_load(f, mem, 0x110000);  static int flagsave_common(STFLAGH sfh, const SFENTRY *tbl) {
         ret |= flagload_load(f, mem + VRAM1_B, 0x18000);  
         ret |= flagload_load(f, mem + VRAM1_E, 0x8000);          return(statflag_write(sfh, tbl->arg1, tbl->arg2));
         (void)t;  }
         return(ret);  
   static int flagload_common(STFLAGH sfh, const SFENTRY *tbl) {
   
           return(statflag_read(sfh, tbl->arg1, tbl->arg2));
 }  }
   
   
 // ---- ext memory  // ---- memory
   
 static int flagsave_ext(NP2FFILE f, const STENTRY *t) {  static int flagsave_mem(STFLAGH sfh, const SFENTRY *tbl) {
   
         int             ret;          int             ret;
   
         ret = flagsave_create(f, t);          ret = statflag_write(sfh, mem, 0x110000);
         if (ret != NP2FLAG_FAILURE) {          ret |= statflag_write(sfh, mem + VRAM1_B, 0x18000);
                 ret |= flagsave_save(f, &extmem, sizeof(extmem));          ret |= statflag_write(sfh, mem + VRAM1_E, 0x8000);
                 if (CPU_EXTMEM) {          (void)tbl;
                         ret |= flagsave_save(f, CPU_EXTMEM, CPU_EXTMEMSIZE);  
                 }  
                 ret |= flagsave_close(f);  
         }  
         return(ret);          return(ret);
 }  }
   
 static int flagload_ext(NP2FFILE f, const STENTRY *t) {  static int flagload_mem(STFLAGH sfh, const SFENTRY *tbl) {
   
         int             ret;          int             ret;
         int             i;  
         UINT    pagemax = 0;  
   
         ret = flagload_load(f, &extmem, sizeof(extmem));          ret = statflag_read(sfh, mem, 0x110000);
         if (extmem.maxmem) {          ret |= statflag_read(sfh, mem + VRAM1_B, 0x18000);
                 if (extmem.maxmem > (13+1)) {          ret |= statflag_read(sfh, mem + VRAM1_E, 0x8000);
                         extmem.maxmem = (13+1);          (void)tbl;
                 }  
                 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);
 }  }
   
Line 456  static int flagload_ext(NP2FFILE f, cons Line 471  static int flagload_ext(NP2FFILE f, cons
 // ---- cg window  // ---- cg window
   
 #if defined(CGWND_FONTPTR)  #if defined(CGWND_FONTPTR)
 static int flagsave_cgwnd(NP2FFILE f, const STENTRY *t) {  static int flagsave_cgwnd(STFLAGH sfh, const SFENTRY *tbl) {
   
         int                     ret;  
         _CGWINDOW       cgwnd;          _CGWINDOW       cgwnd;
   
         cgwnd = cgwindow;          cgwnd = cgwindow;
         cgwnd.fontlow -= (long)fontrom;          cgwnd.fontlow -= (long)fontrom;
         cgwnd.fonthigh -= (long)fontrom;          cgwnd.fonthigh -= (long)fontrom;
         ret = flagsave_create(f, t);          (void)tbl;
         if (ret != NP2FLAG_FAILURE) {          return(statflag_write(sfh, &cgwindow, sizeof(cgwindow)));
                 ret |= flagsave_save(f, &cgwindow, sizeof(cgwindow));  
                 ret |= flagsave_close(f);  
         }  
         return(ret);  
 }  }
   
 static int flagload_cgwnd(NP2FFILE f, const STENTRY *t) {  static int flagload_cgwnd(STFLAGH sfh, const SFENTRY *tbl) {
   
         int             ret;          int             ret;
   
         ret = flagload_load(f, &cgwindow, sizeof(cgwindow));          ret = statflag_read(sfh, &cgwindow, sizeof(cgwindow));
         cgwindow.fontlow += (long)fontrom;          cgwindow.fontlow += (long)fontrom;
         cgwindow.fonthigh += (long)fontrom;          cgwindow.fonthigh += (long)fontrom;
         (void)t;          (void)tbl;
         return(ret);          return(ret);
 }  }
 #endif  #endif
Line 487  static int flagload_cgwnd(NP2FFILE f, co Line 497  static int flagload_cgwnd(NP2FFILE f, co
   
 // ---- dma  // ---- dma
   
 static int flagsave_dma(NP2FFILE f, const STENTRY *t) {  static int flagsave_dma(STFLAGH sfh, const SFENTRY *tbl) {
   
         int                     ret;  
         int                     i;          int                     i;
         _DMAC           dmabak;          _DMAC           dmabak;
   
         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(STATFLAG_FAILURE);
                 }                  }
         }          }
         ret = flagsave_create(f, t);          (void)tbl;
         if (ret != NP2FLAG_FAILURE) {          return(statflag_write(sfh, &dmabak, sizeof(dmabak)));
                 ret |= flagsave_save(f, &dmabak, sizeof(dmabak));  
                 ret |= flagsave_close(f);  
         }  
         return(ret);  
 }  }
   
 static int flagload_dma(NP2FFILE f, const STENTRY *t) {  static int flagload_dma(STFLAGH sfh, const SFENTRY *tbl) {
   
         int             ret;          int             ret;
         int             i;          int             i;
   
         ret = flagload_load(f, &dmac, sizeof(dmac));          ret = statflag_read(sfh, &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 |= STATFLAG_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 |= STATFLAG_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 |= STATFLAG_WARNING;
                 }                  }
         }          }
         (void)t;          (void)tbl;
         return(ret);          return(ret);
 }  }
   
   
 // ---- egc  // ---- egc
   
 static int flagsave_egc(NP2FFILE f, const STENTRY *t) {  static int flagsave_egc(STFLAGH sfh, const SFENTRY *tbl) {
   
         int             ret;  
         _EGC    egcbak;          _EGC    egcbak;
   
         egcbak = egc;          egcbak = egc;
         egcbak.inptr -= (long)egc.buf;          egcbak.inptr -= (long)egc.buf;
         egcbak.outptr -= (long)egc.buf;          egcbak.outptr -= (long)egc.buf;
           (void)tbl;
         ret = flagsave_create(f, t);          return(statflag_write(sfh, &egcbak, sizeof(egcbak)));
         if (ret != NP2FLAG_FAILURE) {  
                 ret |= flagsave_save(f, &egcbak, sizeof(egcbak));  
                 ret |= flagsave_close(f);  
         }  
         return(ret);  
 }  }
   
 static int flagload_egc(NP2FFILE f, const STENTRY *t) {  static int flagload_egc(STFLAGH sfh, const SFENTRY *tbl) {
   
         int             ret;          int             ret;
   
         ret = flagload_load(f, &egc, sizeof(egc));          ret = statflag_read(sfh, &egc, sizeof(egc));
         egc.inptr += (long)egc.buf;          egc.inptr += (long)egc.buf;
         egc.outptr += (long)egc.buf;          egc.outptr += (long)egc.buf;
         (void)t;          (void)tbl;
         return(ret);          return(ret);
 }  }
   
   
 // ---- epson  // ---- epson
   
 static int flagsave_epson(NP2FFILE f, const STENTRY *t) {  static int flagsave_epson(STFLAGH sfh, const SFENTRY *tbl) {
   
         int             ret;          int             ret;
   
         if (!(pc.model & PCMODEL_EPSON)) {          if (!(pccore.model & PCMODEL_EPSON)) {
                 return(NP2FLAG_SUCCESS);                  return(STATFLAG_SUCCESS);
         }  
         ret = flagsave_create(f, t);  
         if (ret != NP2FLAG_FAILURE) {  
                 ret |= flagsave_save(f, &epsonio, sizeof(epsonio));  
                 ret |= flagsave_save(f, mem + 0x1c0000, 0x8000);  
                 ret |= flagsave_save(f, mem + 0x1e8000, 0x18000);  
                 ret |= flagsave_close(f);  
         }          }
           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);          return(ret);
 }  }
   
 static int flagload_epson(NP2FFILE f, const STENTRY *t) {  static int flagload_epson(STFLAGH sfh, const SFENTRY *tbl) {
   
         int             ret;          int             ret;
   
         ret = flagload_load(f, &epsonio, sizeof(epsonio));          ret = statflag_read(sfh, &epsonio, sizeof(epsonio));
         ret |= flagload_load(f, mem + 0x1c0000, 0x8000);          ret |= statflag_read(sfh, mem + 0x1c0000, 0x8000);
         ret |= flagload_load(f, mem + 0x1e8000, 0x18000);          ret |= statflag_read(sfh, mem + 0x1e8000, 0x18000);
         (void)t;          (void)tbl;
         return(ret);          return(ret);
 }  }
   
Line 611  typedef struct { Line 607  typedef struct {
         NEVENTCB        proc;          NEVENTCB        proc;
 } NEVTITEM;  } NEVTITEM;
   
 static int nevent_save(NP2FFILE f, int num) {  static int nevent_write(STFLAGH sfh, int num) {
   
         NEVTITEM        nit;          NEVTITEM        nit;
         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 629  static int nevent_save(NP2FFILE f, int n Line 625  static int nevent_save(NP2FFILE f, int n
         if (PROC2NUM(nit.proc, evtproc)) {          if (PROC2NUM(nit.proc, evtproc)) {
                 nit.proc = NULL;                  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;          NEVTSAVE        nevt;
         int                     ret;          int                     ret;
Line 641  static int flagsave_evt(NP2FFILE f, cons Line 637  static int flagsave_evt(NP2FFILE f, cons
         nevt.readyevents = nevent.readyevents;          nevt.readyevents = nevent.readyevents;
         nevt.waitevents = nevent.waitevents;          nevt.waitevents = nevent.waitevents;
   
         ret = flagsave_create(f, t);          ret = statflag_write(sfh, &nevt, sizeof(nevt));
         if (ret != NP2FLAG_FAILURE) {          for (i=0; i<nevt.readyevents; i++) {
                 ret |= flagsave_save(f, &nevt, sizeof(nevt));                  ret |= nevent_write(sfh, nevent.level[i]);
                 for (i=0; i<nevt.readyevents; i++) {          }
                         ret |= nevent_save(f, nevent.level[i]);          for (i=0; i<nevt.waitevents; i++) {
                 }                  ret |= nevent_write(sfh, nevent.waitevent[i]);
                 for (i=0; i<nevt.waitevents; i++) {  
                         ret |= nevent_save(f, nevent.waitevent[i]);  
                 }  
                 ret |= flagsave_close(f);  
         }          }
           (void)tbl;
         return(ret);          return(ret);
 }  }
   
 static int nevent_load(NP2FFILE f, UINT *tbl, UINT *pos) {  static int nevent_read(STFLAGH sfh, UINT *tbl, UINT *pos) {
   
         int                     ret;          int                     ret;
         NEVTITEM        nit;          NEVTITEM        nit;
         UINT            i;          UINT            i;
         UINT            num;          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) {                  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;
                 nevent.item[num].proc = nit.proc;                  nevent.item[num].proc = nit.proc;
                 if (NUM2PROC(nevent.item[num].proc, evtproc)) {                  if (NUM2PROC(nevent.item[num].proc, evtproc)) {
                         ret |= NP2FLAG_WARNING;                          ret |= STATFLAG_WARNING;
                 }                  }
                 else {                  else {
                         tbl[*pos] = num;                          tbl[*pos] = num;
Line 683  static int nevent_load(NP2FFILE f, UINT  Line 676  static int nevent_load(NP2FFILE f, UINT 
                 }                  }
         }          }
         else {          else {
                 ret |= NP2FLAG_WARNING;                  ret |= STATFLAG_WARNING;
         }          }
         return(ret);          return(ret);
 }  }
   
 static int flagload_evt(NP2FFILE f, const STENTRY *t) {  static int flagload_evt(STFLAGH sfh, const SFENTRY *tbl) {
   
         int                     ret;          int                     ret;
         NEVTSAVE        nevt;          NEVTSAVE        nevt;
         UINT            i;          UINT            i;
   
         ret = flagload_load(f, &nevt, sizeof(nevt));          ret = statflag_read(sfh, &nevt, sizeof(nevt));
   
         nevent.readyevents = 0;          nevent.readyevents = 0;
         nevent.waitevents = 0;          nevent.waitevents = 0;
   
         for (i=0; i<nevt.readyevents; i++) {          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++) {          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) {
   
           int             ret;
   
           ret = STATFLAG_SUCCESS;
           if (CPU_EXTMEM) {
                   ret = statflag_read(sfh, CPU_EXTMEM, CPU_EXTMEMSIZE);
           }
           (void)tbl;
         return(ret);          return(ret);
 }  }
   
   
 // ---- gaiji  // ---- gaiji
   
 static int flagsave_gij(NP2FFILE f, const STENTRY *t) {  static int flagsave_gij(STFLAGH sfh, const SFENTRY *tbl) {
   
         int             ret;          int             ret;
         int             i;          int             i;
         int             j;          int             j;
         BYTE    *fnt;  const UINT8     *fnt;
   
         ret = flagsave_create(f, t);          ret = STATFLAG_SUCCESS;
         if (ret != NP2FLAG_FAILURE) {          for (i=0; i<2; i++) {
                 for (i=0; i<2; i++) {                  fnt = fontrom + ((0x56 + (i << 7)) << 4);
                         fnt = fontrom + ((0x56 + (i << 7)) << 4);                  for (j=0; j<0x80; j++) {
                         for (j=0; j<0x80; j++) {                          ret |= statflag_write(sfh, fnt, 32);
                                 ret |= flagsave_save(f, fnt, 32);                          fnt += 0x1000;
                                 fnt += 0x1000;  
                         }  
                 }                  }
                 ret |= flagsave_close(f);  
         }          }
           (void)tbl;
         return(ret);          return(ret);
 }  }
   
 static int flagload_gij(NP2FFILE f, const STENTRY *t) {  static int flagload_gij(STFLAGH sfh, const SFENTRY *tbl) {
   
         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++) {
                 fnt = fontrom + ((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 |= statflag_read(sfh, fnt, 32);
                         fnt += 0x1000;                          fnt += 0x1000;
                 }                  }
         }          }
         (void)t;          (void)tbl;
         return(ret);          return(ret);
 }  }
   
   
 // ---- FM  // ---- FM
   
   #if !defined(DISABLE_SOUND)
   
 enum {  enum {
         FLAG_MG                 = 0x0001,          FLAG_MG                 = 0x0001,
         FLAG_FM1A               = 0x0002,          FLAG_FM1A               = 0x0002,
Line 771  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(NP2FFILE f, const STENTRY *t) {  static int flagsave_fm(STFLAGH sfh, const SFENTRY *tbl) {
   
         int             ret;          int             ret;
         UINT    saveflg;          UINT    saveflg;
Line 829  static int flagsave_fm(NP2FFILE f, const Line 849  static int flagsave_fm(NP2FFILE f, const
                         break;                          break;
         }          }
   
         ret = flagsave_create(f, t);          ret = statflag_write(sfh, &usesound, sizeof(usesound));
         if (ret != NP2FLAG_FAILURE) {          if (saveflg & FLAG_MG) {
                 ret |= flagsave_save(f, &usesound, sizeof(usesound));                  ret |= statflag_write(sfh, &musicgen, sizeof(musicgen));
   
                 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_PSG3) {  
                         ret |= flagsave_save(f, &psg3.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);  
         }          }
         return(ret);          if (saveflg & FLAG_FM1A) {
 }                  ret |= statflag_write(sfh, &fmtimer, sizeof(fmtimer));
                   ret |= statflag_write(sfh, &opn, sizeof(opn));
 static void play_fmreg(BYTE num, UINT reg) {                  CopyMemory(opnkey.keyreg, opngen.keyreg, sizeof(opngen.keyreg));
                   opnkey.extop[0] = opnch[2].extop;
         UINT    chbase;                  opnkey.extop[1] = opnch[5].extop;
         UINT    i;                  opnkey.extop[2] = opnch[8].extop;
                   opnkey.extop[3] = opnch[11].extop;
         chbase = num * 3;                  ret |= statflag_write(sfh, &opnkey, sizeof(opnkey));
         for (i=0x30; i<0xa0; i++) {  
                 opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);  
         }          }
         for (i=0xb7; i>=0xa0; i--) {          if (saveflg & FLAG_PSG1) {
                 opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);                  ret |= statflag_write(sfh, &psg1.reg, sizeof(PSGREG));
         }          }
         for (i=0; i<3; i++) {          if (saveflg & FLAG_PSG2) {
                 opngen_keyon(chbase + i, opngen.keyreg[chbase + i]);                  ret |= statflag_write(sfh, &psg2.reg, sizeof(PSGREG));
         }          }
 }          if (saveflg & FLAG_PSG3) {
                   ret |= statflag_write(sfh, &psg3.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_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;          int             ret;
         UINT    saveflg;          UINT    saveflg;
         OPNKEY  opnkey;          OPNKEY  opnkey;
         UINT    fmreg1a;  
         UINT    fmreg1b;          ret = statflag_read(sfh, &usesound, sizeof(usesound));
         UINT    fmreg2a;          fmboard_reset(usesound);
         UINT    fmreg2b;  
   
         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);  
   
         fmreg1a = 0x000;  
         fmreg1b = 0x100;  
         fmreg2a = 0x200;  
         fmreg2b = 0x300;  
         switch(usesound) {          switch(usesound) {
                 case 0x01:                  case 0x01:
                         saveflg = FLAG_MG;                          saveflg = FLAG_MG;
Line 938  static int flagload_fm(NP2FFILE f, const Line 911  static int flagload_fm(NP2FFILE f, const
                 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 972  static int flagload_fm(NP2FFILE f, const Line 942  static int flagload_fm(NP2FFILE f, const
                         break;                          break;
         }          }
   
         if ((saveflg & FLAG_MG) && (f->p.ver != 0)) {          if (saveflg & FLAG_MG) {
                 ret |= flagload_load(f, &musicgen, sizeof(musicgen));                  ret |= statflag_read(sfh, &musicgen, sizeof(musicgen));
                 board14_allkeymake();                  board14_allkeymake();
         }          }
   
         if (saveflg & FLAG_FM1A) {          if (saveflg & FLAG_FM1A) {
                 ret |= flagload_load(f, &fmtimer, sizeof(fmtimer));                  ret |= statflag_read(sfh, &fmtimer, sizeof(fmtimer));
                 ret |= flagload_load(f, &opn, sizeof(opn));                  ret |= statflag_read(sfh, &opn, sizeof(opn));
                 ret |= flagload_load(f, &opnkey, sizeof(opnkey));                  ret |= statflag_read(sfh, &opnkey, sizeof(opnkey));
                 CopyMemory(opngen.keyreg, &opnkey.keyreg, sizeof(opngen.keyreg));                  CopyMemory(opngen.keyreg, &opnkey.keyreg, sizeof(opngen.keyreg));
                 opnch[2].extop = opnkey.extop[0];                  opnch[2].extop = opnkey.extop[0];
                 opnch[5].extop = opnkey.extop[1];                  opnch[5].extop = opnkey.extop[1];
Line 988  static int flagload_fm(NP2FFILE f, const Line 958  static int flagload_fm(NP2FFILE f, const
                 opnch[11].extop = opnkey.extop[3];                  opnch[11].extop = opnkey.extop[3];
         }          }
         if (saveflg & FLAG_PSG1) {          if (saveflg & FLAG_PSG1) {
                 ret |= flagload_load(f, &psg1.reg, sizeof(PSGREG));                  ret |= statflag_read(sfh, &psg1.reg, sizeof(PSGREG));
         }          }
         if (saveflg & FLAG_PSG2) {          if (saveflg & FLAG_PSG2) {
                 ret |= flagload_load(f, &psg2.reg, sizeof(PSGREG));                  ret |= statflag_read(sfh, &psg2.reg, sizeof(PSGREG));
         }          }
         if (saveflg & FLAG_PSG3) {          if (saveflg & FLAG_PSG3) {
                 ret |= flagload_load(f, &psg3.reg, sizeof(PSGREG));                  ret |= statflag_read(sfh, &psg3.reg, sizeof(PSGREG));
         }          }
         if (saveflg & FLAG_ADPCM) {          if (saveflg & FLAG_ADPCM) {
                 ret |= flagload_load(f, &adpcm, sizeof(adpcm));                  ret |= statflag_read(sfh, &adpcm, sizeof(adpcm));
         }          }
         if (saveflg & FLAG_PCM86) {          if (saveflg & FLAG_PCM86) {
                 ret |= flagload_load(f, &pcm86, sizeof(pcm86));                  ret |= statflag_read(sfh, &pcm86, sizeof(pcm86));
         }          }
         if (saveflg & FLAG_CS4231) {          if (saveflg & FLAG_CS4231) {
                 ret |= flagload_load(f, &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" CRLITERAL;  
 static const char str_notfound[] = "%s: not found" CRLITERAL;  
   
 static int disksave(NP2FFILE f, 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(flagsave_save(f, &st, sizeof(st)));          (void)tbl;
           return(ret);
 }  }
   
 static int flagsave_disk(NP2FFILE f, const STENTRY *t) {  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 = flagsave_create(f, t);          for (i=0; i<4; i++) {
         if (ret != NP2FLAG_FAILURE) {                  OEMSPRINTF(buf, str_fddx, i+1);
                 for (i=0; i<4; i++) {                  ret |= statflag_checkpath(sfh, buf);
                         ret |= disksave(f, fdd_diskname(i), fdd_diskprotect(i));          }
                 }          (void)tbl;
                 for (i=0x00; i<0x02; i++) {          return(ret);
                         ret |= disksave(f, sxsi_getname(i), 0);  }
                 }  
                 for (i=0x20; i<0x22; i++) {  static int flagload_fdd(STFLAGH sfh, const SFENTRY *tbl) {
                         ret |= disksave(f, sxsi_getname(i), 0);  
           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);
                 }                  }
                 ret |= flagsave_close(f);  
         }          }
           (void)tbl;
         return(ret);          return(ret);
 }  }
   
 static int diskcheck(NP2FFILE f, const char *name, ERR_BUF *e) {  
   // ---- sxsi
   
   typedef struct {
           UINT8   ide[4];
           UINT8   scsi[8];
   } 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;          int                     ret;
         FILEH           fh;          UINT            i;
         STATDISK        st;          SXSIDEVS        sds;
         char            buf[256];  const OEMCHAR   *path;
         DOSDATE         date;  
         DOSTIME         time;  
   
         ret = flagload_load(f, &st, sizeof(st));          sxsi_allflash();
         if (st.path[0]) {          ret = STATFLAG_SUCCESS;
                 fh = file_open_rb(st.path);          for (i=0; i<NELEMENTS(sds.ide); i++) {
                 if (fh != FILEH_INVALID) {                  sds.ide[i] = sxsi_getdevtype((REG8)i);
                         file_getdatetime(fh, &date, &time);          }
                         file_close(fh);          for (i=0; i<NELEMENTS(sds.scsi); i++) {
                         if ((memcmp(&st.date, &date, sizeof(date))) ||                  sds.scsi[i] = sxsi_getdevtype((REG8)(i + 0x20));
                                 (memcmp(&st.time, &time, sizeof(time)))) {          }
                                 ret |= NP2FLAG_DISKCHG;          ret = statflag_write(sfh, &sds, sizeof(sds));
                                 SPRINTF(buf, str_updated, name);          for (i=0; i<NELEMENTS(sds.ide); i++) {
                                 err_append(e, buf);                  if (sds.ide[i] != SXSIDEV_NC) {
                         }                          path = sxsi_getfilename((REG8)i);
                           ret |= statflag_writepath(sfh, path, FTYPE_NONE, 0);
                 }                  }
                 else {          }
                         ret |= NP2FLAG_DISKCHG;          for (i=0; i<NELEMENTS(sds.scsi); i++) {
                         SPRINTF(buf, str_notfound, name);                  if (sds.scsi[i] != SXSIDEV_NC) {
                         err_append(e, buf);                          path = sxsi_getfilename((REG8)(i + 0x20));
                           ret |= statflag_writepath(sfh, path, FTYPE_NONE, 0);
                 }                  }
         }          }
           (void)tbl;
         return(ret);          return(ret);
 }  }
   
 static int flagcheck_disk(NP2FFILE f, const STENTRY *t, ERR_BUF *e) {  static int flagcheck_sxsi(STFLAGH sfh, const SFENTRY *tbl) {
   
         int             ret;          int                     ret;
         int             i;          SXSIDEVS        sds;
         char    buf[8];          UINT            i;
           OEMCHAR         buf[8];
   
         ret = 0;          sxsi_allflash();
         for (i=0; i<4; i++) {          ret = statflag_read(sfh, &sds, sizeof(sds));
                 SPRINTF(buf, str_fddx, i+1);          for (i=0; i<NELEMENTS(sds.ide); i++) {
                 ret |= diskcheck(f, buf, e);                  if (sds.ide[i] != SXSIDEV_NC) {
         }                          OEMSPRINTF(buf, str_sasix, i+1);
         sxsi_flash();                          ret |= statflag_checkpath(sfh, buf);
         for (i=0; i<2; i++) {                  }
                 SPRINTF(buf, str_sasix, i+1);  
                 ret |= diskcheck(f, buf, e);  
         }          }
         for (i=0; i<2; i++) {          for (i=0; i<NELEMENTS(sds.scsi); i++) {
                 SPRINTF(buf, str_scsix, i+1);                  if (sds.scsi[i] != SXSIDEV_NC) {
                 ret |= diskcheck(f, buf, e);                          OEMSPRINTF(buf, str_scsix, i);
                           ret |= statflag_checkpath(sfh, buf);
                   }
         }          }
         (void)t;          (void)tbl;
         return(ret);          return(ret);
 }  }
   
 static int flagload_disk(NP2FFILE f, const STENTRY *t) {  static int flagload_sxsi(STFLAGH sfh, const SFENTRY *tbl) {
   
         int                     ret;          int                     ret;
         BYTE            i;          SXSIDEVS        sds;
         STATDISK        st;          UINT            i;
           REG8            drv;
           STATPATH        sp;
   
         ret = 0;          ret = statflag_read(sfh, &sds, sizeof(sds));
         for (i=0; i<4; i++) {          if (ret != STATFLAG_SUCCESS) {
                 ret |= flagload_load(f, &st, sizeof(st));                  return(ret);
                 if (st.path[0]) {          }
                         fdd_set(i, st.path, FTYPE_NONE, st.readonly);          for (i=0; i<NELEMENTS(sds.ide); i++) {
                 }                  drv = (REG8)i;
         }                  sxsi_setdevtype(drv, sds.ide[i]);
         sxsi_trash();                  if (sds.ide[i] != SXSIDEV_NC) {
         for (i=0x00; i<0x02; i++) {                          ret |= statflag_read(sfh, &sp, sizeof(sp));
                 ret |= flagload_load(f, &st, sizeof(st));                          sxsi_devopen(drv, sp.path);
                 if (st.path[0]) {                  }
                         sxsi_hddopen(i, st.path);          }
                 }          for (i=0; i<NELEMENTS(sds.scsi); i++) {
         }                  drv = (REG8)(i + 0x20);
         for (i=0x20; i<0x22; i++) {                  sxsi_setdevtype(drv, sds.scsi[i]);
                 ret |= flagload_load(f, &st, sizeof(st));                  if (sds.scsi[i] != SXSIDEV_NC) {
 #if 0                          ret |= statflag_read(sfh, &sp, sizeof(sp));
                 if (file[0]) {                          sxsi_devopen(drv, sp.path);
                         bios0x1b_scsiopen(i, file);  
                 }                  }
 #endif  
         }          }
         (void)t;          (void)tbl;
         return(ret);          return(ret);
 }  }
   
   
 // ---- com  // ---- com
   
 static int flagsave_com(NP2FFILE f, const STENTRY *t) {  static int flagsave_com(STFLAGH sfh, const SFENTRY *tbl) {
   
         UINT    device;          UINT    device;
         COMMNG  cm;          COMMNG  cm;
         int             ret;          int             ret;
         COMFLAG flag;          COMFLAG flag;
   
         device = (UINT)t->arg1;          device = (UINT)(long)tbl->arg1;
         switch(device) {          switch(device) {
                 case 0:                  case 0:
                         cm = cm_mpu98;                          cm = cm_mpu98;
Line 1210  static int flagsave_com(NP2FFILE f, cons Line 1168  static int flagsave_com(NP2FFILE f, cons
                         cm = NULL;                          cm = NULL;
                         break;                          break;
         }          }
         ret = NP2FLAG_SUCCESS;          ret = STATFLAG_SUCCESS;
         if (cm) {          if (cm) {
                 flag = (COMFLAG)cm->msg(cm, COMMSG_GETFLAG, 0);                  flag = (COMFLAG)cm->msg(cm, COMMSG_GETFLAG, 0);
                 if (flag) {                  if (flag) {
                         ret = flagsave_create(f, t);                          ret |= statflag_write(sfh, flag, flag->size);
                         if (ret != NP2FLAG_FAILURE) {  
                                 ret |= flagsave_save(f, flag, flag->size);  
                                 ret |= flagsave_close(f);  
                         }  
                         _MFREE(flag);                          _MFREE(flag);
                 }                  }
         }          }
         return(ret);          return(ret);
 }  }
   
 static int flagload_com(NP2FFILE f, const STENTRY *t) {  static int flagload_com(STFLAGH sfh, const SFENTRY *tbl) {
   
         UINT            device;          UINT            device;
         COMMNG          cm;          COMMNG          cm;
Line 1233  static int flagload_com(NP2FFILE f, cons Line 1187  static int flagload_com(NP2FFILE f, cons
         _COMFLAG        fhdr;          _COMFLAG        fhdr;
         COMFLAG         flag;          COMFLAG         flag;
   
         ret = flagload_load(f, &fhdr, sizeof(fhdr));          ret = statflag_read(sfh, &fhdr, sizeof(fhdr));
         if (ret != NP2FLAG_SUCCESS) {          if (ret != STATFLAG_SUCCESS) {
                 goto flcom_err1;                  goto flcom_err1;
         }          }
         if (fhdr.size < sizeof(fhdr)) {          if (fhdr.size < sizeof(fhdr)) {
Line 1245  static int flagload_com(NP2FFILE f, cons Line 1199  static int flagload_com(NP2FFILE f, cons
                 goto flcom_err1;                  goto flcom_err1;
         }          }
         CopyMemory(flag, &fhdr, sizeof(fhdr));          CopyMemory(flag, &fhdr, sizeof(fhdr));
         ret |= flagload_load(f, flag + 1, fhdr.size - sizeof(fhdr));          ret |= statflag_read(sfh, flag + 1, fhdr.size - sizeof(fhdr));
         if (ret != NP2FLAG_SUCCESS) {          if (ret != STATFLAG_SUCCESS) {
                 goto flcom_err2;                  goto flcom_err2;
         }          }
   
         device = (UINT)t->arg1;          device = (UINT)(long)tbl->arg1;
         switch(device) {          switch(device) {
                 case 0:                  case 0:
                         commng_destroy(cm_mpu98);                          commng_destroy(cm_mpu98);
Line 1282  flcom_err1: Line 1236  flcom_err1:
   
 // ----  // ----
   
 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 ((sfh->hdr.ver == tbl->ver) && (sfh->hdr.size == tbl->arg2)) {
                 if ((f->p.ver == t->ver) && (f->p.size == t->arg2)) {                  return(STATFLAG_SUCCESS);
                         return(NP2FLAG_SUCCESS);  
                 }  
                 return(NP2FLAG_VERSION);  
         }          }
         (void)e;          return(STATFLAG_FAILURE);
         return(NP2FLAG_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 (sfh->hdr.ver == tbl->ver) {
                 if (f->p.ver == t->ver) {                  return(STATFLAG_SUCCESS);
                         return(NP2FLAG_SUCCESS);  
                 }  
                 return(NP2FLAG_VERSION);  
         }          }
         (void)e;          return(STATFLAG_FAILURE);
         return(NP2FLAG_FAILURE);  
 }  }
   
   
 // ----  // ----
   
 int statsave_save(const char *filename) {  int statsave_save(const OEMCHAR *filename) {
   
         _NP2FFILE       f;          SFFILEH         sffh;
         int                     ret;          int                     ret;
 const STENTRY   *tbl;  const SFENTRY   *tbl;
 const STENTRY   *tblterm;  const SFENTRY   *tblterm;
   
         ret = flagcreate(&f, filename);          sffh = statflag_create(filename);
         if (ret == NP2FLAG_FAILURE) {          if (sffh == NULL) {
                 return(ret);                  return(STATFLAG_FAILURE);
         }          }
   
           ret = STATFLAG_SUCCESS;
         tbl = np2tbl;          tbl = np2tbl;
         tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));          tblterm = tbl + NELEMENTS(np2tbl);
         while(tbl < tblterm) {          while(tbl < tblterm) {
                   ret |= statflag_createsection(sffh, tbl);
                 switch(tbl->type) {                  switch(tbl->type) {
                         case NP2FLAG_BIN:                          case STATFLAG_BIN:
                         case NP2FLAG_CLOCK:                          case STATFLAG_TERM:
                                 ret |= flagsave_common(&f, tbl);                                  ret |= flagsave_common(&sffh->sfh, tbl);
                                 break;  
   
                         case NP2FLAG_TERM:  
                                 ret |= flagsave_term(&f, tbl);  
                                 break;                                  break;
   
 #if defined(CGWND_FONTPTR)  #if defined(CGWND_FONTPTR)
                         case NP2FLAG_CGW:                          case STATFLAG_CGW:
                                 ret |= flagsave_cgwnd(&f, tbl);                                  ret |= flagsave_cgwnd(&sffh->sfh, tbl);
                                 break;                                  break;
 #endif  #endif
   
                         case NP2FLAG_COM:                          case STATFLAG_COM:
                                 ret |= flagsave_com(&f, tbl);                                  ret |= flagsave_com(&sffh->sfh, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_DISK:                          case STATFLAG_DMA:
                                 ret |= flagsave_disk(&f, tbl);                                  ret |= flagsave_dma(&sffh->sfh, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_DMA:                          case STATFLAG_EGC:
                                 ret |= flagsave_dma(&f, tbl);                                  ret |= flagsave_egc(&sffh->sfh, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_EGC:                          case STATFLAG_EPSON:
                                 ret |= flagsave_egc(&f, tbl);                                  ret |= flagsave_epson(&sffh->sfh, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_EPSON:                          case STATFLAG_EVT:
                                 ret |= flagsave_epson(&f, tbl);                                  ret |= flagsave_evt(&sffh->sfh, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_EVT:                          case STATFLAG_EXT:
                                 ret |= flagsave_evt(&f, tbl);                                  ret |= flagsave_ext(&sffh->sfh, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_EXT:                          case STATFLAG_FDD:
                                 ret |= flagsave_ext(&f, tbl);                                  ret |= flagsave_fdd(&sffh->sfh, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_FM:  #if !defined(DISABLE_SOUND)
                                 ret |= flagsave_fm(&f, tbl);                          case STATFLAG_FM:
                                   ret |= flagsave_fm(&sffh->sfh, tbl);
                                 break;                                  break;
   #endif
   
                         case NP2FLAG_GIJ:                          case STATFLAG_GIJ:
                                 ret |= flagsave_gij(&f, tbl);                                  ret |= flagsave_gij(&sffh->sfh, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_MEM:  #if defined(SUPPORT_HOSTDRV)
                                 ret |= flagsave_mem(&f, tbl);                                  case STATFLAG_HDRV:
                                   ret |= hostdrv_sfsave(&sffh->sfh, tbl);
                                   break;
   #endif
   
                           case STATFLAG_MEM:
                                   ret |= flagsave_mem(&sffh->sfh, tbl);
                                   break;
   
                           case STATFLAG_SXSI:
                                   ret |= flagsave_sxsi(&sffh->sfh, tbl);
                                 break;                                  break;
                 }                  }
                 tbl++;                  tbl++;
         }          }
         flagclose(&f);          statflag_close(sffh);
         return(ret);          return(ret);
 }  }
   
 int statsave_check(const char *filename, char *buf, int size) {  int statsave_check(const OEMCHAR *filename, OEMCHAR *buf, int size) {
   
         ERR_BUF         e;          SFFILEH         sffh;
         _NP2FFILE       f;  
         int                     ret;          int                     ret;
         BOOL            done;          BOOL            done;
 const STENTRY   *tbl;  const SFENTRY   *tbl;
 const STENTRY   *tblterm;  const SFENTRY   *tblterm;
   
         e.buf = buf;          sffh = statflag_open(filename, buf, size);
         e.remain = size;          if (sffh == NULL) {
         if (e.remain) {                  return(STATFLAG_FAILURE);
                 e.remain--;  
                 if (buf) {  
                         *buf = '\0';  
                 }  
         }  
         else {  
                 e.buf = NULL;  
         }          }
   
         ret = flagopen(&f, filename, &e);          done = FALSE;
         if (ret != NP2FLAG_FAILURE) {          ret = STATFLAG_SUCCESS;
                 done = FALSE;          while((!done) && (ret != STATFLAG_FAILURE)) {
                 while((!done) && (ret != NP2FLAG_FAILURE)) {                  ret |= statflag_readsection(sffh);
                         char index[11];                  tbl = np2tbl;
                         ret |= flagload_create(&f);                  tblterm = tbl + NELEMENTS(np2tbl);
                         CopyMemory(index, f.p.index, sizeof(f.p.index));                  while(tbl < tblterm) {
                         index[10] = 0;                          if (!memcmp(sffh->sfh.hdr.index, tbl->index, 10)) {
                         tbl = np2tbl;                                  break;
                         tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));  
                         while(tbl < tblterm) {  
                                 if (!strcmp(index, tbl->index)) {  
                                         break;  
                                 }  
                                 tbl++;  
                         }                          }
                         if (tbl < tblterm) {                          tbl++;
                                 switch(tbl->type) {                  }
                                         case NP2FLAG_BIN:                  if (tbl < tblterm) {
                           switch(tbl->type) {
                                   case STATFLAG_BIN:
 #if defined(CGWND_FONTPTR)  #if defined(CGWND_FONTPTR)
                                         case NP2FLAG_CGW:                                  case STATFLAG_CGW:
 #endif  #endif
                                         case NP2FLAG_CLOCK:                                  case STATFLAG_MEM:
                                         case NP2FLAG_MEM:                                          ret |= flagcheck_versize(&sffh->sfh, tbl);
                                                 ret |= flagcheck_versize(&f, tbl, &e);                                          break;
                                                 break;  
                                   case STATFLAG_TERM:
                                         case NP2FLAG_TERM:                                          done = TRUE;
                                                 done = TRUE;                                          break;
                                                 break;  
                                   case STATFLAG_COM:
                                         case NP2FLAG_COM:                                  case STATFLAG_DMA:
                                         case NP2FLAG_DMA:                                  case STATFLAG_EGC:
                                         case NP2FLAG_EGC:                                  case STATFLAG_EPSON:
                                         case NP2FLAG_EPSON:                                  case STATFLAG_EVT:
                                         case NP2FLAG_EVT:                                  case STATFLAG_EXT:
                                         case NP2FLAG_EXT:                                  case STATFLAG_GIJ:
                                         case NP2FLAG_GIJ:  #if !defined(DISABLE_SOUND)
                                         case NP2FLAG_FM:                                  case STATFLAG_FM:
                                                 ret |= flagcheck_veronly(&f, tbl, &e);  #endif
                                                 break;  #if defined(SUPPORT_HOSTDRV)
                                   case STATFLAG_HDRV:
                                         case NP2FLAG_DISK:  #endif
                                                 ret |= flagcheck_disk(&f, tbl, &e);                                          ret |= flagcheck_veronly(&sffh->sfh, tbl);
                                                 break;                                          break;
   
                                         default:                                  case STATFLAG_FDD:
                                                 ret |= NP2FLAG_WARNING;                                          ret |= flagcheck_fdd(&sffh->sfh, tbl);
                                                 break;                                          break;
                                 }  
                         }                                  case STATFLAG_SXSI:
                         else {                                          ret |= flagcheck_sxsi(&sffh->sfh, tbl);
                                 ret |= NP2FLAG_WARNING;                                          break;
   
                                   default:
                                           ret |= STATFLAG_WARNING;
                                           break;
                         }                          }
                         ret |= flagload_close(&f);  
                 }                  }
                 flagclose(&f);                  else {
         }                          ret |= STATFLAG_WARNING;
         if (e.buf) {                  }
                 *e.buf = '\0';  
         }          }
           statflag_close(sffh);
         return(ret);          return(ret);
 }  }
   
 int statsave_load(const char *filename) {  int statsave_load(const OEMCHAR *filename) {
   
         _NP2FFILE       f;          SFFILEH         sffh;
         int                     ret;          int                     ret;
         BOOL            done;          BOOL            done;
 const STENTRY   *tbl;  const SFENTRY   *tbl;
 const STENTRY   *tblterm;  const SFENTRY   *tblterm;
   
         ret = flagopen(&f, filename, NULL);          sffh = statflag_open(filename, NULL, 0);
         if (ret == NP2FLAG_FAILURE) {          if (sffh == NULL) {
                 return(ret);                  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();          soundmng_stop();
         rs232c_midipanic();          rs232c_midipanic();
         mpu98ii_midipanic();          mpu98ii_midipanic();
         pc9861k_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();          sound_reset();
         fmboard_reset(0);          fddmtrsnd_bind();
   
           iocore_reset();                                                         // サウンドでpicを呼ぶので…
           cbuscore_reset();
           fmboard_reset(pccore.sound);
   
         done = FALSE;          done = FALSE;
         while((!done) && (ret != NP2FLAG_FAILURE)) {          while((!done) && (ret != STATFLAG_FAILURE)) {
                 char index[11];                  ret |= statflag_readsection(sffh);
                 ret |= flagload_create(&f);                  tbl = np2tbl + 1;
                 CopyMemory(index, f.p.index, sizeof(f.p.index));                  tblterm = np2tbl + NELEMENTS(np2tbl);
                 index[10] = 0;  
                 tbl = np2tbl;  
                 tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));  
                 while(tbl < tblterm) {                  while(tbl < tblterm) {
                         if (!strcmp(index, tbl->index)) {                          if (!memcmp(sffh->sfh.hdr.index, tbl->index, 10)) {
                                 break;                                  break;
                         }                          }
                         tbl++;                          tbl++;
                 }                  }
                 if (tbl < tblterm) {                  if (tbl < tblterm) {
                         switch(tbl->type) {                          switch(tbl->type) {
                                 case NP2FLAG_BIN:                                  case STATFLAG_BIN:
                                         ret |= flagload_common(&f, tbl);                                          ret |= flagload_common(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_TERM:                                  case STATFLAG_TERM:
                                         done = TRUE;                                          done = TRUE;
                                         break;                                          break;
   
 #if defined(CGWND_FONTPTR)  #if defined(CGWND_FONTPTR)
                                 case NP2FLAG_CGW:                                  case STATFLAG_CGW:
                                         ret |= flagload_cgwnd(&f, tbl);                                          ret |= flagload_cgwnd(&sffh->sfh, tbl);
                                         break;                                          break;
 #endif  #endif
   
                                 case NP2FLAG_CLOCK:                                  case STATFLAG_COM:
                                         ret |= flagload_clock(&f, tbl);                                          ret |= flagload_com(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_COM:                                  case STATFLAG_DMA:
                                         ret |= flagload_com(&f, tbl);                                          ret |= flagload_dma(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_DISK:                                  case STATFLAG_EGC:
                                         ret |= flagload_disk(&f, tbl);                                          ret |= flagload_egc(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_DMA:                                  case STATFLAG_EPSON:
                                         ret |= flagload_dma(&f, tbl);                                          ret |= flagload_epson(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_EGC:                                  case STATFLAG_EVT:
                                         ret |= flagload_egc(&f, tbl);                                          ret |= flagload_evt(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_EPSON:                                  case STATFLAG_EXT:
                                         ret |= flagload_epson(&f, tbl);                                          ret |= flagload_ext(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_EVT:                                  case STATFLAG_FDD:
                                         ret |= flagload_evt(&f, tbl);                                          ret |= flagload_fdd(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_EXT:  #if !defined(DISABLE_SOUND)
                                         ret |= flagload_ext(&f, tbl);                                  case STATFLAG_FM:
                                           ret |= flagload_fm(&sffh->sfh, tbl);
                                         break;                                          break;
   #endif
   
                                 case NP2FLAG_FM:                                  case STATFLAG_GIJ:
                                         ret |= flagload_fm(&f, tbl);                                          ret |= flagload_gij(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_GIJ:  #if defined(SUPPORT_HOSTDRV)
                                         ret |= flagload_gij(&f, tbl);                                  case STATFLAG_HDRV:
                                           ret |= hostdrv_sfload(&sffh->sfh, tbl);
                                           break;
   #endif
   
                                   case STATFLAG_MEM:
                                           ret |= flagload_mem(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_MEM:                                  case STATFLAG_SXSI:
                                         ret |= flagload_mem(&f, tbl);                                          ret |= flagload_sxsi(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 default:                                  default:
                                         ret |= NP2FLAG_WARNING;                                          ret |= STATFLAG_WARNING;
                                         break;                                          break;
                         }                          }
                 }                  }
                 else {                  else {
                         ret |= NP2FLAG_WARNING;                          ret |= STATFLAG_WARNING;
                 }                  }
                 ret |= flagload_close(&f);  
         }          }
         flagclose(&f);          statflag_close(sffh);
   
         // I/O作り直し          // I/O作り直し
         i286_memorymap((pc.model & PCMODEL_EPSON)?1:0);          i286_memorymap((pccore.model & PCMODEL_EPSON)?1:0);
         iocore_build();          iocore_build();
         iocore_bind();          iocore_bind();
         cbuscore_bind();          cbuscore_bind();
Removed from v.1.24  
changed lines
  Added in v.1.48

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