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

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

version 1.8, 2005/02/09 20:11:35 version 1.13, 2005/04/01 15:35:49
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
   #include        "oemtext.h"
 #include        "dosio.h"  #include        "dosio.h"
   
   
 static  OEMCHAR curpath[MAX_PATH];  static  OEMCHAR curpath[MAX_PATH];
 static  OEMCHAR *curfilep = curpath;  static  OEMCHAR *curfilep = curpath;
   
 #define ISKANJI(c)      (((((c) ^ 0x20) - 0xa1) & 0xff) < 0x3c)  
   
   
 // ----  // ----
   
 void dosio_init(void) { }  void dosio_init(void) { }
 void dosio_term(void) { }  void dosio_term(void) { }
   
   
                                                                                         // ファイル操作                                                                                          // ファイル操作
 FILEH DOSIOCALL file_open(const OEMCHAR *path) {  FILEH DOSIOCALL file_open(const OEMCHAR *path) {
   
         FILEH   ret;  #if defined(OEMCHAR_SAME_TCHAR)
           const TCHAR *tcharpath = path;
         if ((ret = CreateFile(path, GENERIC_READ | GENERIC_WRITE,  #else
                                                 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL))          TCHAR tcharpath[MAX_PATH];
                                                                                                         == INVALID_HANDLE_VALUE) {          oemtotchar(tcharpath, NELEMENTS(tcharpath), path, (UINT)-1);
                 if ((ret = CreateFile(path, GENERIC_READ,  #endif
                                                 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL))          FILEH ret;
                                                                                                         == INVALID_HANDLE_VALUE) {          ret = CreateFile(tcharpath, GENERIC_READ | GENERIC_WRITE,
                                                   0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
           if (ret == INVALID_HANDLE_VALUE) {
                   ret = CreateFile(tcharpath, GENERIC_READ,
                                                   0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
                   if (ret == INVALID_HANDLE_VALUE) {
                         return(FILEH_INVALID);                          return(FILEH_INVALID);
                 }                  }
         }          }
Line 32  FILEH DOSIOCALL file_open(const OEMCHAR  Line 37  FILEH DOSIOCALL file_open(const OEMCHAR 
   
 FILEH DOSIOCALL file_open_rb(const OEMCHAR *path) {  FILEH DOSIOCALL file_open_rb(const OEMCHAR *path) {
   
         FILEH   ret;  #if defined(OEMCHAR_SAME_TCHAR)
           const TCHAR *tcharpath = path;
         if ((ret = CreateFile(path, GENERIC_READ, FILE_SHARE_READ, 0,  #else
                                                                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL))          TCHAR tcharpath[MAX_PATH];
                                                                                                         == INVALID_HANDLE_VALUE) {          oemtotchar(tcharpath, NELEMENTS(tcharpath), path, (UINT)-1);
   #endif
           FILEH ret;
           ret = CreateFile(tcharpath, GENERIC_READ, FILE_SHARE_READ, 0,
                                                                   OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
           if (ret != INVALID_HANDLE_VALUE) {
                   return(ret);
           }
           else {
                 return(FILEH_INVALID);                  return(FILEH_INVALID);
         }          }
         return(ret);  
 }  }
   
 FILEH DOSIOCALL file_create(const OEMCHAR *path) {  FILEH DOSIOCALL file_create(const OEMCHAR *path) {
   
         FILEH   ret;  #if defined(OEMCHAR_SAME_TCHAR)
           const TCHAR *tcharpath = path;
         if ((ret = CreateFile(path, GENERIC_READ | GENERIC_WRITE,  #else
                                                  0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL))          TCHAR tcharpath[MAX_PATH];
                                                                                         == INVALID_HANDLE_VALUE) {          oemtotchar(tcharpath, NELEMENTS(tcharpath), path, (UINT)-1);
   #endif
           FILEH ret;
           ret = CreateFile(tcharpath, GENERIC_READ | GENERIC_WRITE,
                                                    0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
           if (ret != INVALID_HANDLE_VALUE) {
                   return(ret);
           }
           else {
                 return(FILEH_INVALID);                  return(FILEH_INVALID);
         }          }
         return(ret);  
 }  }
   
 long DOSIOCALL file_seek(FILEH handle, long pointer, int method) {  long DOSIOCALL file_seek(FILEH handle, long pointer, int method) {
Line 95  UINT DOSIOCALL file_getsize(FILEH handle Line 114  UINT DOSIOCALL file_getsize(FILEH handle
         return(GetFileSize(handle, NULL));          return(GetFileSize(handle, NULL));
 }  }
   
 static BRESULT DOSIOCALL cnvdatetime(FILETIME *file, DOSDATE *dosdate, DOSTIME *dostime) {  static BRESULT DOSIOCALL cnvdatetime(const FILETIME *file,
                                                                                   DOSDATE *dosdate, DOSTIME *dostime) {
   
         FILETIME        localtime;          FILETIME        localtime;
         SYSTEMTIME      systime;          SYSTEMTIME      systime;
Line 117  static BRESULT DOSIOCALL cnvdatetime(FIL Line 137  static BRESULT DOSIOCALL cnvdatetime(FIL
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 short DOSIOCALL file_getdatetime(FILEH handle, DOSDATE *dosdate, DOSTIME *dostime) {  short DOSIOCALL file_getdatetime(FILEH handle,
                                                                                   DOSDATE *dosdate, DOSTIME *dostime) {
   
         FILETIME        lastwrite;          FILETIME        lastwrite;
   
Line 130  short DOSIOCALL file_getdatetime(FILEH h Line 151  short DOSIOCALL file_getdatetime(FILEH h
   
 short DOSIOCALL file_delete(const OEMCHAR *path) {  short DOSIOCALL file_delete(const OEMCHAR *path) {
   
         return(DeleteFile(path)?0:-1);  #if defined(OEMCHAR_SAME_TCHAR)
           const TCHAR *tcharpath = path;
   #else
           TCHAR tcharpath[MAX_PATH];
           oemtotchar(tcharpath, NELEMENTS(tcharpath), path, (UINT)-1);
   #endif
           return(DeleteFile(tcharpath)?0:-1);
 }  }
   
 short DOSIOCALL file_attr(const OEMCHAR *path) {  short DOSIOCALL file_attr(const OEMCHAR *path) {
   
         return((short)GetFileAttributes(path));  #if defined(OEMCHAR_SAME_TCHAR)
   const TCHAR *tcharpath = path;
   #else
           TCHAR tcharpath[MAX_PATH];
           oemtotchar(tcharpath, NELEMENTS(tcharpath), path, (UINT)-1);
   #endif
           return((short)GetFileAttributes(tcharpath));
 }  }
   
 short DOSIOCALL file_dircreate(const OEMCHAR *path) {  short DOSIOCALL file_dircreate(const OEMCHAR *path) {
   
         return(CreateDirectory(path, NULL)?0:-1);  #if defined(OEMCHAR_SAME_TCHAR)
           const TCHAR *tcharpath = path;
   #else
           TCHAR tcharpath[MAX_PATH];
           oemtotchar(tcharpath, NELEMENTS(tcharpath), path, (UINT)-1);
   #endif
           return(CreateDirectory(tcharpath, NULL)?0:-1);
 }  }
   
   
Line 154  void DOSIOCALL file_setcd(const OEMCHAR  Line 193  void DOSIOCALL file_setcd(const OEMCHAR 
   
 OEMCHAR * DOSIOCALL file_getcd(const OEMCHAR *path) {  OEMCHAR * DOSIOCALL file_getcd(const OEMCHAR *path) {
   
         *curfilep = '\0';          file_cpyname(curfilep, path, NELEMENTS(curpath) - (curfilep - curpath));
         file_catname(curpath, path, NELEMENTS(curpath));  
         return(curpath);          return(curpath);
 }  }
   
 FILEH DOSIOCALL file_open_c(const OEMCHAR *path) {  FILEH DOSIOCALL file_open_c(const OEMCHAR *path) {
   
         *curfilep = '\0';          file_cpyname(curfilep, path, NELEMENTS(curpath) - (curfilep - curpath));
         file_catname(curpath, path, NELEMENTS(curpath));  
         return(file_open(curpath));          return(file_open(curpath));
 }  }
   
 FILEH DOSIOCALL file_open_rb_c(const OEMCHAR *path) {  FILEH DOSIOCALL file_open_rb_c(const OEMCHAR *path) {
   
         *curfilep = '\0';          file_cpyname(curfilep, path, NELEMENTS(curpath) - (curfilep - curpath));
         file_catname(curpath, path, NELEMENTS(curpath));  
         return(file_open_rb(curpath));          return(file_open_rb(curpath));
 }  }
   
 FILEH DOSIOCALL file_create_c(const OEMCHAR *path) {  FILEH DOSIOCALL file_create_c(const OEMCHAR *path) {
   
         *curfilep = '\0';          file_cpyname(curfilep, path, NELEMENTS(curpath) - (curfilep - curpath));
         file_catname(curpath, path, NELEMENTS(curpath));  
         return(file_create(curpath));          return(file_create(curpath));
 }  }
   
 short DOSIOCALL file_delete_c(const OEMCHAR *path) {  short DOSIOCALL file_delete_c(const OEMCHAR *path) {
   
         *curfilep = '\0';          file_cpyname(curfilep, path, NELEMENTS(curpath) - (curfilep - curpath));
         file_catname(curpath, path, NELEMENTS(curpath));  
         return(file_delete(curpath));          return(file_delete(curpath));
 }  }
   
 short DOSIOCALL file_attr_c(const OEMCHAR *path) {  short DOSIOCALL file_attr_c(const OEMCHAR *path) {
   
         *curfilep = '\0';          file_cpyname(curfilep, path, NELEMENTS(curpath) - (curfilep - curpath));
         file_catname(curpath, path, NELEMENTS(curpath));  
         return(file_attr(curpath));          return(file_attr(curpath));
 }  }
   
   
   // ----
   
   #if !defined(_WIN32_WCE)
   static const TCHAR str_selfdir[] = _T(".");
   static const TCHAR str_parentdir[] = _T("..");
   #endif
   static const OEMCHAR str_wildcard[] = OEMTEXT("*.*");
   
 static BRESULT DOSIOCALL setflist(WIN32_FIND_DATA *w32fd, FLINFO *fli) {  static BRESULT DOSIOCALL setflist(WIN32_FIND_DATA *w32fd, FLINFO *fli) {
   
 #if !defined(_WIN32_WCE)  #if !defined(_WIN32_WCE)
         if ((w32fd->dwFileAttributes & FILEATTR_DIRECTORY) &&          if ((w32fd->dwFileAttributes & FILEATTR_DIRECTORY) &&
                 ((!file_cmpname(w32fd->cFileName, OEMTEXT("."))) ||                  ((!lstrcmp(w32fd->cFileName, str_selfdir)) ||
                 (!file_cmpname(w32fd->cFileName, OEMTEXT(".."))))) {                  (!lstrcmp(w32fd->cFileName, str_parentdir)))) {
                 return(FAILURE);                  return(FAILURE);
         }          }
 #endif  #endif
Line 208  static BRESULT DOSIOCALL setflist(WIN32_ Line 249  static BRESULT DOSIOCALL setflist(WIN32_
         fli->size = w32fd->nFileSizeLow;          fli->size = w32fd->nFileSizeLow;
         fli->attr = w32fd->dwFileAttributes;          fli->attr = w32fd->dwFileAttributes;
         cnvdatetime(&w32fd->ftLastWriteTime, &fli->date, &fli->time);          cnvdatetime(&w32fd->ftLastWriteTime, &fli->date, &fli->time);
         milstr_ncpy(fli->path, w32fd->cFileName, NELEMENTS(fli->path));  #if defined(OEMCHAR_SAME_TCHAR)
           file_cpyname(fli->path, w32fd->cFileName, NELEMENTS(fli->path));
   #else
           tchartooem(fli->path, NELEMENTS(fli->path), w32fd->cFileName, (UINT)-1);
   #endif
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 FLISTH DOSIOCALL file_list1st(const OEMCHAR *dir, FLINFO *fli) {  FLISTH DOSIOCALL file_list1st(const OEMCHAR *dir, FLINFO *fli) {
   
         OEMCHAR                 path[MAX_PATH];          OEMCHAR path[MAX_PATH];
         HANDLE                  hdl;          file_cpyname(path, dir, NELEMENTS(path));
         WIN32_FIND_DATA w32fd;  
   
         milstr_ncpy(path, dir, NELEMENTS(path));  
         file_setseparator(path, NELEMENTS(path));          file_setseparator(path, NELEMENTS(path));
         milstr_ncat(path, OEMTEXT("*.*"), NELEMENTS(path));          file_catname(path, str_wildcard, NELEMENTS(path));
         TRACEOUT(("file_list1st %s", path));          TRACEOUT(("file_list1st %s", path));
         hdl = FindFirstFile(path, &w32fd);  #if defined(OEMCHAR_SAME_TCHAR)
   const TCHAR *tcharpath = path;
   #else
           TCHAR tcharpath[MAX_PATH];
           oemtotchar(tcharpath, NELEMENTS(tcharpath), path, (UINT)-1);
   #endif
           HANDLE hdl;
           WIN32_FIND_DATA w32fd;
           hdl = FindFirstFile(tcharpath, &w32fd);
         if (hdl != INVALID_HANDLE_VALUE) {          if (hdl != INVALID_HANDLE_VALUE) {
                 do {                  do {
                         if (setflist(&w32fd, fli) == SUCCESS) {                          if (setflist(&w32fd, fli) == SUCCESS) {
Line 255  void DOSIOCALL file_listclose(FLISTH hdl Line 305  void DOSIOCALL file_listclose(FLISTH hdl
 OEMCHAR * DOSIOCALL file_getname(const OEMCHAR *path) {  OEMCHAR * DOSIOCALL file_getname(const OEMCHAR *path) {
   
 const OEMCHAR   *ret;  const OEMCHAR   *ret;
           int                     csize;
   
         ret = path;          ret = path;
         while(*path != '\0') {          while((csize = milstr_charsize(path)) != 0) {
                 if (!ISKANJI(*path)) {                  if ((csize == 1) &&
                         if ((*path == '\\') || (*path == '/') || (*path == ':')) {                          ((*path == '\\') || (*path == '/') || (*path == ':'))) {
                                 ret = path + 1;                          ret = path + 1;
                         }  
                 }  
                 else {  
                         if (path[1]) {  
                                 path++;  
                         }  
                 }                  }
                 path++;                  path += csize;
         }          }
         return((OEMCHAR *)ret);          return((OEMCHAR *)ret);
 }  }
Line 285  OEMCHAR * DOSIOCALL file_getext(const OE Line 330  OEMCHAR * DOSIOCALL file_getext(const OE
   
 const OEMCHAR   *p;  const OEMCHAR   *p;
 const OEMCHAR   *q;  const OEMCHAR   *q;
           int                     csize;
   
         p = file_getname(path);          p = file_getname(path);
         q = NULL;          q = NULL;
           while((csize = milstr_charsize(p)) != 0) {
         while(*p != '\0') {                  if ((csize == 1) && (*p == '.')) {
                 if (!ISKANJI(*p)) {                          q = p + 1;
                         if (*p == '.') {  
                                 q = p + 1;  
                         }  
                 }                  }
                 else {                  p += csize;
                         if (p[1]) {  
                                 p++;  
                         }  
                 }  
                 p++;  
         }          }
         if (!q) {          if (q == NULL) {
                 q = p;                  q = p;
         }          }
         return((OEMCHAR *)q);          return((OEMCHAR *)q);
Line 312  void DOSIOCALL file_cutext(OEMCHAR *path Line 350  void DOSIOCALL file_cutext(OEMCHAR *path
   
         OEMCHAR *p;          OEMCHAR *p;
         OEMCHAR *q;          OEMCHAR *q;
           int             csize;
   
         p = file_getname(path);          p = file_getname(path);
         q = NULL;          q = NULL;
         while(*p != '\0') {          while((csize = milstr_charsize(p)) != 0) {
                 if (!ISKANJI(*p)) {                  if ((csize == 1) && (*p == '.')) {
                         if (*p == '.') {                          q = p;
                                 q = p;  
                         }  
                 }  
                 else {  
                         if (p[1]) {  
                                 p++;  
                         }  
                 }                  }
                 p++;                  p += csize;
         }          }
         if (q) {          if (q) {
                 *q = '\0';                  *q = '\0';
Removed from v.1.8  
changed lines
  Added in v.1.13

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