lib/System/Win32/Path.inc

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