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