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

Diff for /np2/win9x/dosio.cpp between versions 1.1.1.1 and 1.8

version 1.1.1.1, 2003/10/16 17:58:43 version 1.8, 2005/02/09 20:11:35
Line 2 Line 2
 #include        "dosio.h"  #include        "dosio.h"
   
   
 static  char    curpath[MAX_PATH];  static  OEMCHAR curpath[MAX_PATH];
 static  char    *curfilep = curpath;  static  OEMCHAR *curfilep = curpath;
   
 #define ISKANJI(c)      (((((c) ^ 0x20) - 0xa1) & 0xff) < 0x3c)  #define ISKANJI(c)      (((((c) ^ 0x20) - 0xa1) & 0xff) < 0x3c)
   
 #if defined(UNICODE)  
   
 static HANDLE CreateFile_A(LPCSTR lpFileName,  
                                         DWORD dwDesiredAccess,  
                                         DWORD dwShareMode,  
                                         LPSECURITY_ATTRIBUTES lpSecurityAttributes,  
                                         DWORD dwCreationDisposition,  
                                         DWORD dwFlagsAndAttributes,  
                                         HANDLE hTemplateFile) {  
   
         TCHAR   FileNameW[MAX_PATH*2];  
   
         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, lpFileName, -1,  
                                                         FileNameW, sizeof(FileNameW)/sizeof(TCHAR));  
         return(CreateFile(FileNameW, dwDesiredAccess, dwShareMode,  
                                                 lpSecurityAttributes, dwCreationDisposition,  
                                                 dwFlagsAndAttributes, hTemplateFile));  
 }  
   
 static inline BOOL DeleteFile_A(LPCSTR lpFileName) {  
   
         TCHAR   FileNameW[MAX_PATH*2];  
   
         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, lpFileName, -1,  
                                                         FileNameW, sizeof(FileNameW)/sizeof(TCHAR));  
         return(DeleteFile(FileNameW));  
 }  
   
 static inline DWORD GetFileAttributes_A(LPCSTR lpFileName) {  
   
         TCHAR   FileNameW[MAX_PATH*2];  
   
         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, lpFileName, -1,  
                                                         FileNameW, sizeof(FileNameW)/sizeof(TCHAR));  
         return(GetFileAttributes(FileNameW));  
 }  
   
 static inline BOOL CreateDirectory_A(LPCSTR lpFileName,  
                                                                                                 LPSECURITY_ATTRIBUTES atr) {  
   
         TCHAR   FileNameW[MAX_PATH*2];  
   
         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, lpFileName, -1,  
                                                         FileNameW, sizeof(FileNameW)/sizeof(TCHAR));  
         return(CreateDirectory(FileNameW, atr));  
 }  
   
 static inline HANDLE FindFirstFile_A(LPCSTR lpFileName,  
                                                                                                         WIN32_FIND_DATA *w32fd) {  
   
         TCHAR   FileNameW[MAX_PATH*2];  
   
         MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, lpFileName, -1,  
                                                         FileNameW, sizeof(FileNameW)/sizeof(TCHAR));  
         return(FindFirstFile(FileNameW, w32fd));  
 }  
 #else  
   
 #define CreateFile_A(a, b, c, d, e, f, g)       \  
                                                                 CreateFile(a, b, c, d, e, f, g)  
 #define DeleteFile_A(a)                 DeleteFile(a)  
 #define GetFileAttributes_A(a)  GetFileAttributes(a)  
 #define CreateDirectory_A(a, b) CreateDirectory(a, b)  
 #define FindFirstFile_A(a, b)   FindFirstFile(a, b)  
   
 #endif  
   
   
 // ----  // ----
   
Line 81  void dosio_init(void) { } Line 14  void dosio_init(void) { }
 void dosio_term(void) { }  void dosio_term(void) { }
   
                                                                                         // ファイル操作                                                                                          // ファイル操作
 FILEH file_open(const char *path) {  FILEH DOSIOCALL file_open(const OEMCHAR *path) {
   
         FILEH   ret;          FILEH   ret;
   
         if ((ret = CreateFile_A(path, GENERIC_READ | GENERIC_WRITE,          if ((ret = CreateFile(path, GENERIC_READ | GENERIC_WRITE,
                                                 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL))                                                  0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL))
                                                                                                         == INVALID_HANDLE_VALUE) {                                                                                                          == INVALID_HANDLE_VALUE) {
                 if ((ret = CreateFile_A(path, GENERIC_READ,                  if ((ret = CreateFile(path, GENERIC_READ,
                                                 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL))                                                  0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL))
                                                                                                         == INVALID_HANDLE_VALUE) {                                                                                                          == INVALID_HANDLE_VALUE) {
                         return(FILEH_INVALID);                          return(FILEH_INVALID);
Line 97  FILEH file_open(const char *path) { Line 30  FILEH file_open(const char *path) {
         return(ret);          return(ret);
 }  }
   
 FILEH file_open_rb(const char *path) {  FILEH DOSIOCALL file_open_rb(const OEMCHAR *path) {
   
         FILEH   ret;          FILEH   ret;
   
         if ((ret = CreateFile_A(path, GENERIC_READ, FILE_SHARE_READ, 0,          if ((ret = CreateFile(path, GENERIC_READ, FILE_SHARE_READ, 0,
                                                                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL))                                                                  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL))
                                                                                                         == INVALID_HANDLE_VALUE) {                                                                                                          == INVALID_HANDLE_VALUE) {
                 return(FILEH_INVALID);                  return(FILEH_INVALID);
Line 109  FILEH file_open_rb(const char *path) { Line 42  FILEH file_open_rb(const char *path) {
         return(ret);          return(ret);
 }  }
   
 FILEH file_create(const char *path) {  FILEH DOSIOCALL file_create(const OEMCHAR *path) {
   
         FILEH   ret;          FILEH   ret;
   
         if ((ret = CreateFile_A(path, GENERIC_READ | GENERIC_WRITE,          if ((ret = CreateFile(path, GENERIC_READ | GENERIC_WRITE,
                                                  0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL))                                                   0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL))
                                                                                         == INVALID_HANDLE_VALUE) {                                                                                          == INVALID_HANDLE_VALUE) {
                 return(FILEH_INVALID);                  return(FILEH_INVALID);
Line 121  FILEH file_create(const char *path) { Line 54  FILEH file_create(const char *path) {
         return(ret);          return(ret);
 }  }
   
 long file_seek(FILEH handle, long pointer, int method) {  long DOSIOCALL file_seek(FILEH handle, long pointer, int method) {
   
         return(SetFilePointer(handle, pointer, 0, method));          return(SetFilePointer(handle, pointer, 0, method));
 }  }
   
 UINT file_read(FILEH handle, void *data, UINT length) {  UINT DOSIOCALL file_read(FILEH handle, void *data, UINT length) {
   
         DWORD   readsize;          DWORD   readsize;
   
Line 136  UINT file_read(FILEH handle, void *data, Line 69  UINT file_read(FILEH handle, void *data,
         return(readsize);          return(readsize);
 }  }
   
 UINT file_write(FILEH handle, const void *data, UINT length) {  UINT DOSIOCALL file_write(FILEH handle, const void *data, UINT length) {
   
         DWORD   writesize;          DWORD   writesize;
   
Line 151  UINT file_write(FILEH handle, const void Line 84  UINT file_write(FILEH handle, const void
         return(0);          return(0);
 }  }
   
 short file_close(FILEH handle) {  short DOSIOCALL file_close(FILEH handle) {
   
         CloseHandle(handle);          CloseHandle(handle);
         return(0);          return(0);
 }  }
   
 UINT file_getsize(FILEH handle) {  UINT DOSIOCALL file_getsize(FILEH handle) {
   
         return(GetFileSize(handle, NULL));          return(GetFileSize(handle, NULL));
 }  }
   
 short file_getdatetime(FILEH handle, DOSDATE *dosdate, DOSTIME *dostime) {  static BRESULT DOSIOCALL cnvdatetime(FILETIME *file, DOSDATE *dosdate, DOSTIME *dostime) {
   
         FILETIME        lastwrite;          FILETIME        localtime;
         FILETIME        localwrite;          SYSTEMTIME      systime;
         SYSTEMTIME      syswrite;  
   
         if ((GetFileTime(handle, NULL, NULL, &lastwrite) == 0) ||          if ((FileTimeToLocalFileTime(file, &localtime) == 0) ||
                 (FileTimeToLocalFileTime(&lastwrite, &localwrite) == 0) ||                  (FileTimeToSystemTime(&localtime, &systime) == 0)) {
                 (FileTimeToSystemTime(&localwrite, &syswrite) == 0)) {                  return(FAILURE);
                 return(-1);  
         }          }
         if (dosdate) {          if (dosdate) {
                 dosdate->year = (WORD)syswrite.wYear;                  dosdate->year = (UINT16)systime.wYear;
                 dosdate->month = (BYTE)syswrite.wMonth;                  dosdate->month = (UINT8)systime.wMonth;
                 dosdate->day = (BYTE)syswrite.wDay;                  dosdate->day = (UINT8)systime.wDay;
         }          }
         if (dostime) {          if (dostime) {
                 dostime->hour = (BYTE)syswrite.wHour;                  dostime->hour = (UINT8)systime.wHour;
                 dostime->minute = (BYTE)syswrite.wMinute;                  dostime->minute = (UINT8)systime.wMinute;
                 dostime->second = (BYTE)syswrite.wSecond;                  dostime->second = (UINT8)systime.wSecond;
           }
           return(SUCCESS);
   }
   
   short DOSIOCALL file_getdatetime(FILEH handle, DOSDATE *dosdate, DOSTIME *dostime) {
   
           FILETIME        lastwrite;
   
           if ((GetFileTime(handle, NULL, NULL, &lastwrite) == 0) ||
                   (cnvdatetime(&lastwrite, dosdate, dostime) != SUCCESS)) {
                   return(-1);
         }          }
         return(0);          return(0);
 }  }
   
 short file_delete(const char *path) {  short DOSIOCALL file_delete(const OEMCHAR *path) {
   
         return(DeleteFile_A(path)?0:-1);          return(DeleteFile(path)?0:-1);
 }  }
   
 short file_attr(const char *path) {  short DOSIOCALL file_attr(const OEMCHAR *path) {
   
         return((short)GetFileAttributes_A(path));          return((short)GetFileAttributes(path));
 }  }
   
 short file_dircreate(const char *path) {  short DOSIOCALL file_dircreate(const OEMCHAR *path) {
   
         return(CreateDirectory_A(path, NULL)?0:-1);          return(CreateDirectory(path, NULL)?0:-1);
 }  }
   
   
                                                                                         // カレントファイル操作                                                                                          // カレントファイル操作
 void file_setcd(const char *exepath) {  void DOSIOCALL file_setcd(const OEMCHAR *exepath) {
   
         file_cpyname(curpath, exepath, sizeof(curpath));          file_cpyname(curpath, exepath, NELEMENTS(curpath));
         curfilep = file_getname(curpath);          curfilep = file_getname(curpath);
         *curfilep = '\0';          *curfilep = '\0';
 }  }
   
 char *file_getcd(const char *path) {  OEMCHAR * DOSIOCALL file_getcd(const OEMCHAR *path) {
   
         *curfilep = '\0';          *curfilep = '\0';
         file_catname(curpath, path, sizeof(curpath));          file_catname(curpath, path, NELEMENTS(curpath));
         return(curpath);          return(curpath);
 }  }
   
 FILEH file_open_c(const char *path) {  FILEH DOSIOCALL file_open_c(const OEMCHAR *path) {
   
         *curfilep = '\0';          *curfilep = '\0';
         file_catname(curpath, path, sizeof(curpath));          file_catname(curpath, path, NELEMENTS(curpath));
         return(file_open(curpath));          return(file_open(curpath));
 }  }
   
 FILEH file_open_rb_c(const char *path) {  FILEH DOSIOCALL file_open_rb_c(const OEMCHAR *path) {
   
         *curfilep = '\0';          *curfilep = '\0';
         file_catname(curpath, path, sizeof(curpath));          file_catname(curpath, path, NELEMENTS(curpath));
         return(file_open_rb(curpath));          return(file_open_rb(curpath));
 }  }
   
 FILEH file_create_c(const char *path) {  FILEH DOSIOCALL file_create_c(const OEMCHAR *path) {
   
         *curfilep = '\0';          *curfilep = '\0';
         file_catname(curpath, path, sizeof(curpath));          file_catname(curpath, path, NELEMENTS(curpath));
         return(file_create(curpath));          return(file_create(curpath));
 }  }
   
 short file_delete_c(const char *path) {  short DOSIOCALL file_delete_c(const OEMCHAR *path) {
   
         *curfilep = '\0';          *curfilep = '\0';
         file_catname(curpath, path, sizeof(curpath));          file_catname(curpath, path, NELEMENTS(curpath));
         return(file_delete(curpath));          return(file_delete(curpath));
 }  }
   
 short file_attr_c(const char *path) {  short DOSIOCALL file_attr_c(const OEMCHAR *path) {
   
         *curfilep = '\0';          *curfilep = '\0';
         file_catname(curpath, path, sizeof(curpath));          file_catname(curpath, path, NELEMENTS(curpath));
         return(file_attr(curpath));          return(file_attr(curpath));
 }  }
   
   
 FILEFINDH file_find1st(const char *path, FILEFINDT *fft) {  static BRESULT DOSIOCALL setflist(WIN32_FIND_DATA *w32fd, FLINFO *fli) {
   
   #if !defined(_WIN32_WCE)
           if ((w32fd->dwFileAttributes & FILEATTR_DIRECTORY) &&
                   ((!file_cmpname(w32fd->cFileName, OEMTEXT("."))) ||
                   (!file_cmpname(w32fd->cFileName, OEMTEXT(".."))))) {
                   return(FAILURE);
           }
   #endif
           fli->caps = FLICAPS_SIZE | FLICAPS_ATTR | FLICAPS_DATE | FLICAPS_TIME;
           fli->size = w32fd->nFileSizeLow;
           fli->attr = w32fd->dwFileAttributes;
           cnvdatetime(&w32fd->ftLastWriteTime, &fli->date, &fli->time);
           milstr_ncpy(fli->path, w32fd->cFileName, NELEMENTS(fli->path));
           return(SUCCESS);
   }
   
   FLISTH DOSIOCALL file_list1st(const OEMCHAR *dir, FLINFO *fli) {
   
           OEMCHAR                 path[MAX_PATH];
         HANDLE                  hdl;          HANDLE                  hdl;
         WIN32_FIND_DATA w32fd;          WIN32_FIND_DATA w32fd;
   
         hdl = FindFirstFile_A(path, &w32fd);          milstr_ncpy(path, dir, NELEMENTS(path));
         if (hdl == INVALID_HANDLE_VALUE) {          file_setseparator(path, NELEMENTS(path));
                 return(FILEFINDH_INVALID);          milstr_ncat(path, OEMTEXT("*.*"), NELEMENTS(path));
         }          TRACEOUT(("file_list1st %s", path));
         if (fft) {          hdl = FindFirstFile(path, &w32fd);
 #if defined(UNICODE)          if (hdl != INVALID_HANDLE_VALUE) {
                 WideCharToMultiByte(CP_ACP, 0, w32fd.cFileName, -1,                  do {
                                                                 fft->path, sizeof(fft->path), NULL, NULL);                          if (setflist(&w32fd, fli) == SUCCESS) {
 #else                                  return(hdl);
                 milstr_ncpy(fft->path, w32fd.cFileName, sizeof(fft->path));                          }
 #endif                  } while(FindNextFile(hdl, &w32fd));
                 fft->size = w32fd.nFileSizeLow;                  FindClose(hdl);
                 fft->attr = w32fd.dwFileAttributes;  
         }          }
         return(hdl);          return(FLISTH_INVALID);
 }  }
   
 BOOL file_findnext(FILEFINDH hdl, FILEFINDT *fft) {  BRESULT DOSIOCALL file_listnext(FLISTH hdl, FLINFO *fli) {
   
         WIN32_FIND_DATA w32fd;          WIN32_FIND_DATA w32fd;
   
         if (!FindNextFile(hdl, &w32fd)) {          while(FindNextFile(hdl, &w32fd)) {
                 return(FAILURE);                  if (setflist(&w32fd, fli) == SUCCESS) {
         }                          return(SUCCESS);
         if (fft) {                  }
 #if defined(UNICODE)  
                 WideCharToMultiByte(CP_ACP, 0, w32fd.cFileName, -1,  
                                                                 fft->path, sizeof(fft->path), NULL, NULL);  
 #else  
                 milstr_ncpy(fft->path, w32fd.cFileName, sizeof(fft->path));  
 #endif  
                 fft->size = w32fd.nFileSizeLow;  
                 fft->attr = w32fd.dwFileAttributes;  
         }          }
         return(SUCCESS);          return(FAILURE);
 }  }
   
 void file_findclose(FILEFINDH hdl) {  void DOSIOCALL file_listclose(FLISTH hdl) {
   
         if (hdl) {          FindClose(hdl);
                 FindClose(hdl);  
         }  
 }  }
   
   
 char *file_getname(char *path) {  OEMCHAR * DOSIOCALL file_getname(const OEMCHAR *path) {
   
         char    *ret;  const OEMCHAR   *ret;
   
         ret = path;          ret = path;
         while(*path != '\0') {          while(*path != '\0') {
Line 321  char *file_getname(char *path) { Line 270  char *file_getname(char *path) {
                 }                  }
                 path++;                  path++;
         }          }
         return(ret);          return((OEMCHAR *)ret);
 }  }
   
 void file_cutname(char *path) {  void DOSIOCALL file_cutname(OEMCHAR *path) {
   
         char    *p;          OEMCHAR *p;
   
         p = file_getname(path);          p = file_getname(path);
         p[0] = '\0';          p[0] = '\0';
 }  }
   
 char *file_getext(char *path) {  OEMCHAR * DOSIOCALL file_getext(const OEMCHAR *path) {
   
         char    *p;  const OEMCHAR   *p;
         char    *q;  const OEMCHAR   *q;
   
         p = file_getname(path);          p = file_getname(path);
         q = NULL;          q = NULL;
Line 356  char *file_getext(char *path) { Line 305  char *file_getext(char *path) {
         if (!q) {          if (!q) {
                 q = p;                  q = p;
         }          }
         return(q);          return((OEMCHAR *)q);
 }  }
   
 void file_cutext(char *path) {  void DOSIOCALL file_cutext(OEMCHAR *path) {
   
         char    *p;          OEMCHAR *p;
         char    *q;          OEMCHAR *q;
   
         p = file_getname(path);          p = file_getname(path);
         q = NULL;          q = NULL;
   
         while(*p != '\0') {          while(*p != '\0') {
                 if (!ISKANJI(*p)) {                  if (!ISKANJI(*p)) {
                         if (*p == '.') {                          if (*p == '.') {
Line 385  void file_cutext(char *path) { Line 333  void file_cutext(char *path) {
         }          }
 }  }
   
 void file_cutseparator(char *path) {  void DOSIOCALL file_cutseparator(OEMCHAR *path) {
   
         int             pos;          int             pos;
   
         pos = strlen(path) - 1;          pos = OEMSTRLEN(path) - 1;
         if ((pos > 0) &&                                                        // 2文字以上でー          if ((pos > 0) &&                                                        // 2文字以上でー
                 (path[pos] == '\\') &&                                  // ケツが \ でー                  (path[pos] == '\\') &&                                  // ケツが \ でー
                 (!milstr_kanji2nd(path, pos)) &&                // 漢字の2バイト目ぢゃなくてー                  (!milstr_kanji2nd(path, pos)) &&                // 漢字の2バイト目ぢゃなくてー
Line 399  void file_cutseparator(char *path) { Line 347  void file_cutseparator(char *path) {
         }          }
 }  }
   
 void file_setseparator(char *path, int maxlen) {  void DOSIOCALL file_setseparator(OEMCHAR *path, int maxlen) {
   
         int             pos;          int             pos;
   
         pos = strlen(path) - 1;          pos = OEMSTRLEN(path) - 1;
         if ((pos < 0) ||          if ((pos < 0) ||
                 ((pos == 1) && (path[1] == ':')) ||                  ((pos == 1) && (path[1] == ':')) ||
                 ((path[pos] == '\\') && (!milstr_kanji2nd(path, pos))) ||                  ((path[pos] == '\\') && (!milstr_kanji2nd(path, pos))) ||
Removed from v.1.1.1.1  
changed lines
  Added in v.1.8

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