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

Diff for /np2/statsave.c between versions 1.28 and 1.41

version 1.28, 2004/01/22 01:10:03 version 1.41, 2004/03/30 20:01:29
Line 8 Line 8
 #include        "cpucore.h"  #include        "cpucore.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
   #include        "gdc_sub.h"
 #include        "cbuscore.h"  #include        "cbuscore.h"
   #include        "ideio.h"
   #include        "sasiio.h"
   #include        "scsiio.h"
 #include        "pc9861k.h"  #include        "pc9861k.h"
 #include        "mpu98ii.h"  #include        "mpu98ii.h"
 #include        "board14.h"  #include        "board14.h"
Line 24 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        "keydisp.h"  #include        "keydisp.h"
 #include        "sasiio.h"  
 #include        "scsiio.h"  
 #include        "hostdrv.h"  #include        "hostdrv.h"
   #include        "calendar.h"
   #include        "keystat.h"
   
 #if defined(MACOS)  #if defined(MACOS)
 #define CRCONST         str_cr  #define CRCONST         str_cr
Line 58  enum { Line 60  enum {
 #if defined(CGWND_FONTPTR)  #if defined(CGWND_FONTPTR)
         STATFLAG_CGW,          STATFLAG_CGW,
 #endif  #endif
         STATFLAG_CLOCK,  
         STATFLAG_COM,          STATFLAG_COM,
         STATFLAG_DISK,          STATFLAG_DISK,
         STATFLAG_DMA,          STATFLAG_DMA,
Line 145  typedef struct { Line 146  typedef struct {
         UINT            stat;          UINT            stat;
         FILEH           fh;          FILEH           fh;
         UINT            secpos;          UINT            secpos;
   
 //      long            pos;  
 //      long            bak;  
 //      long            next;  
         NP2FHDR         f;          NP2FHDR         f;
 //      NP2FENT         p;  } _SFFILEH, *SFFILEH;
 } _NP2FFILE, *NP2FFILE, _SFFILEH, *SFFILEH;  
   
 static SFFILEH statflag_open(const char *filename, char *err, int errlen) {  static SFFILEH statflag_open(const char *filename, char *err, int errlen) {
   
Line 368  void statflag_seterr(STFLAGH sfh, const  Line 364  void statflag_seterr(STFLAGH sfh, const 
 }  }
   
   
   
   
 #if 0  
 static int flagopen(NP2FFILE f, const char *filename, ERR_BUF *e) {  
   
         if (f) {  
                 f->fh = file_open(filename);  
                 if (f->fh == FILEH_INVALID) {  
                         return(STATFLAG_FAILURE);  
                 }  
                 if (file_read(f->fh, &f->f, sizeof(NP2FHDR))  
                                                                                                 != sizeof(NP2FHDR)) {  
                         file_close(f->fh);  
                         return(STATFLAG_FAILURE);  
                 }  
                 f->pos = sizeof(NP2FHDR);  
                 if (strcmp(f->f.name, np2flagdef.name)) {  
                         file_close(f->fh);  
                         return(STATFLAG_FAILURE);  
                 }  
                 if (strcmp(f->f.vername, np2flagdef.vername)) {  
 #if 1  
                         file_close(f->fh);  
                         return(STATFLAG_FAILURE);  
 #else  
                         return(STATFLAG_VERSION);                       // 他形式を読むのであれば…  
 #endif  
                 }  
                 if (f->f.ver != np2flagdef.ver) {  
 #if 1  
                         file_close(f->fh);  
                         return(STATFLAG_FAILURE);  
 #else  
                         return(STATFLAG_VERSION);                       // 他verを読むのであれば…  
 #endif  
                 }  
                 return(STATFLAG_SUCCESS);  
         }  
         (void)e;  
         return(STATFLAG_FAILURE);  
 }  
   
 static int flagcreate(NP2FFILE f, const char *filename) {  
   
         if (f) {  
                 f->fh = file_create(filename);  
                 if (f->fh == FILEH_INVALID) {  
                         return(STATFLAG_FAILURE);  
                 }  
                 if (file_write(f->fh, &np2flagdef, sizeof(NP2FHDR))  
                                                                                                                 != sizeof(NP2FHDR)) {  
                         file_close(f->fh);  
                         return(STATFLAG_FAILURE);  
                 }  
                 f->pos = sizeof(NP2FHDR);  
                 return(STATFLAG_SUCCESS);  
         }  
         return(STATFLAG_FAILURE);  
 }  
   
 static int flagload_create(NP2FFILE f) {  
   
         if (f) {  
                 ZeroMemory(&f->p, sizeof(NP2FENT));  
                 if (f->pos & 15) {  
                         f->pos += 15;  
                         f->pos &= ~0xf;  
                         if (file_seek(f->fh, f->pos, 0) != f->pos) {  
                                 return(STATFLAG_FAILURE);  
                         }  
                 }  
                 if (file_read(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {  
                         return(STATFLAG_FAILURE);  
                 }  
                 f->pos += sizeof(NP2FENT);  
                 f->next = f->pos + f->p.size;  
                 return(STATFLAG_SUCCESS);  
         }  
         return(STATFLAG_FAILURE);  
 }  
   
 static int flagload_load(NP2FFILE f, void *buf, UINT size) {  
   
         if (f && buf && size && (file_read(f->fh, buf, size) == size)) {  
                 f->pos += size;  
                 return(STATFLAG_SUCCESS);  
         }  
         return(STATFLAG_FAILURE);  
 }  
   
 static int flagload_close(NP2FFILE f) {  
   
         if (file_seek(f->fh, f->next, 0) != f->next) {  
                 return(STATFLAG_FAILURE);  
         }  
         f->pos = f->next;  
         return(STATFLAG_SUCCESS);  
 }  
   
 static int flagsave_create(NP2FFILE f, const SFENTRY *t) {  
   
         if (f && t) {  
                 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(STATFLAG_FAILURE);  
                         }  
                         f->pos += rem;  
                 }  
                 f->bak = f->pos;  
   
                 len = strlen(t->index);  
                 if (len >= 10) {  
                         len = 10;  
                 }  
                 if (len) {  
                         CopyMemory(f->p.index, t->index, len);  
                 }  
                 f->p.ver = t->ver;  
                 if (file_write(f->fh, &f->p, sizeof(NP2FENT)) != sizeof(NP2FENT)) {  
                         return(STATFLAG_FAILURE);  
                 }  
                 f->pos += sizeof(NP2FENT);  
                 return(STATFLAG_SUCCESS);  
         }  
         return(STATFLAG_FAILURE);  
 }  
   
 static int flagsave_save(NP2FFILE f, void *buf, UINT size) {  
   
         if (f && buf && size && (file_write(f->fh, buf, size) == size)) {  
                 f->pos += size;  
                 f->p.size += size;  
                 return(STATFLAG_SUCCESS);  
         }  
         return(STATFLAG_FAILURE);  
 }  
   
 static int flagsave_close(NP2FFILE f) {  
   
         if (!f) {  
                 goto fs_closeerr;  
         }  
         if (file_seek(f->fh, f->bak, 0) != f->bak) {  
                 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(STATFLAG_SUCCESS);  
         }  
   
 fs_closeerr:  
         return(STATFLAG_FAILURE);  
 }  
   
 static void flagclose(NP2FFILE f) {  
   
         if (f) {  
                 file_close(f->fh);  
         }  
 }  
 #endif  
   
   
 // ---- common  // ---- common
   
 static int flagsave_common(STFLAGH sfh, const SFENTRY *tbl) {  static int flagsave_common(STFLAGH sfh, const SFENTRY *tbl) {
Line 550  static int flagload_common(STFLAGH sfh,  Line 377  static int flagload_common(STFLAGH sfh, 
 }  }
   
   
 // ----- clock  
   
 static int flagload_clock(STFLAGH sfh, const SFENTRY *tbl) {  
   
         int             ret;  
   
         ret = statflag_read(sfh, tbl->arg1, tbl->arg2);  
         sound_changeclock();  
         beep_changeclock();  
         return(ret);  
 }  
   
   
 // ---- memory  // ---- memory
   
 static int flagsave_mem(STFLAGH sfh, const SFENTRY *tbl) {  static int flagsave_mem(STFLAGH sfh, const SFENTRY *tbl) {
Line 588  static int flagload_mem(STFLAGH sfh, con Line 402  static int flagload_mem(STFLAGH sfh, con
 }  }
   
   
 // ---- ext memory  
   
 static int flagsave_ext(STFLAGH sfh, const SFENTRY *tbl) {  
   
         int             ret;  
   
         ret = statflag_write(sfh, &extmem, sizeof(extmem));  
         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;  
         int             i;  
         UINT    pagemax = 0;  
   
         ret = statflag_read(sfh, &extmem, sizeof(extmem));  
         if (extmem.maxmem) {  
                 if (extmem.maxmem > (13+1)) {  
                         extmem.maxmem = (13+1);  
                 }  
                 if (!extmemmng_realloc(extmem.maxmem - 1)) {  
                         pagemax = (extmem.maxmem - 1) << 8;  
                         if (CPU_EXTMEM) {  
                                 ret |= statflag_read(sfh, 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)tbl;  
         return(ret);  
 }  
   
   
 // ---- cg window  // ---- cg window
   
 #if defined(CGWND_FONTPTR)  #if defined(CGWND_FONTPTR)
Line 665  static int flagload_cgwnd(STFLAGH sfh, c Line 431  static int flagload_cgwnd(STFLAGH sfh, c
   
 // ---- dma  // ---- dma
   
 static int flagsave_dma(STFLAGH sfh, const SFENTRY *t) {  static int flagsave_dma(STFLAGH sfh, const SFENTRY *tbl) {
   
         int                     i;          int                     i;
         _DMAC           dmabak;          _DMAC           dmabak;
Line 678  static int flagsave_dma(STFLAGH sfh, con Line 444  static int flagsave_dma(STFLAGH sfh, con
                         return(STATFLAG_FAILURE);                          return(STATFLAG_FAILURE);
                 }                  }
         }          }
           (void)tbl;
         return(statflag_write(sfh, &dmabak, sizeof(dmabak)));          return(statflag_write(sfh, &dmabak, sizeof(dmabak)));
 }  }
   
Line 870  static int flagload_evt(STFLAGH sfh, con Line 637  static int flagload_evt(STFLAGH sfh, con
 }  }
   
   
   // ---- 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);
   }
   
   
 // ---- gaiji  // ---- gaiji
   
 static int flagsave_gij(STFLAGH sfh, const SFENTRY *tbl) {  static int flagsave_gij(STFLAGH sfh, const SFENTRY *tbl) {
Line 1019  static int flagsave_fm(STFLAGH sfh, cons Line 813  static int flagsave_fm(STFLAGH sfh, cons
         if (saveflg & FLAG_CS4231) {          if (saveflg & FLAG_CS4231) {
                 ret |= statflag_write(sfh, &cs4231, sizeof(cs4231));                  ret |= statflag_write(sfh, &cs4231, sizeof(cs4231));
         }          }
           (void)tbl;
         return(ret);          return(ret);
 }  }
   
 static void play_fmreg(BYTE num, UINT reg) {  
   
         UINT    chbase;  
         UINT    i;  
   
         chbase = num * 3;  
         for (i=0x30; i<0xa0; i++) {  
                 opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);  
         }  
         for (i=0xb7; i>=0xa0; i--) {  
                 opngen_setreg((BYTE)chbase, (BYTE)i, opn.reg[reg + i]);  
         }  
         for (i=0; i<3; i++) {  
                 opngen_keyon(chbase + i, opngen.keyreg[chbase + i]);  
         }  
 }  
   
 static void play_psgreg(PSGGEN psg) {  
   
         BYTE    i;  
   
         for (i=0; i<0x0e; i++) {  
                 psggen_setreg(psg, i, ((BYTE *)&psg->reg)[i]);  
         }  
 }  
   
 static int flagload_fm(STFLAGH sfh, const SFENTRY *t) {  static int flagload_fm(STFLAGH sfh, const SFENTRY *t) {
   
         int             ret;          int             ret;
         UINT    saveflg;          UINT    saveflg;
         OPNKEY  opnkey;          OPNKEY  opnkey;
         UINT    fmreg1a;  
         UINT    fmreg1b;  
         UINT    fmreg2a;  
         UINT    fmreg2b;  
   
         opngen_reset();  
         psggen_reset(&psg1);  
         psggen_reset(&psg2);  
         psggen_reset(&psg3);  
         rhythm_reset(&rhythm);  
         adpcm_reset(&adpcm);  
         pcm86_reset();  
         cs4231_reset();  
   
         ret = statflag_read(sfh, &usesound, sizeof(usesound));          ret = statflag_read(sfh, &usesound, sizeof(usesound));
         fmboard_reset((BYTE)usesound);          fmboard_reset(usesound);
   
         fmreg1a = 0x000;  
         fmreg1b = 0x100;  
         fmreg2a = 0x200;  
         fmreg2b = 0x300;  
         switch(usesound) {          switch(usesound) {
                 case 0x01:                  case 0x01:
                         saveflg = FLAG_MG;                          saveflg = FLAG_MG;
Line 1091  static int flagload_fm(STFLAGH sfh, cons Line 843  static int flagload_fm(STFLAGH sfh, cons
                 case 0x06:                  case 0x06:
                         saveflg = FLAG_FM1A | FLAG_FM1B | FLAG_FM2A | FLAG_PSG1 |                          saveflg = FLAG_FM1A | FLAG_FM1B | FLAG_FM2A | FLAG_PSG1 |
                                                                                 FLAG_PSG2 | FLAG_RHYTHM | FLAG_PCM86;                                                                                  FLAG_PSG2 | FLAG_RHYTHM | FLAG_PCM86;
                         fmreg1a = 0x200;        // 逆転してるのん…  
                         fmreg1b = 0x000;  
                         fmreg2a = 0x100;  
                         break;                          break;
   
                 case 0x08:                  case 0x08:
Line 1157  static int flagload_fm(STFLAGH sfh, cons Line 906  static int flagload_fm(STFLAGH sfh, cons
         }          }
         if (saveflg & FLAG_CS4231) {          if (saveflg & FLAG_CS4231) {
                 ret |= statflag_read(sfh, &cs4231, sizeof(cs4231));                  ret |= statflag_read(sfh, &cs4231, sizeof(cs4231));
                 cs4231.proc = cs4231dec[cs4231.reg.datafmt >> 4];  
         }          }
   
         // 復元。          // 復元。 これ移動すること！
         rhythm_update(&rhythm);  
         adpcm_update(&adpcm);          adpcm_update(&adpcm);
         pcm86gen_update();          pcm86gen_update();
         if (saveflg & FLAG_PCM86) {          if (saveflg & FLAG_PCM86) {
                 fmboard_extenable((BYTE)(pcm86.extfunc & 1));                  fmboard_extenable((REG8)(pcm86.extfunc & 1));
         }          }
         if (saveflg & FLAG_CS4231) {          if (saveflg & FLAG_CS4231) {
                 fmboard_extenable((BYTE)(cs4231.extfunc & 1));                  fmboard_extenable((REG8)(cs4231.extfunc & 1));
         }  
   
         if (saveflg & FLAG_FM1A) {  
                 play_fmreg(0, fmreg1a);  
         }  
         if (saveflg & FLAG_FM1B) {  
                 play_fmreg(1, fmreg1b);  
         }  
         if (saveflg & FLAG_FM2A) {  
                 play_fmreg(2, fmreg2a);  
         }  
         if (saveflg & FLAG_FM2B) {  
                 play_fmreg(3, fmreg2b);  
         }  
         if (saveflg & FLAG_PSG1) {  
                 play_psgreg(&psg1);  
         }  
         if (saveflg & FLAG_PSG2) {  
                 play_psgreg(&psg2);  
         }  
         if (saveflg & FLAG_PSG3) {  
                 play_psgreg(&psg3);  
         }          }
         (void)t;          (void)t;
         return(ret);          return(ret);
Line 1318  static int flagload_disk(STFLAGH sfh, co Line 1043  static int flagload_disk(STFLAGH sfh, co
                         fdd_set(i, st.path, FTYPE_NONE, st.readonly);                          fdd_set(i, st.path, FTYPE_NONE, st.readonly);
                 }                  }
         }          }
         sxsi_trash();  
         for (i=0x00; i<0x02; i++) {          for (i=0x00; i<0x02; i++) {
                 ret |= statflag_read(sfh, &st, sizeof(st));                  ret |= statflag_read(sfh, &st, sizeof(st));
                 if (st.path[0]) {                  if (st.path[0]) {
Line 1465  const SFENTRY *tblterm; Line 1189  const SFENTRY *tblterm;
                 ret |= statflag_createsection(sffh, tbl);                  ret |= statflag_createsection(sffh, tbl);
                 switch(tbl->type) {                  switch(tbl->type) {
                         case STATFLAG_BIN:                          case STATFLAG_BIN:
                         case STATFLAG_CLOCK:  
                         case STATFLAG_TERM:                          case STATFLAG_TERM:
                                 ret |= flagsave_common(&sffh->sfh, tbl);                                  ret |= flagsave_common(&sffh->sfh, tbl);
                                 break;                                  break;
Line 1559  const SFENTRY *tblterm; Line 1282  const SFENTRY *tblterm;
 #if defined(CGWND_FONTPTR)  #if defined(CGWND_FONTPTR)
                                 case STATFLAG_CGW:                                  case STATFLAG_CGW:
 #endif  #endif
                                 case STATFLAG_CLOCK:  
                                 case STATFLAG_MEM:                                  case STATFLAG_MEM:
                                         ret |= flagcheck_versize(&sffh->sfh, tbl);                                          ret |= flagcheck_versize(&sffh->sfh, tbl);
                                         break;                                          break;
Line 1612  const SFENTRY *tblterm; Line 1334  const SFENTRY *tblterm;
                 return(STATFLAG_FAILURE);                  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_trash();
   
           ret |= flagload_common(&sffh->sfh, np2tbl);
   
           CPU_RESET();
           CPU_SETEXTSIZE((UINT32)pccore.extmem);
           nevent_allreset();
   
           sound_changeclock();
           beep_changeclock();
         sound_reset();          sound_reset();
 #if defined(SUPPORT_WAVEMIX)          fddmtrsnd_bind();
         wavemix_bind();  
 #endif          iocore_reset();                                                         // サウンドでpicを呼ぶので…
         fmboard_reset(0);          cbuscore_reset();
           fmboard_reset(pccore.sound);
   
         done = FALSE;          done = FALSE;
         ret = STATFLAG_SUCCESS;  
         while((!done) && (ret != STATFLAG_FAILURE)) {          while((!done) && (ret != STATFLAG_FAILURE)) {
                 ret |= statflag_readsection(sffh);                  ret |= statflag_readsection(sffh);
                 tbl = np2tbl;                  tbl = np2tbl + 1;
                 tblterm = tbl + (sizeof(np2tbl)/sizeof(SFENTRY));                  tblterm = np2tbl + (sizeof(np2tbl)/sizeof(SFENTRY));
                 while(tbl < tblterm) {                  while(tbl < tblterm) {
                         if (!memcmp(sffh->sfh.hdr.index, tbl->index, 10)) {                          if (!memcmp(sffh->sfh.hdr.index, tbl->index, 10)) {
                                 break;                                  break;
Line 1650  const SFENTRY *tblterm; Line 1390  const SFENTRY *tblterm;
                                         break;                                          break;
 #endif  #endif
   
                                 case STATFLAG_CLOCK:  
                                         ret |= flagload_clock(&sffh->sfh, tbl);  
                                         break;  
   
                                 case STATFLAG_COM:                                  case STATFLAG_COM:
                                         ret |= flagload_com(&sffh->sfh, tbl);                                          ret |= flagload_com(&sffh->sfh, tbl);
                                         break;                                          break;
Removed from v.1.28  
changed lines
  Added in v.1.41

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