Mercurial > vba-linux

     1 // Windows/FileDir.cpp

     2 

     3 #include "StdAfx.h"

     4 

     5 #include "FileDir.h"

     6 #include "FileName.h"

     7 #include "FileFind.h"

     8 #include "Defs.h"

     9 #ifndef _UNICODE

    10 #include "../Common/StringConvert.h"

    11 #endif

    12 

    13 #ifndef _UNICODE

    14 extern bool g_IsNT;

    15 #endif

    16 

    17 namespace NWindows {

    18 namespace NFile {

    19 

    20 #if defined(WIN_LONG_PATH) && defined(_UNICODE)

    21 #define WIN_LONG_PATH2

    22 #endif

    23 

    24 // SetCurrentDirectory doesn't support \\?\ prefix

    25 

    26 #ifdef WIN_LONG_PATH

    27 bool GetLongPathBase(LPCWSTR fileName, UString &res);

    28 bool GetLongPath(LPCWSTR fileName, UString &res);

    29 #endif

    30 

    31 namespace NDirectory {

    32 

    33 #ifndef _UNICODE

    34 static inline UINT GetCurrentCodePage() { return ::AreFileApisANSI() ? CP_ACP : CP_OEMCP; }

    35 static UString GetUnicodePath(const CSysString &sysPath)

    36   { return MultiByteToUnicodeString(sysPath, GetCurrentCodePage()); }

    37 static CSysString GetSysPath(LPCWSTR sysPath)

    38   { return UnicodeStringToMultiByte(sysPath, GetCurrentCodePage()); }

    39 #endif

    40 

    41 bool MyGetWindowsDirectory(CSysString &path)

    42 {

    43   UINT needLength = ::GetWindowsDirectory(path.GetBuffer(MAX_PATH + 1), MAX_PATH + 1);

    44   path.ReleaseBuffer();

    45   return (needLength > 0 && needLength <= MAX_PATH);

    46 }

    47 

    48 bool MyGetSystemDirectory(CSysString &path)

    49 {

    50   UINT needLength = ::GetSystemDirectory(path.GetBuffer(MAX_PATH + 1), MAX_PATH + 1);

    51   path.ReleaseBuffer();

    52   return (needLength > 0 && needLength <= MAX_PATH);

    53 }

    54 

    55 #ifndef _UNICODE

    56 bool MyGetWindowsDirectory(UString &path)

    57 {

    58   if (g_IsNT)

    59   {

    60     UINT needLength = ::GetWindowsDirectoryW(path.GetBuffer(MAX_PATH + 1), MAX_PATH + 1);

    61     path.ReleaseBuffer();

    62     return (needLength > 0 && needLength <= MAX_PATH);

    63   }

    64   CSysString sysPath;

    65   if (!MyGetWindowsDirectory(sysPath))

    66     return false;

    67   path = GetUnicodePath(sysPath);

    68   return true;

    69 }

    70 

    71 bool MyGetSystemDirectory(UString &path)

    72 {

    73   if (g_IsNT)

    74   {

    75     UINT needLength = ::GetSystemDirectoryW(path.GetBuffer(MAX_PATH + 1), MAX_PATH + 1);

    76     path.ReleaseBuffer();

    77     return (needLength > 0 && needLength <= MAX_PATH);

    78   }

    79   CSysString sysPath;

    80   if (!MyGetSystemDirectory(sysPath))

    81     return false;

    82   path = GetUnicodePath(sysPath);

    83   return true;

    84 }

    85 #endif

    86 

    87 bool SetDirTime(LPCWSTR fileName, const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime)

    88 {

    89   #ifndef _UNICODE

    90   if (!g_IsNT)

    91   {

    92     ::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

    93     return false;

    94   }

    95   #endif

    96   HANDLE hDir = ::CreateFileW(fileName, GENERIC_WRITE,

    97       FILE_SHARE_READ | FILE_SHARE_WRITE,

    98       NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);

    99   #ifdef WIN_LONG_PATH

   100   if (hDir == INVALID_HANDLE_VALUE)

   101   {

   102     UString longPath;

   103     if (GetLongPath(fileName, longPath))

   104       hDir = ::CreateFileW(longPath, GENERIC_WRITE,

   105         FILE_SHARE_READ | FILE_SHARE_WRITE,

   106         NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);

   107   }

   108   #endif

   109 

   110   bool res = false;

   111   if (hDir != INVALID_HANDLE_VALUE)

   112   {

   113     res = BOOLToBool(::SetFileTime(hDir, cTime, aTime, mTime));

   114     ::CloseHandle(hDir);

   115   }

   116   return res;

   117 }

   118 

   119 bool MySetFileAttributes(LPCTSTR fileName, DWORD fileAttributes)

   120 {

   121   if (::SetFileAttributes(fileName, fileAttributes))

   122     return true;

   123   #ifdef WIN_LONG_PATH2

   124   UString longPath;

   125   if (GetLongPath(fileName, longPath))

   126     return BOOLToBool(::SetFileAttributesW(longPath, fileAttributes));

   127   #endif

   128   return false;

   129 }

   130 

   131 bool MyRemoveDirectory(LPCTSTR pathName)

   132 {

   133   if (::RemoveDirectory(pathName))

   134     return true;

   135   #ifdef WIN_LONG_PATH2

   136   UString longPath;

   137   if (GetLongPath(pathName, longPath))

   138     return BOOLToBool(::RemoveDirectoryW(longPath));

   139   #endif

   140   return false;

   141 }

   142 

   143 #ifdef WIN_LONG_PATH

   144 bool GetLongPaths(LPCWSTR s1, LPCWSTR s2, UString &d1, UString &d2)

   145 {

   146   if (!GetLongPathBase(s1, d1) || !GetLongPathBase(s2, d2))

   147     return false;

   148   if (d1.IsEmpty() && d2.IsEmpty()) return false;

   149   if (d1.IsEmpty()) d1 = s1;

   150   if (d2.IsEmpty()) d2 = s2;

   151   return true;

   152 }

   153 #endif

   154 

   155 bool MyMoveFile(LPCTSTR existFileName, LPCTSTR newFileName)

   156 {

   157   if (::MoveFile(existFileName, newFileName))

   158     return true;

   159   #ifdef WIN_LONG_PATH2

   160   UString d1, d2;

   161   if (GetLongPaths(existFileName, newFileName, d1, d2))

   162     return BOOLToBool(::MoveFileW(d1, d2));

   163   #endif

   164   return false;

   165 }

   166 

   167 #ifndef _UNICODE

   168 bool MySetFileAttributes(LPCWSTR fileName, DWORD fileAttributes)

   169 {

   170   if (!g_IsNT)

   171     return MySetFileAttributes(GetSysPath(fileName), fileAttributes);

   172   if (::SetFileAttributesW(fileName, fileAttributes))

   173     return true;

   174   #ifdef WIN_LONG_PATH

   175   UString longPath;

   176   if (GetLongPath(fileName, longPath))

   177     return BOOLToBool(::SetFileAttributesW(longPath, fileAttributes));

   178   #endif

   179   return false;

   180 }

   181 

   182 

   183 bool MyRemoveDirectory(LPCWSTR pathName)

   184 {

   185   if (!g_IsNT)

   186     return MyRemoveDirectory(GetSysPath(pathName));

   187   if (::RemoveDirectoryW(pathName))

   188     return true;

   189   #ifdef WIN_LONG_PATH

   190   UString longPath;

   191   if (GetLongPath(pathName, longPath))

   192     return BOOLToBool(::RemoveDirectoryW(longPath));

   193   #endif

   194   return false;

   195 }

   196 

   197 bool MyMoveFile(LPCWSTR existFileName, LPCWSTR newFileName)

   198 {

   199   if (!g_IsNT)

   200     return MyMoveFile(GetSysPath(existFileName), GetSysPath(newFileName));

   201   if (::MoveFileW(existFileName, newFileName))

   202     return true;

   203   #ifdef WIN_LONG_PATH

   204   UString d1, d2;

   205   if (GetLongPaths(existFileName, newFileName, d1, d2))

   206     return BOOLToBool(::MoveFileW(d1, d2));

   207   #endif

   208   return false;

   209 }

   210 #endif

   211 

   212 bool MyCreateDirectory(LPCTSTR pathName)

   213 {

   214   if (::CreateDirectory(pathName, NULL))

   215     return true;

   216   #ifdef WIN_LONG_PATH2

   217   if (::GetLastError() != ERROR_ALREADY_EXISTS)

   218   {

   219     UString longPath;

   220     if (GetLongPath(pathName, longPath))

   221       return BOOLToBool(::CreateDirectoryW(longPath, NULL));

   222   }

   223   #endif

   224   return false;

   225 }

   226 

   227 #ifndef _UNICODE

   228 bool MyCreateDirectory(LPCWSTR pathName)

   229 {

   230   if (!g_IsNT)

   231     return MyCreateDirectory(GetSysPath(pathName));

   232   if (::CreateDirectoryW(pathName, NULL))

   233     return true;

   234   #ifdef WIN_LONG_PATH

   235   if (::GetLastError() != ERROR_ALREADY_EXISTS)

   236   {

   237     UString longPath;

   238     if (GetLongPath(pathName, longPath))

   239       return BOOLToBool(::CreateDirectoryW(longPath, NULL));

   240   }

   241   #endif

   242   return false;

   243 }

   244 #endif

   245 

   246 /*

   247 bool CreateComplexDirectory(LPCTSTR pathName)

   248 {

   249   NName::CParsedPath path;

   250   path.ParsePath(pathName);

   251   CSysString fullPath = path.Prefix;

   252   DWORD errorCode = ERROR_SUCCESS;

   253   for (int i = 0; i < path.PathParts.Size(); i++)

   254   {

   255     const CSysString &string = path.PathParts[i];

   256     if (string.IsEmpty())

   257     {

   258       if (i != path.PathParts.Size() - 1)

   259         return false;

   260       return true;

   261     }

   262     fullPath += path.PathParts[i];

   263     if (!MyCreateDirectory(fullPath))

   264     {

   265       DWORD errorCode = GetLastError();

   266       if (errorCode != ERROR_ALREADY_EXISTS)

   267         return false;

   268     }

   269     fullPath += NName::kDirDelimiter;

   270   }

   271   return true;

   272 }

   273 */

   274 

   275 bool CreateComplexDirectory(LPCTSTR _aPathName)

   276 {

   277   CSysString pathName = _aPathName;

   278   int pos = pathName.ReverseFind(TEXT(CHAR_PATH_SEPARATOR));

   279   if (pos > 0 && pos == pathName.Length() - 1)

   280   {

   281     if (pathName.Length() == 3 && pathName[1] == ':')

   282       return true; // Disk folder;

   283     pathName.Delete(pos);

   284   }

   285   CSysString pathName2 = pathName;

   286   pos = pathName.Length();

   287   for (;;)

   288   {

   289     if (MyCreateDirectory(pathName))

   290       break;

   291     if (::GetLastError() == ERROR_ALREADY_EXISTS)

   292     {

   293       NFind::CFileInfo fileInfo;

   294       if (!NFind::FindFile(pathName, fileInfo)) // For network folders

   295         return true;

   296       if (!fileInfo.IsDir())

   297         return false;

   298       break;

   299     }

   300     pos = pathName.ReverseFind(TEXT(CHAR_PATH_SEPARATOR));

   301     if (pos < 0 || pos == 0)

   302       return false;

   303     if (pathName[pos - 1] == ':')

   304       return false;

   305     pathName = pathName.Left(pos);

   306   }

   307   pathName = pathName2;

   308   while (pos < pathName.Length())

   309   {

   310     pos = pathName.Find(TEXT(CHAR_PATH_SEPARATOR), pos + 1);

   311     if (pos < 0)

   312       pos = pathName.Length();

   313     if (!MyCreateDirectory(pathName.Left(pos)))

   314       return false;

   315   }

   316   return true;

   317 }

   318 

   319 #ifndef _UNICODE

   320 

   321 bool CreateComplexDirectory(LPCWSTR _aPathName)

   322 {

   323   UString pathName = _aPathName;

   324   int pos = pathName.ReverseFind(WCHAR_PATH_SEPARATOR);

   325   if (pos > 0 && pos == pathName.Length() - 1)

   326   {

   327     if (pathName.Length() == 3 && pathName[1] == L':')

   328       return true; // Disk folder;

   329     pathName.Delete(pos);

   330   }

   331   UString pathName2 = pathName;

   332   pos = pathName.Length();

   333   for (;;)

   334   {

   335     if (MyCreateDirectory(pathName))

   336       break;

   337     if (::GetLastError() == ERROR_ALREADY_EXISTS)

   338     {

   339       NFind::CFileInfoW fileInfo;

   340       if (!NFind::FindFile(pathName, fileInfo)) // For network folders

   341         return true;

   342       if (!fileInfo.IsDir())

   343         return false;

   344       break;

   345     }

   346     pos = pathName.ReverseFind(WCHAR_PATH_SEPARATOR);

   347     if (pos < 0 || pos == 0)

   348       return false;

   349     if (pathName[pos - 1] == L':')

   350       return false;

   351     pathName = pathName.Left(pos);

   352   }

   353   pathName = pathName2;

   354   while (pos < pathName.Length())

   355   {

   356     pos = pathName.Find(WCHAR_PATH_SEPARATOR, pos + 1);

   357     if (pos < 0)

   358       pos = pathName.Length();

   359     if (!MyCreateDirectory(pathName.Left(pos)))

   360       return false;

   361   }

   362   return true;

   363 }

   364 

   365 #endif

   366 

   367 bool DeleteFileAlways(LPCTSTR name)

   368 {

   369   if (!MySetFileAttributes(name, 0))

   370     return false;

   371   if (::DeleteFile(name))

   372     return true;

   373   #ifdef WIN_LONG_PATH2

   374   UString longPath;

   375   if (GetLongPath(name, longPath))

   376     return BOOLToBool(::DeleteFileW(longPath));

   377   #endif

   378   return false;

   379 }

   380 

   381 #ifndef _UNICODE

   382 bool DeleteFileAlways(LPCWSTR name)

   383 {

   384   if (!g_IsNT)

   385     return DeleteFileAlways(GetSysPath(name));

   386   if (!MySetFileAttributes(name, 0))

   387     return false;

   388   if (::DeleteFileW(name))

   389     return true;

   390   #ifdef WIN_LONG_PATH

   391   UString longPath;

   392   if (GetLongPath(name, longPath))

   393     return BOOLToBool(::DeleteFileW(longPath));

   394   #endif

   395   return false;

   396 }

   397 #endif

   398 

   399 static bool RemoveDirectorySubItems2(const CSysString pathPrefix, const NFind::CFileInfo &fileInfo)

   400 {

   401   if (fileInfo.IsDir())

   402     return RemoveDirectoryWithSubItems(pathPrefix + fileInfo.Name);

   403   return DeleteFileAlways(pathPrefix + fileInfo.Name);

   404 }

   405 

   406 bool RemoveDirectoryWithSubItems(const CSysString &path)

   407 {

   408   NFind::CFileInfo fileInfo;

   409   CSysString pathPrefix = path + NName::kDirDelimiter;

   410   {

   411     NFind::CEnumerator enumerator(pathPrefix + TCHAR(NName::kAnyStringWildcard));

   412     while (enumerator.Next(fileInfo))

   413       if (!RemoveDirectorySubItems2(pathPrefix, fileInfo))

   414         return false;

   415   }

   416   if (!MySetFileAttributes(path, 0))

   417     return false;

   418   return MyRemoveDirectory(path);

   419 }

   420 

   421 #ifndef _UNICODE

   422 static bool RemoveDirectorySubItems2(const UString pathPrefix, const NFind::CFileInfoW &fileInfo)

   423 {

   424   if (fileInfo.IsDir())

   425     return RemoveDirectoryWithSubItems(pathPrefix + fileInfo.Name);

   426   return DeleteFileAlways(pathPrefix + fileInfo.Name);

   427 }

   428 bool RemoveDirectoryWithSubItems(const UString &path)

   429 {

   430   NFind::CFileInfoW fileInfo;

   431   UString pathPrefix = path + UString(NName::kDirDelimiter);

   432   {

   433     NFind::CEnumeratorW enumerator(pathPrefix + UString(NName::kAnyStringWildcard));

   434     while (enumerator.Next(fileInfo))

   435       if (!RemoveDirectorySubItems2(pathPrefix, fileInfo))

   436         return false;

   437   }

   438   if (!MySetFileAttributes(path, 0))

   439     return false;

   440   return MyRemoveDirectory(path);

   441 }

   442 #endif

   443 

   444 #ifndef _WIN32_WCE

   445 

   446 bool MyGetShortPathName(LPCTSTR longPath, CSysString &shortPath)

   447 {

   448   DWORD needLength = ::GetShortPathName(longPath, shortPath.GetBuffer(MAX_PATH + 1), MAX_PATH + 1);

   449   shortPath.ReleaseBuffer();

   450   return (needLength > 0 && needLength < MAX_PATH);

   451 }

   452 

   453 bool MyGetFullPathName(LPCTSTR fileName, CSysString &resultPath, int &fileNamePartStartIndex)

   454 {

   455   resultPath.Empty();

   456   LPTSTR fileNamePointer = 0;

   457   LPTSTR buffer = resultPath.GetBuffer(MAX_PATH);

   458   DWORD needLength = ::GetFullPathName(fileName, MAX_PATH + 1, buffer, &fileNamePointer);

   459   resultPath.ReleaseBuffer();

   460   if (needLength == 0)

   461     return false;

   462   if (needLength >= MAX_PATH)

   463   {

   464     #ifdef WIN_LONG_PATH2

   465     needLength++;

   466     buffer = resultPath.GetBuffer(needLength + 1);

   467     DWORD needLength2 = ::GetFullPathNameW(fileName, needLength, buffer, &fileNamePointer);

   468     resultPath.ReleaseBuffer();

   469     if (needLength2 == 0 || needLength2 > needLength)

   470     #endif

   471       return false;

   472   }

   473   if (fileNamePointer == 0)

   474     fileNamePartStartIndex = lstrlen(fileName);

   475   else

   476     fileNamePartStartIndex = (int)(fileNamePointer - buffer);

   477   return true;

   478 }

   479 

   480 #ifndef _UNICODE

   481 bool MyGetFullPathName(LPCWSTR fileName, UString &resultPath, int &fileNamePartStartIndex)

   482 {

   483   resultPath.Empty();

   484   if (g_IsNT)

   485   {

   486     LPWSTR fileNamePointer = 0;

   487     LPWSTR buffer = resultPath.GetBuffer(MAX_PATH);

   488     DWORD needLength = ::GetFullPathNameW(fileName, MAX_PATH + 1, buffer, &fileNamePointer);

   489     resultPath.ReleaseBuffer();

   490     if (needLength == 0)

   491       return false;

   492     if (needLength >= MAX_PATH)

   493     {

   494       #ifdef WIN_LONG_PATH

   495       needLength++;

   496       buffer = resultPath.GetBuffer(needLength + 1);

   497       DWORD needLength2 = ::GetFullPathNameW(fileName, needLength, buffer, &fileNamePointer);

   498       resultPath.ReleaseBuffer();

   499       if (needLength2 == 0 || needLength2 > needLength)

   500       #endif

   501         return false;

   502     }

   503     if (fileNamePointer == 0)

   504       fileNamePartStartIndex = MyStringLen(fileName);

   505     else

   506       fileNamePartStartIndex = (int)(fileNamePointer - buffer);

   507   }

   508   else

   509   {

   510     CSysString sysPath;

   511     if (!MyGetFullPathName(GetSysPath(fileName), sysPath, fileNamePartStartIndex))

   512       return false;

   513     UString resultPath1 = GetUnicodePath(sysPath.Left(fileNamePartStartIndex));

   514     UString resultPath2 = GetUnicodePath(sysPath.Mid(fileNamePartStartIndex));

   515     fileNamePartStartIndex = resultPath1.Length();

   516     resultPath = resultPath1 + resultPath2;

   517   }

   518   return true;

   519 }

   520 #endif

   521 

   522 

   523 bool MyGetFullPathName(LPCTSTR fileName, CSysString &path)

   524 {

   525   int index;

   526   return MyGetFullPathName(fileName, path, index);

   527 }

   528 

   529 #ifndef _UNICODE

   530 bool MyGetFullPathName(LPCWSTR fileName, UString &path)

   531 {

   532   int index;

   533   return MyGetFullPathName(fileName, path, index);

   534 }

   535 #endif

   536 

   537 bool GetOnlyName(LPCTSTR fileName, CSysString &resultName)

   538 {

   539   int index;

   540   if (!MyGetFullPathName(fileName, resultName, index))

   541     return false;

   542   resultName = resultName.Mid(index);

   543   return true;

   544 }

   545 

   546 #ifndef _UNICODE

   547 bool GetOnlyName(LPCWSTR fileName, UString &resultName)

   548 {

   549   int index;

   550   if (!MyGetFullPathName(fileName, resultName, index))

   551     return false;

   552   resultName = resultName.Mid(index);

   553   return true;

   554 }

   555 #endif

   556 

   557 bool GetOnlyDirPrefix(LPCTSTR fileName, CSysString &resultName)

   558 {

   559   int index;

   560   if (!MyGetFullPathName(fileName, resultName, index))

   561     return false;

   562   resultName = resultName.Left(index);

   563   return true;

   564 }

   565 

   566 #ifndef _UNICODE

   567 bool GetOnlyDirPrefix(LPCWSTR fileName, UString &resultName)

   568 {

   569   int index;

   570   if (!MyGetFullPathName(fileName, resultName, index))

   571     return false;

   572   resultName = resultName.Left(index);

   573   return true;

   574 }

   575 #endif

   576 

   577 bool MyGetCurrentDirectory(CSysString &path)

   578 {

   579   DWORD needLength = ::GetCurrentDirectory(MAX_PATH + 1, path.GetBuffer(MAX_PATH + 1));

   580   path.ReleaseBuffer();

   581   return (needLength > 0 && needLength <= MAX_PATH);

   582 }

   583 

   584 #ifndef _UNICODE

   585 bool MySetCurrentDirectory(LPCWSTR path)

   586 {

   587   if (g_IsNT)

   588     return BOOLToBool(::SetCurrentDirectoryW(path));

   589   return MySetCurrentDirectory(GetSysPath(path));

   590 }

   591 bool MyGetCurrentDirectory(UString &path)

   592 {

   593   if (g_IsNT)

   594   {

   595     DWORD needLength = ::GetCurrentDirectoryW(MAX_PATH + 1, path.GetBuffer(MAX_PATH + 1));

   596     path.ReleaseBuffer();

   597     return (needLength > 0 && needLength <= MAX_PATH);

   598   }

   599   CSysString sysPath;

   600   if (!MyGetCurrentDirectory(sysPath))

   601     return false;

   602   path = GetUnicodePath(sysPath);

   603   return true;

   604 }

   605 #endif

   606 #endif

   607 

   608 bool MySearchPath(LPCTSTR path, LPCTSTR fileName, LPCTSTR extension,

   609   CSysString &resultPath, UINT32 &filePart)

   610 {

   611   LPTSTR filePartPointer;

   612   DWORD value = ::SearchPath(path, fileName, extension,

   613     MAX_PATH, resultPath.GetBuffer(MAX_PATH + 1), &filePartPointer);

   614   filePart = (UINT32)(filePartPointer - (LPCTSTR)resultPath);

   615   resultPath.ReleaseBuffer();

   616   return (value > 0 && value <= MAX_PATH);

   617 }

   618 

   619 #ifndef _UNICODE

   620 bool MySearchPath(LPCWSTR path, LPCWSTR fileName, LPCWSTR extension,

   621   UString &resultPath, UINT32 &filePart)

   622 {

   623   if (g_IsNT)

   624   {

   625     LPWSTR filePartPointer = 0;

   626     DWORD value = ::SearchPathW(path, fileName, extension,

   627         MAX_PATH, resultPath.GetBuffer(MAX_PATH + 1), &filePartPointer);

   628     filePart = (UINT32)(filePartPointer - (LPCWSTR)resultPath);

   629     resultPath.ReleaseBuffer();

   630     return (value > 0 && value <= MAX_PATH);

   631   }

   632   

   633   CSysString sysPath;

   634   if (!MySearchPath(

   635       path != 0 ? (LPCTSTR)GetSysPath(path): 0,

   636       fileName != 0 ? (LPCTSTR)GetSysPath(fileName): 0,

   637       extension != 0 ? (LPCTSTR)GetSysPath(extension): 0,

   638       sysPath, filePart))

   639     return false;

   640   UString resultPath1 = GetUnicodePath(sysPath.Left(filePart));

   641   UString resultPath2 = GetUnicodePath(sysPath.Mid(filePart));

   642   filePart = resultPath1.Length();

   643   resultPath = resultPath1 + resultPath2;

   644   return true;

   645 }

   646 #endif

   647 

   648 bool MyGetTempPath(CSysString &path)

   649 {

   650   DWORD needLength = ::GetTempPath(MAX_PATH + 1, path.GetBuffer(MAX_PATH + 1));

   651   path.ReleaseBuffer();

   652   return (needLength > 0 && needLength <= MAX_PATH);

   653 }

   654 

   655 #ifndef _UNICODE

   656 bool MyGetTempPath(UString &path)

   657 {

   658   path.Empty();

   659   if (g_IsNT)

   660   {

   661     DWORD needLength = ::GetTempPathW(MAX_PATH + 1, path.GetBuffer(MAX_PATH + 1));

   662     path.ReleaseBuffer();

   663     return (needLength > 0 && needLength <= MAX_PATH);

   664   }

   665   CSysString sysPath;

   666   if (!MyGetTempPath(sysPath))

   667     return false;

   668   path = GetUnicodePath(sysPath);

   669   return true;

   670 }

   671 #endif

   672 

   673 UINT MyGetTempFileName(LPCTSTR dirPath, LPCTSTR prefix, CSysString &path)

   674 {

   675   UINT number = ::GetTempFileName(dirPath, prefix, 0, path.GetBuffer(MAX_PATH + 1));

   676   path.ReleaseBuffer();

   677   return number;

   678 }

   679 

   680 #ifndef _UNICODE

   681 UINT MyGetTempFileName(LPCWSTR dirPath, LPCWSTR prefix, UString &path)

   682 {

   683   if (g_IsNT)

   684   {

   685     UINT number = ::GetTempFileNameW(dirPath, prefix, 0, path.GetBuffer(MAX_PATH));

   686     path.ReleaseBuffer();

   687     return number;

   688   }

   689   CSysString sysPath;

   690   UINT number = MyGetTempFileName(

   691       dirPath ? (LPCTSTR)GetSysPath(dirPath): 0,

   692       prefix ? (LPCTSTR)GetSysPath(prefix): 0,

   693       sysPath);

   694   path = GetUnicodePath(sysPath);

   695   return number;

   696 }

   697 #endif

   698 

   699 UINT CTempFile::Create(LPCTSTR dirPath, LPCTSTR prefix, CSysString &resultPath)

   700 {

   701   Remove();

   702   UINT number = MyGetTempFileName(dirPath, prefix, resultPath);

   703   if (number != 0)

   704   {

   705     _fileName = resultPath;

   706     _mustBeDeleted = true;

   707   }

   708   return number;

   709 }

   710 

   711 bool CTempFile::Create(LPCTSTR prefix, CSysString &resultPath)

   712 {

   713   CSysString tempPath;

   714   if (!MyGetTempPath(tempPath))

   715     return false;

   716   if (Create(tempPath, prefix, resultPath) != 0)

   717     return true;

   718   if (!MyGetWindowsDirectory(tempPath))

   719     return false;

   720   return (Create(tempPath, prefix, resultPath) != 0);

   721 }

   722 

   723 bool CTempFile::Remove()

   724 {

   725   if (!_mustBeDeleted)

   726     return true;

   727   _mustBeDeleted = !DeleteFileAlways(_fileName);

   728   return !_mustBeDeleted;

   729 }

   730 

   731 #ifndef _UNICODE

   732 

   733 UINT CTempFileW::Create(LPCWSTR dirPath, LPCWSTR prefix, UString &resultPath)

   734 {

   735   Remove();

   736   UINT number = MyGetTempFileName(dirPath, prefix, resultPath);

   737   if (number != 0)

   738   {

   739     _fileName = resultPath;

   740     _mustBeDeleted = true;

   741   }

   742   return number;

   743 }

   744 

   745 bool CTempFileW::Create(LPCWSTR prefix, UString &resultPath)

   746 {

   747   UString tempPath;

   748   if (!MyGetTempPath(tempPath))

   749     return false;

   750   if (Create(tempPath, prefix, resultPath) != 0)

   751     return true;

   752   if (!MyGetWindowsDirectory(tempPath))

   753     return false;

   754   return (Create(tempPath, prefix, resultPath) != 0);

   755 }

   756 

   757 bool CTempFileW::Remove()

   758 {

   759   if (!_mustBeDeleted)

   760     return true;

   761   _mustBeDeleted = !DeleteFileAlways(_fileName);

   762   return !_mustBeDeleted;

   763 }

   764 

   765 #endif

   766 

   767 bool CreateTempDirectory(LPCTSTR prefix, CSysString &dirName)

   768 {

   769   /*

   770   CSysString prefix = tempPath + prefixChars;

   771   CRandom random;

   772   random.Init();

   773   */

   774   for (;;)

   775   {

   776     CTempFile tempFile;

   777     if (!tempFile.Create(prefix, dirName))

   778       return false;

   779     if (!::DeleteFile(dirName))

   780       return false;

   781     /*

   782     UINT32 randomNumber = random.Generate();

   783     TCHAR randomNumberString[32];

   784     _stprintf(randomNumberString, _T("%04X"), randomNumber);

   785     dirName = prefix + randomNumberString;

   786     */

   787     if (NFind::DoesFileExist(dirName))

   788       continue;

   789     if (MyCreateDirectory(dirName))

   790       return true;

   791     if (::GetLastError() != ERROR_ALREADY_EXISTS)

   792       return false;

   793   }

   794 }

   795 

   796 bool CTempDirectory::Create(LPCTSTR prefix)

   797 {

   798   Remove();

   799   return (_mustBeDeleted = CreateTempDirectory(prefix, _tempDir));

   800 }

   801 

   802 #ifndef _UNICODE

   803 

   804 bool CreateTempDirectory(LPCWSTR prefix, UString &dirName)

   805 {

   806   /*

   807   CSysString prefix = tempPath + prefixChars;

   808   CRandom random;

   809   random.Init();

   810   */

   811   for (;;)

   812   {

   813     CTempFileW tempFile;

   814     if (!tempFile.Create(prefix, dirName))

   815       return false;

   816     if (!DeleteFileAlways(dirName))

   817       return false;

   818     /*

   819     UINT32 randomNumber = random.Generate();

   820     TCHAR randomNumberString[32];

   821     _stprintf(randomNumberString, _T("%04X"), randomNumber);

   822     dirName = prefix + randomNumberString;

   823     */

   824     if (NFind::DoesFileExist(dirName))

   825       continue;

   826     if (MyCreateDirectory(dirName))

   827       return true;

   828     if (::GetLastError() != ERROR_ALREADY_EXISTS)

   829       return false;

   830   }

   831 }

   832 

   833 bool CTempDirectoryW::Create(LPCWSTR prefix)

   834 {

   835   Remove();

   836   return (_mustBeDeleted = CreateTempDirectory(prefix, _tempDir));

   837 }

   838 

   839 #endif

   840 

   841 }}}
author	Robert McIntyre <rlm@mit.edu>
date	Sat, 03 Mar 2012 10:31:27 -0600
parents
children