// We need to undo a macro defined in Windows.h, otherwise we won't compile:
#undef CopyFile
+// 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++)
if (s[i] == '\\')
// and followed by something.
size_t len = path.size();
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.
// Append a subdirectory passed on our process id so multiple LLVMs don't
// step on each other's toes.
- sprintf(pathname, "LLVM_%u", GetCurrentProcessId());
+ sprintf(pathname, "LLVM_%u", unsigned(GetCurrentProcessId()));
result.appendComponent(pathname);
// If there's a directory left over from a previous LLVM execution that
Path
Path::GetRootDirectory() {
Path result;
- result.set("C:\\");
+ result.set("C:/");
return result;
}
const char* at = path;
const char* delim = strchr(at, ';');
Path tmpPath;
- while( delim != 0 ) {
+ while (delim != 0) {
std::string tmp(at, size_t(delim-at));
if (tmpPath.set(tmp))
if (tmpPath.canRead())
at = delim + 1;
delim = strchr(at, ';');
}
+
if (*at != 0)
if (tmpPath.set(std::string(at)))
if (tmpPath.canRead())
Paths.push_back(tmpPath);
-
}
-void
+void
Path::GetSystemLibraryPaths(std::vector<sys::Path>& Paths) {
- Paths.push_back(sys::Path("C:\\WINDOWS\\SYSTEM32\\"));
- Paths.push_back(sys::Path("C:\\WINDOWS\\"));
+ Paths.push_back(sys::Path("C:/WINDOWS/SYSTEM32"));
+ Paths.push_back(sys::Path("C:/WINDOWS"));
}
void
Path
Path::GetLLVMDefaultConfigDir() {
// TODO: this isn't going to fly on Windows
- return Path("/etc/llvm/");
+ return Path("/etc/llvm");
}
Path
bool
Path::isFile() const {
- return !isDirectory();
+ 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;
- if (!GetFileAttributesEx(path.c_str(), GetFileExInfoStandard, &fi))
- ThrowError(std::string(path) + ": Can't get status: ");
- return fi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
+ 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 {
- // FIXME: implement this correctly for Win32. It should check the hidden file
- // attribute.
+ 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 {
+ size_t len = path.size();
+ return len > 0 && path[len-1] == '/';
+}
+
std::string
Path::getBasename() const {
// Find the last slash
else
slash++;
- return path.substr(slash, path.rfind('.'));
+ size_t dot = path.rfind('.');
+ if (dot == std::string::npos || dot < slash)
+ return path.substr(slash);
+ else
+ return path.substr(slash, dot - slash);
}
bool Path::hasMagicNumber(const std::string &Magic) const {
return false;
}
-bool
+bool
Path::isBytecodeFile() const {
+ if (!isFile())
+ return false;
std::string actualMagic;
if (!getMagicNumber(actualMagic, 4))
return false;
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);
}
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: ");
+ ThrowError("getStatusInfo():" + std::string(path) + ": Can't get status: ");
info.fileSize = fi.nFileSizeHigh;
- info.fileSize <<= 32;
+ info.fileSize <<= sizeof(fi.nFileSizeHigh)*8;
info.fileSize += fi.nFileSizeLow;
info.mode = fi.dwFileAttributes & FILE_ATTRIBUTE_READONLY ? 0555 : 0777;
info.modTime.fromWin32Time(ft);
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);
}
static bool AddPermissionBits(const std::string& Filename, int bits) {
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)
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));
std::string save(path);
path = a_path;
FlipBackSlashes(path);
- size_t last = a_path.size() -1;
if (!isValid()) {
path = save;
return false;
std::string save(path);
if (!path.empty()) {
size_t last = path.size() - 1;
- if (path[last] != '/')
+ if (path[last] != '/')
path += '/';
}
path += name;
bool
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);
+ if (!isValid()) {
+ path = save;
+ return false;
+ }
return true;
}
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;
}
bool
-Path::createDirectoryOnDisk( bool create_parents) {
+Path::createDirectoryOnDisk(bool create_parents) {
// 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;
}
} else {
// Drop trailing slash.
- pathname[path.size()-1] = 0;
+ pathname[len-1] = 0;
if (!CreateDirectory(pathname, NULL)) {
ThrowError(std::string(pathname) + ": Can't create directory: ");
}
}
bool
-Path::eraseFromDisk(bool remove_contents) const {
+Path::eraseFromDisk(bool remove_contents, std::string *ErrStr) const {
if (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 GetError(path + ": Can't destroy file: ", ErrStr);
}
if (!DeleteFile(path.c_str()))
ThrowError(path + ": Can't destroy file: ");
return true;
- } else /* isDirectory() */ {
-
+ } else if (isDirectory()) {
// If it doesn't exist, we're done.
- if (!exists())
- return true;
+ if (!exists())
+ return false;
- char *pathname = reinterpret_cast<char *>(_alloca(path.length()+2));
+ char *pathname = reinterpret_cast<char *>(_alloca(path.length()+3));
int lastchar = path.length() - 1 ;
- path.copy(pathname,lastchar+2);
+ path.copy(pathname, lastchar+1);
// Make path end with '/*'.
+ if (pathname[lastchar] != '/')
+ pathname[++lastchar] = '/';
pathname[lastchar+1] = '*';
pathname[lastchar+2] = 0;
if (strcmp(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]);
list.push_back(aPath);
} while (FindNextFile(h, &fd));
FindClose(h);
if (err != ERROR_NO_MORE_FILES) {
SetLastError(err);
- ThrowError(path + ": Can't read directory: ");
+ return GetError(path + ": Can't read directory: ", ErrStr);
}
- for (std::vector<Path>::iterator I = list.begin(); I != list.end();
+ 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)
- ThrowError(path + ": Can't read directory: ");
+ return GetError(path + ": Can't read directory: ", ErrStr);
}
}
pathname[lastchar] = 0;
if (!RemoveDirectory(pathname))
- ThrowError(std::string(pathname) + ": Can't destroy directory: ");
+ return GetError(std::string(pathname) + ": Can't destroy directory: ",
+ ErrStr);
+ return false;
+ } else {
+ // It appears the path doesn't exist.
return true;
}
}
bool
Path::renamePathOnDisk(const Path& newName) {
- // FIXME: This should rename a directory too.
- if (!isFile()) return false;
- if (!MoveFile(path.c_str(), newName.c_str()))
- ThrowError("Can't move '" + path +
+ if (!MoveFileEx(path.c_str(), newName.c_str(), MOVEFILE_REPLACE_EXISTING))
+ ThrowError("Can't move '" + path +
"' to '" + newName.path + "': ");
return true;
}
bool
Path::setStatusInfoOnDisk(const StatusInfo& si) const {
+ // FIXME: should work on directories also.
if (!isFile()) return false;
HANDLE h = CreateFile(path.c_str(),
return true;
}
-void
-sys::CopyFile(const sys::Path &Dest, const sys::Path &Src) {
+void
+CopyFile(const sys::Path &Dest, const sys::Path &Src) {
// 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() +
+ ThrowError("Can't copy '" + Src.toString() +
"' to '" + Dest.toString() + "': ");
}
-void
+void
Path::makeUnique(bool reuse_current) {
if (reuse_current && !exists())
return; // File doesn't exist already, just use it!
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);
bool
Path::createTemporaryFileOnDisk(bool reuse_current) {
// Make this into a unique file name
- makeUnique( reuse_current );
+ makeUnique(reuse_current);
// Now go and create it
HANDLE h = CreateFile(path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_NEW,
}
}
-
-
projects / oota-llvm.git / blobdiff