/// areas of memory after this call.
/// @throws std::string if an error occurs
/// @brief Set the size of the file and memory mapping.
- void size(size_t new_size);
+ bool size(size_t new_size, std::string* ErrMsg = 0);
void close() { if (info_) terminate(); }
/// This function registers signal handlers to ensure that if a signal gets
/// delivered that the named file is removed.
/// @brief Remove a file if a fatal signal occurs.
- void RemoveFileOnSignal(const Path &Filename);
+ bool RemoveFileOnSignal(const Path &Filename, std::string* ErrMsg = 0);
/// This function registers a signal handler to ensure that if a fatal signal
/// gets delivered to the process that the named directory and all its
/// contents are removed.
/// @brief Remove a directory if a fatal signal occurs.
- void RemoveDirectoryOnSignal(const Path& path);
+ bool RemoveDirectoryOnSignal(const Path& path, std::string* ErrMsg = 0);
/// When an error signal (such as SIBABRT or SIGSEGV) is delivered to the
/// process, print a stack trace and then exit.
return info_->Size;
}
-void MappedFile::size(size_t new_size) {
+bool MappedFile::size(size_t new_size, std::string* ErrMsg) {
assert(info_ && "MappedFile not initialized");
// Take the mapping out of memory
if (new_size > cur_size) {
// Ensure we can allocate at least the idodes necessary to handle the
// file size requested.
- ::lseek(info_->FD, new_size, SEEK_SET);
- ::write(info_->FD, "\0", 1);
+ if ((off_t)-1 == ::lseek(info_->FD, new_size, SEEK_SET))
+ return MakeErrMsg(ErrMsg, "Can't lseek: ");
+ if (-1 == ::write(info_->FD, "\0", 1))
+ return MakeErrMsg(ErrMsg, "Can't write: ");
}
// Put the mapping back into memory.
- this->map(0);
+ return this->map(ErrMsg);
}
}
}
// RemoveFileOnSignal - The public API
-void sys::RemoveFileOnSignal(const sys::Path &Filename) {
+bool sys::RemoveFileOnSignal(const sys::Path &Filename, std::string* ErrMsg) {
if (FilesToRemove == 0)
FilesToRemove = new std::vector<sys::Path>;
std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
+ return false;
}
// RemoveDirectoryOnSignal - The public API
-void sys::RemoveDirectoryOnSignal(const sys::Path& path) {
+bool sys::RemoveDirectoryOnSignal(const sys::Path& path, std::string* ErrMsg) {
// Not a directory?
sys::FileStatus Status;
- if (path.getFileStatus(Status) || !Status.isDir)
- return;
+ if (path.getFileStatus(Status) || !Status.isDir) {
+ if (ErrMsg)
+ *ErrMsg = path.toString() + " is not a directory";
+ return true;
+ }
if (DirectoriesToRemove == 0)
DirectoriesToRemove = new std::vector<sys::Path>;
std::for_each(IntSigs, IntSigsEnd, RegisterHandler);
std::for_each(KillSigs, KillSigsEnd, RegisterHandler);
+ return false;
}
/// PrintStackTraceOnErrorSignal - When an error signal (such as SIBABRT or
// but, oh well, just use a generic message
sprintf(buffer, "Error #%d", errnum);
#endif
- *ErrMsg = buffer;
+ *ErrMsg = prefix + buffer;
return true;
}
OpenedHandles.push_back((HMODULE)handle);
}
-DynamicLibrary::DynamicLibrary(const char*filename) : handle(0) {
- HMODULE a_handle = LoadLibrary(filename);
-
- if (a_handle == 0)
- ThrowError(std::string(filename) + ": Can't open : ");
-
- handle = a_handle;
- OpenedHandles.push_back(a_handle);
-}
-
DynamicLibrary::~DynamicLibrary() {
if (handle == 0)
return;
HMODULE a_handle = LoadLibrary(filename);
if (a_handle == 0)
- return GetError(std::string(filename) + ": Can't open : ", ErrMsg);
+ return MakeErrMsg(ErrMsg, std::string(filename) + ": Can't open : ");
OpenedHandles.push_back(a_handle);
} else {
size_t size;
};
-void MappedFile::initialize() {
+bool MappedFile::initialize(std::string* ErrMsg) {
assert(!info_);
info_ = new MappedFileInfo;
info_->hFile = INVALID_HANDLE_VALUE;
if (info_->hFile == INVALID_HANDLE_VALUE) {
delete info_;
info_ = NULL;
- ThrowError(std::string("Can't open file: ") + path_.toString());
+ return MakeErrMsg(ErrMsg,
+ std::string("Can't open file: ") + path_.toString());
}
LARGE_INTEGER size;
CloseHandle(info_->hFile);
delete info_;
info_ = NULL;
- ThrowError(std::string("Can't get size of file: ") + path_.toString());
+ return MakeErrMsg(ErrMsg,
+ std::string("Can't get size of file: ") + path_.toString());
}
}
}
}
-void* MappedFile::map() {
+void* MappedFile::map(std::string* ErrMsg) {
if (!isMapped()) {
DWORD prot = PAGE_READONLY;
if (options_ & EXEC_ACCESS)
else if (options_ & WRITE_ACCESS)
prot = PAGE_READWRITE;
info_->hMapping = CreateFileMapping(info_->hFile, NULL, prot, 0, 0, NULL);
- if (info_->hMapping == NULL)
- ThrowError(std::string("Can't map file: ") + path_.toString());
+ if (info_->hMapping == NULL) {
+ MakeErrMsg(ErrMsg, std::string("Can't map file: ") + path_.toString());
+ return 0;
+ }
prot = (options_ & WRITE_ACCESS) ? FILE_MAP_WRITE : FILE_MAP_READ;
base_ = MapViewOfFileEx(info_->hMapping, prot, 0, 0, 0, NULL);
if (base_ == NULL) {
CloseHandle(info_->hMapping);
info_->hMapping = NULL;
- ThrowError(std::string("Can't map file: ") + path_.toString());
+ MakeErrMsg(ErrMsg, std::string("Can't map file: ") + path_.toString());
+ return 0;
}
}
return base_;
return info_->size;
}
-void MappedFile::size(size_t new_size) {
+bool MappedFile::size(size_t new_size, std::string* ErrMsg) {
assert(info_ && "MappedFile not initialized");
// Take the mapping out of memory.
LARGE_INTEGER eof;
eof.QuadPart = new_size;
if (!SetFilePointerEx(info_->hFile, eof, NULL, FILE_BEGIN))
- ThrowError(std::string("Can't set end of file: ") + path_.toString());
+ return MakeErrMsg(ErrMsg,
+ std::string("Can't set end of file: ") + path_.toString());
if (!SetEndOfFile(info_->hFile))
- ThrowError(std::string("Can't set end of file: ") + path_.toString());
+ return MakeErrMsg(ErrMsg,
+ std::string("Can't set end of file: ") + path_.toString());
info_->size = new_size;
}
// Remap the file.
- map();
+ return map(ErrMsg);
}
}
void *pa = VirtualAlloc(NULL, NumPages*pageSize, MEM_COMMIT,
PAGE_EXECUTE_READWRITE);
if (pa == NULL) {
- GetError("Can't allocate RWX Memory: ", ErrMsg);
+ MakeErrMsg(ErrMsg, "Can't allocate RWX Memory: ");
return MemoryBlock();
}
bool Memory::ReleaseRWX(MemoryBlock &M, std::string *ErrMsg) {
if (M.Address == 0 || M.Size == 0) return false;
if (!VirtualFree(M.Address, 0, MEM_RELEASE))
- return GetError("Can't release RWX Memory: ", ErrMsg);
+ return MakeErrMsg(ErrMsg, "Can't release RWX Memory: ");
return false;
}
Path::getFileStatus(FileStatus &info, std::string *ErrStr) const {
WIN32_FILE_ATTRIBUTE_DATA fi;
if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi))
- return GetError("getStatusInfo():" + std::string(path) +
- ": Can't get status: ", ErrStr);
+ return MakeErrMsg(ErrStr, "getStatusInfo():" + std::string(path) +
+ ": Can't get status: ");
info.fileSize = fi.nFileSizeHigh;
info.fileSize <<= sizeof(fi.nFileSizeHigh)*8;
// attribute first.
if (attr & FILE_ATTRIBUTE_READONLY) {
if (!SetFileAttributes(path.c_str(), attr & ~FILE_ATTRIBUTE_READONLY))
- return GetError(path + ": Can't destroy file: ", ErrStr);
+ return MakeErrMsg(ErrStr, path + ": Can't destroy file: ");
}
if (!DeleteFile(path.c_str()))
FindClose(h);
if (err != ERROR_NO_MORE_FILES) {
SetLastError(err);
- return GetError(path + ": Can't read directory: ", ErrStr);
+ 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)
- return GetError(path + ": Can't read directory: ", ErrStr);
+ return MakeErrMsg(ErrStr, path + ": Can't read directory: ");
}
}
pathname[lastchar] = 0;
if (!RemoveDirectory(pathname))
- return GetError(std::string(pathname) + ": Can't destroy directory: ",
- ErrStr);
+ return MakeErrMsg(ErrStr,
+ std::string(pathname) + ": Can't destroy directory: ");
return false;
}
// It appears the path doesn't exist.
DWORD err = GetLastError();
CloseHandle(h);
SetLastError(err);
- return GetError(path + ": GetFileInformationByHandle: ", ErrStr);
+ return MakeErrMsg(ErrStr, path + ": GetFileInformationByHandle: ");
}
FILETIME ft;
CloseHandle(h);
if (!ret) {
SetLastError(err);
- return GetError(path + ": SetFileTime: ", ErrStr);
+ return MakeErrMsg(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))
- return GetError(path + ": SetFileAttributes: ", ErrStr);
+ return MakeErrMsg(ErrStr, path + ": SetFileAttributes: ");
}
} else {
if (!(bhfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) {
if (!SetFileAttributes(path.c_str(),
bhfi.dwFileAttributes | FILE_ATTRIBUTE_READONLY))
- return GetError(path + ": SetFileAttributes: ", ErrStr);
+ return MakeErrMsg(ErrStr, path + ": SetFileAttributes: ");
}
}
}
// RemoveFileOnSignal - The public API
-void sys::RemoveFileOnSignal(const sys::Path &Filename) {
+bool sys::RemoveFileOnSignal(const sys::Path &Filename, std::string* ErrMsg) {
RegisterHandler();
- if (CleanupExecuted)
- throw std::string("Process terminating -- cannot register for removal");
+ if (CleanupExecuted) {
+ if (ErrMsg)
+ *ErrMsg = "Process terminating -- cannot register for removal";
+ return true;
+ }
if (FilesToRemove == NULL)
FilesToRemove = new std::vector<sys::Path>;
FilesToRemove->push_back(Filename);
LeaveCriticalSection(&CriticalSection);
+ return false;
}
// RemoveDirectoryOnSignal - The public API
-void sys::RemoveDirectoryOnSignal(const sys::Path& path) {
+bool sys::RemoveDirectoryOnSignal(const sys::Path& path, std::string* ErrMsg) {
// Not a directory?
sys::FileStatus Status;
- if (path.getFileStatus(Status) || !Status.isDir)
- return;
+ if (path.getFileStatus(Status) || !Status.isDir) {
+ if (ErrMsg)
+ *ErrMsg = path.toString() + " is not a directory";
+ return true;
+ }
RegisterHandler();
- if (CleanupExecuted)
- throw std::string("Process terminating -- cannot register for removal");
+ if (CleanupExecuted) {
+ if (ErrMsg)
+ *ErrMsg = "Process terminating -- cannot register for removal";
+ return true;
+ }
if (DirectoriesToRemove == NULL)
DirectoriesToRemove = new std::vector<sys::Path>;
DirectoriesToRemove->push_back(path);
LeaveCriticalSection(&CriticalSection);
+ return false;
}
/// PrintStackTraceOnErrorSignal - When an error signal (such as SIBABRT or
#include <cassert>
#include <string>
-inline bool GetError(const std::string &Prefix, std::string *Dest) {
- if (Dest == 0) return true;
- char *buffer = NULL;
- FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
- NULL, GetLastError(), 0, (LPSTR)&buffer, 1, NULL);
- *Dest = Prefix + buffer;
- LocalFree(buffer);
- return true;
-}
-
-inline void ThrowError(const std::string& msg) {
- char *buffer = NULL;
- FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
- NULL, GetLastError(), 0, (LPSTR)&buffer, 1, NULL);
- std::string s(msg);
- s += buffer;
- LocalFree(buffer);
- throw s;
-}
-
inline bool MakeErrMsg(std::string* ErrMsg, const std::string& prefix) {
if (!ErrMsg)
return true;
return true;
}
-inline void ThrowErrno(const std::string& prefix) {
- ThrowError(prefix + ": " + strerror(errno));
-}
-
inline void MakeErrnoMsg(std::string* ErrMsg, const std::string & prefix) {
MakeErrorMsg(prefix + ": " + strerror(errno));
}
projects / oota-llvm.git / commitdiff