lib/System/Win32/Path.inc

   1 //===- llvm/System/Win32/Path.cpp - Win32 Path Implementation ---*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 // Modified by Henrik Bach to comply with at least MinGW.
   9 // Ported to Win32 by Jeff Cohen.
  10 //
  11 //===----------------------------------------------------------------------===//
  12 //
  13 // This file provides the Win32 specific implementation of the Path class.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 //===----------------------------------------------------------------------===//
  18 //=== WARNING: Implementation here must contain only generic Win32 code that
  19 //===          is guaranteed to work on *all* Win32 variants.
  20 //===----------------------------------------------------------------------===//
  21
  22 #include "Win32.h"
  23 #include <malloc.h>
  24
  25 // We need to undo a macro defined in Windows.h, otherwise we won't compile:
  26 #undef CopyFile
  27 #undef GetCurrentDirectory
  28
  29 // Windows happily accepts either forward or backward slashes, though any path
  30 // returned by a Win32 API will have backward slashes.  As LLVM code basically
  31 // assumes forward slashes are used, backward slashs are converted where they
  32 // can be introduced into a path.
  33 //
  34 // Another invariant is that a path ends with a slash if and only if the path
  35 // is a root directory.  Any other use of a trailing slash is stripped.  Unlike
  36 // in Unix, Windows has a rather complicated notion of a root path and this
  37 // invariant helps simply the code.
  38
  39 static void FlipBackSlashes(std::string& s) {
  40   for (size_t i = 0; i < s.size(); i++)
  41     if (s[i] == '\\')
  42       s[i] = '/';
  43 }
  44
  45 namespace llvm {
  46 namespace sys {
  47 const char PathSeparator = ';';
  48
  49 Path::Path(const std::string& p)
  50   : path(p) {
  51   FlipBackSlashes(path);
  52 }
  53
  54 Path::Path(const char *StrStart, unsigned StrLen)
  55   : path(StrStart, StrLen) {
  56   FlipBackSlashes(path);
  57 }
  58
  59 bool
  60 Path::isValid() const {
  61   if (path.empty())
  62     return false;
  63
  64   // If there is a colon, it must be the second character, preceded by a letter
  65   // and followed by something.
  66   size_t len = path.size();
  67   size_t pos = path.rfind(':',len);
  68   size_t rootslash = 0;
  69   if (pos != std::string::npos) {
  70     if (pos != 1 || !isalpha(path[0]) || len < 3)
  71       return false;
  72       rootslash = 2;
  73   }
  74
  75   // Look for a UNC path, and if found adjust our notion of the root slash.
  76   if (len > 3 && path[0] == '/' && path[1] == '/') {
  77     rootslash = path.find('/', 2);
  78     if (rootslash == std::string::npos)
  79       rootslash = 0;
  80   }
  81
  82   // Check for illegal characters.
  83   if (path.find_first_of("\\<>\"|\001\002\003\004\005\006\007\010\011\012"
  84                          "\013\014\015\016\017\020\021\022\023\024\025\026"
  85                          "\027\030\031\032\033\034\035\036\037")
  86       != std::string::npos)
  87     return false;
  88
  89   // Remove trailing slash, unless it's a root slash.
  90   if (len > rootslash+1 && path[len-1] == '/')
  91     path.erase(--len);
  92
  93   // Check each component for legality.
  94   for (pos = 0; pos < len; ++pos) {
  95     // A component may not end in a space.
  96     if (path[pos] == ' ') {
  97       if (path[pos+1] == '/' || path[pos+1] == '\0')
  98         return false;
  99     }
 100
 101     // A component may not end in a period.
 102     if (path[pos] == '.') {
 103       if (path[pos+1] == '/' || path[pos+1] == '\0') {
 104         // Unless it is the pseudo-directory "."...
 105         if (pos == 0 || path[pos-1] == '/' || path[pos-1] == ':')
 106           return true;
 107         // or "..".
 108         if (pos > 0 && path[pos-1] == '.') {
 109           if (pos == 1 || path[pos-2] == '/' || path[pos-2] == ':')
 110             return true;
 111         }
 112         return false;
 113       }
 114     }
 115   }
 116
 117   return true;
 118 }
 119
 120 bool
 121 Path::isAbsolute() const {
 122   switch (path.length()) {
 123     case 0:
 124       return false;
 125     case 1:
 126     case 2:
 127       return path[0] == '/';
 128     default:
 129       return path[0] == '/' || (path[1] == ':' && path[2] == '/');
 130   }
 131 }
 132
 133 static Path *TempDirectory = NULL;
 134
 135 Path
 136 Path::GetTemporaryDirectory(std::string* ErrMsg) {
 137   if (TempDirectory)
 138     return *TempDirectory;
 139
 140   char pathname[MAX_PATH];
 141   if (!GetTempPath(MAX_PATH, pathname)) {
 142     if (ErrMsg)
 143       *ErrMsg = "Can't determine temporary directory";
 144     return Path();
 145   }
 146
 147   Path result;
 148   result.set(pathname);
 149
 150   // Append a subdirectory passed on our process id so multiple LLVMs don't
 151   // step on each other's toes.
 152 #ifdef __MINGW32__
 153   // Mingw's Win32 header files are broken.
 154   sprintf(pathname, "LLVM_%u", unsigned(GetCurrentProcessId()));
 155 #else
 156   sprintf(pathname, "LLVM_%u", GetCurrentProcessId());
 157 #endif
 158   result.appendComponent(pathname);
 159
 160   // If there's a directory left over from a previous LLVM execution that
 161   // happened to have the same process id, get rid of it.
 162   result.eraseFromDisk(true);
 163
 164   // And finally (re-)create the empty directory.
 165   result.createDirectoryOnDisk(false);
 166   TempDirectory = new Path(result);
 167   return *TempDirectory;
 168 }
 169
 170 // FIXME: the following set of functions don't map to Windows very well.
 171 Path
 172 Path::GetRootDirectory() {
 173   Path result;
 174   result.set("C:/");
 175   return result;
 176 }
 177
 178 void
 179 Path::GetSystemLibraryPaths(std::vector<sys::Path>& Paths) {
 180   Paths.push_back(sys::Path("C:/WINDOWS/SYSTEM32"));
 181   Paths.push_back(sys::Path("C:/WINDOWS"));
 182 }
 183
 184 void
 185 Path::GetBitcodeLibraryPaths(std::vector<sys::Path>& Paths) {
 186   char * env_var = getenv("LLVM_LIB_SEARCH_PATH");
 187   if (env_var != 0) {
 188     getPathList(env_var,Paths);
 189   }
 190 #ifdef LLVM_LIBDIR
 191   {
 192     Path tmpPath;
 193     if (tmpPath.set(LLVM_LIBDIR))
 194       if (tmpPath.canRead())
 195         Paths.push_back(tmpPath);
 196   }
 197 #endif
 198   GetSystemLibraryPaths(Paths);
 199 }
 200
 201 Path
 202 Path::GetLLVMDefaultConfigDir() {
 203   // TODO: this isn't going to fly on Windows
 204   return Path("/etc/llvm");
 205 }
 206
 207 Path
 208 Path::GetUserHomeDirectory() {
 209   // TODO: Typical Windows setup doesn't define HOME.
 210   const char* home = getenv("HOME");
 211   if (home) {
 212     Path result;
 213     if (result.set(home))
 214       return result;
 215   }
 216   return GetRootDirectory();
 217 }
 218
 219 Path
 220 Path::GetCurrentDirectory() {
 221   char pathname[MAX_PATH];
 222   ::GetCurrentDirectoryA(MAX_PATH,pathname);
 223   return Path(pathname);
 224 }
 225
 226 /// GetMainExecutable - Return the path to the main executable, given the
 227 /// value of argv[0] from program startup.
 228 Path Path::GetMainExecutable(const char *argv0, void *MainAddr) {
 229   return Path();
 230 }
 231
 232
 233 // FIXME: the above set of functions don't map to Windows very well.
 234
 235
 236 bool
 237 Path::isRootDirectory() const {
 238   size_t len = path.size();
 239   return len > 0 && path[len-1] == '/';
 240 }
 241
 242 std::string Path::getDirname() const {
 243   return getDirnameCharSep(path, '/');
 244 }
 245
 246 std::string
 247 Path::getBasename() const {
 248   // Find the last slash
 249   size_t slash = path.rfind('/');
 250   if (slash == std::string::npos)
 251     slash = 0;
 252   else
 253     slash++;
 254
 255   size_t dot = path.rfind('.');
 256   if (dot == std::string::npos || dot < slash)
 257     return path.substr(slash);
 258   else
 259     return path.substr(slash, dot - slash);
 260 }
 261
 262 std::string
 263 Path::getSuffix() const {
 264   // Find the last slash
 265   size_t slash = path.rfind('/');
 266   if (slash == std::string::npos)
 267     slash = 0;
 268   else
 269     slash++;
 270
 271   size_t dot = path.rfind('.');
 272   if (dot == std::string::npos || dot < slash)
 273     return std::string();
 274   else
 275     return path.substr(dot + 1);
 276 }
 277
 278 bool
 279 Path::exists() const {
 280   DWORD attr = GetFileAttributes(path.c_str());
 281   return attr != INVALID_FILE_ATTRIBUTES;
 282 }
 283
 284 bool
 285 Path::isDirectory() const {
 286   DWORD attr = GetFileAttributes(path.c_str());
 287   return (attr != INVALID_FILE_ATTRIBUTES) &&
 288          (attr & FILE_ATTRIBUTE_DIRECTORY);
 289 }
 290
 291 bool
 292 Path::canRead() const {
 293   // FIXME: take security attributes into account.
 294   DWORD attr = GetFileAttributes(path.c_str());
 295   return attr != INVALID_FILE_ATTRIBUTES;
 296 }
 297
 298 bool
 299 Path::canWrite() const {
 300   // FIXME: take security attributes into account.
 301   DWORD attr = GetFileAttributes(path.c_str());
 302   return (attr != INVALID_FILE_ATTRIBUTES) && !(attr & FILE_ATTRIBUTE_READONLY);
 303 }
 304
 305 bool
 306 Path::canExecute() const {
 307   // FIXME: take security attributes into account.
 308   DWORD attr = GetFileAttributes(path.c_str());
 309   return attr != INVALID_FILE_ATTRIBUTES;
 310 }
 311
 312 std::string
 313 Path::getLast() const {
 314   // Find the last slash
 315   size_t pos = path.rfind('/');
 316
 317   // Handle the corner cases
 318   if (pos == std::string::npos)
 319     return path;
 320
 321   // If the last character is a slash, we have a root directory
 322   if (pos == path.length()-1)
 323     return path;
 324
 325   // Return everything after the last slash
 326   return path.substr(pos+1);
 327 }
 328
 329 const FileStatus *
 330 PathWithStatus::getFileStatus(bool update, std::string *ErrStr) const {
 331   if (!fsIsValid || update) {
 332     WIN32_FILE_ATTRIBUTE_DATA fi;
 333     if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi)) {
 334       MakeErrMsg(ErrStr, "getStatusInfo():" + std::string(path) +
 335                       ": Can't get status: ");
 336       return 0;
 337     }
 338
 339     status.fileSize = fi.nFileSizeHigh;
 340     status.fileSize <<= sizeof(fi.nFileSizeHigh)*8;
 341     status.fileSize += fi.nFileSizeLow;
 342
 343     status.mode = fi.dwFileAttributes & FILE_ATTRIBUTE_READONLY ? 0555 : 0777;
 344     status.user = 9999;    // Not applicable to Windows, so...
 345     status.group = 9999;   // Not applicable to Windows, so...
 346
 347     // FIXME: this is only unique if the file is accessed by the same file path.
 348     // How do we do this for C:\dir\file and ..\dir\file ? Unix has inode
 349     // numbers, but the concept doesn't exist in Windows.
 350     status.uniqueID = 0;
 351     for (unsigned i = 0; i < path.length(); ++i)
 352       status.uniqueID += path[i];
 353
 354     __int64 ft = *reinterpret_cast<__int64*>(&fi.ftLastWriteTime);
 355     status.modTime.fromWin32Time(ft);
 356
 357     status.isDir = fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
 358     fsIsValid = true;
 359   }
 360   return &status;
 361 }
 362
 363 bool Path::makeReadableOnDisk(std::string* ErrMsg) {
 364   // All files are readable on Windows (ignoring security attributes).
 365   return false;
 366 }
 367
 368 bool Path::makeWriteableOnDisk(std::string* ErrMsg) {
 369   DWORD attr = GetFileAttributes(path.c_str());
 370
 371   // If it doesn't exist, we're done.
 372   if (attr == INVALID_FILE_ATTRIBUTES)
 373     return false;
 374
 375   if (attr & FILE_ATTRIBUTE_READONLY) {
 376     if (!SetFileAttributes(path.c_str(), attr & ~FILE_ATTRIBUTE_READONLY)) {
 377       MakeErrMsg(ErrMsg, std::string(path) + ": Can't make file writable: ");
 378       return true;
 379     }
 380   }
 381   return false;
 382 }
 383
 384 bool Path::makeExecutableOnDisk(std::string* ErrMsg) {
 385   // All files are executable on Windows (ignoring security attributes).
 386   return false;
 387 }
 388
 389 bool
 390 Path::getDirectoryContents(std::set<Path>& result, std::string* ErrMsg) const {
 391   WIN32_FILE_ATTRIBUTE_DATA fi;
 392   if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi)) {
 393     MakeErrMsg(ErrMsg, path + ": can't get status of file");
 394     return true;
 395   }
 396
 397   if (!(fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
 398     if (ErrMsg)
 399       *ErrMsg = path + ": not a directory";
 400     return true;
 401   }
 402
 403   result.clear();
 404   WIN32_FIND_DATA fd;
 405   std::string searchpath = path;
 406   if (path.size() == 0 || searchpath[path.size()-1] == '/')
 407     searchpath += "*";
 408   else
 409     searchpath += "/*";
 410
 411   HANDLE h = FindFirstFile(searchpath.c_str(), &fd);
 412   if (h == INVALID_HANDLE_VALUE) {
 413     if (GetLastError() == ERROR_FILE_NOT_FOUND)
 414       return true; // not really an error, now is it?
 415     MakeErrMsg(ErrMsg, path + ": Can't read directory: ");
 416     return true;
 417   }
 418
 419   do {
 420     if (fd.cFileName[0] == '.')
 421       continue;
 422     Path aPath(path);
 423     aPath.appendComponent(&fd.cFileName[0]);
 424     result.insert(aPath);
 425   } while (FindNextFile(h, &fd));
 426
 427   DWORD err = GetLastError();
 428   FindClose(h);
 429   if (err != ERROR_NO_MORE_FILES) {
 430     SetLastError(err);
 431     MakeErrMsg(ErrMsg, path + ": Can't read directory: ");
 432     return true;
 433   }
 434   return false;
 435 }
 436
 437 bool
 438 Path::set(const std::string& a_path) {
 439   if (a_path.empty())
 440     return false;
 441   std::string save(path);
 442   path = a_path;
 443   FlipBackSlashes(path);
 444   if (!isValid()) {
 445     path = save;
 446     return false;
 447   }
 448   return true;
 449 }
 450
 451 bool
 452 Path::appendComponent(const std::string& name) {
 453   if (name.empty())
 454     return false;
 455   std::string save(path);
 456   if (!path.empty()) {
 457     size_t last = path.size() - 1;
 458     if (path[last] != '/')
 459       path += '/';
 460   }
 461   path += name;
 462   if (!isValid()) {
 463     path = save;
 464     return false;
 465   }
 466   return true;
 467 }
 468
 469 bool
 470 Path::eraseComponent() {
 471   size_t slashpos = path.rfind('/',path.size());
 472   if (slashpos == path.size() - 1 || slashpos == std::string::npos)
 473     return false;
 474   std::string save(path);
 475   path.erase(slashpos);
 476   if (!isValid()) {
 477     path = save;
 478     return false;
 479   }
 480   return true;
 481 }
 482
 483 bool
 484 Path::appendSuffix(const std::string& suffix) {
 485   std::string save(path);
 486   path.append(".");
 487   path.append(suffix);
 488   if (!isValid()) {
 489     path = save;
 490     return false;
 491   }
 492   return true;
 493 }
 494
 495 bool
 496 Path::eraseSuffix() {
 497   size_t dotpos = path.rfind('.',path.size());
 498   size_t slashpos = path.rfind('/',path.size());
 499   if (dotpos != std::string::npos) {
 500     if (slashpos == std::string::npos || dotpos > slashpos+1) {
 501       std::string save(path);
 502       path.erase(dotpos, path.size()-dotpos);
 503       if (!isValid()) {
 504         path = save;
 505         return false;
 506       }
 507       return true;
 508     }
 509   }
 510   return false;
 511 }
 512
 513 inline bool PathMsg(std::string* ErrMsg, const char* pathname, const char*msg) {
 514   if (ErrMsg)
 515     *ErrMsg = std::string(pathname) + ": " + std::string(msg);
 516   return true;
 517 }
 518
 519 bool
 520 Path::createDirectoryOnDisk(bool create_parents, std::string* ErrMsg) {
 521   // Get a writeable copy of the path name
 522   size_t len = path.length();
 523   char *pathname = reinterpret_cast<char *>(_alloca(len+2));
 524   path.copy(pathname, len);
 525   pathname[len] = 0;
 526
 527   // Make sure it ends with a slash.
 528   if (len == 0 || pathname[len - 1] != '/') {
 529     pathname[len] = '/';
 530     pathname[++len] = 0;
 531   }
 532
 533   // Determine starting point for initial / search.
 534   char *next = pathname;
 535   if (pathname[0] == '/' && pathname[1] == '/') {
 536     // Skip host name.
 537     next = strchr(pathname+2, '/');
 538     if (next == NULL)
 539       return PathMsg(ErrMsg, pathname, "badly formed remote directory");
 540
 541     // Skip share name.
 542     next = strchr(next+1, '/');
 543     if (next == NULL)
 544       return PathMsg(ErrMsg, pathname,"badly formed remote directory");
 545
 546     next++;
 547     if (*next == 0)
 548       return PathMsg(ErrMsg, pathname, "badly formed remote directory");
 549
 550   } else {
 551     if (pathname[1] == ':')
 552       next += 2;    // skip drive letter
 553     if (*next == '/')
 554       next++;       // skip root directory
 555   }
 556
 557   // If we're supposed to create intermediate directories
 558   if (create_parents) {
 559     // Loop through the directory components until we're done
 560     while (*next) {
 561       next = strchr(next, '/');
 562       *next = 0;
 563       if (!CreateDirectory(pathname, NULL))
 564           return MakeErrMsg(ErrMsg,
 565             std::string(pathname) + ": Can't create directory: ");
 566       *next++ = '/';
 567     }
 568   } else {
 569     // Drop trailing slash.
 570     pathname[len-1] = 0;
 571     if (!CreateDirectory(pathname, NULL)) {
 572       return MakeErrMsg(ErrMsg, std::string(pathname) + ": Can't create directory: ");
 573     }
 574   }
 575   return false;
 576 }
 577
 578 bool
 579 Path::createFileOnDisk(std::string* ErrMsg) {
 580   // Create the file
 581   HANDLE h = CreateFile(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_NEW,
 582                         FILE_ATTRIBUTE_NORMAL, NULL);
 583   if (h == INVALID_HANDLE_VALUE)
 584     return MakeErrMsg(ErrMsg, path + ": Can't create file: ");
 585
 586   CloseHandle(h);
 587   return false;
 588 }
 589
 590 bool
 591 Path::eraseFromDisk(bool remove_contents, std::string *ErrStr) const {
 592   WIN32_FILE_ATTRIBUTE_DATA fi;
 593   if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi))
 594     return true;
 595
 596   if (fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
 597     // If it doesn't exist, we're done.
 598     if (!exists())
 599       return false;
 600
 601     char *pathname = reinterpret_cast<char *>(_alloca(path.length()+3));
 602     int lastchar = path.length() - 1 ;
 603     path.copy(pathname, lastchar+1);
 604
 605     // Make path end with '/*'.
 606     if (pathname[lastchar] != '/')
 607       pathname[++lastchar] = '/';
 608     pathname[lastchar+1] = '*';
 609     pathname[lastchar+2] = 0;
 610
 611     if (remove_contents) {
 612       WIN32_FIND_DATA fd;
 613       HANDLE h = FindFirstFile(pathname, &fd);
 614
 615       // It's a bad idea to alter the contents of a directory while enumerating
 616       // its contents. So build a list of its contents first, then destroy them.
 617
 618       if (h != INVALID_HANDLE_VALUE) {
 619         std::vector<Path> list;
 620
 621         do {
 622           if (strcmp(fd.cFileName, ".") == 0)
 623             continue;
 624           if (strcmp(fd.cFileName, "..") == 0)
 625             continue;
 626
 627           Path aPath(path);
 628           aPath.appendComponent(&fd.cFileName[0]);
 629           list.push_back(aPath);
 630         } while (FindNextFile(h, &fd));
 631
 632         DWORD err = GetLastError();
 633         FindClose(h);
 634         if (err != ERROR_NO_MORE_FILES) {
 635           SetLastError(err);
 636           return MakeErrMsg(ErrStr, path + ": Can't read directory: ");
 637         }
 638
 639         for (std::vector<Path>::iterator I = list.begin(); I != list.end();
 640              ++I) {
 641           Path &aPath = *I;
 642           aPath.eraseFromDisk(true);
 643         }
 644       } else {
 645         if (GetLastError() != ERROR_FILE_NOT_FOUND)
 646           return MakeErrMsg(ErrStr, path + ": Can't read directory: ");
 647       }
 648     }
 649
 650     pathname[lastchar] = 0;
 651     if (!RemoveDirectory(pathname))
 652       return MakeErrMsg(ErrStr,
 653         std::string(pathname) + ": Can't destroy directory: ");
 654     return false;
 655   } else {
 656     // Read-only files cannot be deleted on Windows.  Must remove the read-only
 657     // attribute first.
 658     if (fi.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
 659       if (!SetFileAttributes(path.c_str(),
 660                              fi.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY))
 661         return MakeErrMsg(ErrStr, path + ": Can't destroy file: ");
 662     }
 663
 664     if (!DeleteFile(path.c_str()))
 665       return MakeErrMsg(ErrStr, path + ": Can't destroy file: ");
 666     return false;
 667   }
 668 }
 669
 670 bool Path::getMagicNumber(std::string& Magic, unsigned len) const {
 671   assert(len < 1024 && "Request for magic string too long");
 672   char* buf = (char*) alloca(1 + len);
 673
 674   HANDLE h = CreateFile(path.c_str(),
 675                         GENERIC_READ,
 676                         FILE_SHARE_READ,
 677                         NULL,
 678                         OPEN_EXISTING,
 679                         FILE_ATTRIBUTE_NORMAL,
 680                         NULL);
 681   if (h == INVALID_HANDLE_VALUE)
 682     return false;
 683
 684   DWORD nRead = 0;
 685   BOOL ret = ReadFile(h, buf, len, &nRead, NULL);
 686   CloseHandle(h);
 687
 688   if (!ret || nRead != len)
 689     return false;
 690
 691   buf[len] = '\0';
 692   Magic = buf;
 693   return true;
 694 }
 695
 696 bool
 697 Path::renamePathOnDisk(const Path& newName, std::string* ErrMsg) {
 698   if (!MoveFileEx(path.c_str(), newName.c_str(), MOVEFILE_REPLACE_EXISTING))
 699     return MakeErrMsg(ErrMsg, "Can't move '" + path + "' to '" + newName.path
 700         + "': ");
 701   return false;
 702 }
 703
 704 bool
 705 Path::setStatusInfoOnDisk(const FileStatus &si, std::string *ErrMsg) const {
 706   // FIXME: should work on directories also.
 707   if (!si.isFile) {
 708     return true;
 709   }
 710
 711   HANDLE h = CreateFile(path.c_str(),
 712                         FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
 713                         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 714                         NULL,
 715                         OPEN_EXISTING,
 716                         FILE_ATTRIBUTE_NORMAL,
 717                         NULL);
 718   if (h == INVALID_HANDLE_VALUE)
 719     return true;
 720
 721   BY_HANDLE_FILE_INFORMATION bhfi;
 722   if (!GetFileInformationByHandle(h, &bhfi)) {
 723     DWORD err = GetLastError();
 724     CloseHandle(h);
 725     SetLastError(err);
 726     return MakeErrMsg(ErrMsg, path + ": GetFileInformationByHandle: ");
 727   }
 728
 729   FILETIME ft;
 730   (uint64_t&)ft = si.modTime.toWin32Time();
 731   BOOL ret = SetFileTime(h, NULL, &ft, &ft);
 732   DWORD err = GetLastError();
 733   CloseHandle(h);
 734   if (!ret) {
 735     SetLastError(err);
 736     return MakeErrMsg(ErrMsg, path + ": SetFileTime: ");
 737   }
 738
 739   // Best we can do with Unix permission bits is to interpret the owner
 740   // writable bit.
 741   if (si.mode & 0200) {
 742     if (bhfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
 743       if (!SetFileAttributes(path.c_str(),
 744               bhfi.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY))
 745         return MakeErrMsg(ErrMsg, path + ": SetFileAttributes: ");
 746     }
 747   } else {
 748     if (!(bhfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) {
 749       if (!SetFileAttributes(path.c_str(),
 750               bhfi.dwFileAttributes | FILE_ATTRIBUTE_READONLY))
 751         return MakeErrMsg(ErrMsg, path + ": SetFileAttributes: ");
 752     }
 753   }
 754
 755   return false;
 756 }
 757
 758 bool
 759 CopyFile(const sys::Path &Dest, const sys::Path &Src, std::string* ErrMsg) {
 760   // Can't use CopyFile macro defined in Windows.h because it would mess up the
 761   // above line.  We use the expansion it would have in a non-UNICODE build.
 762   if (!::CopyFileA(Src.c_str(), Dest.c_str(), false))
 763     return MakeErrMsg(ErrMsg, "Can't copy '" + Src.toString() +
 764                "' to '" + Dest.toString() + "': ");
 765   return false;
 766 }
 767
 768 bool
 769 Path::makeUnique(bool reuse_current, std::string* ErrMsg) {
 770   if (reuse_current && !exists())
 771     return false; // File doesn't exist already, just use it!
 772
 773   // Reserve space for -XXXXXX at the end.
 774   char *FNBuffer = (char*) alloca(path.size()+8);
 775   unsigned offset = path.size();
 776   path.copy(FNBuffer, offset);
 777
 778   // Find a numeric suffix that isn't used by an existing file.  Assume there
 779   // won't be more than 1 million files with the same prefix.  Probably a safe
 780   // bet.
 781   static unsigned FCounter = 0;
 782   do {
 783     sprintf(FNBuffer+offset, "-%06u", FCounter);
 784     if (++FCounter > 999999)
 785       FCounter = 0;
 786     path = FNBuffer;
 787   } while (exists());
 788   return false;
 789 }
 790
 791 bool
 792 Path::createTemporaryFileOnDisk(bool reuse_current, std::string* ErrMsg) {
 793   // Make this into a unique file name
 794   makeUnique(reuse_current, ErrMsg);
 795
 796   // Now go and create it
 797   HANDLE h = CreateFile(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_NEW,
 798                         FILE_ATTRIBUTE_NORMAL, NULL);
 799   if (h == INVALID_HANDLE_VALUE)
 800     return MakeErrMsg(ErrMsg, path + ": can't create file");
 801
 802   CloseHandle(h);
 803   return false;
 804 }
 805
 806 /// MapInFilePages - Not yet implemented on win32.
 807 const char *Path::MapInFilePages(int FD, uint64_t FileSize) {
 808   return 0;
 809 }
 810
 811 /// MapInFilePages - Not yet implemented on win32.
 812 void Path::UnMapFilePages(const char *Base, uint64_t FileSize) {
 813   assert(0 && "NOT IMPLEMENTED");
 814 }
 815
 816 }
 817 }