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

Diff for /np2/sdl/dosio.c between versions 1.3 and 1.5

version 1.3, 2004/01/07 07:27:41 version 1.5, 2004/01/12 08:01:00
Line 100  struct stat sb; Line 100  struct stat sb;
         return(-1);          return(-1);
 }  }
   
   static BOOL cnv_sttime(time_t *t, DOSDATE *dosdate, DOSTIME *dostime) {
   
   struct tm       *ftime;
   
           ftime = localtime(t);
           if (ftime == NULL) {
                   return(FAILURE);
           }
           if (dosdate) {
                   dosdate->year = ftime->tm_year + 1900;
                   dosdate->month = ftime->tm_mon + 1;
                   dosdate->day = ftime->tm_mday;
           }
           if (dostime) {
                   dostime->hour = ftime->tm_hour;
                   dostime->minute = ftime->tm_min;
                   dostime->second = ftime->tm_sec;
           }
           return(SUCCESS);
   }
   
 short file_getdatetime(FILEH handle, DOSDATE *dosdate, DOSTIME *dostime) {  short file_getdatetime(FILEH handle, DOSDATE *dosdate, DOSTIME *dostime) {
   
 struct stat sb;  struct stat sb;
 struct tm       *ftime;  
   
         if (fstat(fileno(handle), &sb) == 0) {          if (fstat(fileno(handle), &sb) == 0) {
                 ftime = localtime(&sb.st_mtime);                  if (cnv_sttime(&sb.st_mtime, dosdate, dostime) == SUCCESS) {
                 if (ftime) {  
                         if (dosdate) {  
                                 dosdate->year = ftime->tm_year + 1900;  
                                 dosdate->month = ftime->tm_mon + 1;  
                                 dosdate->day = ftime->tm_mday;  
                         }  
                         if (dostime) {  
                                 dostime->hour = ftime->tm_hour;  
                                 dostime->minute = ftime->tm_min;  
                                 dostime->second = ftime->tm_sec;  
                         }  
                         return(0);                          return(0);
                 }                  }
         }          }
Line 184  short file_attr_c(const char *path) { Line 193  short file_attr_c(const char *path) {
 }  }
   
 #if defined(WIN32)  #if defined(WIN32)
 FILEFINDH file_find1st(const char *dir, FILEFINDT *fft) {  static BOOL cnvdatetime(FILETIME *file, DOSDATE *dosdate, DOSTIME *dostime) {
   
           FILETIME        localtime;
           SYSTEMTIME      systime;
   
           if ((FileTimeToLocalFileTime(file, &localtime) == 0) ||
                   (FileTimeToSystemTime(&localtime, &systime) == 0)) {
                   return(FAILURE);
           }
           if (dosdate) {
                   dosdate->year = (UINT16)systime.wYear;
                   dosdate->month = (UINT8)systime.wMonth;
                   dosdate->day = (UINT8)systime.wDay;
           }
           if (dostime) {
                   dostime->hour = (UINT8)systime.wHour;
                   dostime->minute = (UINT8)systime.wMinute;
                   dostime->second = (UINT8)systime.wSecond;
           }
           return(SUCCESS);
   }
   
   static BOOL setflist(WIN32_FIND_DATA *w32fd, FLINFO *fli) {
   
           if ((w32fd->dwFileAttributes & FILEATTR_DIRECTORY) &&
                   ((!file_cmpname(w32fd->cFileName, ".")) ||
                   (!file_cmpname(w32fd->cFileName, "..")))) {
                   return(FAILURE);
           }
           fli->caps = FLICAPS_SIZE | FLICAPS_ATTR;
           fli->size = w32fd->nFileSizeLow;
           fli->attr = w32fd->dwFileAttributes;
           if (cnvdatetime(&w32fd->ftLastWriteTime, &fli->date, &fli->time)
                                                                                                                                   == SUCCESS) {
                   fli->caps |= FLICAPS_DATE | FLICAPS_TIME;
           }
           milstr_ncpy(fli->path, w32fd->cFileName, sizeof(fli->path));
           return(SUCCESS);
   }
   
   FLISTH file_list1st(const char *dir, FLINFO *fli) {
   
         char                    path[MAX_PATH];          char                    path[MAX_PATH];
         HANDLE                  hdl;          HANDLE                  hdl;
Line 194  FILEFINDH file_find1st(const char *dir,  Line 243  FILEFINDH file_find1st(const char *dir, 
         file_setseparator(path, sizeof(path));          file_setseparator(path, sizeof(path));
         milsjis_ncat(path, "*.*", sizeof(path));          milsjis_ncat(path, "*.*", sizeof(path));
         hdl = FindFirstFile(path, &w32fd);          hdl = FindFirstFile(path, &w32fd);
         if (hdl == INVALID_HANDLE_VALUE) {          if (hdl != INVALID_HANDLE_VALUE) {
                 return(FILEFINDH_INVALID);                  do {
         }                          if (setflist(&w32fd, fli) == SUCCESS) {
         if (fft) {                                  return(hdl);
                 milsjis_ncpy(fft->path, w32fd.cFileName, sizeof(fft->path));                          }
                 fft->size = w32fd.nFileSizeLow;                  } while(FindNextFile(hdl, &w32fd));
                 fft->attr = w32fd.dwFileAttributes;                  FindClose(hdl);
         }          }
         return((FILEFINDH)hdl);          return(FLISTH_INVALID);
 }  }
   
 BOOL file_findnext(FILEFINDH hdl, FILEFINDT *fft) {  BOOL file_listnext(FLISTH hdl, FLINFO *fli) {
   
         WIN32_FIND_DATA w32fd;          WIN32_FIND_DATA w32fd;
   
         if (!FindNextFile((HANDLE)hdl, &w32fd)) {          while(FindNextFile(hdl, &w32fd)) {
                 return(FAILURE);                  if (setflist(&w32fd, fli) == SUCCESS) {
         }                          return(SUCCESS);
         if (fft) {                  }
                 milsjis_ncpy(fft->path, w32fd.cFileName, sizeof(fft->path));  
                 fft->size = w32fd.nFileSizeLow;  
                 fft->attr = w32fd.dwFileAttributes;  
         }          }
         return(SUCCESS);          return(FAILURE);
 }  }
   
 void file_findclose(FILEFINDH hdl) {  void file_listclose(FLISTH hdl) {
   
         FindClose((HANDLE)hdl);          FindClose(hdl);
 }  }
 #else  #else
 FILEFINDH file_find1st(const char *dir, FILEFINDT *fft) {  FLISTH file_list1st(const char *dir, FLINFO *fli) {
   
         DIR             *ret;          DIR             *ret;
   
Line 233  FILEFINDH file_find1st(const char *dir,  Line 279  FILEFINDH file_find1st(const char *dir, 
         if (ret == NULL) {          if (ret == NULL) {
                 goto ff1_err;                  goto ff1_err;
         }          }
         if (file_findnext((FILEFINDH)ret, fft) == SUCCESS) {          if (file_listnext((FLISTH)ret, fli) == SUCCESS) {
                 return((FILEFINDH)ret);                  return((FLISTH)ret);
         }          }
         closedir(ret);          closedir(ret);
   
 ff1_err:  ff1_err:
         return(FILEFINDH_INVALID);          return(FLISTH_INVALID);
 }  }
   
 BOOL file_findnext(FILEFINDH hdl, FILEFINDT *fft) {  BOOL file_listnext(FLISTH hdl, FLINFO *fli) {
   
 struct dirent   *de;  struct dirent   *de;
 struct stat             sb;  struct stat             sb;
         UINT32          attr;          UINT32          attr;
         UINT32          size;  
   
         de = readdir((DIR *)hdl);          de = readdir((DIR *)hdl);
         if (de == NULL) {          if (de == NULL) {
                 return(FAILURE);                  return(FAILURE);
         }          }
         if (fft) {          if (fli) {
                 mileuc_ncpy(fft->path, de->d_name, sizeof(fft->path));  
                 size = 0;  
                 attr = 0;  
                 if (stat(de->d_name, &sb) == 0) {                  if (stat(de->d_name, &sb) == 0) {
                         size = sb.st_size;                          fli->caps = FLICAPS_SIZE | FLICAPS_ATTR;
                           fli->size = sb.st_size;
                           attr = 0;
                         if (S_ISDIR(sb.st_mode)) {                          if (S_ISDIR(sb.st_mode)) {
                                 attr = FILEATTR_DIRECTORY;                                  attr = FILEATTR_DIRECTORY;
                         }                          }
                         else if (!(sb.st_mode & S_IWUSR)) {                          else if (!(sb.st_mode & S_IWUSR)) {
                                 attr = FILEATTR_READONLY;                                  attr = FILEATTR_READONLY;
                         }                          }
                           fli->attr = attr;
                           if (cnv_sttime(&sb.st_mtime, &fli->date, &fli->time) == SUCCESS) {
                                   fli->caps |= FLICAPS_DATE | FLICAPS_TIME;
                           }
                   }
                   else {
                           fli->caps = 0;
                           fli->size = 0;
                           fli->attr = 0;
                 }                  }
                 fft->size = size;                  mileuc_ncpy(fli->path, de->d_name, sizeof(fli->path));
                 fft->attr = attr;  
         }          }
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 void file_findclose(FILEFINDH hdl) {  void file_listclose(FLISTH hdl) {
   
         closedir((DIR *)hdl);          closedir((DIR *)hdl);
 }  }
Removed from v.1.3  
changed lines
  Added in v.1.5

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