-//===- llvm/System/Linux/Path.cpp - Linux Path Implementation ---*- C++ -*-===//
+//===- llvm/System/Win32/Path.cpp - Win32 Path Implementation ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
-// This file was developed by Reid Spencer and is distributed under the
-// University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-// Modified by Henrik Bach to comply with at least MinGW.
-// Ported to Win32 by Jeff Cohen.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#include "Win32.h"
#include <malloc.h>
+#include <cstdio>
// We need to undo a macro defined in Windows.h, otherwise we won't compile:
#undef CopyFile
+#undef GetCurrentDirectory
+
+// Windows happily accepts either forward or backward slashes, though any path
+// returned by a Win32 API will have backward slashes. As LLVM code basically
+// assumes forward slashes are used, backward slashs are converted where they
+// can be introduced into a path.
+//
+// Another invariant is that a path ends with a slash if and only if the path
+// is a root directory. Any other use of a trailing slash is stripped. Unlike
+// in Unix, Windows has a rather complicated notion of a root path and this
+// invariant helps simply the code.
static void FlipBackSlashes(std::string& s) {
for (size_t i = 0; i < s.size(); i++)
namespace llvm {
namespace sys {
+const char PathSeparator = ';';
+
+StringRef Path::GetEXESuffix() {
+ return "exe";
+}
+
+Path::Path(llvm::StringRef p)
+ : path(p) {
+ FlipBackSlashes(path);
+}
+
+Path::Path(const char *StrStart, unsigned StrLen)
+ : path(StrStart, StrLen) {
+ FlipBackSlashes(path);
+}
+
+Path&
+Path::operator=(StringRef that) {
+ path.assign(that.data(), that.size());
+ FlipBackSlashes(path);
+ return *this;
+}
+
+// push_back 0 on create, and pop_back on delete.
+struct ScopedNullTerminator {
+ std::string &str;
+ ScopedNullTerminator(std::string &s) : str(s) { str.push_back(0); }
+ ~ScopedNullTerminator() {
+ // str.pop_back(); But wait, C++03 doesn't have this...
+ assert(!str.empty() && str[str.size() - 1] == 0
+ && "Null char not present!");
+ str.resize(str.size() - 1);
+ }
+};
+
bool
Path::isValid() const {
if (path.empty())
// If there is a colon, it must be the second character, preceded by a letter
// and followed by something.
size_t len = path.size();
+ // This code assumes that path is null terminated, so make sure it is.
+ ScopedNullTerminator snt(path);
size_t pos = path.rfind(':',len);
+ size_t rootslash = 0;
if (pos != std::string::npos) {
if (pos != 1 || !isalpha(path[0]) || len < 3)
return false;
+ rootslash = 2;
+ }
+
+ // Look for a UNC path, and if found adjust our notion of the root slash.
+ if (len > 3 && path[0] == '/' && path[1] == '/') {
+ rootslash = path.find('/', 2);
+ if (rootslash == std::string::npos)
+ rootslash = 0;
}
// Check for illegal characters.
!= std::string::npos)
return false;
+ // Remove trailing slash, unless it's a root slash.
+ if (len > rootslash+1 && path[len-1] == '/')
+ path.erase(--len);
+
// Check each component for legality.
for (pos = 0; pos < len; ++pos) {
// A component may not end in a space.
return true;
}
-static Path *TempDirectory = NULL;
+void Path::makeAbsolute() {
+ TCHAR FullPath[MAX_PATH + 1] = {0};
+ LPTSTR FilePart = NULL;
+
+ DWORD RetLength = ::GetFullPathNameA(path.c_str(),
+ sizeof(FullPath)/sizeof(FullPath[0]),
+ FullPath, &FilePart);
+
+ if (0 == RetLength) {
+ // FIXME: Report the error GetLastError()
+ assert(0 && "Unable to make absolute path!");
+ } else if (RetLength > MAX_PATH) {
+ // FIXME: Report too small buffer (needed RetLength bytes).
+ assert(0 && "Unable to make absolute path!");
+ } else {
+ path = FullPath;
+ }
+}
+
+bool
+Path::isAbsolute(const char *NameStart, unsigned NameLen) {
+ assert(NameStart);
+ // FIXME: This does not handle correctly an absolute path starting from
+ // a drive letter or in UNC format.
+ switch (NameLen) {
+ case 0:
+ return false;
+ case 1:
+ case 2:
+ return NameStart[0] == '/';
+ default:
+ return
+ (NameStart[0] == '/' || (NameStart[1] == ':' && NameStart[2] == '/')) ||
+ (NameStart[0] == '\\' || (NameStart[1] == ':' && NameStart[2] == '\\'));
+ }
+}
+
+bool
+Path::isAbsolute() const {
+ // FIXME: This does not handle correctly an absolute path starting from
+ // a drive letter or in UNC format.
+ switch (path.length()) {
+ case 0:
+ return false;
+ case 1:
+ case 2:
+ return path[0] == '/';
+ default:
+ return path[0] == '/' || (path[1] == ':' && path[2] == '/');
+ }
+}
+
+static Path *TempDirectory;
Path
-Path::GetTemporaryDirectory() {
+Path::GetTemporaryDirectory(std::string* ErrMsg) {
if (TempDirectory)
return *TempDirectory;
char pathname[MAX_PATH];
- if (!GetTempPath(MAX_PATH, pathname))
- throw std::string("Can't determine temporary directory");
+ if (!GetTempPath(MAX_PATH, pathname)) {
+ if (ErrMsg)
+ *ErrMsg = "Can't determine temporary directory";
+ return Path();
+ }
Path result;
- result.setDirectory(pathname);
+ result.set(pathname);
// Append a subdirectory passed on our process id so multiple LLVMs don't
// step on each other's toes.
+#ifdef __MINGW32__
+ // Mingw's Win32 header files are broken.
+ sprintf(pathname, "LLVM_%u", unsigned(GetCurrentProcessId()));
+#else
sprintf(pathname, "LLVM_%u", GetCurrentProcessId());
- result.appendDirectory(pathname);
+#endif
+ result.appendComponent(pathname);
// If there's a directory left over from a previous LLVM execution that
// happened to have the same process id, get rid of it.
- result.destroyDirectory(true);
+ result.eraseFromDisk(true);
// And finally (re-)create the empty directory.
- result.createDirectory(false);
+ result.createDirectoryOnDisk(false);
TempDirectory = new Path(result);
return *TempDirectory;
}
-Path::Path(const std::string& unverified_path)
- : path(unverified_path)
-{
- FlipBackSlashes(path);
- if (unverified_path.empty())
- return;
- if (this->isValid())
- return;
- // oops, not valid.
- path.clear();
- throw std::string(unverified_path + ": path is not valid");
-}
-
// FIXME: the following set of functions don't map to Windows very well.
Path
Path::GetRootDirectory() {
- Path result;
- result.setDirectory("/");
- return result;
-}
-
-static void getPathList(const char*path, std::vector<sys::Path>& Paths) {
- const char* at = path;
- const char* delim = strchr(at, ';');
- Path tmpPath;
- while( delim != 0 ) {
- std::string tmp(at, size_t(delim-at));
- if (tmpPath.setDirectory(tmp))
- if (tmpPath.canRead())
- Paths.push_back(tmpPath);
- at = delim + 1;
- delim = strchr(at, ';');
- }
- if (*at != 0)
- if (tmpPath.setDirectory(std::string(at)))
- if (tmpPath.canRead())
- Paths.push_back(tmpPath);
-
+ // This is the only notion that that Windows has of a root directory. Nothing
+ // is here except for drives.
+ return Path("file:///");
}
-void
+void
Path::GetSystemLibraryPaths(std::vector<sys::Path>& Paths) {
- Paths.push_back(sys::Path("C:\\WINDOWS\\SYSTEM32\\"));
- Paths.push_back(sys::Path("C:\\WINDOWS\\"));
+ char buff[MAX_PATH];
+ // Generic form of C:\Windows\System32
+ HRESULT res = SHGetFolderPathA(NULL,
+ CSIDL_FLAG_CREATE | CSIDL_SYSTEM,
+ NULL,
+ SHGFP_TYPE_CURRENT,
+ buff);
+ if (res != S_OK) {
+ assert(0 && "Failed to get system directory");
+ return;
+ }
+ Paths.push_back(sys::Path(buff));
+
+ // Reset buff.
+ buff[0] = 0;
+ // Generic form of C:\Windows
+ res = SHGetFolderPathA(NULL,
+ CSIDL_FLAG_CREATE | CSIDL_WINDOWS,
+ NULL,
+ SHGFP_TYPE_CURRENT,
+ buff);
+ if (res != S_OK) {
+ assert(0 && "Failed to get windows directory");
+ return;
+ }
+ Paths.push_back(sys::Path(buff));
}
void
-Path::GetBytecodeLibraryPaths(std::vector<sys::Path>& Paths) {
+Path::GetBitcodeLibraryPaths(std::vector<sys::Path>& Paths) {
char * env_var = getenv("LLVM_LIB_SEARCH_PATH");
if (env_var != 0) {
getPathList(env_var,Paths);
#ifdef LLVM_LIBDIR
{
Path tmpPath;
- if (tmpPath.setDirectory(LLVM_LIBDIR))
+ if (tmpPath.set(LLVM_LIBDIR))
if (tmpPath.canRead())
Paths.push_back(tmpPath);
}
Path
Path::GetLLVMDefaultConfigDir() {
- // TODO: this isn't going to fly on Windows
- return Path("/etc/llvm/");
+ Path ret = GetUserHomeDirectory();
+ if (!ret.appendComponent(".llvm"))
+ assert(0 && "Failed to append .llvm");
+ return ret;
}
Path
Path::GetUserHomeDirectory() {
- // TODO: Typical Windows setup doesn't define HOME.
- const char* home = getenv("HOME");
- if (home) {
- Path result;
- if (result.setDirectory(home))
- return result;
- }
- return GetRootDirectory();
+ char buff[MAX_PATH];
+ HRESULT res = SHGetFolderPathA(NULL,
+ CSIDL_FLAG_CREATE | CSIDL_APPDATA,
+ NULL,
+ SHGFP_TYPE_CURRENT,
+ buff);
+ if (res != S_OK)
+ assert(0 && "Failed to get user home directory");
+ return Path(buff);
}
-// FIXME: the above set of functions don't map to Windows very well.
-bool
-Path::isFile() const {
- return (isValid() && path[path.length()-1] != '/');
+Path
+Path::GetCurrentDirectory() {
+ char pathname[MAX_PATH];
+ ::GetCurrentDirectoryA(MAX_PATH,pathname);
+ return Path(pathname);
}
-bool
-Path::isDirectory() const {
- return (isValid() && path[path.length()-1] == '/');
+/// GetMainExecutable - Return the path to the main executable, given the
+/// value of argv[0] from program startup.
+Path Path::GetMainExecutable(const char *argv0, void *MainAddr) {
+ char pathname[MAX_PATH];
+ DWORD ret = ::GetModuleFileNameA(NULL, pathname, MAX_PATH);
+ return ret != MAX_PATH ? Path(pathname) : Path();
}
-std::string
+
+// FIXME: the above set of functions don't map to Windows very well.
+
+
+StringRef Path::getDirname() const {
+ return getDirnameCharSep(path, "/");
+}
+
+StringRef
Path::getBasename() const {
// Find the last slash
size_t slash = path.rfind('/');
else
slash++;
- return path.substr(slash, path.rfind('.'));
+ size_t dot = path.rfind('.');
+ if (dot == std::string::npos || dot < slash)
+ return StringRef(path).substr(slash);
+ else
+ return StringRef(path).substr(slash, dot - slash);
}
-bool Path::hasMagicNumber(const std::string &Magic) const {
- std::string actualMagic;
- if (getMagicNumber(actualMagic, Magic.size()))
- return Magic == actualMagic;
- return false;
-}
+StringRef
+Path::getSuffix() const {
+ // Find the last slash
+ size_t slash = path.rfind('/');
+ if (slash == std::string::npos)
+ slash = 0;
+ else
+ slash++;
-bool
-Path::isBytecodeFile() const {
- std::string actualMagic;
- if (!getMagicNumber(actualMagic, 4))
- return false;
- return actualMagic == "llvc" || actualMagic == "llvm";
+ size_t dot = path.rfind('.');
+ if (dot == std::string::npos || dot < slash)
+ return StringRef("");
+ else
+ return StringRef(path).substr(dot + 1);
}
bool
return attr != INVALID_FILE_ATTRIBUTES;
}
+bool
+Path::isDirectory() const {
+ DWORD attr = GetFileAttributes(path.c_str());
+ return (attr != INVALID_FILE_ATTRIBUTES) &&
+ (attr & FILE_ATTRIBUTE_DIRECTORY);
+}
+
+bool
+Path::isSymLink() const {
+ DWORD attributes = GetFileAttributes(path.c_str());
+
+ if (attributes == INVALID_FILE_ATTRIBUTES)
+ // There's no sane way to report this :(.
+ assert(0 && "GetFileAttributes returned INVALID_FILE_ATTRIBUTES");
+
+ // This isn't exactly what defines a NTFS symlink, but it is only true for
+ // paths that act like a symlink.
+ return attributes & FILE_ATTRIBUTE_REPARSE_POINT;
+}
+
bool
Path::canRead() const {
// FIXME: take security attributes into account.
return attr != INVALID_FILE_ATTRIBUTES;
}
-std::string
+bool
+Path::isRegularFile() const {
+ if (isDirectory())
+ return false;
+ return true;
+}
+
+StringRef
Path::getLast() const {
// Find the last slash
size_t pos = path.rfind('/');
if (pos == std::string::npos)
return path;
- // If the last character is a slash
- if (pos == path.length()-1) {
- // Find the second to last slash
- size_t pos2 = path.rfind('/', pos-1);
- if (pos2 == std::string::npos)
- return path.substr(0,pos);
- else
- return path.substr(pos2+1,pos-pos2-1);
- }
+ // If the last character is a slash, we have a root directory
+ if (pos == path.length()-1)
+ return path;
+
// Return everything after the last slash
- return path.substr(pos+1);
+ return StringRef(path).substr(pos+1);
}
-void
-Path::getStatusInfo(StatusInfo& info) const {
- WIN32_FILE_ATTRIBUTE_DATA fi;
- if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi))
- ThrowError(std::string(path) + ": Can't get status: ");
-
- info.fileSize = fi.nFileSizeHigh;
- info.fileSize <<= 32;
- info.fileSize += fi.nFileSizeLow;
-
- info.mode = fi.dwFileAttributes & FILE_ATTRIBUTE_READONLY ? 0555 : 0777;
- info.user = 9999; // Not applicable to Windows, so...
- info.group = 9999; // Not applicable to Windows, so...
+const FileStatus *
+PathWithStatus::getFileStatus(bool update, std::string *ErrStr) const {
+ if (!fsIsValid || update) {
+ WIN32_FILE_ATTRIBUTE_DATA fi;
+ if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi)) {
+ MakeErrMsg(ErrStr, "getStatusInfo():" + std::string(path) +
+ ": Can't get status: ");
+ return 0;
+ }
- __int64 ft = *reinterpret_cast<__int64*>(&fi.ftLastWriteTime);
- info.modTime.fromWin32Time(ft);
+ status.fileSize = fi.nFileSizeHigh;
+ status.fileSize <<= sizeof(fi.nFileSizeHigh)*8;
+ status.fileSize += fi.nFileSizeLow;
- info.isDir = fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
- if (info.isDir && path[path.length() - 1] != '/')
- path += '/';
- else if (!info.isDir && path[path.length() - 1] == '/')
- path.erase(path.length() - 1);
-}
+ status.mode = fi.dwFileAttributes & FILE_ATTRIBUTE_READONLY ? 0555 : 0777;
+ status.user = 9999; // Not applicable to Windows, so...
+ status.group = 9999; // Not applicable to Windows, so...
-static bool AddPermissionBits(const std::string& Filename, int bits) {
- DWORD attr = GetFileAttributes(Filename.c_str());
+ // FIXME: this is only unique if the file is accessed by the same file path.
+ // How do we do this for C:\dir\file and ..\dir\file ? Unix has inode
+ // numbers, but the concept doesn't exist in Windows.
+ status.uniqueID = 0;
+ for (unsigned i = 0; i < path.length(); ++i)
+ status.uniqueID += path[i];
- // If it doesn't exist, we're done.
- if (attr == INVALID_FILE_ATTRIBUTES)
- return false;
+ ULARGE_INTEGER ui;
+ ui.LowPart = fi.ftLastWriteTime.dwLowDateTime;
+ ui.HighPart = fi.ftLastWriteTime.dwHighDateTime;
+ status.modTime.fromWin32Time(ui.QuadPart);
- // The best we can do to interpret Unix permission bits is to use
- // the owner writable bit.
- if ((attr & FILE_ATTRIBUTE_READONLY) && (bits & 0200)) {
- if (!SetFileAttributes(Filename.c_str(), attr & ~FILE_ATTRIBUTE_READONLY))
- ThrowError(Filename + ": SetFileAttributes: ");
+ status.isDir = fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
+ fsIsValid = true;
}
- return true;
+ return &status;
}
-void Path::makeReadable() {
+bool Path::makeReadableOnDisk(std::string* ErrMsg) {
// All files are readable on Windows (ignoring security attributes).
+ return false;
}
-void Path::makeWriteable() {
+bool Path::makeWriteableOnDisk(std::string* ErrMsg) {
DWORD attr = GetFileAttributes(path.c_str());
// If it doesn't exist, we're done.
if (attr == INVALID_FILE_ATTRIBUTES)
- return;
+ return false;
if (attr & FILE_ATTRIBUTE_READONLY) {
- if (!SetFileAttributes(path.c_str(), attr & ~FILE_ATTRIBUTE_READONLY))
- ThrowError(std::string(path) + ": Can't make file writable: ");
+ if (!SetFileAttributes(path.c_str(), attr & ~FILE_ATTRIBUTE_READONLY)) {
+ MakeErrMsg(ErrMsg, std::string(path) + ": Can't make file writable: ");
+ return true;
+ }
}
+ return false;
}
-void Path::makeExecutable() {
+bool Path::makeExecutableOnDisk(std::string* ErrMsg) {
// All files are executable on Windows (ignoring security attributes).
+ return false;
}
bool
-Path::getDirectoryContents(std::set<Path>& result) const {
- if (!isDirectory())
- return false;
+Path::getDirectoryContents(std::set<Path>& result, std::string* ErrMsg) const {
+ WIN32_FILE_ATTRIBUTE_DATA fi;
+ if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi)) {
+ MakeErrMsg(ErrMsg, path + ": can't get status of file");
+ return true;
+ }
+
+ if (!(fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
+ if (ErrMsg)
+ *ErrMsg = path + ": not a directory";
+ return true;
+ }
result.clear();
WIN32_FIND_DATA fd;
- std::string searchpath = path + "*";
+ std::string searchpath = path;
+ if (path.size() == 0 || searchpath[path.size()-1] == '/')
+ searchpath += "*";
+ else
+ searchpath += "/*";
+
HANDLE h = FindFirstFile(searchpath.c_str(), &fd);
if (h == INVALID_HANDLE_VALUE) {
if (GetLastError() == ERROR_FILE_NOT_FOUND)
return true; // not really an error, now is it?
- ThrowError(path + ": Can't read directory: ");
+ MakeErrMsg(ErrMsg, path + ": Can't read directory: ");
+ return true;
}
do {
if (fd.cFileName[0] == '.')
continue;
- Path aPath(path + &fd.cFileName[0]);
- if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
- aPath.path += "/";
+ Path aPath(path);
+ aPath.appendComponent(&fd.cFileName[0]);
result.insert(aPath);
} while (FindNextFile(h, &fd));
FindClose(h);
if (err != ERROR_NO_MORE_FILES) {
SetLastError(err);
- ThrowError(path + ": Can't read directory: ");
+ MakeErrMsg(ErrMsg, path + ": Can't read directory: ");
+ return true;
}
- return true;
+ return false;
}
bool
-Path::setDirectory(const std::string& a_path) {
- if (a_path.size() == 0)
+Path::set(StringRef a_path) {
+ if (a_path.empty())
return false;
- Path save(*this);
+ std::string save(path);
path = a_path;
FlipBackSlashes(path);
- size_t last = a_path.size() -1;
- if (a_path[last] != '/')
- path += '/';
if (!isValid()) {
- path = save.path;
+ path = save;
return false;
}
return true;
}
bool
-Path::setFile(const std::string& a_path) {
- if (a_path.size() == 0)
- return false;
- Path save(*this);
- path = a_path;
- FlipBackSlashes(path);
- size_t last = a_path.size() - 1;
- while (last > 0 && a_path[last] == '/')
- last--;
- path.erase(last+1);
- if (!isValid()) {
- path = save.path;
+Path::appendComponent(StringRef name) {
+ if (name.empty())
return false;
+ std::string save(path);
+ if (!path.empty()) {
+ size_t last = path.size() - 1;
+ if (path[last] != '/')
+ path += '/';
}
- return true;
-}
-
-bool
-Path::appendDirectory(const std::string& dir) {
- if (isFile())
- return false;
- Path save(*this);
- path += dir;
- path += "/";
+ path += name;
if (!isValid()) {
- path = save.path;
+ path = save;
return false;
}
return true;
}
bool
-Path::elideDirectory() {
- if (isFile())
- return false;
+Path::eraseComponent() {
size_t slashpos = path.rfind('/',path.size());
- if (slashpos == 0 || slashpos == std::string::npos)
- return false;
- if (slashpos == path.size() - 1)
- slashpos = path.rfind('/',slashpos-1);
- if (slashpos == std::string::npos)
+ if (slashpos == path.size() - 1 || slashpos == std::string::npos)
return false;
+ std::string save(path);
path.erase(slashpos);
- return true;
-}
-
-bool
-Path::appendFile(const std::string& file) {
- if (!isDirectory())
- return false;
- Path save(*this);
- path += file;
- if (!isValid()) {
- path = save.path;
- return false;
- }
- return true;
-}
-
-bool
-Path::elideFile() {
- if (isDirectory())
- return false;
- size_t slashpos = path.rfind('/',path.size());
- if (slashpos == std::string::npos)
- return false;
- path.erase(slashpos+1);
- return true;
-}
-
-bool
-Path::appendSuffix(const std::string& suffix) {
- if (isDirectory())
- return false;
- Path save(*this);
- path.append(".");
- path.append(suffix);
if (!isValid()) {
- path = save.path;
+ path = save;
return false;
}
return true;
}
bool
-Path::elideSuffix() {
- if (isDirectory()) return false;
+Path::eraseSuffix() {
size_t dotpos = path.rfind('.',path.size());
size_t slashpos = path.rfind('/',path.size());
- if (slashpos != std::string::npos && dotpos != std::string::npos &&
- dotpos > slashpos) {
- path.erase(dotpos, path.size()-dotpos);
- return true;
+ if (dotpos != std::string::npos) {
+ if (slashpos == std::string::npos || dotpos > slashpos+1) {
+ std::string save(path);
+ path.erase(dotpos, path.size()-dotpos);
+ if (!isValid()) {
+ path = save;
+ return false;
+ }
+ return true;
+ }
}
return false;
}
+inline bool PathMsg(std::string* ErrMsg, const char* pathname, const char*msg) {
+ if (ErrMsg)
+ *ErrMsg = std::string(pathname) + ": " + std::string(msg);
+ return true;
+}
bool
-Path::createDirectory( bool create_parents) {
- // Make sure we're dealing with a directory
- if (!isDirectory()) return false;
-
+Path::createDirectoryOnDisk(bool create_parents, std::string* ErrMsg) {
// Get a writeable copy of the path name
- char *pathname = reinterpret_cast<char *>(_alloca(path.length()+1));
- path.copy(pathname,path.length());
- pathname[path.length()] = 0;
+ size_t len = path.length();
+ char *pathname = reinterpret_cast<char *>(_alloca(len+2));
+ path.copy(pathname, len);
+ pathname[len] = 0;
+
+ // Make sure it ends with a slash.
+ if (len == 0 || pathname[len - 1] != '/') {
+ pathname[len] = '/';
+ pathname[++len] = 0;
+ }
// Determine starting point for initial / search.
char *next = pathname;
// Skip host name.
next = strchr(pathname+2, '/');
if (next == NULL)
- throw std::string(pathname) + ": badly formed remote directory";
+ return PathMsg(ErrMsg, pathname, "badly formed remote directory");
+
// Skip share name.
next = strchr(next+1, '/');
if (next == NULL)
- throw std::string(pathname) + ": badly formed remote directory";
+ return PathMsg(ErrMsg, pathname,"badly formed remote directory");
+
next++;
if (*next == 0)
- throw std::string(pathname) + ": badly formed remote directory";
+ return PathMsg(ErrMsg, pathname, "badly formed remote directory");
+
} else {
if (pathname[1] == ':')
next += 2; // skip drive letter
while (*next) {
next = strchr(next, '/');
*next = 0;
- if (!CreateDirectory(pathname, NULL))
- ThrowError(std::string(pathname) + ": Can't create directory: ");
+ if (!CreateDirectory(pathname, NULL) &&
+ GetLastError() != ERROR_ALREADY_EXISTS)
+ return MakeErrMsg(ErrMsg,
+ std::string(pathname) + ": Can't create directory: ");
*next++ = '/';
}
} else {
// Drop trailing slash.
- pathname[path.size()-1] = 0;
- if (!CreateDirectory(pathname, NULL)) {
- ThrowError(std::string(pathname) + ": Can't create directory: ");
+ pathname[len-1] = 0;
+ if (!CreateDirectory(pathname, NULL) &&
+ GetLastError() != ERROR_ALREADY_EXISTS) {
+ return MakeErrMsg(ErrMsg, std::string(pathname) +
+ ": Can't create directory: ");
}
}
- return true;
+ return false;
}
bool
-Path::createFile() {
- // Make sure we're dealing with a file
- if (!isFile()) return false;
-
+Path::createFileOnDisk(std::string* ErrMsg) {
// Create the file
HANDLE h = CreateFile(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_NEW,
FILE_ATTRIBUTE_NORMAL, NULL);
if (h == INVALID_HANDLE_VALUE)
- ThrowError(path + ": Can't create file: ");
+ return MakeErrMsg(ErrMsg, path + ": Can't create file: ");
CloseHandle(h);
- return true;
+ return false;
}
bool
-Path::destroyDirectory(bool remove_contents) const {
- // Make sure we're dealing with a directory
- if (!isDirectory()) return false;
+Path::eraseFromDisk(bool remove_contents, std::string *ErrStr) const {
+ WIN32_FILE_ATTRIBUTE_DATA fi;
+ if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi))
+ return true;
- // If it doesn't exist, we're done.
- if (!exists()) return true;
-
- char *pathname = reinterpret_cast<char *>(_alloca(path.length()+2));
- int lastchar = path.length() - 1 ;
- path.copy(pathname,lastchar+2);
-
- // Make path end with '/*'.
- pathname[lastchar+1] = '*';
- pathname[lastchar+2] = 0;
-
- if (remove_contents) {
- WIN32_FIND_DATA fd;
- HANDLE h = FindFirstFile(pathname, &fd);
-
- // It's a bad idea to alter the contents of a directory while enumerating
- // its contents. So build a list of its contents first, then destroy them.
-
- if (h != INVALID_HANDLE_VALUE) {
- std::vector<Path> list;
-
- do {
- if (strcmp(fd.cFileName, ".") == 0)
- continue;
- if (strcmp(fd.cFileName, "..") == 0)
- continue;
-
- Path aPath(path + &fd.cFileName[0]);
- if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
- aPath.path += "/";
- list.push_back(aPath);
- } while (FindNextFile(h, &fd));
-
- DWORD err = GetLastError();
- FindClose(h);
- if (err != ERROR_NO_MORE_FILES) {
- SetLastError(err);
- ThrowError(path + ": Can't read directory: ");
- }
+ if (fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+ // If it doesn't exist, we're done.
+ if (!exists())
+ return false;
+
+ char *pathname = reinterpret_cast<char *>(_alloca(path.length()+3));
+ int lastchar = path.length() - 1 ;
+ path.copy(pathname, lastchar+1);
+
+ // Make path end with '/*'.
+ if (pathname[lastchar] != '/')
+ pathname[++lastchar] = '/';
+ pathname[lastchar+1] = '*';
+ pathname[lastchar+2] = 0;
+
+ if (remove_contents) {
+ WIN32_FIND_DATA fd;
+ HANDLE h = FindFirstFile(pathname, &fd);
+
+ // It's a bad idea to alter the contents of a directory while enumerating
+ // its contents. So build a list of its contents first, then destroy them.
+
+ if (h != INVALID_HANDLE_VALUE) {
+ std::vector<Path> list;
+
+ do {
+ if (strcmp(fd.cFileName, ".") == 0)
+ continue;
+ if (strcmp(fd.cFileName, "..") == 0)
+ continue;
+
+ Path aPath(path);
+ aPath.appendComponent(&fd.cFileName[0]);
+ list.push_back(aPath);
+ } while (FindNextFile(h, &fd));
+
+ DWORD err = GetLastError();
+ FindClose(h);
+ if (err != ERROR_NO_MORE_FILES) {
+ SetLastError(err);
+ return MakeErrMsg(ErrStr, path + ": Can't read directory: ");
+ }
- for (std::vector<Path>::iterator I = list.begin(); I != list.end(); ++I) {
- Path &aPath = *I;
- if (aPath.isDirectory())
- aPath.destroyDirectory(true);
- else
- aPath.destroyFile();
+ for (std::vector<Path>::iterator I = list.begin(); I != list.end();
+ ++I) {
+ Path &aPath = *I;
+ aPath.eraseFromDisk(true);
+ }
+ } else {
+ if (GetLastError() != ERROR_FILE_NOT_FOUND)
+ return MakeErrMsg(ErrStr, path + ": Can't read directory: ");
}
- } else {
- if (GetLastError() != ERROR_FILE_NOT_FOUND)
- ThrowError(path + ": Can't read directory: ");
}
- }
-
- pathname[lastchar] = 0;
- if (!RemoveDirectory(pathname))
- ThrowError(std::string(pathname) + ": Can't destroy directory: ");
- return true;
-}
-
-bool
-Path::destroyFile() const {
- if (!isFile()) return false;
- DWORD attr = GetFileAttributes(path.c_str());
-
- // If it doesn't exist, we're done.
- if (attr == INVALID_FILE_ATTRIBUTES)
- return true;
+ pathname[lastchar] = 0;
+ if (!RemoveDirectory(pathname))
+ return MakeErrMsg(ErrStr,
+ std::string(pathname) + ": Can't destroy directory: ");
+ return false;
+ } else {
+ // Read-only files cannot be deleted on Windows. Must remove the read-only
+ // attribute first.
+ if (fi.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
+ if (!SetFileAttributes(path.c_str(),
+ fi.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY))
+ return MakeErrMsg(ErrStr, path + ": Can't destroy file: ");
+ }
- // Read-only files cannot be deleted on Windows. Must remove the read-only
- // attribute first.
- if (attr & FILE_ATTRIBUTE_READONLY) {
- if (!SetFileAttributes(path.c_str(), attr & ~FILE_ATTRIBUTE_READONLY))
- ThrowError(path + ": Can't destroy file: ");
+ if (!DeleteFile(path.c_str()))
+ return MakeErrMsg(ErrStr, path + ": Can't destroy file: ");
+ return false;
}
-
- if (!DeleteFile(path.c_str()))
- ThrowError(path + ": Can't destroy file: ");
- return true;
}
bool Path::getMagicNumber(std::string& Magic, unsigned len) const {
- if (!isFile())
- return false;
assert(len < 1024 && "Request for magic string too long");
- char* buf = (char*) alloca(1 + len);
+ char* buf = reinterpret_cast<char*>(alloca(len));
HANDLE h = CreateFile(path.c_str(),
GENERIC_READ,
if (!ret || nRead != len)
return false;
- buf[len] = '\0';
- Magic = buf;
+ Magic = std::string(buf, len);
return true;
}
bool
-Path::renameFile(const Path& newName) {
- if (!isFile()) return false;
- if (!MoveFile(path.c_str(), newName.c_str()))
- ThrowError("Can't move '" + path +
- "' to '" + newName.path + "': ");
- return true;
+Path::renamePathOnDisk(const Path& newName, std::string* ErrMsg) {
+ if (!MoveFileEx(path.c_str(), newName.c_str(), MOVEFILE_REPLACE_EXISTING))
+ return MakeErrMsg(ErrMsg, "Can't move '" + path + "' to '" + newName.path
+ + "': ");
+ return false;
}
bool
-Path::setStatusInfo(const StatusInfo& si) const {
- if (!isFile()) return false;
+Path::setStatusInfoOnDisk(const FileStatus &si, std::string *ErrMsg) const {
+ // FIXME: should work on directories also.
+ if (!si.isFile) {
+ return true;
+ }
HANDLE h = CreateFile(path.c_str(),
FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (h == INVALID_HANDLE_VALUE)
- return false;
+ return true;
BY_HANDLE_FILE_INFORMATION bhfi;
if (!GetFileInformationByHandle(h, &bhfi)) {
DWORD err = GetLastError();
CloseHandle(h);
SetLastError(err);
- ThrowError(path + ": GetFileInformationByHandle: ");
+ return MakeErrMsg(ErrMsg, path + ": GetFileInformationByHandle: ");
}
+ ULARGE_INTEGER ui;
+ ui.QuadPart = si.modTime.toWin32Time();
FILETIME ft;
- (uint64_t&)ft = si.modTime.toWin32Time();
+ ft.dwLowDateTime = ui.LowPart;
+ ft.dwHighDateTime = ui.HighPart;
BOOL ret = SetFileTime(h, NULL, &ft, &ft);
DWORD err = GetLastError();
CloseHandle(h);
if (!ret) {
SetLastError(err);
- ThrowError(path + ": SetFileTime: ");
+ return MakeErrMsg(ErrMsg, path + ": SetFileTime: ");
}
// Best we can do with Unix permission bits is to interpret the owner
if (bhfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
if (!SetFileAttributes(path.c_str(),
bhfi.dwFileAttributes & ~FILE_ATTRIBUTE_READONLY))
- ThrowError(path + ": SetFileAttributes: ");
+ return MakeErrMsg(ErrMsg, path + ": SetFileAttributes: ");
}
} else {
if (!(bhfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) {
if (!SetFileAttributes(path.c_str(),
bhfi.dwFileAttributes | FILE_ATTRIBUTE_READONLY))
- ThrowError(path + ": SetFileAttributes: ");
+ return MakeErrMsg(ErrMsg, path + ": SetFileAttributes: ");
}
}
- return true;
+ return false;
}
-void
-sys::CopyFile(const sys::Path &Dest, const sys::Path &Src) {
+bool
+CopyFile(const sys::Path &Dest, const sys::Path &Src, std::string* ErrMsg) {
// Can't use CopyFile macro defined in Windows.h because it would mess up the
// above line. We use the expansion it would have in a non-UNICODE build.
if (!::CopyFileA(Src.c_str(), Dest.c_str(), false))
- ThrowError("Can't copy '" + Src.toString() +
- "' to '" + Dest.toString() + "': ");
+ return MakeErrMsg(ErrMsg, "Can't copy '" + Src.str() +
+ "' to '" + Dest.str() + "': ");
+ return false;
}
-void
-Path::makeUnique(bool reuse_current) {
+bool
+Path::makeUnique(bool reuse_current, std::string* ErrMsg) {
if (reuse_current && !exists())
- return; // File doesn't exist already, just use it!
+ return false; // File doesn't exist already, just use it!
// Reserve space for -XXXXXX at the end.
char *FNBuffer = (char*) alloca(path.size()+8);
unsigned offset = path.size();
path.copy(FNBuffer, offset);
- // Find a numeric suffix that isn't used by an existing file.
+ // Find a numeric suffix that isn't used by an existing file. Assume there
+ // won't be more than 1 million files with the same prefix. Probably a safe
+ // bet.
static unsigned FCounter = 0;
do {
sprintf(FNBuffer+offset, "-%06u", FCounter);
FCounter = 0;
path = FNBuffer;
} while (exists());
+ return false;
}
bool
-Path::createTemporaryFile(bool reuse_current) {
- // Make sure we're dealing with a file
- if (!isFile())
- return false;
-
+Path::createTemporaryFileOnDisk(bool reuse_current, std::string* ErrMsg) {
// Make this into a unique file name
- makeUnique( reuse_current );
+ makeUnique(reuse_current, ErrMsg);
// Now go and create it
HANDLE h = CreateFile(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_NEW,
FILE_ATTRIBUTE_NORMAL, NULL);
if (h == INVALID_HANDLE_VALUE)
- return false;
+ return MakeErrMsg(ErrMsg, path + ": can't create file");
CloseHandle(h);
- return true;
+ return false;
}
-}
+/// MapInFilePages - Not yet implemented on win32.
+const char *Path::MapInFilePages(int FD, uint64_t FileSize) {
+ return 0;
}
+/// MapInFilePages - Not yet implemented on win32.
+void Path::UnMapFilePages(const char *Base, uint64_t FileSize) {
+ assert(0 && "NOT IMPLEMENTED");
+}
+}
+}
projects / oota-llvm.git / blobdiff