[BACK]Return to fddfile.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / xmil / fdd

Diff for /xmil/fdd/fddfile.c between versions 1.3 and 1.6

version 1.3, 2004/08/02 13:38:46 version 1.6, 2004/08/15 12:32:11
Line 12 Line 12
         _FDDFILE        fddfile[MAX_FDDFILE];          _FDDFILE        fddfile[MAX_FDDFILE];
   
   
 void fddfile_initialize(void) {  static REG8 dummyseek(FDDFILE fdd, REG8 media, UINT track) {
   
           (void)fdd;
           (void)media;
           (void)track;
           return(FDDSTAT_SEEKERR);
 }  }
   
 const OEMCHAR *fdd_diskname(REG8 drv) {  static REG8 dummyread(FDDFILE fdd, REG8 media, UINT track, REG8 sc,
                                                                                                   UINT8 *ptr, UINT *size) {
   
         if (drv >= MAX_FDDFILE) {          (void)fdd;
                 return(str_null);          (void)media;
         }          (void)track;
         return(fddfile[drv].fname);          (void)sc;
           (void)ptr;
           (void)size;
           return(FDDSTAT_RECNFND);
 }  }
   
 BRESULT fdd_diskready(REG8 drv) {  static REG8 dummywrite(FDDFILE fdd, REG8 media, UINT track, REG8 sc,
                                                                                                   const UINT8 *ptr, UINT size) {
   
         if ((drv >= MAX_FDDFILE) || (fddfile[drv].fname[0] == '\0')) {          (void)fdd;
                 return(FALSE);          (void)media;
         }          (void)track;
         return(TRUE);          (void)sc;
           (void)ptr;
           (void)size;
           return(FDDSTAT_RECNFND | FDDSTAT_WRITEFAULT);
 }  }
   
   static REG8 dummycrc(FDDFILE fdd, REG8 media, UINT track, UINT num,
                                                                                                   UINT8 *ptr) {
   
 // ----          (void)fdd;
           (void)media;
           (void)track;
           (void)num;
           (void)ptr;
           return(FDDSTAT_RECNFND);
   }
   
 static REG8 getfdtype(const OEMCHAR *fname) {  static UINT32 getfdtype(const OEMCHAR *fname) {
   
 const OEMCHAR   *ext;  const OEMCHAR   *ext;
   
         ext = file_getext(fname);          ext = file_getext(fname);
         if (!milstr_cmp(ext, str_e2d)) {          if (!milstr_cmp(ext, str_e2d)) {
                 return(DISKTYPE_BETA);                  return(FTYPE_BETA);
         }          }
         if ((!milstr_cmp(ext, str_d88)) || (!milstr_cmp(ext, str_88d))) {          if ((!milstr_cmp(ext, str_d88)) || (!milstr_cmp(ext, str_88d))) {
                 return(DISKTYPE_D88);                  return(FTYPE_D88);
           }
           return(FTYPE_NONE);
   }
   
   static void setempty(FDDFILE fdd) {
   
           ZeroMemory(fdd, sizeof(_FDDFILE));
           fdd->seek = dummyseek;
           fdd->read = dummyread;
           fdd->write = dummywrite;
           fdd->crc = dummycrc;
   }
   
   
   // ----
   
   void fddfile_initialize(void) {
   
           UINT    i;
   
           for (i=0; i<MAX_FDDFILE; i++) {
                   setempty(fddfile + i);
           }
   }
   
   const OEMCHAR *fddfile_diskname(REG8 drv) {
   
           if (drv >= MAX_FDDFILE) {
                   return(str_null);
         }          }
         return(DISKTYPE_NOTREADY);          return(fddfile[drv].fname);
 }  }
   
 BRESULT fdd_set(REG8 drv, const OEMCHAR *fname, UINT ftype, int ro) {  BRESULT fddfile_diskready(REG8 drv) {
   
         FDDFILE         fdd;          if ((drv >= MAX_FDDFILE) || (fddfile[drv].type == DISKTYPE_NOTREADY)) {
                   return(FALSE);
           }
           return(TRUE);
   }
   
   BRESULT fddfile_diskprotect(REG8 drv) {
   
           if ((drv >= MAX_FDDFILE) || (!fddfile[drv].protect)) {
                   return(FALSE);
           }
           return(TRUE);
   }
   
   BRESULT fddfile_set(REG8 drv, const OEMCHAR *fname, UINT32 ftype, int ro) {
   
           FDDFILE fdd;
           BRESULT r;
   
         if (drv >= MAX_FDDFILE) {          if (drv >= MAX_FDDFILE) {
                 return(FAILURE);                  return(FAILURE);
         }          }
         fdd_eject(drv);          fddfile_eject(drv);
         fdd = fddfile + drv;          fdd = fddfile + drv;
         switch(getfdtype(fname)) {          if (ftype == FTYPE_NONE) {
                 case DISKTYPE_NOTREADY:                  ftype = getfdtype(fname);
                         return(FAILURE);          }
           switch(ftype) {
                 case DISKTYPE_BETA:                  case FTYPE_BETA:
                         return(fdd2d_set(fdd, drv, fname));                          r = fdd2d_set(fdd, fname);
                           break;
   
                   case FTYPE_D88:
                           r = fddd88_set(fdd, fname);
                           break;
   
                 case DISKTYPE_D88:  
                 default:                  default:
                         return(fddd88_set(fdd, drv, fname));                          r = FAILURE;
                           break;
           }
           if (r == SUCCESS) {
                   fdd->ftype = ftype;
                   milstr_ncpy(fdd->fname, fname, NELEMENTS(fdd->fname));
                   if (ro) {
                           fdd->protect = TRUE;
                   }
         }          }
         return(FAILURE);          return(r);
 }  }
   
 BRESULT fdd_eject(REG8 drv) {  void fddfile_eject(REG8 drv) {
   
         FDDFILE         fdd;          FDDFILE fdd;
   
         if (drv >= MAX_FDDFILE) {          if (drv >= MAX_FDDFILE) {
                 return(FAILURE);                  return;
         }          }
         fdd = fddfile + drv;          fdd = fddfile + drv;
         switch(fdd->type) {          switch(fdd->type) {
                 case DISKTYPE_NOTREADY:  
                         return(FAILURE);  
   
                 case DISKTYPE_BETA:                  case DISKTYPE_BETA:
                         return(fdd2d_eject(fdd, drv));                          fdd2d_eject(fdd);
   
                 case DISKTYPE_D88:                  case DISKTYPE_D88:
                 default:                          fddd88_eject(fdd);
                         return(fddd88_eject(fdd, drv));  
         }          }
         return(FAILURE);          setempty(fdd);
 }  }
   
Removed from v.1.3  
changed lines
  Added in v.1.6

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