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