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