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

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

version 1.4, 2003/10/18 07:28:50 version 1.18, 2003/12/05 09:46:15
Line 12 Line 12
 #include        "pc9861k.h"  #include        "pc9861k.h"
 #include        "mpu98ii.h"  #include        "mpu98ii.h"
 #include        "board14.h"  #include        "board14.h"
   #include        "amd98.h"
   #include        "bios.h"
 #include        "vram.h"  #include        "vram.h"
 #include        "maketext.h"  
 #include        "palettes.h"  #include        "palettes.h"
 #include        "font.h"  #include        "maketext.h"
 #include        "sound.h"  #include        "sound.h"
 #include        "bios.h"  
 #include        "fmboard.h"  #include        "fmboard.h"
 #include        "beep.h"  #include        "beep.h"
   #include        "font.h"
 #include        "fddfile.h"  #include        "fddfile.h"
 #include        "fdd_mtr.h"  #include        "fdd_mtr.h"
 #include        "sxsi.h"  #include        "sxsi.h"
Line 28 Line 29
 #include        "keydisp.h"  #include        "keydisp.h"
   
   
   #if defined(MACOS)
   #define CRLITERAL       "\r"
   #define CRCONST         str_cr
   #elif defined(WIN32) || defined(X11) || defined(SLZAURUS)
   #define CRLITERAL       "\n"
   #define CRCONST         str_lf
   #else
   #define CRLITERAL       "\r\n"
   #define CRCONST         str_crlf
   #endif
   
   
 typedef struct {  typedef struct {
         char    name[16];          char    name[16];
         char    vername[28];          char    vername[28];
Line 38  typedef struct { Line 51  typedef struct {
         char    index[10];          char    index[10];
         UINT16  ver;          UINT16  ver;
         UINT32  size;          UINT32  size;
 } NP2FLAGPART_T;  } NP2FENT;
   
 enum {  enum {
         NP2FLAG_BIN                     = 0,          NP2FLAG_BIN                     = 0,
         NP2FLAG_TERM,          NP2FLAG_TERM,
         NP2FLAG_CORE,          NP2FLAG_CLOCK,
           NP2FLAG_COM,
           NP2FLAG_DISK,
         NP2FLAG_DMA,          NP2FLAG_DMA,
         NP2FLAG_EGC,          NP2FLAG_EGC,
         NP2FLAG_EXT,  
         NP2FLAG_EVT,          NP2FLAG_EVT,
         NP2FLAG_GIJ,          NP2FLAG_EXT,
         NP2FLAG_FM,          NP2FLAG_FM,
         NP2FLAG_BEEP,          NP2FLAG_GIJ,
         NP2FLAG_MIDI,          NP2FLAG_MEM
         NP2FLAG_DISK  
 };  };
   
 typedef struct {  typedef struct {
Line 73  typedef struct { Line 86  typedef struct {
         int             num;          int             num;
 } ENUMTBL;  } ENUMTBL;
   
 #define PROCID(a, b, c, d)      (((d) << 24) | ((c) << 16) | ((b) << 8) | (a))  #define PROCID(a, b, c, d)      (((d) << 24) + ((c) << 16) + ((b) << 8) + (a))
 #define PROC2NUM(a, b)          proc2num(&(a), b, sizeof(b)/sizeof(PROCTBL))  #define PROC2NUM(a, b)          proc2num(&(a), (b), sizeof(b)/sizeof(PROCTBL))
 #define NUM2PROC(a, b)          num2proc(&(a), b, sizeof(b)/sizeof(PROCTBL))  #define NUM2PROC(a, b)          num2proc(&(a), (b), sizeof(b)/sizeof(PROCTBL))
   
 #include "statsave.tbl"  #include "statsave.tbl"
   
Line 90  typedef struct { Line 103  typedef struct {
   
 static void err_append(ERR_BUF *e, char *buf) {  static void err_append(ERR_BUF *e, char *buf) {
   
           int             len;
   
         if ((e) && (buf)) {          if ((e) && (buf)) {
                 if (e->buf) {                  if (e->buf) {
                         int len;  
                         len = strlen(buf);                          len = strlen(buf);
                         if (e->remain >= len) {                          if (e->remain >= len) {
                                 CopyMemory(e->buf, buf, len);                                  CopyMemory(e->buf, buf, len);
Line 139  static BOOL num2proc(void *func, const P Line 153  static BOOL num2proc(void *func, const P
 // ----  // ----
   
 typedef struct {  typedef struct {
         FILEH           fh;          FILEH   fh;
         long            pos;          long    pos;
         long            bak;          long    bak;
         long            next;          long    next;
         NP2FHDR         f;          NP2FHDR f;
         NP2FLAGPART_T   p;          NP2FENT p;
 } NP2FFILE;  } _NP2FFILE, *NP2FFILE;
   
 static int flagopen(NP2FFILE *f, const char *filename, ERR_BUF *e) {  static int flagopen(NP2FFILE f, const char *filename, ERR_BUF *e) {
   
         if (f) {          if (f) {
                 f->fh = file_open(filename);                  f->fh = file_open(filename);
Line 186  static int flagopen(NP2FFILE *f, const c Line 200  static int flagopen(NP2FFILE *f, const c
         return(NP2FLAG_FAILURE);          return(NP2FLAG_FAILURE);
 }  }
   
 static int flagcreate(NP2FFILE *f, const char *filename) {  static int flagcreate(NP2FFILE f, const char *filename) {
   
         if (f) {          if (f) {
                 f->fh = file_create(filename);                  f->fh = file_create(filename);
Line 204  static int flagcreate(NP2FFILE *f, const Line 218  static int flagcreate(NP2FFILE *f, const
         return(NP2FLAG_FAILURE);          return(NP2FLAG_FAILURE);
 }  }
   
 static int flagload_create(NP2FFILE *f) {  static int flagload_create(NP2FFILE f) {
   
         if (f) {          if (f) {
                 ZeroMemory(&f->p, sizeof(NP2FLAGPART_T));                  ZeroMemory(&f->p, sizeof(NP2FENT));
                 if (f->pos & 15) {                  if (f->pos & 15) {
                         f->pos += 15;                          f->pos += 15;
                         f->pos &= ~0xf;                          f->pos &= ~0xf;
Line 215  static int flagload_create(NP2FFILE *f)  Line 229  static int flagload_create(NP2FFILE *f) 
                                 return(NP2FLAG_FAILURE);                                  return(NP2FLAG_FAILURE);
                         }                          }
                 }                  }
                 if (file_read(f->fh, &f->p, sizeof(NP2FLAGPART_T))                  if (file_read(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {
                                                                                                 != sizeof(NP2FLAGPART_T)) {  
                         return(NP2FLAG_FAILURE);                          return(NP2FLAG_FAILURE);
                 }                  }
                 f->pos += sizeof(NP2FLAGPART_T);                  f->pos += sizeof(NP2FENT);
                 f->next = f->pos + f->p.size;                  f->next = f->pos + f->p.size;
                 return(NP2FLAG_SUCCESS);                  return(NP2FLAG_SUCCESS);
         }          }
         return(NP2FLAG_FAILURE);          return(NP2FLAG_FAILURE);
 }  }
   
 static int flagload_load(NP2FFILE *f, void *buf, UINT size) {  static int flagload_load(NP2FFILE f, void *buf, UINT size) {
   
         if (f && buf && size && (file_read(f->fh, buf, size) == size)) {          if (f && buf && size && (file_read(f->fh, buf, size) == size)) {
                 f->pos += size;                  f->pos += size;
Line 235  static int flagload_load(NP2FFILE *f, vo Line 248  static int flagload_load(NP2FFILE *f, vo
         return(NP2FLAG_FAILURE);          return(NP2FLAG_FAILURE);
 }  }
   
 static int flagload_close(NP2FFILE *f) {  static int flagload_close(NP2FFILE f) {
   
         if (file_seek(f->fh, f->next, 0) != f->next) {          if (file_seek(f->fh, f->next, 0) != f->next) {
                 return(NP2FLAG_FAILURE);                  return(NP2FLAG_FAILURE);
Line 244  static int flagload_close(NP2FFILE *f) { Line 257  static int flagload_close(NP2FFILE *f) {
         return(NP2FLAG_SUCCESS);          return(NP2FLAG_SUCCESS);
 }  }
   
 static int flagsave_create(NP2FFILE *f, const STENTRY *t) {  static int flagsave_create(NP2FFILE f, const STENTRY *t) {
   
         if (f && t) {          if (f && t) {
                 int             len;                  int             len;
                 ZeroMemory(&f->p, sizeof(NP2FLAGPART_T));                  ZeroMemory(&f->p, sizeof(NP2FENT));
                 if (f->pos & 15) {                  if (f->pos & 15) {
                         UINT rem;                          UINT rem;
                         rem = 16 - (f->pos & 15);                          rem = 16 - (f->pos & 15);
Line 267  static int flagsave_create(NP2FFILE *f,  Line 280  static int flagsave_create(NP2FFILE *f, 
                         CopyMemory(f->p.index, t->index, len);                          CopyMemory(f->p.index, t->index, len);
                 }                  }
                 f->p.ver = t->ver;                  f->p.ver = t->ver;
                 if (file_write(f->fh, &f->p, sizeof(NP2FLAGPART_T))                  if (file_write(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {
                                                                                                 != sizeof(NP2FLAGPART_T)) {  
                         return(NP2FLAG_FAILURE);                          return(NP2FLAG_FAILURE);
                 }                  }
                 f->pos += sizeof(NP2FLAGPART_T);                  f->pos += sizeof(NP2FENT);
                 return(NP2FLAG_SUCCESS);                  return(NP2FLAG_SUCCESS);
         }          }
         return(NP2FLAG_FAILURE);          return(NP2FLAG_FAILURE);
 }  }
   
 static int flagsave_save(NP2FFILE *f, void *buf, UINT size) {  static int flagsave_save(NP2FFILE f, void *buf, UINT size) {
   
         if (f && buf && size && (file_write(f->fh, buf, size) == size)) {          if (f && buf && size && (file_write(f->fh, buf, size) == size)) {
                 f->pos += size;                  f->pos += size;
Line 287  static int flagsave_save(NP2FFILE *f, vo Line 299  static int flagsave_save(NP2FFILE *f, vo
         return(NP2FLAG_FAILURE);          return(NP2FLAG_FAILURE);
 }  }
   
 static int flagsave_close(NP2FFILE *f) {  static int flagsave_close(NP2FFILE f) {
   
         if (!f) {          if (!f) {
                 goto fs_closeerr;                  goto fs_closeerr;
Line 295  static int flagsave_close(NP2FFILE *f) { Line 307  static int flagsave_close(NP2FFILE *f) {
         if (file_seek(f->fh, f->bak, 0) != f->bak) {          if (file_seek(f->fh, f->bak, 0) != f->bak) {
                 goto fs_closeerr;                  goto fs_closeerr;
         }          }
         if (file_write(f->fh, &f->p, sizeof(NP2FLAGPART_T))          if (file_write(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {
                                                                                                 != sizeof(NP2FLAGPART_T)) {  
                 goto fs_closeerr;                  goto fs_closeerr;
         }          }
         if (file_seek(f->fh, f->pos, 0) == f->pos) {          if (file_seek(f->fh, f->pos, 0) == f->pos) {
Line 307  fs_closeerr: Line 318  fs_closeerr:
         return(NP2FLAG_FAILURE);          return(NP2FLAG_FAILURE);
 }  }
   
 static void flagclose(NP2FFILE *f) {  static void flagclose(NP2FFILE f) {
   
         if (f) {          if (f) {
                 file_close(f->fh);                  file_close(f->fh);
Line 317  static void flagclose(NP2FFILE *f) { Line 328  static void flagclose(NP2FFILE *f) {
   
 // ----  // ----
   
 static int flagsave_term(NP2FFILE *f, const STENTRY *t) {  static int flagsave_term(NP2FFILE f, const STENTRY *t) {
   
         int             ret;          int             ret;
   
Line 327  static int flagsave_term(NP2FFILE *f, co Line 338  static int flagsave_term(NP2FFILE *f, co
 }  }
   
   
 // ----  // ---- common
   
 static int flagsave_common(NP2FFILE *f, const STENTRY *t) {  static int flagsave_common(NP2FFILE f, const STENTRY *t) {
   
         int             ret;          int             ret;
   
Line 341  static int flagsave_common(NP2FFILE *f,  Line 352  static int flagsave_common(NP2FFILE *f, 
         return(ret);          return(ret);
 }  }
   
 static int flagload_common(NP2FFILE *f, const STENTRY *t) {  static int flagload_common(NP2FFILE f, const STENTRY *t) {
   
         return(flagload_load(f, t->arg1, t->arg2));          return(flagload_load(f, t->arg1, t->arg2));
 }  }
   
   
 // -----  // ----- clock
   
 static int flagload_core(NP2FFILE *f, const STENTRY *t) {  static int flagload_clock(NP2FFILE f, const STENTRY *t) {
   
         int             ret;          int             ret;
   
         ret = flagload_common(f, t);          ret = flagload_common(f, t);
         if (opna_rate) {          sound_changeclock();
                 pc.sampleclock = (pc.realclock / opna_rate) + 1;          beep_changeclock();
           return(ret);
   }
   
   
   // ---- memory
   
   static int flagsave_mem(NP2FFILE f, const STENTRY *t) {
   
           int             ret;
   
           ret = flagsave_create(f, t);
           if (ret != NP2FLAG_FAILURE) {
                   ret |= flagsave_save(f, mem, 0x110000);
                   ret |= flagsave_save(f, mem + VRAM1_B, 0x18000);
                   ret |= flagsave_save(f, mem + VRAM1_E, 0x8000);
                   ret |= flagsave_close(f);
         }          }
         else {          return(ret);
                 pc.sampleclock = 0;  }
   
   static int flagload_mem(NP2FFILE f, const STENTRY *t) {
   
           int             ret;
   
           ret = flagload_load(f, mem, 0x110000);
           ret |= flagload_load(f, mem + VRAM1_B, 0x18000);
           ret |= flagload_load(f, mem + VRAM1_E, 0x8000);
           (void)t;
           return(ret);
   }
   
   
   // ---- ext memory
   
   static int flagsave_ext(NP2FFILE f, const STENTRY *t) {
   
           int             ret;
   
           ret = flagsave_create(f, t);
           if (ret != NP2FLAG_FAILURE) {
                   ret |= flagsave_save(f, &extmem, sizeof(extmem));
                   if (extmemmng_size) {
                           ret |= flagsave_save(f, extmemmng_ptr, extmemmng_size);
                   }
                   ret |= flagsave_close(f);
         }          }
         return(ret);          return(ret);
 }  }
   
   static int flagload_ext(NP2FFILE f, const STENTRY *t) {
   
 // -----          int             ret;
           int             i;
           UINT    pagemax = 0;
   
           ret = flagload_load(f, &extmem, sizeof(extmem));
           if (extmem.maxmem) {
                   if (extmem.maxmem > (13+1)) {
                           extmem.maxmem = (13+1);
                   }
                   if (!extmemmng_realloc(extmem.maxmem - 1)) {
                           pagemax = (extmem.maxmem - 1) << 8;
                           if (extmemmng_size) {
                                   ret |= flagload_load(f, extmemmng_ptr, extmemmng_size);
                           }
                   }
                   else {
                           extmem.maxmem = 0;
                   }
           }
           for (i=0; i<4; i++) {
                   if (extmem.page[i] < pagemax) {
                           extmem.pageptr[i] = extmemmng_ptr + (extmem.page[i] << 12);
                   }
                   else {
                           extmem.pageptr[i] = mem + 0xc0000 + (i << 14);
                   }
           }
           (void)t;
           return(ret);
   }
   
 static int flagsave_dma(NP2FFILE *f, const STENTRY *t) {  
   // ---- dma
   
   static int flagsave_dma(NP2FFILE f, const STENTRY *t) {
   
         int                     ret;          int                     ret;
         int                     i;          int                     i;
Line 388  static int flagsave_dma(NP2FFILE *f, con Line 474  static int flagsave_dma(NP2FFILE *f, con
         return(ret);          return(ret);
 }  }
   
 static int flagload_dma(NP2FFILE *f, const STENTRY *t) {  static int flagload_dma(NP2FFILE f, const STENTRY *t) {
   
         int             ret;          int             ret;
         int             i;          int             i;
Line 414  static int flagload_dma(NP2FFILE *f, con Line 500  static int flagload_dma(NP2FFILE *f, con
 }  }
   
   
 // -----  // ---- egc
   
 static int flagsave_egc(NP2FFILE *f, const STENTRY *t) {  static int flagsave_egc(NP2FFILE f, const STENTRY *t) {
   
         int             ret;          int             ret;
         _EGC    egcbak;          _EGC    egcbak;
Line 433  static int flagsave_egc(NP2FFILE *f, con Line 519  static int flagsave_egc(NP2FFILE *f, con
         return(ret);          return(ret);
 }  }
   
 static int flagload_egc(NP2FFILE *f, const STENTRY *t) {  static int flagload_egc(NP2FFILE f, const STENTRY *t) {
   
         int             ret;          int             ret;
   
Line 445  static int flagload_egc(NP2FFILE *f, con Line 531  static int flagload_egc(NP2FFILE *f, con
 }  }
   
   
 // -----  // ---- event
   
 static int flagsave_ext(NP2FFILE *f, const STENTRY *t) {  
   
         int             ret;  
   
         ret = flagsave_create(f, t);  
         if (ret != NP2FLAG_FAILURE) {  
                 ret |= flagsave_save(f, &extmem, sizeof(extmem));  
                 if (extmemmng_size) {  
                         ret |= flagsave_save(f, extmemmng_ptr, extmemmng_size);  
                 }  
                 ret |= flagsave_close(f);  
         }  
         return(ret);  
 }  
   
 static int flagload_ext(NP2FFILE *f, const STENTRY *t) {  
   
         int             ret;  
         int             i;  
         UINT    pagemax = 0;  
   
         ret = flagload_load(f, &extmem, sizeof(extmem));  
         if (extmem.maxmem) {  
                 if (extmem.maxmem > (13+1)) {  
                         extmem.maxmem = (13+1);  
                 }  
                 if (!extmemmng_realloc(extmem.maxmem - 1)) {  
                         pagemax = (extmem.maxmem - 1) << 8;  
                         if (extmemmng_size) {  
                                 ret |= flagload_load(f, extmemmng_ptr, extmemmng_size);  
                         }  
                 }  
                 else {  
                         extmem.maxmem = 0;  
                 }  
         }  
         for (i=0; i<4; i++) {  
                 if (extmem.page[i] < pagemax) {  
                         extmem.pageptr[i] = extmemmng_ptr + (extmem.page[i] << 12);  
                 }  
                 else {  
                         extmem.pageptr[i] = mem + 0xc0000 + (i << 14);  
                 }  
         }  
         (void)t;  
         return(ret);  
 }  
   
   
 // -----  
   
 typedef struct {  typedef struct {
         SINT32          remainclock;  
         SINT32          baseclock;  
         UINT32          clock;  
         UINT            readyevents;          UINT            readyevents;
         UINT            waitevents;          UINT            waitevents;
 } NEVTSAVE;  } NEVTSAVE;
Line 513  typedef struct { Line 545  typedef struct {
         NEVENTCB        proc;          NEVENTCB        proc;
 } NEVTITEM;  } NEVTITEM;
   
 static int nevent_save(NP2FFILE *f, int num) {  static int nevent_save(NP2FFILE f, int num) {
   
         NEVTITEM        nit;          NEVTITEM        nit;
         UINT            i;          UINT            i;
Line 534  static int nevent_save(NP2FFILE *f, int  Line 566  static int nevent_save(NP2FFILE *f, int 
         return(flagsave_save(f, &nit, sizeof(nit)));          return(flagsave_save(f, &nit, sizeof(nit)));
 }  }
   
 static int flagsave_evt(NP2FFILE *f, const STENTRY *t) {  static int flagsave_evt(NP2FFILE f, const STENTRY *t) {
   
         NEVTSAVE        nevt;          NEVTSAVE        nevt;
         int                     ret;          int                     ret;
         UINT            i;          UINT            i;
   
         nevt.remainclock = nevent.remainclock;  
         nevt.baseclock = nevent.baseclock;  
         nevt.clock = nevent.clock;  
         nevt.readyevents = nevent.readyevents;          nevt.readyevents = nevent.readyevents;
         nevt.waitevents = nevent.waitevents;          nevt.waitevents = nevent.waitevents;
   
Line 560  static int flagsave_evt(NP2FFILE *f, con Line 589  static int flagsave_evt(NP2FFILE *f, con
         return(ret);          return(ret);
 }  }
   
 static int nevent_load(NP2FFILE *f, UINT *tbl, UINT *pos) {  static int nevent_load(NP2FFILE f, UINT *tbl, UINT *pos) {
   
         int                     ret;          int                     ret;
         NEVTITEM        nit;          NEVTITEM        nit;
Line 593  static int nevent_load(NP2FFILE *f, UINT Line 622  static int nevent_load(NP2FFILE *f, UINT
         return(ret);          return(ret);
 }  }
   
 static int flagload_evt(NP2FFILE *f, const STENTRY *t) {  static int flagload_evt(NP2FFILE f, const STENTRY *t) {
   
         int                     ret;          int                     ret;
         NEVTSAVE        nevt;          NEVTSAVE        nevt;
Line 601  static int flagload_evt(NP2FFILE *f, con Line 630  static int flagload_evt(NP2FFILE *f, con
   
         ret = flagload_load(f, &nevt, sizeof(nevt));          ret = flagload_load(f, &nevt, sizeof(nevt));
   
         nevent.remainclock = nevt.remainclock;  
         nevent.baseclock = nevt.baseclock;  
         nevent.clock = nevt.clock;  
         nevent.readyevents = 0;          nevent.readyevents = 0;
         nevent.waitevents = 0;          nevent.waitevents = 0;
   
Line 618  static int flagload_evt(NP2FFILE *f, con Line 644  static int flagload_evt(NP2FFILE *f, con
 }  }
   
   
 // ----  // ---- gaiji
   
 static int flagsave_gij(NP2FFILE *f, const STENTRY *t) {  static int flagsave_gij(NP2FFILE f, const STENTRY *t) {
   
         int             ret;          int             ret;
         int             i;          int             i;
Line 630  static int flagsave_gij(NP2FFILE *f, con Line 656  static int flagsave_gij(NP2FFILE *f, con
         ret = flagsave_create(f, t);          ret = flagsave_create(f, t);
         if (ret != NP2FLAG_FAILURE) {          if (ret != NP2FLAG_FAILURE) {
                 for (i=0; i<2; i++) {                  for (i=0; i<2; i++) {
                         fnt = font + ((0x56 + (i << 7)) << 4);                          fnt = fontrom + ((0x56 + (i << 7)) << 4);
                         for (j=0; j<0x80; j++) {                          for (j=0; j<0x80; j++) {
                                 ret |= flagsave_save(f, fnt, 32);                                  ret |= flagsave_save(f, fnt, 32);
                                 fnt += 0x1000;                                  fnt += 0x1000;
Line 641  static int flagsave_gij(NP2FFILE *f, con Line 667  static int flagsave_gij(NP2FFILE *f, con
         return(ret);          return(ret);
 }  }
   
 static int flagload_gij(NP2FFILE *f, const STENTRY *t) {  static int flagload_gij(NP2FFILE f, const STENTRY *t) {
   
         int             ret;          int             ret;
         int             i;          int             i;
Line 650  static int flagload_gij(NP2FFILE *f, con Line 676  static int flagload_gij(NP2FFILE *f, con
   
         ret = 0;          ret = 0;
         for (i=0; i<2; i++) {          for (i=0; i<2; i++) {
                 fnt = font + ((0x56 + (i << 7)) << 4);                  fnt = fontrom + ((0x56 + (i << 7)) << 4);
                 for (j=0; j<0x80; j++) {                  for (j=0; j<0x80; j++) {
                         ret |= flagload_load(f, fnt, 32);                          ret |= flagload_load(f, fnt, 32);
                         fnt += 0x1000;                          fnt += 0x1000;
Line 661  static int flagload_gij(NP2FFILE *f, con Line 687  static int flagload_gij(NP2FFILE *f, con
 }  }
   
   
 // -----  // ---- FM
   
 enum {  enum {
         FLAG_MG                 = 0x0001,          FLAG_MG                 = 0x0001,
Line 671  enum { Line 697  enum {
         FLAG_FM2B               = 0x0010,          FLAG_FM2B               = 0x0010,
         FLAG_PSG1               = 0x0020,          FLAG_PSG1               = 0x0020,
         FLAG_PSG2               = 0x0040,          FLAG_PSG2               = 0x0040,
         FLAG_RHYTHM             = 0x0080,          FLAG_PSG3               = 0x0080,
         FLAG_ADPCM              = 0x0100,          FLAG_RHYTHM             = 0x0100,
         FLAG_PCM86              = 0x0200,          FLAG_ADPCM              = 0x0200,
         FLAG_CS4231             = 0x0400          FLAG_PCM86              = 0x0400,
           FLAG_CS4231             = 0x0800
 };  };
   
 typedef struct {  typedef struct {
Line 682  typedef struct { Line 709  typedef struct {
         BYTE    extop[4];          BYTE    extop[4];
 } OPNKEY;  } OPNKEY;
   
 static int flagsave_fm(NP2FFILE *f, const STENTRY *t) {  static int flagsave_fm(NP2FFILE f, const STENTRY *t) {
   
         int             ret;          int             ret;
         UINT    saveflg;          UINT    saveflg;
Line 727  static int flagsave_fm(NP2FFILE *f, cons Line 754  static int flagsave_fm(NP2FFILE *f, cons
                                                                                 FLAG_PSG1 | FLAG_RHYTHM | FLAG_ADPCM;                                                                                  FLAG_PSG1 | FLAG_RHYTHM | FLAG_ADPCM;
                         break;                          break;
   
                   case 0x80:
                           saveflg = FLAG_PSG1 | FLAG_PSG2 | FLAG_PSG3;
                           break;
   
                 default:                  default:
                         saveflg = 0;                          saveflg = 0;
                         break;                          break;
Line 755  static int flagsave_fm(NP2FFILE *f, cons Line 786  static int flagsave_fm(NP2FFILE *f, cons
                 if (saveflg & FLAG_PSG2) {                  if (saveflg & FLAG_PSG2) {
                         ret |= flagsave_save(f, &psg2.reg, sizeof(PSGREG));                          ret |= flagsave_save(f, &psg2.reg, sizeof(PSGREG));
                 }                  }
                   if (saveflg & FLAG_PSG3) {
                           ret |= flagsave_save(f, &psg3.reg, sizeof(PSGREG));
                   }
                 if (saveflg & FLAG_ADPCM) {                  if (saveflg & FLAG_ADPCM) {
                         ret |= flagsave_save(f, &adpcm, sizeof(adpcm));                          ret |= flagsave_save(f, &adpcm, sizeof(adpcm));
                 }                  }
Line 769  static int flagsave_fm(NP2FFILE *f, cons Line 803  static int flagsave_fm(NP2FFILE *f, cons
         return(ret);          return(ret);
 }  }
   
 static void play_fmreg(BYTE num) {  static void play_fmreg(BYTE num, UINT reg) {
   
         UINT    chbase;          UINT    chbase;
         UINT    reg;  
         UINT    i;          UINT    i;
   
         chbase = num * 3;          chbase = num * 3;
         reg = num * 0x100;  
         for (i=0x30; i<0xa0; i++) {          for (i=0x30; i<0xa0; i++) {
                 opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);                  opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);
         }          }
Line 797  static void play_psgreg(PSGGEN psg) { Line 829  static void play_psgreg(PSGGEN psg) {
         }          }
 }  }
   
 static int flagload_fm(NP2FFILE *f, const STENTRY *t) {  static int flagload_fm(NP2FFILE f, const STENTRY *t) {
   
         int             ret;          int             ret;
         UINT    saveflg;          UINT    saveflg;
         OPNKEY  opnkey;          OPNKEY  opnkey;
           UINT    fmreg1a;
           UINT    fmreg1b;
           UINT    fmreg2a;
           UINT    fmreg2b;
   
         opngen_reset();          opngen_reset();
         psggen_reset(&psg1);          psggen_reset(&psg1);
Line 815  static int flagload_fm(NP2FFILE *f, cons Line 851  static int flagload_fm(NP2FFILE *f, cons
         ret = flagload_load(f, &usesound, sizeof(usesound));          ret = flagload_load(f, &usesound, sizeof(usesound));
         fmboard_reset((BYTE)usesound);          fmboard_reset((BYTE)usesound);
   
           fmreg1a = 0x000;
           fmreg1b = 0x100;
           fmreg2a = 0x200;
           fmreg2b = 0x300;
         switch(usesound) {          switch(usesound) {
                 case 0x01:                  case 0x01:
                         saveflg = FLAG_MG;                          saveflg = FLAG_MG;
Line 832  static int flagload_fm(NP2FFILE *f, cons Line 872  static int flagload_fm(NP2FFILE *f, cons
                 case 0x06:                  case 0x06:
                         saveflg = FLAG_FM1A | FLAG_FM1B | FLAG_FM2A | FLAG_PSG1 |                          saveflg = FLAG_FM1A | FLAG_FM1B | FLAG_FM2A | FLAG_PSG1 |
                                                                                 FLAG_PSG2 | FLAG_RHYTHM | FLAG_PCM86;                                                                                  FLAG_PSG2 | FLAG_RHYTHM | FLAG_PCM86;
                           fmreg1a = 0x200;        // µÕž¤·¤Æ¤ë¤Î¤ó¡Ä
                           fmreg1b = 0x000;
                           fmreg2a = 0x100;
                         break;                          break;
   
                 case 0x08:                  case 0x08:
Line 854  static int flagload_fm(NP2FFILE *f, cons Line 897  static int flagload_fm(NP2FFILE *f, cons
                                                                                 FLAG_PSG1 | FLAG_RHYTHM | FLAG_ADPCM;                                                                                  FLAG_PSG1 | FLAG_RHYTHM | FLAG_ADPCM;
                         break;                          break;
   
                   case 0x80:
                           saveflg = FLAG_PSG1 | FLAG_PSG2 | FLAG_PSG3;
                           break;
   
                 default:                  default:
                           saveflg = 0;
                         break;                          break;
         }          }
   
Line 879  static int flagload_fm(NP2FFILE *f, cons Line 927  static int flagload_fm(NP2FFILE *f, cons
         if (saveflg & FLAG_PSG2) {          if (saveflg & FLAG_PSG2) {
                 ret |= flagload_load(f, &psg2.reg, sizeof(PSGREG));                  ret |= flagload_load(f, &psg2.reg, sizeof(PSGREG));
         }          }
           if (saveflg & FLAG_PSG3) {
                   ret |= flagload_load(f, &psg3.reg, sizeof(PSGREG));
           }
         if (saveflg & FLAG_ADPCM) {          if (saveflg & FLAG_ADPCM) {
                 ret |= flagload_load(f, &adpcm, sizeof(adpcm));                  ret |= flagload_load(f, &adpcm, sizeof(adpcm));
         }          }
Line 902  static int flagload_fm(NP2FFILE *f, cons Line 953  static int flagload_fm(NP2FFILE *f, cons
         }          }
   
         if (saveflg & FLAG_FM1A) {          if (saveflg & FLAG_FM1A) {
                 play_fmreg(0);                  play_fmreg(0, fmreg1a);
         }          }
         if (saveflg & FLAG_FM1B) {          if (saveflg & FLAG_FM1B) {
                 play_fmreg(1);                  play_fmreg(1, fmreg1b);
         }          }
         if (saveflg & FLAG_FM2A) {          if (saveflg & FLAG_FM2A) {
                 play_fmreg(2);                  play_fmreg(2, fmreg2a);
         }          }
         if (saveflg & FLAG_FM2B) {          if (saveflg & FLAG_FM2B) {
                 play_fmreg(3);                  play_fmreg(3, fmreg2b);
         }          }
         if (saveflg & FLAG_PSG1) {          if (saveflg & FLAG_PSG1) {
                 play_psgreg(&psg1);                  play_psgreg(&psg1);
Line 919  static int flagload_fm(NP2FFILE *f, cons Line 970  static int flagload_fm(NP2FFILE *f, cons
         if (saveflg & FLAG_PSG2) {          if (saveflg & FLAG_PSG2) {
                 play_psgreg(&psg2);                  play_psgreg(&psg2);
         }          }
           if (saveflg & FLAG_PSG3) {
                   play_psgreg(&psg3);
           }
         (void)t;          (void)t;
         return(ret);          return(ret);
 }  }
Line 933  typedef struct { Line 987  typedef struct {
         DOSTIME time;          DOSTIME time;
 } STATDISK;  } STATDISK;
   
 static int disksave(NP2FFILE *f, const char *path, int readonly) {  static const char str_fddx[] = "FDD%u";
   static const char str_sasix[] = "SASI%u";
   static const char str_scsix[] = "SCSI%u";
   static const char str_updated[] = "%s: updated" CRLITERAL;
   static const char str_notfound[] = "%s: not found" CRLITERAL;
   
   static int disksave(NP2FFILE f, const char *path, int readonly) {
   
         STATDISK        st;          STATDISK        st;
         FILEH           fh;          FILEH           fh;
Line 951  static int disksave(NP2FFILE *f, const c Line 1011  static int disksave(NP2FFILE *f, const c
         return(flagsave_save(f, &st, sizeof(st)));          return(flagsave_save(f, &st, sizeof(st)));
 }  }
   
 static int flagsave_disk(NP2FFILE *f, const STENTRY *t) {  static int flagsave_disk(NP2FFILE f, const STENTRY *t) {
   
         int             ret;          int             ret;
         BYTE    i;          BYTE    i;
Line 973  static int flagsave_disk(NP2FFILE *f, co Line 1033  static int flagsave_disk(NP2FFILE *f, co
         return(ret);          return(ret);
 }  }
   
 static int diskcheck(NP2FFILE *f, const char *name, ERR_BUF *e) {  static int diskcheck(NP2FFILE f, const char *name, ERR_BUF *e) {
   
         int                     ret;          int                     ret;
         FILEH           fh;          FILEH           fh;
Line 991  static int diskcheck(NP2FFILE *f, const  Line 1051  static int diskcheck(NP2FFILE *f, const 
                         if ((memcmp(&st.date, &date, sizeof(date))) ||                          if ((memcmp(&st.date, &date, sizeof(date))) ||
                                 (memcmp(&st.time, &time, sizeof(time)))) {                                  (memcmp(&st.time, &time, sizeof(time)))) {
                                 ret |= NP2FLAG_DISKCHG;                                  ret |= NP2FLAG_DISKCHG;
                                 SPRINTF(buf, "%s: updated\n", name);                                  SPRINTF(buf, str_updated, name);
                                 err_append(e, buf);                                  err_append(e, buf);
                         }                          }
                 }                  }
                 else {                  else {
                         ret |= NP2FLAG_DISKCHG;                          ret |= NP2FLAG_DISKCHG;
                         SPRINTF(buf, "%s: not found\n", name);                          SPRINTF(buf, str_notfound, name);
                         err_append(e, buf);                          err_append(e, buf);
                 }                  }
         }          }
         return(ret);          return(ret);
 }  }
   
 static int flagcheck_disk(NP2FFILE *f, const STENTRY *t, ERR_BUF *e) {  static int flagcheck_disk(NP2FFILE f, const STENTRY *t, ERR_BUF *e) {
   
         int             ret;          int             ret;
         int             i;          int             i;
Line 1012  static int flagcheck_disk(NP2FFILE *f, c Line 1072  static int flagcheck_disk(NP2FFILE *f, c
   
         ret = 0;          ret = 0;
         for (i=0; i<4; i++) {          for (i=0; i<4; i++) {
                 SPRINTF(buf, "FDD%d", i+1);                  SPRINTF(buf, str_fddx, i+1);
                 ret |= diskcheck(f, buf, e);                  ret |= diskcheck(f, buf, e);
         }          }
         sxsi_flash();          sxsi_flash();
         for (i=0; i<2; i++) {          for (i=0; i<2; i++) {
                 SPRINTF(buf, "SASI%u", i+1);                  SPRINTF(buf, str_sasix, i+1);
                 ret |= diskcheck(f, buf, e);                  ret |= diskcheck(f, buf, e);
         }          }
         for (i=0; i<2; i++) {          for (i=0; i<2; i++) {
                 SPRINTF(buf, "SCSI%d", i+1);                  SPRINTF(buf, str_scsix, i+1);
                 ret |= diskcheck(f, buf, e);                  ret |= diskcheck(f, buf, e);
         }          }
         (void)t;          (void)t;
         return(ret);          return(ret);
 }  }
   
 static int flagload_disk(NP2FFILE *f, const STENTRY *t) {  static int flagload_disk(NP2FFILE f, const STENTRY *t) {
   
         int                     ret;          int                     ret;
         BYTE            i;          BYTE            i;
Line 1061  static int flagload_disk(NP2FFILE *f, co Line 1121  static int flagload_disk(NP2FFILE *f, co
 }  }
   
   
 // -----  // ---- com
   
 #ifdef _MIDICH  static int flagsave_com(NP2FFILE f, const STENTRY *t) {
 static int flagsave_midi(NP2FFILE *f, const STENTRY *t) {  
   
         UINT    device;          UINT    device;
         COMMNG  cm;          COMMNG  cm;
         int             ret;          int             ret;
         _MIDICH mch[16];          COMFLAG flag;
   
         device = (UINT)t->arg1;          device = (UINT)t->arg1;
         switch(device) {          switch(device) {
Line 1086  static int flagsave_midi(NP2FFILE *f, co Line 1145  static int flagsave_midi(NP2FFILE *f, co
                         break;                          break;
         }          }
         ret = NP2FLAG_SUCCESS;          ret = NP2FLAG_SUCCESS;
         if ((cm != NULL) && (cm->msg(cm, COMMSG_MIDISTATGET, (long)mch))) {          if (cm) {
                 ret = flagsave_create(f, t);                  flag = (COMFLAG)cm->msg(cm, COMMSG_GETFLAG, 0);
                 if (ret != NP2FLAG_FAILURE) {                  if (flag) {
                         ret |= flagsave_save(f, mch, sizeof(mch));                          ret = flagsave_create(f, t);
                         ret |= flagsave_close(f);                          if (ret != NP2FLAG_FAILURE) {
                                   ret |= flagsave_save(f, flag, flag->size);
                                   ret |= flagsave_close(f);
                           }
                           _MFREE(flag);
                 }                  }
         }          }
         return(ret);          return(ret);
 }  }
   
 static int flagload_midi(NP2FFILE *f, const STENTRY *t) {  static int flagload_com(NP2FFILE f, const STENTRY *t) {
   
         _MIDICH mch[16];          UINT            device;
         UINT    device;          COMMNG          cm;
         COMMNG  cm;          int                     ret;
         int             ret;          _COMFLAG        fhdr;
           COMFLAG         flag;
   
         ret = flagload_load(f, mch, sizeof(mch));          ret = flagload_load(f, &fhdr, sizeof(fhdr));
         if (ret != NP2FLAG_FAILURE) {          if (ret != NP2FLAG_SUCCESS) {
                 device = (UINT)t->arg1;                  goto flcom_err1;
                 switch(device) {          }
                         case 0:          if (fhdr.size < sizeof(fhdr)) {
                                 commng_destroy(cm_mpu98);                  goto flcom_err1;
                                 cm = commng_create(COMCREATE_MPU98II);          }
                                 cm_mpu98 = cm;          flag = (COMFLAG)_MALLOC(fhdr.size, "com stat flag");
                                 break;          if (flag == NULL) {
                   goto flcom_err1;
           }
           CopyMemory(flag, &fhdr, sizeof(fhdr));
           ret |= flagload_load(f, flag + 1, fhdr.size - sizeof(fhdr));
           if (ret != NP2FLAG_SUCCESS) {
                   goto flcom_err2;
           }
   
                         case 1:          device = (UINT)t->arg1;
                                 commng_destroy(cm_rs232c);          switch(device) {
                                 cm = commng_create(COMCREATE_SERIAL);                  case 0:
                                 cm_rs232c = cm;                          commng_destroy(cm_mpu98);
                                 break;                          cm = commng_create(COMCREATE_MPU98II);
                           cm_mpu98 = cm;
                           break;
   
                         default:                  case 1:
                                 cm = NULL;                          commng_destroy(cm_rs232c);
                                 break;                          cm = commng_create(COMCREATE_SERIAL);
                 }                          cm_rs232c = cm;
                 if (cm) {                          break;
                         cm->msg(cm, COMMSG_MIDISTATSET, (long)mch);  
                 }                  default:
                           cm = NULL;
                           break;
         }          }
           if (cm) {
                   cm->msg(cm, COMMSG_SETFLAG, (long)flag);
           }
   
   flcom_err2:
           _MFREE(flag);
   
   flcom_err1:
         return(ret);          return(ret);
 }  }
 #endif  
   
   
 // ----  // ----
   
 static int flagcheck_versize(NP2FFILE *f, const STENTRY *t, ERR_BUF *e) {  static int flagcheck_versize(NP2FFILE f, const STENTRY *t, ERR_BUF *e) {
   
         if ((f) && (t)) {          if ((f) && (t)) {
                 if ((f->p.ver == t->ver) && (f->p.size == t->arg2)) {                  if ((f->p.ver == t->ver) && (f->p.size == t->arg2)) {
Line 1146  static int flagcheck_versize(NP2FFILE *f Line 1228  static int flagcheck_versize(NP2FFILE *f
         return(NP2FLAG_FAILURE);          return(NP2FLAG_FAILURE);
 }  }
   
 static int flagcheck_veronly(NP2FFILE *f, const STENTRY *t, ERR_BUF *e) {  static int flagcheck_veronly(NP2FFILE f, const STENTRY *t, ERR_BUF *e) {
   
         if ((f) && (t)) {          if ((f) && (t)) {
                 if (f->p.ver == t->ver) {                  if (f->p.ver == t->ver) {
Line 1163  static int flagcheck_veronly(NP2FFILE *f Line 1245  static int flagcheck_veronly(NP2FFILE *f
   
 int statsave_save(const char *filename) {  int statsave_save(const char *filename) {
   
         NP2FFILE        f;          _NP2FFILE       f;
         int                     ret;          int                     ret;
         UINT            i;  const STENTRY   *tbl;
   const STENTRY   *tblterm;
   
         ret = flagcreate(&f, filename);          ret = flagcreate(&f, filename);
         if (ret == NP2FLAG_FAILURE) {          if (ret == NP2FLAG_FAILURE) {
                 return(ret);                  return(ret);
         }          }
         for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {          tbl = np2tbl;
                 switch(np2tbl[i].type) {          tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
           while(tbl < tblterm) {
                   switch(tbl->type) {
                         case NP2FLAG_BIN:                          case NP2FLAG_BIN:
                         case NP2FLAG_CORE:                          case NP2FLAG_CLOCK:
                         case NP2FLAG_BEEP:                                  ret |= flagsave_common(&f, tbl);
                                 ret |= flagsave_common(&f, &np2tbl[i]);  
                                 break;                                  break;
   
                         case NP2FLAG_TERM:                          case NP2FLAG_TERM:
                                 ret |= flagsave_term(&f, &np2tbl[i]);                                  ret |= flagsave_term(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_DMA:                          case NP2FLAG_COM:
                                 ret |= flagsave_dma(&f, &np2tbl[i]);                                  ret |= flagsave_com(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_EGC:                          case NP2FLAG_DISK:
                                 ret |= flagsave_egc(&f, &np2tbl[i]);                                  ret |= flagsave_disk(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_EXT:                          case NP2FLAG_DMA:
                                 ret |= flagsave_ext(&f, &np2tbl[i]);                                  ret |= flagsave_dma(&f, tbl);
                                   break;
   
                           case NP2FLAG_EGC:
                                   ret |= flagsave_egc(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_EVT:                          case NP2FLAG_EVT:
                                 ret |= flagsave_evt(&f, &np2tbl[i]);                                  ret |= flagsave_evt(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_GIJ:                          case NP2FLAG_EXT:
                                 ret |= flagsave_gij(&f, &np2tbl[i]);                                  ret |= flagsave_ext(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_FM:                          case NP2FLAG_FM:
                                 ret |= flagsave_fm(&f, &np2tbl[i]);                                  ret |= flagsave_fm(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_DISK:                          case NP2FLAG_GIJ:
                                 ret |= flagsave_disk(&f, &np2tbl[i]);                                  ret |= flagsave_gij(&f, tbl);
                                 break;                                  break;
   
 #if defined(MIDICH)                          case NP2FLAG_MEM:
                         case NP2FLAG_MIDI:                                  ret |= flagsave_mem(&f, tbl);
                                 ret |= flagsave_midi(&f, &np2tbl[i]);  
                                 break;                                  break;
 #endif  
                 }                  }
                   tbl++;
         }          }
         flagclose(&f);          flagclose(&f);
         return(ret);          return(ret);
Line 1224  int statsave_save(const char *filename)  Line 1311  int statsave_save(const char *filename) 
   
 int statsave_check(const char *filename, char *buf, int size) {  int statsave_check(const char *filename, char *buf, int size) {
   
         NP2FFILE        f;          ERR_BUF         e;
           _NP2FFILE       f;
         int                     ret;          int                     ret;
         UINT            i;  
         BOOL            done;          BOOL            done;
         ERR_BUF         e;  const STENTRY   *tbl;
   const STENTRY   *tblterm;
   
         e.buf = buf;          e.buf = buf;
         e.remain = size;          e.remain = size;
Line 1250  int statsave_check(const char *filename, Line 1338  int statsave_check(const char *filename,
                         ret |= flagload_create(&f);                          ret |= flagload_create(&f);
                         CopyMemory(index, f.p.index, sizeof(f.p.index));                          CopyMemory(index, f.p.index, sizeof(f.p.index));
                         index[10] = 0;                          index[10] = 0;
                         for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {                          tbl = np2tbl;
                                 if (!strcmp(index, np2tbl[i].index)) {                          tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
                           while(tbl < tblterm) {
                                   if (!strcmp(index, tbl->index)) {
                                         break;                                          break;
                                 }                                  }
                                   tbl++;
                         }                          }
                         if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {                          if (tbl < tblterm) {
                                 switch(np2tbl[i].type) {                                  switch(tbl->type) {
                                         case NP2FLAG_BIN:                                          case NP2FLAG_BIN:
                                                 ret |= flagcheck_versize(&f, &np2tbl[i], &e);                                          case NP2FLAG_CLOCK:
                                           case NP2FLAG_MEM:
                                                   ret |= flagcheck_versize(&f, tbl, &e);
                                                 break;                                                  break;
   
                                         case NP2FLAG_TERM:                                          case NP2FLAG_TERM:
                                                 done = TRUE;                                                  done = TRUE;
                                                 break;                                                  break;
   
                                         case NP2FLAG_CORE:                                          case NP2FLAG_COM:
                                         case NP2FLAG_DMA:                                          case NP2FLAG_DMA:
                                         case NP2FLAG_EGC:                                          case NP2FLAG_EGC:
                                         case NP2FLAG_EXT:  
                                         case NP2FLAG_EVT:                                          case NP2FLAG_EVT:
                                           case NP2FLAG_EXT:
                                         case NP2FLAG_GIJ:                                          case NP2FLAG_GIJ:
                                         case NP2FLAG_BEEP:                                          case NP2FLAG_FM:
 #if defined(MIDICH)                                                  ret |= flagcheck_veronly(&f, tbl, &e);
                                         case NP2FLAG_MIDI:  
 #endif  
                                                 ret |= flagcheck_veronly(&f, &np2tbl[i], &e);  
                                                 break;                                                  break;
   
                                         case NP2FLAG_DISK:                                          case NP2FLAG_DISK:
                                                 ret |= flagcheck_disk(&f, &np2tbl[i], &e);                                                  ret |= flagcheck_disk(&f, tbl, &e);
                                                 break;  
   
                                         case NP2FLAG_FM:                                                        // ver0.31  
                                                 break;                                                  break;
   
                                         default:                                          default:
Line 1305  int statsave_check(const char *filename, Line 1392  int statsave_check(const char *filename,
   
 int statsave_load(const char *filename) {  int statsave_load(const char *filename) {
   
         NP2FFILE        f;          _NP2FFILE       f;
         int                     ret;          int                     ret;
         UINT            i;  
         BOOL            done;          BOOL            done;
   const STENTRY   *tbl;
   const STENTRY   *tblterm;
   
         ret = flagopen(&f, filename, NULL);          ret = flagopen(&f, filename, NULL);
         if (ret == NP2FLAG_FAILURE) {          if (ret == NP2FLAG_FAILURE) {
Line 1328  int statsave_load(const char *filename)  Line 1416  int statsave_load(const char *filename) 
                 ret |= flagload_create(&f);                  ret |= flagload_create(&f);
                 CopyMemory(index, f.p.index, sizeof(f.p.index));                  CopyMemory(index, f.p.index, sizeof(f.p.index));
                 index[10] = 0;                  index[10] = 0;
                 for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {                  tbl = np2tbl;
                         if (!strcmp(index, np2tbl[i].index)) {                  tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
                   while(tbl < tblterm) {
                           if (!strcmp(index, tbl->index)) {
                                 break;                                  break;
                         }                          }
                           tbl++;
                 }                  }
                 if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {                  if (tbl < tblterm) {
                         switch(np2tbl[i].type) {                          switch(tbl->type) {
                                 case NP2FLAG_BIN:                                  case NP2FLAG_BIN:
                                 case NP2FLAG_BEEP:                                          ret |= flagload_common(&f, tbl);
                                         ret |= flagload_common(&f, &np2tbl[i]);  
                                         break;                                          break;
   
                                 case NP2FLAG_TERM:                                  case NP2FLAG_TERM:
                                         done = TRUE;                                          done = TRUE;
                                         break;                                          break;
   
                                 case NP2FLAG_CORE:                                  case NP2FLAG_CLOCK:
                                         ret |= flagload_core(&f, &np2tbl[i]);                                          ret |= flagload_clock(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_DMA:                                  case NP2FLAG_COM:
                                         ret |= flagload_dma(&f, &np2tbl[i]);                                          ret |= flagload_com(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_EGC:                                  case NP2FLAG_DISK:
                                         ret |= flagload_egc(&f, &np2tbl[i]);                                          ret |= flagload_disk(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_EXT:                                  case NP2FLAG_DMA:
                                         ret |= flagload_ext(&f, &np2tbl[i]);                                          ret |= flagload_dma(&f, tbl);
                                           break;
   
                                   case NP2FLAG_EGC:
                                           ret |= flagload_egc(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_EVT:                                  case NP2FLAG_EVT:
                                         ret |= flagload_evt(&f, &np2tbl[i]);                                          ret |= flagload_evt(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_GIJ:                                  case NP2FLAG_EXT:
                                         ret |= flagload_gij(&f, &np2tbl[i]);                                          ret |= flagload_ext(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_FM:                                  case NP2FLAG_FM:
                                         ret |= flagload_fm(&f, &np2tbl[i]);                                          ret |= flagload_fm(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_DISK:                                  case NP2FLAG_GIJ:
                                         ret |= flagload_disk(&f, &np2tbl[i]);                                          ret |= flagload_gij(&f, tbl);
                                         break;                                          break;
   
 #if defined(MIDICH)                                  case NP2FLAG_MEM:
                                 case NP2FLAG_MIDI:                                          ret |= flagload_mem(&f, tbl);
                                         ret |= flagload_midi(&f, &np2tbl[i]);  
                                         break;                                          break;
 #endif  
   
                                 default:                                  default:
                                         ret |= NP2FLAG_WARNING;                                          ret |= NP2FLAG_WARNING;
Removed from v.1.4  
changed lines
  Added in v.1.18

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