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

Diff for /np2/statsave.c between versions 1.46 and 1.47

version 1.46, 2005/03/05 06:02:28 version 1.47, 2005/03/22 04:03:15
Line 61  enum { Line 61  enum {
         STATFLAG_CGW,          STATFLAG_CGW,
 #endif  #endif
         STATFLAG_COM,          STATFLAG_COM,
         STATFLAG_DISK,  
         STATFLAG_DMA,          STATFLAG_DMA,
         STATFLAG_EGC,          STATFLAG_EGC,
         STATFLAG_EPSON,          STATFLAG_EPSON,
         STATFLAG_EVT,          STATFLAG_EVT,
         STATFLAG_EXT,          STATFLAG_EXT,
           STATFLAG_FDD,
         STATFLAG_FM,          STATFLAG_FM,
         STATFLAG_GIJ,          STATFLAG_GIJ,
 #if defined(SUPPORT_HOSTDRV)  #if defined(SUPPORT_HOSTDRV)
         STATFLAG_HDRV,          STATFLAG_HDRV,
 #endif  #endif
         STATFLAG_MEM          STATFLAG_MEM,
           STATFLAG_SXSI
 };  };
   
 typedef struct {  typedef struct {
Line 103  typedef struct { Line 104  typedef struct {
   
 // ----  // ----
   
 // 関数ポインタを intに変更。  
 static BRESULT proc2num(void *func, const PROCTBL *tbl, int size) {  
   
         int             i;  
   
         for (i=0; i<size; i++) {  
                 if (*(long *)func == (long)tbl->proc) {  
                         *(long *)func = (long)tbl->id;  
                         return(SUCCESS);  
                 }  
                 tbl++;  
         }  
         return(FAILURE);  
 }  
   
 static BRESULT num2proc(void *func, const PROCTBL *tbl, int size) {  
   
         int             i;  
   
         for (i=0; i<size; i++) {  
                 if (*(long *)func == (long)tbl->id) {  
                         *(long *)func = (long)tbl->proc;  
                         return(SUCCESS);  
                 }  
                 tbl++;  
         }  
         return(FAILURE);  
 }  
   
   
 // ----  
   
 enum {  enum {
         SFFILEH_WRITE   = 0x0001,          SFFILEH_WRITE   = 0x0001,
         SFFILEH_BLOCK   = 0x0002,          SFFILEH_BLOCK   = 0x0002,
Line 364  void statflag_seterr(STFLAGH sfh, const  Line 333  void statflag_seterr(STFLAGH sfh, const 
 }  }
   
   
   // ---- function
   
   // 関数ポインタを intに変更。
   static BRESULT proc2num(void *func, const PROCTBL *tbl, int size) {
   
           int             i;
   
           for (i=0; i<size; i++) {
                   if (*(long *)func == (long)tbl->proc) {
                           *(long *)func = (long)tbl->id;
                           return(SUCCESS);
                   }
                   tbl++;
           }
           return(FAILURE);
   }
   
   static BRESULT num2proc(void *func, const PROCTBL *tbl, int size) {
   
           int             i;
   
           for (i=0; i<size; i++) {
                   if (*(long *)func == (long)tbl->id) {
                           *(long *)func = (long)tbl->proc;
                           return(SUCCESS);
                   }
                   tbl++;
           }
           return(FAILURE);
   }
   
   
   // ---- file
   
   typedef struct {
           OEMCHAR path[MAX_PATH];
           UINT    ftype;
           int             readonly;
           DOSDATE date;
           DOSTIME time;
   } STATPATH;
   
   static const OEMCHAR str_updated[] = OEMTEXT("%s: updated");
   static const OEMCHAR str_notfound[] = OEMTEXT("%s: not found");
   
   static int statflag_writepath(STFLAGH sfh, const OEMCHAR *path,
                                                                                                   UINT ftype, int readonly) {
   
           STATPATH        sp;
           FILEH           fh;
   
           ZeroMemory(&sp, sizeof(sp));
           if ((path) && (path[0])) {
                   file_cpyname(sp.path, path, NELEMENTS(sp.path));
                   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) {
   
           int                     ret;
           STATPATH        sp;
           FILEH           fh;
           OEMCHAR         buf[256];
           DOSDATE         date;
           DOSTIME         time;
   
           ret = statflag_read(sfh, &sp, sizeof(sp));
           if (sp.path[0]) {
                   fh = file_open_rb(sp.path);
                   if (fh != FILEH_INVALID) {
                           file_getdatetime(fh, &date, &time);
                           file_close(fh);
                           if ((memcmp(&sp.date, &date, sizeof(date))) ||
                                   (memcmp(&sp.time, &time, sizeof(time)))) {
                                   ret |= STATFLAG_DISKCHG;
                                   OEMSPRINTF(buf, str_updated, devname);
                                   statflag_seterr(sfh, buf);
                           }
                   }
                   else {
                           ret |= STATFLAG_DISKCHG;
                           OEMSPRINTF(buf, str_notfound, devname);
                           statflag_seterr(sfh, buf);
                   }
           }
           return(ret);
   }
   
   
 // ---- common  // ---- common
   
 static int flagsave_common(STFLAGH sfh, const SFENTRY *tbl) {  static int flagsave_common(STFLAGH sfh, const SFENTRY *tbl) {
Line 925  static int flagload_fm(STFLAGH sfh, cons Line 991  static int flagload_fm(STFLAGH sfh, cons
 #endif  #endif
   
   
 // ---- disk  // ---- fdd
   
 typedef struct {  
         OEMCHAR path[MAX_PATH];  
         int             readonly;  
         DOSDATE date;  
         DOSTIME time;  
 } STATDISK;  
   
 static const OEMCHAR str_fddx[] = OEMTEXT("FDD%u");  static const OEMCHAR str_fddx[] = OEMTEXT("FDD%u");
 static const OEMCHAR str_sasix[] = OEMTEXT("SASI%u");  
 static const OEMCHAR str_scsix[] = OEMTEXT("SCSI%u");  
 static const OEMCHAR str_updated[] = OEMTEXT("%s: updated");  
 static const OEMCHAR str_notfound[] = OEMTEXT("%s: not found");  
   
 static int disksave(STFLAGH sfh, const OEMCHAR *path, int readonly) {  static int flagsave_fdd(STFLAGH sfh, const SFENTRY *tbl) {
   
         STATDISK        st;          int                     ret;
         FILEH           fh;          UINT8           i;
   const OEMCHAR   *path;
           UINT            ftype;
           int                     ro;
   
         ZeroMemory(&st, sizeof(st));          ret = STATFLAG_SUCCESS;
         if ((path) && (path[0])) {          for (i=0; i<4; i++) {
                 file_cpyname(st.path, path, sizeof(st.path));                  path = fdd_getfileex(i, &ftype, &ro);
                 st.readonly = readonly;                  ret |= statflag_writepath(sfh, path, ftype, ro);
                 fh = file_open_rb(path);  
                 if (fh != FILEH_INVALID) {  
                         file_getdatetime(fh, &st.date, &st.time);  
                         file_close(fh);  
                 }  
         }          }
         return(statflag_write(sfh, &st, sizeof(st)));          (void)tbl;
           return(ret);
 }  }
   
 static int flagsave_disk(STFLAGH sfh, const SFENTRY *tbl) {  static int flagcheck_fdd(STFLAGH sfh, const SFENTRY *tbl) {
   
         int             ret;          int             ret;
         UINT8   i;          int             i;
           OEMCHAR buf[8];
   
         sxsi_allflash();  
         ret = STATFLAG_SUCCESS;          ret = STATFLAG_SUCCESS;
         for (i=0; i<4; i++) {          for (i=0; i<4; i++) {
                 ret |= disksave(sfh, fdd_diskname(i), fdd_diskprotect(i));                  OEMSPRINTF(buf, str_fddx, i+1);
         }                  ret |= statflag_checkpath(sfh, buf);
         for (i=0x00; i<0x02; i++) {  
                 ret |= disksave(sfh, sxsi_getfilename(i), 0);  
         }  
         for (i=0x20; i<0x24; i++) {  
                 ret |= disksave(sfh, sxsi_getfilename(i), 0);  
         }          }
         (void)tbl;          (void)tbl;
         return(ret);          return(ret);
 }  }
   
 static int diskcheck(STFLAGH sfh, const OEMCHAR *name) {  static int flagload_fdd(STFLAGH sfh, const SFENTRY *tbl) {
   
         int                     ret;          int                     ret;
         FILEH           fh;          UINT8           i;
         STATDISK        st;          STATPATH        sp;
         OEMCHAR         buf[256];  
         DOSDATE         date;  
         DOSTIME         time;  
   
         ret = statflag_read(sfh, &st, sizeof(st));          ret = STATFLAG_SUCCESS;
         if (st.path[0]) {          for (i=0; i<4; i++) {
                 fh = file_open_rb(st.path);                  ret |= statflag_read(sfh, &sp, sizeof(sp));
                 if (fh != FILEH_INVALID) {                  if (sp.path[0]) {
                         file_getdatetime(fh, &date, &time);                          fdd_set(i, sp.path, FTYPE_NONE, sp.readonly);
                         file_close(fh);  
                         if ((memcmp(&st.date, &date, sizeof(date))) ||  
                                 (memcmp(&st.time, &time, sizeof(time)))) {  
                                 ret |= STATFLAG_DISKCHG;  
                                 OEMSPRINTF(buf, str_updated, name);  
                                 statflag_seterr(sfh, buf);  
                         }  
                 }  
                 else {  
                         ret |= STATFLAG_DISKCHG;  
                         OEMSPRINTF(buf, str_notfound, name);  
                         statflag_seterr(sfh, buf);  
                 }                  }
         }          }
           (void)tbl;
         return(ret);          return(ret);
 }  }
   
 static int flagcheck_disk(STFLAGH sfh, const SFENTRY *tbl) {  
   
         int             ret;  // ---- sxsi
         int             i;  
         OEMCHAR buf[8];  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;
           UINT            i;
           SXSIDEVS        sds;
   const OEMCHAR   *path;
   
         ret = 0;  
         for (i=0; i<4; i++) {  
                 OEMSPRINTF(buf, str_fddx, i+1);  
                 ret |= diskcheck(sfh, buf);  
         }  
         sxsi_allflash();          sxsi_allflash();
         for (i=0; i<2; i++) {          ret = STATFLAG_SUCCESS;
                 OEMSPRINTF(buf, str_sasix, i+1);          for (i=0; i<NELEMENTS(sds.ide); i++) {
                 ret |= diskcheck(sfh, buf);                  sds.ide[i] = sxsi_getdevtype((REG8)i);
         }          }
         for (i=0; i<4; i++) {          for (i=0; i<NELEMENTS(sds.scsi); i++) {
                 OEMSPRINTF(buf, str_scsix, i);                  sds.scsi[i] = sxsi_getdevtype((REG8)(i + 0x20));
                 ret |= diskcheck(sfh, buf);          }
           ret = statflag_write(sfh, &sds, sizeof(sds));
           for (i=0; i<NELEMENTS(sds.ide); i++) {
                   if (sds.ide[i] != SXSIDEV_NC) {
                           path = sxsi_getfilename((REG8)i);
                           ret |= statflag_writepath(sfh, path, FTYPE_NONE, 0);
                   }
           }
           for (i=0; i<NELEMENTS(sds.scsi); i++) {
                   if (sds.scsi[i] != SXSIDEV_NC) {
                           path = sxsi_getfilename((REG8)(i + 0x20));
                           ret |= statflag_writepath(sfh, path, FTYPE_NONE, 0);
                   }
         }          }
         (void)tbl;          (void)tbl;
         return(ret);          return(ret);
 }  }
   
 static int flagload_disk(STFLAGH sfh, const SFENTRY *tbl) {  static int flagcheck_sxsi(STFLAGH sfh, const SFENTRY *tbl) {
   
         int                     ret;          int                     ret;
         UINT8           i;          SXSIDEVS        sds;
         STATDISK        st;          UINT            i;
           OEMCHAR         buf[8];
   
         ret = 0;          sxsi_allflash();
         for (i=0; i<4; i++) {          ret = statflag_read(sfh, &sds, sizeof(sds));
                 ret |= statflag_read(sfh, &st, sizeof(st));          for (i=0; i<NELEMENTS(sds.ide); i++) {
                 if (st.path[0]) {                  if (sds.ide[i] != SXSIDEV_NC) {
                         fdd_set(i, st.path, FTYPE_NONE, st.readonly);                          OEMSPRINTF(buf, str_sasix, i+1);
                           ret |= statflag_checkpath(sfh, buf);
                 }                  }
         }          }
         for (i=0x00; i<0x02; i++) {          for (i=0; i<NELEMENTS(sds.scsi); i++) {
                 ret |= statflag_read(sfh, &st, sizeof(st));                  if (sds.scsi[i] != SXSIDEV_NC) {
                 if (st.path[0]) {                          OEMSPRINTF(buf, str_scsix, i);
                         sxsi_devopen(i, st.path);                          ret |= statflag_checkpath(sfh, buf);
                 }                  }
         }          }
         for (i=0x20; i<0x24; i++) {          (void)tbl;
                 ret |= statflag_read(sfh, &st, sizeof(st));          return(ret);
                 if (st.path[0]) {  }
                         sxsi_devopen(i, st.path);  
   static int flagload_sxsi(STFLAGH sfh, const SFENTRY *tbl) {
   
           int                     ret;
           SXSIDEVS        sds;
           UINT            i;
           REG8            drv;
           STATPATH        sp;
   
           ret = statflag_read(sfh, &sds, sizeof(sds));
           if (ret != STATFLAG_SUCCESS) {
                   return(ret);
           }
           for (i=0; i<NELEMENTS(sds.ide); i++) {
                   drv = (REG8)i;
                   sxsi_setdevtype(drv, sds.ide[i]);
                   if (sds.ide[i] != SXSIDEV_NC) {
                           ret |= statflag_read(sfh, &sp, sizeof(sp));
                           sxsi_devopen(drv, sp.path);
                   }
           }
           for (i=0; i<NELEMENTS(sds.scsi); i++) {
                   drv = (REG8)(i + 0x20);
                   sxsi_setdevtype(drv, sds.scsi[i]);
                   if (sds.scsi[i] != SXSIDEV_NC) {
                           ret |= statflag_read(sfh, &sp, sizeof(sp));
                           sxsi_devopen(drv, sp.path);
                 }                  }
         }          }
         (void)tbl;          (void)tbl;
Line 1206  const SFENTRY *tblterm; Line 1288  const SFENTRY *tblterm;
                                 ret |= flagsave_com(&sffh->sfh, tbl);                                  ret |= flagsave_com(&sffh->sfh, tbl);
                                 break;                                  break;
   
                         case STATFLAG_DISK:  
                                 ret |= flagsave_disk(&sffh->sfh, tbl);  
                                 break;  
   
                         case STATFLAG_DMA:                          case STATFLAG_DMA:
                                 ret |= flagsave_dma(&sffh->sfh, tbl);                                  ret |= flagsave_dma(&sffh->sfh, tbl);
                                 break;                                  break;
Line 1230  const SFENTRY *tblterm; Line 1308  const SFENTRY *tblterm;
                                 ret |= flagsave_ext(&sffh->sfh, tbl);                                  ret |= flagsave_ext(&sffh->sfh, tbl);
                                 break;                                  break;
   
                           case STATFLAG_FDD:
                                   ret |= flagsave_fdd(&sffh->sfh, tbl);
                                   break;
   
 #if !defined(DISABLE_SOUND)  #if !defined(DISABLE_SOUND)
                         case STATFLAG_FM:                          case STATFLAG_FM:
                                 ret |= flagsave_fm(&sffh->sfh, tbl);                                  ret |= flagsave_fm(&sffh->sfh, tbl);
Line 1249  const SFENTRY *tblterm; Line 1331  const SFENTRY *tblterm;
                         case STATFLAG_MEM:                          case STATFLAG_MEM:
                                 ret |= flagsave_mem(&sffh->sfh, tbl);                                  ret |= flagsave_mem(&sffh->sfh, tbl);
                                 break;                                  break;
   
                           case STATFLAG_SXSI:
                                   ret |= flagsave_sxsi(&sffh->sfh, tbl);
                                   break;
                 }                  }
                 tbl++;                  tbl++;
         }          }
Line 1311  const SFENTRY *tblterm; Line 1397  const SFENTRY *tblterm;
                                         ret |= flagcheck_veronly(&sffh->sfh, tbl);                                          ret |= flagcheck_veronly(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case STATFLAG_DISK:                                  case STATFLAG_FDD:
                                         ret |= flagcheck_disk(&sffh->sfh, tbl);                                          ret |= flagcheck_fdd(&sffh->sfh, tbl);
                                           break;
   
                                   case STATFLAG_SXSI:
                                           ret |= flagcheck_sxsi(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 default:                                  default:
Line 1401  const SFENTRY *tblterm; Line 1491  const SFENTRY *tblterm;
                                         ret |= flagload_com(&sffh->sfh, tbl);                                          ret |= flagload_com(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case STATFLAG_DISK:  
                                         ret |= flagload_disk(&sffh->sfh, tbl);  
                                         break;  
   
                                 case STATFLAG_DMA:                                  case STATFLAG_DMA:
                                         ret |= flagload_dma(&sffh->sfh, tbl);                                          ret |= flagload_dma(&sffh->sfh, tbl);
                                         break;                                          break;
Line 1425  const SFENTRY *tblterm; Line 1511  const SFENTRY *tblterm;
                                         ret |= flagload_ext(&sffh->sfh, tbl);                                          ret |= flagload_ext(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                   case STATFLAG_FDD:
                                           ret |= flagload_fdd(&sffh->sfh, tbl);
                                           break;
   
 #if !defined(DISABLE_SOUND)  #if !defined(DISABLE_SOUND)
                                 case STATFLAG_FM:                                  case STATFLAG_FM:
                                         ret |= flagload_fm(&sffh->sfh, tbl);                                          ret |= flagload_fm(&sffh->sfh, tbl);
Line 1445  const SFENTRY *tblterm; Line 1535  const SFENTRY *tblterm;
                                         ret |= flagload_mem(&sffh->sfh, tbl);                                          ret |= flagload_mem(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                   case STATFLAG_SXSI:
                                           ret |= flagload_sxsi(&sffh->sfh, tbl);
                                           break;
   
                                 default:                                  default:
                                         ret |= STATFLAG_WARNING;                                          ret |= STATFLAG_WARNING;
                                         break;                                          break;
Removed from v.1.46  
changed lines
  Added in v.1.47

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