static Path *TempDirectory = NULL;
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.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());
+#endif
result.appendComponent(pathname);
// If there's a directory left over from a previous LLVM execution that
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() {
}
// FIXME: the above set of functions don't map to Windows very well.
-bool
-Path::isFile() const {
- WIN32_FILE_ATTRIBUTE_DATA fi;
- BOOL rc = GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi);
- if (rc)
- return !(fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
- else if (GetLastError() != ERROR_FILE_NOT_FOUND) {
- ThrowError("isFile(): " + std::string(path) + ": Can't get status: ");
- }
- return false;
-}
-
-bool
-Path::isDirectory() const {
- WIN32_FILE_ATTRIBUTE_DATA fi;
- BOOL rc = GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi);
- if (rc)
- return fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
- else if (GetLastError() != ERROR_FILE_NOT_FOUND)
- ThrowError("isDirectory(): " + std::string(path) + ": Can't get status: ");
- return false;
-}
-
-bool
-Path::isHidden() const {
- WIN32_FILE_ATTRIBUTE_DATA fi;
- BOOL rc = GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi);
- if (rc)
- return fi.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN;
- else if (GetLastError() != ERROR_FILE_NOT_FOUND)
- ThrowError("isHidden(): " + std::string(path) + ": Can't get status: ");
- return false;
-}
bool
Path::isRootDirectory() const {
bool
Path::isBytecodeFile() const {
- if (!isFile())
- return false;
std::string actualMagic;
if (!getMagicNumber(actualMagic, 4))
return false;
return path.substr(pos+1);
}
-void
-Path::getStatusInfo(StatusInfo& info) const {
+bool
+Path::getFileStatus(FileStatus &info, std::string *ErrStr) const {
WIN32_FILE_ATTRIBUTE_DATA fi;
if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi))
- ThrowError("getStatusInfo():" + std::string(path) + ": Can't get status: ");
+ return MakeErrMsg(ErrStr, "getStatusInfo():" + std::string(path) +
+ ": Can't get status: ");
info.fileSize = fi.nFileSizeHigh;
info.fileSize <<= sizeof(fi.nFileSizeHigh)*8;
info.modTime.fromWin32Time(ft);
info.isDir = fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
+ return false;
}
-static bool AddPermissionBits(const std::string& Filename, int bits) {
- DWORD attr = GetFileAttributes(Filename.c_str());
-
- // If it doesn't exist, we're done.
- if (attr == INVALID_FILE_ATTRIBUTES)
- return false;
-
- // 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: ");
- }
- return true;
-}
-
-void Path::makeReadableOnDisk() {
+bool Path::makeReadableOnDisk(std::string* ErrMsg) {
// All files are readable on Windows (ignoring security attributes).
+ return false;
}
-void Path::makeWriteableOnDisk() {
+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::makeExecutableOnDisk() {
+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 {
+ FileStatus Status;
+ if (getFileStatus(Status, ErrMsg))
+ return true;
+
+ if (!Status.isDir) {
+ MakeErrMsg(ErrMsg, path + ": not a directory");
+ return true;
+ }
result.clear();
WIN32_FIND_DATA 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 {
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
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::createDirectoryOnDisk(bool create_parents) {
+Path::createDirectoryOnDisk(bool create_parents, std::string* ErrMsg) {
// Get a writeable copy of the path name
size_t len = path.length();
char *pathname = reinterpret_cast<char *>(_alloca(len+2));
// 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
next = strchr(next, '/');
*next = 0;
if (!CreateDirectory(pathname, NULL))
- ThrowError(std::string(pathname) + ": Can't create directory: ");
+ return MakeErrMsg(ErrMsg,
+ std::string(pathname) + ": Can't create directory: ");
*next++ = '/';
}
} else {
// Drop trailing slash.
pathname[len-1] = 0;
if (!CreateDirectory(pathname, NULL)) {
- ThrowError(std::string(pathname) + ": Can't create directory: ");
+ return MakeErrMsg(ErrMsg, std::string(pathname) + ": Can't create directory: ");
}
}
- return true;
+ return false;
}
bool
-Path::createFileOnDisk() {
+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::eraseFromDisk(bool remove_contents) const {
- if (isFile()) {
+Path::eraseFromDisk(bool remove_contents, std::string *ErrStr) const {
+ FileStatus Status;
+ if (getFileStatus(Status, ErrStr))
+ return false;
+
+ if (Status.isFile) {
DWORD attr = GetFileAttributes(path.c_str());
// If it doesn't exist, we're done.
if (attr == INVALID_FILE_ATTRIBUTES)
- return true;
+ return false;
// 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: ");
+ return MakeErrMsg(ErrStr, path + ": Can't destroy file: ");
}
if (!DeleteFile(path.c_str()))
- ThrowError(path + ": Can't destroy file: ");
- return true;
- } else if (isDirectory()) {
+ return MakeErrMsg(ErrStr, path + ": Can't destroy file: ");
+ return false;
+ } else if (Status.isDir) {
// If it doesn't exist, we're done.
if (!exists())
- return true;
+ return false;
char *pathname = reinterpret_cast<char *>(_alloca(path.length()+3));
int lastchar = path.length() - 1 ;
FindClose(h);
if (err != ERROR_NO_MORE_FILES) {
SetLastError(err);
- ThrowError(path + ": Can't read directory: ");
+ return MakeErrMsg(ErrStr, path + ": Can't read directory: ");
}
for (std::vector<Path>::iterator I = list.begin(); I != list.end();
}
} else {
if (GetLastError() != ERROR_FILE_NOT_FOUND)
- ThrowError(path + ": Can't read directory: ");
+ return MakeErrMsg(ErrStr, path + ": Can't read directory: ");
}
}
pathname[lastchar] = 0;
if (!RemoveDirectory(pathname))
- ThrowError(std::string(pathname) + ": Can't destroy directory: ");
- return true;
- } else {
- // It appears the path doesn't exist.
+ return MakeErrMsg(ErrStr,
+ std::string(pathname) + ": Can't destroy directory: ");
return false;
- }
+ }
+ // It appears the path doesn't exist.
+ 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);
}
bool
-Path::renamePathOnDisk(const Path& newName) {
+Path::renamePathOnDisk(const Path& newName, std::string* ErrMsg) {
if (!MoveFileEx(path.c_str(), newName.c_str(), MOVEFILE_REPLACE_EXISTING))
- ThrowError("Can't move '" + path +
- "' to '" + newName.path + "': ");
+ return MakeErrMsg(ErrMsg, "Can't move '" + path + "' to '" + newName.path
+ + "': ");
return true;
}
bool
-Path::setStatusInfoOnDisk(const StatusInfo& si) const {
+Path::setStatusInfoOnDisk(const FileStatus &si, std::string *ErrMsg) const {
// FIXME: should work on directories also.
- if (!isFile()) return false;
-
+ if (!si.isFile) {
+ return true;
+ }
+
HANDLE h = CreateFile(path.c_str(),
FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
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: ");
}
FILETIME ft;
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
-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() +
+ return MakeErrMsg(ErrMsg, "Can't copy '" + Src.toString() +
"' to '" + Dest.toString() + "': ");
+ 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);
FCounter = 0;
path = FNBuffer;
} while (exists());
+ return false;
}
bool
-Path::createTemporaryFileOnDisk(bool reuse_current) {
+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;
}
}
}
-
-