diff options
Diffstat (limited to 'source/Host/common/FileSpec.cpp')
| -rw-r--r-- | source/Host/common/FileSpec.cpp | 2341 |
1 files changed, 1050 insertions, 1291 deletions
diff --git a/source/Host/common/FileSpec.cpp b/source/Host/common/FileSpec.cpp index 53c0ab40e676..7f46d303a5d8 100644 --- a/source/Host/common/FileSpec.cpp +++ b/source/Host/common/FileSpec.cpp @@ -7,7 +7,6 @@ // //===----------------------------------------------------------------------===// - #ifndef _WIN32 #include <dirent.h> #else @@ -17,9 +16,9 @@ #ifndef _MSC_VER #include <libgen.h> #endif +#include <fstream> #include <set> #include <string.h> -#include <fstream> #include "lldb/Host/Config.h" // Have to include this before we test the define... #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER @@ -30,14 +29,15 @@ #include "lldb/Core/DataBufferHeap.h" #include "lldb/Core/DataBufferMemoryMap.h" #include "lldb/Core/RegularExpression.h" -#include "lldb/Core/StreamString.h" #include "lldb/Core/Stream.h" +#include "lldb/Core/StreamString.h" #include "lldb/Host/File.h" #include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSystem.h" #include "lldb/Host/Host.h" #include "lldb/Utility/CleanUp.h" +#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/ConvertUTF.h" #include "llvm/Support/FileSystem.h" @@ -49,339 +49,281 @@ using namespace lldb_private; namespace { -bool -PathSyntaxIsPosix(FileSpec::PathSyntax syntax) -{ - return (syntax == FileSpec::ePathSyntaxPosix || - (syntax == FileSpec::ePathSyntaxHostNative && - FileSystem::GetNativePathSyntax() == FileSpec::ePathSyntaxPosix)); +bool PathSyntaxIsPosix(FileSpec::PathSyntax syntax) { + return (syntax == FileSpec::ePathSyntaxPosix || + (syntax == FileSpec::ePathSyntaxHostNative && + FileSystem::GetNativePathSyntax() == FileSpec::ePathSyntaxPosix)); } -const char * -GetPathSeparators(FileSpec::PathSyntax syntax) -{ - return PathSyntaxIsPosix(syntax) ? "/" : "\\/"; +const char *GetPathSeparators(FileSpec::PathSyntax syntax) { + return PathSyntaxIsPosix(syntax) ? "/" : "\\/"; } -char -GetPrefferedPathSeparator(FileSpec::PathSyntax syntax) -{ - return GetPathSeparators(syntax)[0]; +char GetPreferredPathSeparator(FileSpec::PathSyntax syntax) { + return GetPathSeparators(syntax)[0]; } -bool -IsPathSeparator(char value, FileSpec::PathSyntax syntax) -{ - return value == '/' || (!PathSyntaxIsPosix(syntax) && value == '\\'); +bool IsPathSeparator(char value, FileSpec::PathSyntax syntax) { + return value == '/' || (!PathSyntaxIsPosix(syntax) && value == '\\'); } -void -Normalize(llvm::SmallVectorImpl<char> &path, FileSpec::PathSyntax syntax) -{ - if (PathSyntaxIsPosix(syntax)) return; - - std::replace(path.begin(), path.end(), '\\', '/'); - // Windows path can have \\ slashes which can be changed by replace - // call above to //. Here we remove the duplicate. - auto iter = std::unique ( path.begin(), path.end(), - []( char &c1, char &c2 ){ - return (c1 == '/' && c2 == '/');}); - path.erase(iter, path.end()); +void Normalize(llvm::SmallVectorImpl<char> &path, FileSpec::PathSyntax syntax) { + if (PathSyntaxIsPosix(syntax)) + return; + + std::replace(path.begin(), path.end(), '\\', '/'); + // Windows path can have \\ slashes which can be changed by replace + // call above to //. Here we remove the duplicate. + auto iter = std::unique(path.begin(), path.end(), [](char &c1, char &c2) { + return (c1 == '/' && c2 == '/'); + }); + path.erase(iter, path.end()); } -void -Denormalize(llvm::SmallVectorImpl<char> &path, FileSpec::PathSyntax syntax) -{ - if (PathSyntaxIsPosix(syntax)) return; +void Denormalize(llvm::SmallVectorImpl<char> &path, + FileSpec::PathSyntax syntax) { + if (PathSyntaxIsPosix(syntax)) + return; - std::replace(path.begin(), path.end(), '/', '\\'); + std::replace(path.begin(), path.end(), '/', '\\'); } -bool -GetFileStats (const FileSpec *file_spec, struct stat *stats_ptr) -{ - char resolved_path[PATH_MAX]; - if (file_spec->GetPath (resolved_path, sizeof(resolved_path))) - return FileSystem::Stat(resolved_path, stats_ptr) == 0; - return false; +bool GetFileStats(const FileSpec *file_spec, struct stat *stats_ptr) { + char resolved_path[PATH_MAX]; + if (file_spec->GetPath(resolved_path, sizeof(resolved_path))) + return FileSystem::Stat(resolved_path, stats_ptr) == 0; + return false; } -size_t -FilenamePos(llvm::StringRef str, FileSpec::PathSyntax syntax) -{ - if (str.size() == 2 && IsPathSeparator(str[0], syntax) && str[0] == str[1]) - return 0; +size_t FilenamePos(llvm::StringRef str, FileSpec::PathSyntax syntax) { + if (str.size() == 2 && IsPathSeparator(str[0], syntax) && str[0] == str[1]) + return 0; - if (str.size() > 0 && IsPathSeparator(str.back(), syntax)) - return str.size() - 1; + if (str.size() > 0 && IsPathSeparator(str.back(), syntax)) + return str.size() - 1; - size_t pos = str.find_last_of(GetPathSeparators(syntax), str.size() - 1); + size_t pos = str.find_last_of(GetPathSeparators(syntax), str.size() - 1); - if (!PathSyntaxIsPosix(syntax) && pos == llvm::StringRef::npos) - pos = str.find_last_of(':', str.size() - 2); + if (!PathSyntaxIsPosix(syntax) && pos == llvm::StringRef::npos) + pos = str.find_last_of(':', str.size() - 2); - if (pos == llvm::StringRef::npos || (pos == 1 && IsPathSeparator(str[0], syntax))) - return 0; + if (pos == llvm::StringRef::npos || + (pos == 1 && IsPathSeparator(str[0], syntax))) + return 0; - return pos + 1; + return pos + 1; } -size_t -RootDirStart(llvm::StringRef str, FileSpec::PathSyntax syntax) -{ - // case "c:/" - if (!PathSyntaxIsPosix(syntax) && (str.size() > 2 && str[1] == ':' && IsPathSeparator(str[2], syntax))) - return 2; +size_t RootDirStart(llvm::StringRef str, FileSpec::PathSyntax syntax) { + // case "c:/" + if (!PathSyntaxIsPosix(syntax) && + (str.size() > 2 && str[1] == ':' && IsPathSeparator(str[2], syntax))) + return 2; - // case "//" - if (str.size() == 2 && IsPathSeparator(str[0], syntax) && str[0] == str[1]) - return llvm::StringRef::npos; + // case "//" + if (str.size() == 2 && IsPathSeparator(str[0], syntax) && str[0] == str[1]) + return llvm::StringRef::npos; - // case "//net" - if (str.size() > 3 && IsPathSeparator(str[0], syntax) && str[0] == str[1] && !IsPathSeparator(str[2], syntax)) - return str.find_first_of(GetPathSeparators(syntax), 2); + // case "//net" + if (str.size() > 3 && IsPathSeparator(str[0], syntax) && str[0] == str[1] && + !IsPathSeparator(str[2], syntax)) + return str.find_first_of(GetPathSeparators(syntax), 2); - // case "/" - if (str.size() > 0 && IsPathSeparator(str[0], syntax)) - return 0; + // case "/" + if (str.size() > 0 && IsPathSeparator(str[0], syntax)) + return 0; - return llvm::StringRef::npos; + return llvm::StringRef::npos; } -size_t -ParentPathEnd(llvm::StringRef path, FileSpec::PathSyntax syntax) -{ - size_t end_pos = FilenamePos(path, syntax); +size_t ParentPathEnd(llvm::StringRef path, FileSpec::PathSyntax syntax) { + size_t end_pos = FilenamePos(path, syntax); - bool filename_was_sep = path.size() > 0 && IsPathSeparator(path[end_pos], syntax); + bool filename_was_sep = + path.size() > 0 && IsPathSeparator(path[end_pos], syntax); - // Skip separators except for root dir. - size_t root_dir_pos = RootDirStart(path.substr(0, end_pos), syntax); + // Skip separators except for root dir. + size_t root_dir_pos = RootDirStart(path.substr(0, end_pos), syntax); - while (end_pos > 0 && (end_pos - 1) != root_dir_pos && IsPathSeparator(path[end_pos - 1], syntax)) - --end_pos; + while (end_pos > 0 && (end_pos - 1) != root_dir_pos && + IsPathSeparator(path[end_pos - 1], syntax)) + --end_pos; - if (end_pos == 1 && root_dir_pos == 0 && filename_was_sep) - return llvm::StringRef::npos; + if (end_pos == 1 && root_dir_pos == 0 && filename_was_sep) + return llvm::StringRef::npos; - return end_pos; + return end_pos; } } // end anonymous namespace // Resolves the username part of a path of the form ~user/other/directories, and -// writes the result into dst_path. This will also resolve "~" to the current user. -// If you want to complete "~" to the list of users, pass it to ResolvePartialUsername. -void -FileSpec::ResolveUsername (llvm::SmallVectorImpl<char> &path) -{ +// writes the result into dst_path. This will also resolve "~" to the current +// user. +// If you want to complete "~" to the list of users, pass it to +// ResolvePartialUsername. +void FileSpec::ResolveUsername(llvm::SmallVectorImpl<char> &path) { #if LLDB_CONFIG_TILDE_RESOLVES_TO_USER - if (path.empty() || path[0] != '~') - return; - - llvm::StringRef path_str(path.data(), path.size()); - size_t slash_pos = path_str.find('/', 1); - if (slash_pos == 1 || path.size() == 1) - { - // A path of ~/ resolves to the current user's home dir - llvm::SmallString<64> home_dir; - // llvm::sys::path::home_directory() only checks if "HOME" is set in the - // environment and does nothing else to locate the user home directory - if (!llvm::sys::path::home_directory(home_dir)) - { - struct passwd *pw = getpwuid(getuid()); - if (pw && pw->pw_dir && pw->pw_dir[0]) - { - // Update our environemnt so llvm::sys::path::home_directory() works next time - setenv("HOME", pw->pw_dir, 0); - home_dir.assign(llvm::StringRef(pw->pw_dir)); - } - else - { - return; - } - } - - // Overwrite the ~ with the first character of the homedir, and insert - // the rest. This way we only trigger one move, whereas an insert - // followed by a delete (or vice versa) would trigger two. - path[0] = home_dir[0]; - path.insert(path.begin() + 1, home_dir.begin() + 1, home_dir.end()); + if (path.empty() || path[0] != '~') + return; + + llvm::StringRef path_str(path.data(), path.size()); + size_t slash_pos = path_str.find('/', 1); + if (slash_pos == 1 || path.size() == 1) { + // A path of ~/ resolves to the current user's home dir + llvm::SmallString<64> home_dir; + // llvm::sys::path::home_directory() only checks if "HOME" is set in the + // environment and does nothing else to locate the user home directory + if (!llvm::sys::path::home_directory(home_dir)) { + struct passwd *pw = getpwuid(getuid()); + if (pw && pw->pw_dir && pw->pw_dir[0]) { + // Update our environemnt so llvm::sys::path::home_directory() works + // next time + setenv("HOME", pw->pw_dir, 0); + home_dir.assign(llvm::StringRef(pw->pw_dir)); + } else { return; + } } - - auto username_begin = path.begin()+1; - auto username_end = (slash_pos == llvm::StringRef::npos) - ? path.end() - : (path.begin() + slash_pos); - size_t replacement_length = std::distance(path.begin(), username_end); - - llvm::SmallString<20> username(username_begin, username_end); - struct passwd *user_entry = ::getpwnam(username.c_str()); - if (user_entry != nullptr) - { - // Copy over the first n characters of the path, where n is the smaller of the length - // of the home directory and the slash pos. - llvm::StringRef homedir(user_entry->pw_dir); - size_t initial_copy_length = std::min(homedir.size(), replacement_length); - auto src_begin = homedir.begin(); - auto src_end = src_begin + initial_copy_length; - std::copy(src_begin, src_end, path.begin()); - if (replacement_length > homedir.size()) - { - // We copied the entire home directory, but the ~username portion of the path was - // longer, so there's characters that need to be removed. - path.erase(path.begin() + initial_copy_length, username_end); - } - else if (replacement_length < homedir.size()) - { - // We copied all the way up to the slash in the destination, but there's still more - // characters that need to be inserted. - path.insert(username_end, src_end, homedir.end()); - } - } - else - { - // Unable to resolve username (user doesn't exist?) - path.clear(); + + // Overwrite the ~ with the first character of the homedir, and insert + // the rest. This way we only trigger one move, whereas an insert + // followed by a delete (or vice versa) would trigger two. + path[0] = home_dir[0]; + path.insert(path.begin() + 1, home_dir.begin() + 1, home_dir.end()); + return; + } + + auto username_begin = path.begin() + 1; + auto username_end = (slash_pos == llvm::StringRef::npos) + ? path.end() + : (path.begin() + slash_pos); + size_t replacement_length = std::distance(path.begin(), username_end); + + llvm::SmallString<20> username(username_begin, username_end); + struct passwd *user_entry = ::getpwnam(username.c_str()); + if (user_entry != nullptr) { + // Copy over the first n characters of the path, where n is the smaller of + // the length + // of the home directory and the slash pos. + llvm::StringRef homedir(user_entry->pw_dir); + size_t initial_copy_length = std::min(homedir.size(), replacement_length); + auto src_begin = homedir.begin(); + auto src_end = src_begin + initial_copy_length; + std::copy(src_begin, src_end, path.begin()); + if (replacement_length > homedir.size()) { + // We copied the entire home directory, but the ~username portion of the + // path was + // longer, so there's characters that need to be removed. + path.erase(path.begin() + initial_copy_length, username_end); + } else if (replacement_length < homedir.size()) { + // We copied all the way up to the slash in the destination, but there's + // still more + // characters that need to be inserted. + path.insert(username_end, src_end, homedir.end()); } + } else { + // Unable to resolve username (user doesn't exist?) + path.clear(); + } #endif } -size_t -FileSpec::ResolvePartialUsername (const char *partial_name, StringList &matches) -{ +size_t FileSpec::ResolvePartialUsername(llvm::StringRef partial_name, + StringList &matches) { #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER - size_t extant_entries = matches.GetSize(); - - setpwent(); - struct passwd *user_entry; - const char *name_start = partial_name + 1; - std::set<std::string> name_list; - - while ((user_entry = getpwent()) != NULL) - { - if (strstr(user_entry->pw_name, name_start) == user_entry->pw_name) - { - std::string tmp_buf("~"); - tmp_buf.append(user_entry->pw_name); - tmp_buf.push_back('/'); - name_list.insert(tmp_buf); - } - } - std::set<std::string>::iterator pos, end = name_list.end(); - for (pos = name_list.begin(); pos != end; pos++) - { - matches.AppendString((*pos).c_str()); + size_t extant_entries = matches.GetSize(); + + setpwent(); + struct passwd *user_entry; + partial_name = partial_name.drop_front(); + std::set<std::string> name_list; + + while ((user_entry = getpwent()) != NULL) { + if (llvm::StringRef(user_entry->pw_name).startswith(partial_name)) { + std::string tmp_buf("~"); + tmp_buf.append(user_entry->pw_name); + tmp_buf.push_back('/'); + name_list.insert(tmp_buf); } - return matches.GetSize() - extant_entries; + } + + for (auto &name : name_list) { + matches.AppendString(name); + } + return matches.GetSize() - extant_entries; #else - // Resolving home directories is not supported, just copy the path... - return 0; -#endif // #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER + // Resolving home directories is not supported, just copy the path... + return 0; +#endif // #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER } -void -FileSpec::Resolve (llvm::SmallVectorImpl<char> &path) -{ - if (path.empty()) - return; +void FileSpec::Resolve(llvm::SmallVectorImpl<char> &path) { + if (path.empty()) + return; #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER - if (path[0] == '~') - ResolveUsername(path); + if (path[0] == '~') + ResolveUsername(path); #endif // #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER - // Save a copy of the original path that's passed in - llvm::SmallString<128> original_path(path.begin(), path.end()); + // Save a copy of the original path that's passed in + llvm::SmallString<128> original_path(path.begin(), path.end()); - llvm::sys::fs::make_absolute(path); - if (!llvm::sys::fs::exists(path)) - { - path.clear(); - path.append(original_path.begin(), original_path.end()); - } + llvm::sys::fs::make_absolute(path); + if (!llvm::sys::fs::exists(path)) { + path.clear(); + path.append(original_path.begin(), original_path.end()); + } } -FileSpec::FileSpec() : - m_directory(), - m_filename(), - m_syntax(FileSystem::GetNativePathSyntax()) -{ -} +FileSpec::FileSpec() : m_syntax(FileSystem::GetNativePathSyntax()) {} //------------------------------------------------------------------ // Default constructor that can take an optional full path to a // file on disk. //------------------------------------------------------------------ -FileSpec::FileSpec(const char *pathname, bool resolve_path, PathSyntax syntax) : - m_directory(), - m_filename(), - m_is_resolved(false), - m_syntax(syntax) -{ - if (pathname && pathname[0]) - SetFile(pathname, resolve_path, syntax); -} - -FileSpec::FileSpec(const char *pathname, bool resolve_path, ArchSpec arch) : - FileSpec{pathname, resolve_path, arch.GetTriple().isOSWindows() ? ePathSyntaxWindows : ePathSyntaxPosix} -{ -} - -FileSpec::FileSpec(const std::string &path, bool resolve_path, PathSyntax syntax) : - FileSpec{path.c_str(), resolve_path, syntax} -{ +FileSpec::FileSpec(llvm::StringRef path, bool resolve_path, PathSyntax syntax) + : m_syntax(syntax) { + SetFile(path, resolve_path, syntax); } -FileSpec::FileSpec(const std::string &path, bool resolve_path, ArchSpec arch) : - FileSpec{path.c_str(), resolve_path, arch} -{ -} +FileSpec::FileSpec(llvm::StringRef path, bool resolve_path, ArchSpec arch) + : FileSpec{path, resolve_path, arch.GetTriple().isOSWindows() + ? ePathSyntaxWindows + : ePathSyntaxPosix} {} //------------------------------------------------------------------ // Copy constructor //------------------------------------------------------------------ -FileSpec::FileSpec(const FileSpec& rhs) : - m_directory (rhs.m_directory), - m_filename (rhs.m_filename), - m_is_resolved (rhs.m_is_resolved), - m_syntax (rhs.m_syntax) -{ -} +FileSpec::FileSpec(const FileSpec &rhs) + : m_directory(rhs.m_directory), m_filename(rhs.m_filename), + m_is_resolved(rhs.m_is_resolved), m_syntax(rhs.m_syntax) {} //------------------------------------------------------------------ // Copy constructor //------------------------------------------------------------------ -FileSpec::FileSpec(const FileSpec* rhs) : - m_directory(), - m_filename() -{ - if (rhs) - *this = *rhs; +FileSpec::FileSpec(const FileSpec *rhs) : m_directory(), m_filename() { + if (rhs) + *this = *rhs; } //------------------------------------------------------------------ // Virtual destructor in case anyone inherits from this class. //------------------------------------------------------------------ -FileSpec::~FileSpec() -{ -} +FileSpec::~FileSpec() {} //------------------------------------------------------------------ // Assignment operator. //------------------------------------------------------------------ -const FileSpec& -FileSpec::operator= (const FileSpec& rhs) -{ - if (this != &rhs) - { - m_directory = rhs.m_directory; - m_filename = rhs.m_filename; - m_is_resolved = rhs.m_is_resolved; - m_syntax = rhs.m_syntax; - } - return *this; +const FileSpec &FileSpec::operator=(const FileSpec &rhs) { + if (this != &rhs) { + m_directory = rhs.m_directory; + m_filename = rhs.m_filename; + m_is_resolved = rhs.m_is_resolved; + m_syntax = rhs.m_syntax; + } + return *this; } //------------------------------------------------------------------ @@ -389,66 +331,57 @@ FileSpec::operator= (const FileSpec& rhs) // be split up into a directory and filename and stored as uniqued // string values for quick comparison and efficient memory usage. //------------------------------------------------------------------ -void -FileSpec::SetFile (const char *pathname, bool resolve, PathSyntax syntax) -{ - m_filename.Clear(); - m_directory.Clear(); - m_is_resolved = false; - m_syntax = (syntax == ePathSyntaxHostNative) ? FileSystem::GetNativePathSyntax() : syntax; - - if (pathname == NULL || pathname[0] == '\0') - return; - - llvm::SmallString<64> resolved(pathname); - - if (resolve) - { - FileSpec::Resolve (resolved); - m_is_resolved = true; - } +void FileSpec::SetFile(llvm::StringRef pathname, bool resolve, + PathSyntax syntax) { + // CLEANUP: Use StringRef for string handling. This function is kind of a + // mess and the unclear semantics of RootDirStart and ParentPathEnd make + // it very difficult to understand this function. There's no reason this + // function should be particularly complicated or difficult to understand. + m_filename.Clear(); + m_directory.Clear(); + m_is_resolved = false; + m_syntax = (syntax == ePathSyntaxHostNative) + ? FileSystem::GetNativePathSyntax() + : syntax; + + if (pathname.empty()) + return; - Normalize(resolved, syntax); + llvm::SmallString<64> resolved(pathname); - llvm::StringRef resolve_path_ref(resolved.c_str()); - size_t dir_end = ParentPathEnd(resolve_path_ref, syntax); - if (dir_end == 0) - { - m_filename.SetString(resolve_path_ref); - return; - } + if (resolve) { + FileSpec::Resolve(resolved); + m_is_resolved = true; + } - m_directory.SetString(resolve_path_ref.substr(0, dir_end)); + Normalize(resolved, m_syntax); - size_t filename_begin = dir_end; - size_t root_dir_start = RootDirStart(resolve_path_ref, syntax); - while (filename_begin != llvm::StringRef::npos && filename_begin < resolve_path_ref.size() && - filename_begin != root_dir_start && IsPathSeparator(resolve_path_ref[filename_begin], syntax)) - ++filename_begin; - m_filename.SetString((filename_begin == llvm::StringRef::npos || filename_begin >= resolve_path_ref.size()) - ? "." - : resolve_path_ref.substr(filename_begin)); -} + llvm::StringRef resolve_path_ref(resolved.c_str()); + size_t dir_end = ParentPathEnd(resolve_path_ref, m_syntax); + if (dir_end == 0) { + m_filename.SetString(resolve_path_ref); + return; + } -void -FileSpec::SetFile(const char *pathname, bool resolve, ArchSpec arch) -{ - return SetFile(pathname, resolve, - arch.GetTriple().isOSWindows() - ? ePathSyntaxWindows - : ePathSyntaxPosix); -} + m_directory.SetString(resolve_path_ref.substr(0, dir_end)); -void -FileSpec::SetFile(const std::string &pathname, bool resolve, PathSyntax syntax) -{ - return SetFile(pathname.c_str(), resolve, syntax); + size_t filename_begin = dir_end; + size_t root_dir_start = RootDirStart(resolve_path_ref, m_syntax); + while (filename_begin != llvm::StringRef::npos && + filename_begin < resolve_path_ref.size() && + filename_begin != root_dir_start && + IsPathSeparator(resolve_path_ref[filename_begin], m_syntax)) + ++filename_begin; + m_filename.SetString((filename_begin == llvm::StringRef::npos || + filename_begin >= resolve_path_ref.size()) + ? "." + : resolve_path_ref.substr(filename_begin)); } -void -FileSpec::SetFile(const std::string &pathname, bool resolve, ArchSpec arch) -{ - return SetFile(pathname.c_str(), resolve, arch); +void FileSpec::SetFile(llvm::StringRef path, bool resolve, ArchSpec arch) { + return SetFile(path, resolve, arch.GetTriple().isOSWindows() + ? ePathSyntaxWindows + : ePathSyntaxPosix); } //---------------------------------------------------------------------- @@ -458,10 +391,7 @@ FileSpec::SetFile(const std::string &pathname, bool resolve, ArchSpec arch) // if (file_spec) // {} //---------------------------------------------------------------------- -FileSpec::operator bool() const -{ - return m_filename || m_directory; -} +FileSpec::operator bool() const { return m_filename || m_directory; } //---------------------------------------------------------------------- // Logical NOT operator. This allows code to check any FileSpec @@ -470,123 +400,96 @@ FileSpec::operator bool() const // if (!file_spec) // {} //---------------------------------------------------------------------- -bool -FileSpec::operator!() const -{ - return !m_directory && !m_filename; -} +bool FileSpec::operator!() const { return !m_directory && !m_filename; } -bool -FileSpec::DirectoryEquals(const FileSpec &rhs) const -{ - const bool case_sensitive = IsCaseSensitive() || rhs.IsCaseSensitive(); - return ConstString::Equals(m_directory, rhs.m_directory, case_sensitive); +bool FileSpec::DirectoryEquals(const FileSpec &rhs) const { + const bool case_sensitive = IsCaseSensitive() || rhs.IsCaseSensitive(); + return ConstString::Equals(m_directory, rhs.m_directory, case_sensitive); } -bool -FileSpec::FileEquals(const FileSpec &rhs) const -{ - const bool case_sensitive = IsCaseSensitive() || rhs.IsCaseSensitive(); - return ConstString::Equals(m_filename, rhs.m_filename, case_sensitive); +bool FileSpec::FileEquals(const FileSpec &rhs) const { + const bool case_sensitive = IsCaseSensitive() || rhs.IsCaseSensitive(); + return ConstString::Equals(m_filename, rhs.m_filename, case_sensitive); } //------------------------------------------------------------------ // Equal to operator //------------------------------------------------------------------ -bool -FileSpec::operator== (const FileSpec& rhs) const -{ - if (!FileEquals(rhs)) - return false; - if (DirectoryEquals(rhs)) - return true; - - // TODO: determine if we want to keep this code in here. - // The code below was added to handle a case where we were - // trying to set a file and line breakpoint and one path - // was resolved, and the other not and the directory was - // in a mount point that resolved to a more complete path: - // "/tmp/a.c" == "/private/tmp/a.c". I might end up pulling - // this out... - if (IsResolved() && rhs.IsResolved()) - { - // Both paths are resolved, no need to look further... - return false; - } - - FileSpec resolved_lhs(*this); - - // If "this" isn't resolved, resolve it - if (!IsResolved()) - { - if (resolved_lhs.ResolvePath()) - { - // This path wasn't resolved but now it is. Check if the resolved - // directory is the same as our unresolved directory, and if so, - // we can mark this object as resolved to avoid more future resolves - m_is_resolved = (m_directory == resolved_lhs.m_directory); - } - else - return false; - } - - FileSpec resolved_rhs(rhs); - if (!rhs.IsResolved()) - { - if (resolved_rhs.ResolvePath()) - { - // rhs's path wasn't resolved but now it is. Check if the resolved - // directory is the same as rhs's unresolved directory, and if so, - // we can mark this object as resolved to avoid more future resolves - rhs.m_is_resolved = (rhs.m_directory == resolved_rhs.m_directory); - } - else - return false; - } - - // If we reach this point in the code we were able to resolve both paths - // and since we only resolve the paths if the basenames are equal, then - // we can just check if both directories are equal... - return DirectoryEquals(rhs); +bool FileSpec::operator==(const FileSpec &rhs) const { + if (!FileEquals(rhs)) + return false; + if (DirectoryEquals(rhs)) + return true; + + // TODO: determine if we want to keep this code in here. + // The code below was added to handle a case where we were + // trying to set a file and line breakpoint and one path + // was resolved, and the other not and the directory was + // in a mount point that resolved to a more complete path: + // "/tmp/a.c" == "/private/tmp/a.c". I might end up pulling + // this out... + if (IsResolved() && rhs.IsResolved()) { + // Both paths are resolved, no need to look further... + return false; + } + + FileSpec resolved_lhs(*this); + + // If "this" isn't resolved, resolve it + if (!IsResolved()) { + if (resolved_lhs.ResolvePath()) { + // This path wasn't resolved but now it is. Check if the resolved + // directory is the same as our unresolved directory, and if so, + // we can mark this object as resolved to avoid more future resolves + m_is_resolved = (m_directory == resolved_lhs.m_directory); + } else + return false; + } + + FileSpec resolved_rhs(rhs); + if (!rhs.IsResolved()) { + if (resolved_rhs.ResolvePath()) { + // rhs's path wasn't resolved but now it is. Check if the resolved + // directory is the same as rhs's unresolved directory, and if so, + // we can mark this object as resolved to avoid more future resolves + rhs.m_is_resolved = (rhs.m_directory == resolved_rhs.m_directory); + } else + return false; + } + + // If we reach this point in the code we were able to resolve both paths + // and since we only resolve the paths if the basenames are equal, then + // we can just check if both directories are equal... + return DirectoryEquals(rhs); } //------------------------------------------------------------------ // Not equal to operator //------------------------------------------------------------------ -bool -FileSpec::operator!= (const FileSpec& rhs) const -{ - return !(*this == rhs); -} +bool FileSpec::operator!=(const FileSpec &rhs) const { return !(*this == rhs); } //------------------------------------------------------------------ // Less than operator //------------------------------------------------------------------ -bool -FileSpec::operator< (const FileSpec& rhs) const -{ - return FileSpec::Compare(*this, rhs, true) < 0; +bool FileSpec::operator<(const FileSpec &rhs) const { + return FileSpec::Compare(*this, rhs, true) < 0; } //------------------------------------------------------------------ // Dump a FileSpec object to a stream //------------------------------------------------------------------ -Stream& -lldb_private::operator << (Stream &s, const FileSpec& f) -{ - f.Dump(&s); - return s; +Stream &lldb_private::operator<<(Stream &s, const FileSpec &f) { + f.Dump(&s); + return s; } //------------------------------------------------------------------ // Clear this object by releasing both the directory and filename // string values and making them both the empty string. //------------------------------------------------------------------ -void -FileSpec::Clear() -{ - m_directory.Clear(); - m_filename.Clear(); +void FileSpec::Clear() { + m_directory.Clear(); + m_filename.Clear(); } //------------------------------------------------------------------ @@ -600,166 +503,102 @@ FileSpec::Clear() // Return -1 if the "a" is less than "b", 0 if "a" is equal to "b" // and "1" if "a" is greater than "b". //------------------------------------------------------------------ -int -FileSpec::Compare(const FileSpec& a, const FileSpec& b, bool full) -{ - int result = 0; - - // case sensitivity of compare - const bool case_sensitive = a.IsCaseSensitive() || b.IsCaseSensitive(); - - // If full is true, then we must compare both the directory and filename. - - // If full is false, then if either directory is empty, then we match on - // the basename only, and if both directories have valid values, we still - // do a full compare. This allows for matching when we just have a filename - // in one of the FileSpec objects. - - if (full || (a.m_directory && b.m_directory)) - { - result = ConstString::Compare(a.m_directory, b.m_directory, case_sensitive); - if (result) - return result; - } - return ConstString::Compare(a.m_filename, b.m_filename, case_sensitive); -} +int FileSpec::Compare(const FileSpec &a, const FileSpec &b, bool full) { + int result = 0; -bool -FileSpec::Equal (const FileSpec& a, const FileSpec& b, bool full, bool remove_backups) -{ - // case sensitivity of equality test - const bool case_sensitive = a.IsCaseSensitive() || b.IsCaseSensitive(); - - if (!full && (a.GetDirectory().IsEmpty() || b.GetDirectory().IsEmpty())) - return ConstString::Equals(a.m_filename, b.m_filename, case_sensitive); - else if (remove_backups == false) - return a == b; - else - { - if (!ConstString::Equals(a.m_filename, b.m_filename, case_sensitive)) - return false; - if (ConstString::Equals(a.m_directory, b.m_directory, case_sensitive)) - return true; - ConstString a_without_dots; - ConstString b_without_dots; + // case sensitivity of compare + const bool case_sensitive = a.IsCaseSensitive() || b.IsCaseSensitive(); - RemoveBackupDots (a.m_directory, a_without_dots); - RemoveBackupDots (b.m_directory, b_without_dots); - return ConstString::Equals(a_without_dots, b_without_dots, case_sensitive); - } + // If full is true, then we must compare both the directory and filename. + + // If full is false, then if either directory is empty, then we match on + // the basename only, and if both directories have valid values, we still + // do a full compare. This allows for matching when we just have a filename + // in one of the FileSpec objects. + + if (full || (a.m_directory && b.m_directory)) { + result = ConstString::Compare(a.m_directory, b.m_directory, case_sensitive); + if (result) + return result; + } + return ConstString::Compare(a.m_filename, b.m_filename, case_sensitive); } -void -FileSpec::NormalizePath () -{ - ConstString normalized_directory; - FileSpec::RemoveBackupDots(m_directory, normalized_directory); - m_directory = normalized_directory; +bool FileSpec::Equal(const FileSpec &a, const FileSpec &b, bool full, + bool remove_backups) { + // case sensitivity of equality test + const bool case_sensitive = a.IsCaseSensitive() || b.IsCaseSensitive(); + + if (!full && (a.GetDirectory().IsEmpty() || b.GetDirectory().IsEmpty())) + return ConstString::Equals(a.m_filename, b.m_filename, case_sensitive); + + if (remove_backups == false) + return a == b; + + if (a == b) + return true; + + return Equal(a.GetNormalizedPath(), b.GetNormalizedPath(), full, false); } -void -FileSpec::RemoveBackupDots (const ConstString &input_const_str, ConstString &result_const_str) -{ - const char *input = input_const_str.GetCString(); - result_const_str.Clear(); - if (!input || input[0] == '\0') - return; +FileSpec FileSpec::GetNormalizedPath() const { + // Fast path. Do nothing if the path is not interesting. + if (!m_directory.GetStringRef().contains(".") && + !m_directory.GetStringRef().contains("//") && + m_filename.GetStringRef() != ".." && m_filename.GetStringRef() != ".") + return *this; - const char win_sep = '\\'; - const char unix_sep = '/'; - char found_sep; - const char *win_backup = "\\.."; - const char *unix_backup = "/.."; - - bool is_win = false; - - // Determine the platform for the path (win or unix): - - if (input[0] == win_sep) - is_win = true; - else if (input[0] == unix_sep) - is_win = false; - else if (input[1] == ':') - is_win = true; - else if (strchr(input, unix_sep) != nullptr) - is_win = false; - else if (strchr(input, win_sep) != nullptr) - is_win = true; - else - { - // No separators at all, no reason to do any work here. - result_const_str = input_const_str; - return; + llvm::SmallString<64> path, result; + const bool normalize = false; + GetPath(path, normalize); + llvm::StringRef rest(path); + + // We will not go below root dir. + size_t root_dir_start = RootDirStart(path, m_syntax); + const bool absolute = root_dir_start != llvm::StringRef::npos; + if (absolute) { + result += rest.take_front(root_dir_start + 1); + rest = rest.drop_front(root_dir_start + 1); + } else { + if (m_syntax == ePathSyntaxWindows && path.size() > 2 && path[1] == ':') { + result += rest.take_front(2); + rest = rest.drop_front(2); } - - llvm::StringRef backup_sep; - if (is_win) - { - found_sep = win_sep; - backup_sep = win_backup; + } + + bool anything_added = false; + llvm::SmallVector<llvm::StringRef, 0> components, processed; + rest.split(components, '/', -1, false); + processed.reserve(components.size()); + for (auto component : components) { + if (component == ".") + continue; // Skip these. + if (component != "..") { + processed.push_back(component); + continue; // Regular file name. } - else - { - found_sep = unix_sep; - backup_sep = unix_backup; + if (!processed.empty()) { + processed.pop_back(); + continue; // Dots. Go one level up if we can. } - - llvm::StringRef input_ref(input); - llvm::StringRef curpos(input); - - bool had_dots = false; - std::string result; - - while (1) - { - // Start of loop - llvm::StringRef before_sep; - std::pair<llvm::StringRef, llvm::StringRef> around_sep = curpos.split(backup_sep); - - before_sep = around_sep.first; - curpos = around_sep.second; - - if (curpos.empty()) - { - if (had_dots) - { - while (before_sep.startswith("//")) - before_sep = before_sep.substr(1); - if (!before_sep.empty()) - { - result.append(before_sep.data(), before_sep.size()); - } - } - break; - } - had_dots = true; - - unsigned num_backups = 1; - while (curpos.startswith(backup_sep)) - { - num_backups++; - curpos = curpos.slice(backup_sep.size(), curpos.size()); - } - - size_t end_pos = before_sep.size(); - while (num_backups-- > 0) - { - end_pos = before_sep.rfind(found_sep, end_pos); - if (end_pos == llvm::StringRef::npos) - { - result_const_str = input_const_str; - return; - } - } - result.append(before_sep.data(), end_pos); - } - - if (had_dots) - result_const_str.SetCString(result.c_str()); - else - result_const_str = input_const_str; - - return; + if (absolute) + continue; // We're at the top level. Cannot go higher than that. Skip. + + result += component; // We're a relative path. We need to keep these. + result += '/'; + anything_added = true; + } + for (auto component : processed) { + result += component; + result += '/'; + anything_added = true; + } + if (anything_added) + result.pop_back(); // Pop last '/'. + else if (result.empty()) + result = "."; + + return FileSpec(result, false, m_syntax); } //------------------------------------------------------------------ @@ -767,279 +606,223 @@ FileSpec::RemoveBackupDots (const ConstString &input_const_str, ConstString &res // a valid directory name, it will be displayed followed by a // directory delimiter, and the filename. //------------------------------------------------------------------ -void -FileSpec::Dump(Stream *s) const -{ - if (s) - { - std::string path{GetPath(true)}; - s->PutCString(path.c_str()); - char path_separator = GetPrefferedPathSeparator(m_syntax); - if (!m_filename && !path.empty() && path.back() != path_separator) - s->PutChar(path_separator); - } +void FileSpec::Dump(Stream *s) const { + if (s) { + std::string path{GetPath(true)}; + s->PutCString(path); + char path_separator = GetPreferredPathSeparator(m_syntax); + if (!m_filename && !path.empty() && path.back() != path_separator) + s->PutChar(path_separator); + } } //------------------------------------------------------------------ // Returns true if the file exists. //------------------------------------------------------------------ -bool -FileSpec::Exists () const -{ - struct stat file_stats; - return GetFileStats (this, &file_stats); -} - -bool -FileSpec::Readable () const -{ - const uint32_t permissions = GetPermissions(); - if (permissions & eFilePermissionsEveryoneR) - return true; - return false; -} - -bool -FileSpec::ResolveExecutableLocation () -{ - if (!m_directory) - { - const char *file_cstr = m_filename.GetCString(); - if (file_cstr) - { - const std::string file_str (file_cstr); - llvm::ErrorOr<std::string> error_or_path = llvm::sys::findProgramByName (file_str); - if (!error_or_path) - return false; - std::string path = error_or_path.get(); - llvm::StringRef dir_ref = llvm::sys::path::parent_path(path); - if (!dir_ref.empty()) - { - // FindProgramByName returns "." if it can't find the file. - if (strcmp (".", dir_ref.data()) == 0) - return false; - - m_directory.SetCString (dir_ref.data()); - if (Exists()) - return true; - else - { - // If FindProgramByName found the file, it returns the directory + filename in its return results. - // We need to separate them. - FileSpec tmp_file (dir_ref.data(), false); - if (tmp_file.Exists()) - { - m_directory = tmp_file.m_directory; - return true; - } - } - } +bool FileSpec::Exists() const { + struct stat file_stats; + return GetFileStats(this, &file_stats); +} + +bool FileSpec::Readable() const { + const uint32_t permissions = GetPermissions(); + if (permissions & eFilePermissionsEveryoneR) + return true; + return false; +} + +bool FileSpec::ResolveExecutableLocation() { + // CLEANUP: Use StringRef for string handling. + if (!m_directory) { + const char *file_cstr = m_filename.GetCString(); + if (file_cstr) { + const std::string file_str(file_cstr); + llvm::ErrorOr<std::string> error_or_path = + llvm::sys::findProgramByName(file_str); + if (!error_or_path) + return false; + std::string path = error_or_path.get(); + llvm::StringRef dir_ref = llvm::sys::path::parent_path(path); + if (!dir_ref.empty()) { + // FindProgramByName returns "." if it can't find the file. + if (strcmp(".", dir_ref.data()) == 0) + return false; + + m_directory.SetCString(dir_ref.data()); + if (Exists()) + return true; + else { + // If FindProgramByName found the file, it returns the directory + + // filename in its return results. + // We need to separate them. + FileSpec tmp_file(dir_ref.data(), false); + if (tmp_file.Exists()) { + m_directory = tmp_file.m_directory; + return true; + } } + } } - - return false; + } + + return false; } -bool -FileSpec::ResolvePath () -{ - if (m_is_resolved) - return true; // We have already resolved this path +bool FileSpec::ResolvePath() { + if (m_is_resolved) + return true; // We have already resolved this path - char path_buf[PATH_MAX]; - if (!GetPath (path_buf, PATH_MAX, false)) - return false; - // SetFile(...) will set m_is_resolved correctly if it can resolve the path - SetFile (path_buf, true); - return m_is_resolved; + char path_buf[PATH_MAX]; + if (!GetPath(path_buf, PATH_MAX, false)) + return false; + // SetFile(...) will set m_is_resolved correctly if it can resolve the path + SetFile(path_buf, true); + return m_is_resolved; } -uint64_t -FileSpec::GetByteSize() const -{ - struct stat file_stats; - if (GetFileStats (this, &file_stats)) - return file_stats.st_size; - return 0; +uint64_t FileSpec::GetByteSize() const { + struct stat file_stats; + if (GetFileStats(this, &file_stats)) + return file_stats.st_size; + return 0; } -FileSpec::PathSyntax -FileSpec::GetPathSyntax() const -{ - return m_syntax; -} +FileSpec::PathSyntax FileSpec::GetPathSyntax() const { return m_syntax; } -FileSpec::FileType -FileSpec::GetFileType () const -{ - struct stat file_stats; - if (GetFileStats (this, &file_stats)) - { - mode_t file_type = file_stats.st_mode & S_IFMT; - switch (file_type) - { - case S_IFDIR: return eFileTypeDirectory; - case S_IFREG: return eFileTypeRegular; +FileSpec::FileType FileSpec::GetFileType() const { + struct stat file_stats; + if (GetFileStats(this, &file_stats)) { + mode_t file_type = file_stats.st_mode & S_IFMT; + switch (file_type) { + case S_IFDIR: + return eFileTypeDirectory; + case S_IFREG: + return eFileTypeRegular; #ifndef _WIN32 - case S_IFIFO: return eFileTypePipe; - case S_IFSOCK: return eFileTypeSocket; - case S_IFLNK: return eFileTypeSymbolicLink; + case S_IFIFO: + return eFileTypePipe; + case S_IFSOCK: + return eFileTypeSocket; + case S_IFLNK: + return eFileTypeSymbolicLink; #endif - default: - break; - } - return eFileTypeUnknown; + default: + break; } - return eFileTypeInvalid; + return eFileTypeUnknown; + } + return eFileTypeInvalid; } -bool -FileSpec::IsSymbolicLink () const -{ - char resolved_path[PATH_MAX]; - if (!GetPath (resolved_path, sizeof (resolved_path))) - return false; +bool FileSpec::IsSymbolicLink() const { + char resolved_path[PATH_MAX]; + if (!GetPath(resolved_path, sizeof(resolved_path))) + return false; #ifdef _WIN32 - std::wstring wpath; - if (!llvm::ConvertUTF8toWide(resolved_path, wpath)) - return false; - auto attrs = ::GetFileAttributesW(wpath.c_str()); - if (attrs == INVALID_FILE_ATTRIBUTES) - return false; + std::wstring wpath; + if (!llvm::ConvertUTF8toWide(resolved_path, wpath)) + return false; + auto attrs = ::GetFileAttributesW(wpath.c_str()); + if (attrs == INVALID_FILE_ATTRIBUTES) + return false; - return (attrs & FILE_ATTRIBUTE_REPARSE_POINT); + return (attrs & FILE_ATTRIBUTE_REPARSE_POINT); #else - struct stat file_stats; - if (::lstat (resolved_path, &file_stats) != 0) - return false; + struct stat file_stats; + if (::lstat(resolved_path, &file_stats) != 0) + return false; - return (file_stats.st_mode & S_IFMT) == S_IFLNK; + return (file_stats.st_mode & S_IFMT) == S_IFLNK; #endif } -uint32_t -FileSpec::GetPermissions () const -{ - uint32_t file_permissions = 0; - if (*this) - FileSystem::GetFilePermissions(*this, file_permissions); - return file_permissions; -} - -TimeValue -FileSpec::GetModificationTime () const -{ - TimeValue mod_time; - struct stat file_stats; - if (GetFileStats (this, &file_stats)) - mod_time.OffsetWithSeconds(file_stats.st_mtime); - return mod_time; +uint32_t FileSpec::GetPermissions() const { + uint32_t file_permissions = 0; + if (*this) + FileSystem::GetFilePermissions(*this, file_permissions); + return file_permissions; } //------------------------------------------------------------------ // Directory string get accessor. //------------------------------------------------------------------ -ConstString & -FileSpec::GetDirectory() -{ - return m_directory; -} +ConstString &FileSpec::GetDirectory() { return m_directory; } //------------------------------------------------------------------ // Directory string const get accessor. //------------------------------------------------------------------ -const ConstString & -FileSpec::GetDirectory() const -{ - return m_directory; -} +const ConstString &FileSpec::GetDirectory() const { return m_directory; } //------------------------------------------------------------------ // Filename string get accessor. //------------------------------------------------------------------ -ConstString & -FileSpec::GetFilename() -{ - return m_filename; -} +ConstString &FileSpec::GetFilename() { return m_filename; } //------------------------------------------------------------------ // Filename string const get accessor. //------------------------------------------------------------------ -const ConstString & -FileSpec::GetFilename() const -{ - return m_filename; -} +const ConstString &FileSpec::GetFilename() const { return m_filename; } //------------------------------------------------------------------ // Extract the directory and path into a fixed buffer. This is // needed as the directory and path are stored in separate string // values. //------------------------------------------------------------------ -size_t -FileSpec::GetPath(char *path, size_t path_max_len, bool denormalize) const -{ - if (!path) - return 0; - - std::string result = GetPath(denormalize); - ::snprintf(path, path_max_len, "%s", result.c_str()); - return std::min(path_max_len-1, result.length()); -} +size_t FileSpec::GetPath(char *path, size_t path_max_len, + bool denormalize) const { + if (!path) + return 0; -std::string -FileSpec::GetPath(bool denormalize) const -{ - llvm::SmallString<64> result; - GetPath(result, denormalize); - return std::string(result.begin(), result.end()); + std::string result = GetPath(denormalize); + ::snprintf(path, path_max_len, "%s", result.c_str()); + return std::min(path_max_len - 1, result.length()); } -const char * -FileSpec::GetCString(bool denormalize) const -{ - return ConstString{GetPath(denormalize)}.AsCString(NULL); +std::string FileSpec::GetPath(bool denormalize) const { + llvm::SmallString<64> result; + GetPath(result, denormalize); + return std::string(result.begin(), result.end()); } -void -FileSpec::GetPath(llvm::SmallVectorImpl<char> &path, bool denormalize) const -{ - path.append(m_directory.GetStringRef().begin(), m_directory.GetStringRef().end()); - if (m_directory && m_filename && !IsPathSeparator(m_directory.GetStringRef().back(), m_syntax)) - path.insert(path.end(), GetPrefferedPathSeparator(m_syntax)); - path.append(m_filename.GetStringRef().begin(), m_filename.GetStringRef().end()); - Normalize(path, m_syntax); - if (denormalize && !path.empty()) - Denormalize(path, m_syntax); +const char *FileSpec::GetCString(bool denormalize) const { + return ConstString{GetPath(denormalize)}.AsCString(NULL); } -ConstString -FileSpec::GetFileNameExtension () const -{ - if (m_filename) - { - const char *filename = m_filename.GetCString(); - const char* dot_pos = strrchr(filename, '.'); - if (dot_pos && dot_pos[1] != '\0') - return ConstString(dot_pos+1); - } - return ConstString(); +void FileSpec::GetPath(llvm::SmallVectorImpl<char> &path, + bool denormalize) const { + path.append(m_directory.GetStringRef().begin(), + m_directory.GetStringRef().end()); + if (m_directory && m_filename && + !IsPathSeparator(m_directory.GetStringRef().back(), m_syntax)) + path.insert(path.end(), GetPreferredPathSeparator(m_syntax)); + path.append(m_filename.GetStringRef().begin(), + m_filename.GetStringRef().end()); + Normalize(path, m_syntax); + if (denormalize && !path.empty()) + Denormalize(path, m_syntax); } -ConstString -FileSpec::GetFileNameStrippingExtension () const -{ +ConstString FileSpec::GetFileNameExtension() const { + if (m_filename) { const char *filename = m_filename.GetCString(); - if (filename == NULL) - return ConstString(); - - const char* dot_pos = strrchr(filename, '.'); - if (dot_pos == NULL) - return m_filename; - - return ConstString(filename, dot_pos-filename); + const char *dot_pos = strrchr(filename, '.'); + if (dot_pos && dot_pos[1] != '\0') + return ConstString(dot_pos + 1); + } + return ConstString(); +} + +ConstString FileSpec::GetFileNameStrippingExtension() const { + const char *filename = m_filename.GetCString(); + if (filename == NULL) + return ConstString(); + + const char *dot_pos = strrchr(filename, '.'); + if (dot_pos == NULL) + return m_filename; + + return ConstString(filename, dot_pos - filename); } //------------------------------------------------------------------ @@ -1053,66 +836,56 @@ FileSpec::GetFileNameStrippingExtension () const // truncated. The final number of bytes that get mapped can be // verified using the DataBuffer::GetByteSize() function. //------------------------------------------------------------------ -DataBufferSP -FileSpec::MemoryMapFileContents(off_t file_offset, size_t file_size) const -{ - DataBufferSP data_sp; - std::unique_ptr<DataBufferMemoryMap> mmap_data(new DataBufferMemoryMap()); - if (mmap_data.get()) - { - const size_t mapped_length = mmap_data->MemoryMapFromFileSpec (this, file_offset, file_size); - if (((file_size == SIZE_MAX) && (mapped_length > 0)) || (mapped_length >= file_size)) - data_sp.reset(mmap_data.release()); - } - return data_sp; +DataBufferSP FileSpec::MemoryMapFileContents(off_t file_offset, + size_t file_size) const { + DataBufferSP data_sp; + std::unique_ptr<DataBufferMemoryMap> mmap_data(new DataBufferMemoryMap()); + if (mmap_data.get()) { + const size_t mapped_length = + mmap_data->MemoryMapFromFileSpec(this, file_offset, file_size); + if (((file_size == SIZE_MAX) && (mapped_length > 0)) || + (mapped_length >= file_size)) + data_sp.reset(mmap_data.release()); + } + return data_sp; +} + +DataBufferSP FileSpec::MemoryMapFileContentsIfLocal(off_t file_offset, + size_t file_size) const { + if (FileSystem::IsLocal(*this)) + return MemoryMapFileContents(file_offset, file_size); + else + return ReadFileContents(file_offset, file_size, NULL); } -DataBufferSP -FileSpec::MemoryMapFileContentsIfLocal(off_t file_offset, size_t file_size) const -{ - if (FileSystem::IsLocal(*this)) - return MemoryMapFileContents(file_offset, file_size); - else - return ReadFileContents(file_offset, file_size, NULL); -} - - //------------------------------------------------------------------ // Return the size in bytes that this object takes in memory. This // returns the size in bytes of this object, not any shared string // values it may refer to. //------------------------------------------------------------------ -size_t -FileSpec::MemorySize() const -{ - return m_filename.MemorySize() + m_directory.MemorySize(); -} - - -size_t -FileSpec::ReadFileContents (off_t file_offset, void *dst, size_t dst_len, Error *error_ptr) const -{ - Error error; - size_t bytes_read = 0; - char resolved_path[PATH_MAX]; - if (GetPath(resolved_path, sizeof(resolved_path))) - { - File file; - error = file.Open(resolved_path, File::eOpenOptionRead); - if (error.Success()) - { - off_t file_offset_after_seek = file_offset; - bytes_read = dst_len; - error = file.Read(dst, bytes_read, file_offset_after_seek); - } - } - else - { - error.SetErrorString("invalid file specification"); +size_t FileSpec::MemorySize() const { + return m_filename.MemorySize() + m_directory.MemorySize(); +} + +size_t FileSpec::ReadFileContents(off_t file_offset, void *dst, size_t dst_len, + Error *error_ptr) const { + Error error; + size_t bytes_read = 0; + char resolved_path[PATH_MAX]; + if (GetPath(resolved_path, sizeof(resolved_path))) { + File file; + error = file.Open(resolved_path, File::eOpenOptionRead); + if (error.Success()) { + off_t file_offset_after_seek = file_offset; + bytes_read = dst_len; + error = file.Read(dst, bytes_read, file_offset_after_seek); } - if (error_ptr) - *error_ptr = error; - return bytes_read; + } else { + error.SetErrorString("invalid file specification"); + } + if (error_ptr) + *error_ptr = error; + return bytes_read; } //------------------------------------------------------------------ @@ -1126,486 +899,441 @@ FileSpec::ReadFileContents (off_t file_offset, void *dst, size_t dst_len, Error // truncated. The final number of bytes that get mapped can be // verified using the DataBuffer::GetByteSize() function. //------------------------------------------------------------------ -DataBufferSP -FileSpec::ReadFileContents (off_t file_offset, size_t file_size, Error *error_ptr) const -{ - Error error; - DataBufferSP data_sp; - char resolved_path[PATH_MAX]; - if (GetPath(resolved_path, sizeof(resolved_path))) - { - File file; - error = file.Open(resolved_path, File::eOpenOptionRead); - if (error.Success()) - { - const bool null_terminate = false; - error = file.Read (file_size, file_offset, null_terminate, data_sp); - } +DataBufferSP FileSpec::ReadFileContents(off_t file_offset, size_t file_size, + Error *error_ptr) const { + Error error; + DataBufferSP data_sp; + char resolved_path[PATH_MAX]; + if (GetPath(resolved_path, sizeof(resolved_path))) { + File file; + error = file.Open(resolved_path, File::eOpenOptionRead); + if (error.Success()) { + const bool null_terminate = false; + error = file.Read(file_size, file_offset, null_terminate, data_sp); + } + } else { + error.SetErrorString("invalid file specification"); + } + if (error_ptr) + *error_ptr = error; + return data_sp; +} + +DataBufferSP FileSpec::ReadFileContentsAsCString(Error *error_ptr) { + Error error; + DataBufferSP data_sp; + char resolved_path[PATH_MAX]; + if (GetPath(resolved_path, sizeof(resolved_path))) { + File file; + error = file.Open(resolved_path, File::eOpenOptionRead); + if (error.Success()) { + off_t offset = 0; + size_t length = SIZE_MAX; + const bool null_terminate = true; + error = file.Read(length, offset, null_terminate, data_sp); } - else - { - error.SetErrorString("invalid file specification"); + } else { + error.SetErrorString("invalid file specification"); + } + if (error_ptr) + *error_ptr = error; + return data_sp; +} + +size_t FileSpec::ReadFileLines(STLStringArray &lines) { + lines.clear(); + char path[PATH_MAX]; + if (GetPath(path, sizeof(path))) { + std::ifstream file_stream(path); + + if (file_stream) { + std::string line; + while (getline(file_stream, line)) + lines.push_back(line); } - if (error_ptr) - *error_ptr = error; - return data_sp; + } + return lines.size(); } -DataBufferSP -FileSpec::ReadFileContentsAsCString(Error *error_ptr) -{ - Error error; - DataBufferSP data_sp; - char resolved_path[PATH_MAX]; - if (GetPath(resolved_path, sizeof(resolved_path))) - { - File file; - error = file.Open(resolved_path, File::eOpenOptionRead); - if (error.Success()) - { - off_t offset = 0; - size_t length = SIZE_MAX; - const bool null_terminate = true; - error = file.Read (length, offset, null_terminate, data_sp); - } +FileSpec::EnumerateDirectoryResult +FileSpec::ForEachItemInDirectory(llvm::StringRef dir_path, + DirectoryCallback const &callback) { + if (dir_path.empty()) + return eEnumerateDirectoryResultNext; + +#ifdef _WIN32 + std::string szDir(dir_path); + szDir += "\\*"; + + std::wstring wszDir; + if (!llvm::ConvertUTF8toWide(szDir, wszDir)) { + return eEnumerateDirectoryResultNext; } - else - { - error.SetErrorString("invalid file specification"); + + WIN32_FIND_DATAW ffd; + HANDLE hFind = FindFirstFileW(wszDir.c_str(), &ffd); + + if (hFind == INVALID_HANDLE_VALUE) { + return eEnumerateDirectoryResultNext; } - if (error_ptr) - *error_ptr = error; - return data_sp; -} -size_t -FileSpec::ReadFileLines (STLStringArray &lines) -{ - lines.clear(); - char path[PATH_MAX]; - if (GetPath(path, sizeof(path))) - { - std::ifstream file_stream (path); - - if (file_stream) - { - std::string line; - while (getline (file_stream, line)) - lines.push_back (line); + do { + FileSpec::FileType file_type = eFileTypeUnknown; + if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { + size_t len = wcslen(ffd.cFileName); + + if (len == 1 && ffd.cFileName[0] == L'.') + continue; + + if (len == 2 && ffd.cFileName[0] == L'.' && ffd.cFileName[1] == L'.') + continue; + + file_type = eFileTypeDirectory; + } else if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DEVICE) { + file_type = eFileTypeOther; + } else { + file_type = eFileTypeRegular; + } + + std::string fileName; + if (!llvm::convertWideToUTF8(ffd.cFileName, fileName)) { + continue; + } + + std::string child_path = llvm::join_items("\\", dir_path, fileName); + // Don't resolve the file type or path + FileSpec child_path_spec(child_path.data(), false); + + EnumerateDirectoryResult result = callback(file_type, child_path_spec); + + switch (result) { + case eEnumerateDirectoryResultNext: + // Enumerate next entry in the current directory. We just + // exit this switch and will continue enumerating the + // current directory as we currently are... + break; + + case eEnumerateDirectoryResultEnter: // Recurse into the current entry + // if it is a directory or symlink, + // or next if not + if (FileSpec::ForEachItemInDirectory(child_path.data(), callback) == + eEnumerateDirectoryResultQuit) { + // The subdirectory returned Quit, which means to + // stop all directory enumerations at all levels. + return eEnumerateDirectoryResultQuit; } - } - return lines.size(); -} + break; -FileSpec::EnumerateDirectoryResult -FileSpec::ForEachItemInDirectory (const char *dir_path, DirectoryCallback const &callback) -{ - if (dir_path && dir_path[0]) - { -#ifdef _WIN32 - std::string szDir(dir_path); - szDir += "\\*"; + case eEnumerateDirectoryResultExit: // Exit from the current directory + // at the current level. + // Exit from this directory level and tell parent to + // keep enumerating. + return eEnumerateDirectoryResultNext; - std::wstring wszDir; - if (!llvm::ConvertUTF8toWide(szDir, wszDir)) - { - return eEnumerateDirectoryResultNext; + case eEnumerateDirectoryResultQuit: // Stop directory enumerations at + // any level + return eEnumerateDirectoryResultQuit; + } + } while (FindNextFileW(hFind, &ffd) != 0); + + FindClose(hFind); +#else + std::string dir_string(dir_path); + lldb_utility::CleanUp<DIR *, int> dir_path_dir(opendir(dir_string.c_str()), + NULL, closedir); + if (dir_path_dir.is_valid()) { + char dir_path_last_char = dir_path.back(); + + long path_max = fpathconf(dirfd(dir_path_dir.get()), _PC_NAME_MAX); +#if defined(__APPLE_) && defined(__DARWIN_MAXPATHLEN) + if (path_max < __DARWIN_MAXPATHLEN) + path_max = __DARWIN_MAXPATHLEN; +#endif + struct dirent *buf, *dp; + buf = (struct dirent *)malloc(offsetof(struct dirent, d_name) + path_max + + 1); + + while (buf && readdir_r(dir_path_dir.get(), buf, &dp) == 0 && dp) { + // Only search directories + if (dp->d_type == DT_DIR || dp->d_type == DT_UNKNOWN) { + size_t len = strlen(dp->d_name); + + if (len == 1 && dp->d_name[0] == '.') + continue; + + if (len == 2 && dp->d_name[0] == '.' && dp->d_name[1] == '.') + continue; } - WIN32_FIND_DATAW ffd; - HANDLE hFind = FindFirstFileW(wszDir.c_str(), &ffd); + FileSpec::FileType file_type = eFileTypeUnknown; - if (hFind == INVALID_HANDLE_VALUE) - { - return eEnumerateDirectoryResultNext; + switch (dp->d_type) { + default: + case DT_UNKNOWN: + file_type = eFileTypeUnknown; + break; + case DT_FIFO: + file_type = eFileTypePipe; + break; + case DT_CHR: + file_type = eFileTypeOther; + break; + case DT_DIR: + file_type = eFileTypeDirectory; + break; + case DT_BLK: + file_type = eFileTypeOther; + break; + case DT_REG: + file_type = eFileTypeRegular; + break; + case DT_LNK: + file_type = eFileTypeSymbolicLink; + break; + case DT_SOCK: + file_type = eFileTypeSocket; + break; +#if !defined(__OpenBSD__) + case DT_WHT: + file_type = eFileTypeOther; + break; +#endif } - do - { - FileSpec::FileType file_type = eFileTypeUnknown; - if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) - { - size_t len = wcslen(ffd.cFileName); + std::string child_path; + // Don't make paths with "/foo//bar", that just confuses everybody. + if (dir_path_last_char == '/') + child_path = llvm::join_items("", dir_path, dp->d_name); + else + child_path = llvm::join_items('/', dir_path, dp->d_name); - if (len == 1 && ffd.cFileName[0] == L'.') - continue; + // Don't resolve the file type or path + FileSpec child_path_spec(child_path, false); - if (len == 2 && ffd.cFileName[0] == L'.' && ffd.cFileName[1] == L'.') - continue; + EnumerateDirectoryResult result = + callback(file_type, child_path_spec); - file_type = eFileTypeDirectory; - } - else if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DEVICE) - { - file_type = eFileTypeOther; - } - else - { - file_type = eFileTypeRegular; - } + switch (result) { + case eEnumerateDirectoryResultNext: + // Enumerate next entry in the current directory. We just + // exit this switch and will continue enumerating the + // current directory as we currently are... + break; - std::string fileName; - if (!llvm::convertWideToUTF8(ffd.cFileName, fileName)) - { - continue; + case eEnumerateDirectoryResultEnter: // Recurse into the current entry + // if it is a directory or + // symlink, or next if not + if (FileSpec::ForEachItemInDirectory(child_path, callback) == + eEnumerateDirectoryResultQuit) { + // The subdirectory returned Quit, which means to + // stop all directory enumerations at all levels. + if (buf) + free(buf); + return eEnumerateDirectoryResultQuit; } + break; - std::vector<char> child_path(PATH_MAX); - const int child_path_len = - ::snprintf(child_path.data(), child_path.size(), "%s\\%s", dir_path, fileName.c_str()); - if (child_path_len < (int)(child_path.size() - 1)) - { - // Don't resolve the file type or path - FileSpec child_path_spec(child_path.data(), false); - - EnumerateDirectoryResult result = callback (file_type, child_path_spec); - - switch (result) - { - case eEnumerateDirectoryResultNext: - // Enumerate next entry in the current directory. We just - // exit this switch and will continue enumerating the - // current directory as we currently are... - break; - - case eEnumerateDirectoryResultEnter: // Recurse into the current entry if it is a directory or symlink, or next if not - if (FileSpec::ForEachItemInDirectory(child_path.data(), callback) == - eEnumerateDirectoryResultQuit) - { - // The subdirectory returned Quit, which means to - // stop all directory enumerations at all levels. - return eEnumerateDirectoryResultQuit; - } - break; - - case eEnumerateDirectoryResultExit: // Exit from the current directory at the current level. - // Exit from this directory level and tell parent to - // keep enumerating. - return eEnumerateDirectoryResultNext; - - case eEnumerateDirectoryResultQuit: // Stop directory enumerations at any level - return eEnumerateDirectoryResultQuit; - } - } - } while (FindNextFileW(hFind, &ffd) != 0); + case eEnumerateDirectoryResultExit: // Exit from the current directory + // at the current level. + // Exit from this directory level and tell parent to + // keep enumerating. + if (buf) + free(buf); + return eEnumerateDirectoryResultNext; - FindClose(hFind); -#else - lldb_utility::CleanUp <DIR *, int> dir_path_dir(opendir(dir_path), NULL, closedir); - if (dir_path_dir.is_valid()) - { - char dir_path_last_char = dir_path[strlen(dir_path) - 1]; - - long path_max = fpathconf (dirfd (dir_path_dir.get()), _PC_NAME_MAX); -#if defined (__APPLE_) && defined (__DARWIN_MAXPATHLEN) - if (path_max < __DARWIN_MAXPATHLEN) - path_max = __DARWIN_MAXPATHLEN; -#endif - struct dirent *buf, *dp; - buf = (struct dirent *) malloc (offsetof (struct dirent, d_name) + path_max + 1); - - while (buf && readdir_r(dir_path_dir.get(), buf, &dp) == 0 && dp) - { - // Only search directories - if (dp->d_type == DT_DIR || dp->d_type == DT_UNKNOWN) - { - size_t len = strlen(dp->d_name); - - if (len == 1 && dp->d_name[0] == '.') - continue; - - if (len == 2 && dp->d_name[0] == '.' && dp->d_name[1] == '.') - continue; - } - - FileSpec::FileType file_type = eFileTypeUnknown; - - switch (dp->d_type) - { - default: - case DT_UNKNOWN: file_type = eFileTypeUnknown; break; - case DT_FIFO: file_type = eFileTypePipe; break; - case DT_CHR: file_type = eFileTypeOther; break; - case DT_DIR: file_type = eFileTypeDirectory; break; - case DT_BLK: file_type = eFileTypeOther; break; - case DT_REG: file_type = eFileTypeRegular; break; - case DT_LNK: file_type = eFileTypeSymbolicLink; break; - case DT_SOCK: file_type = eFileTypeSocket; break; -#if !defined(__OpenBSD__) - case DT_WHT: file_type = eFileTypeOther; break; -#endif - } - - char child_path[PATH_MAX]; - - // Don't make paths with "/foo//bar", that just confuses everybody. - int child_path_len; - if (dir_path_last_char == '/') - child_path_len = ::snprintf (child_path, sizeof(child_path), "%s%s", dir_path, dp->d_name); - else - child_path_len = ::snprintf (child_path, sizeof(child_path), "%s/%s", dir_path, dp->d_name); - - if (child_path_len < (int)(sizeof(child_path) - 1)) - { - // Don't resolve the file type or path - FileSpec child_path_spec (child_path, false); - - EnumerateDirectoryResult result = callback (file_type, child_path_spec); - - switch (result) - { - case eEnumerateDirectoryResultNext: - // Enumerate next entry in the current directory. We just - // exit this switch and will continue enumerating the - // current directory as we currently are... - break; - - case eEnumerateDirectoryResultEnter: // Recurse into the current entry if it is a directory or symlink, or next if not - if (FileSpec::ForEachItemInDirectory (child_path, callback) == eEnumerateDirectoryResultQuit) - { - // The subdirectory returned Quit, which means to - // stop all directory enumerations at all levels. - if (buf) - free (buf); - return eEnumerateDirectoryResultQuit; - } - break; - - case eEnumerateDirectoryResultExit: // Exit from the current directory at the current level. - // Exit from this directory level and tell parent to - // keep enumerating. - if (buf) - free (buf); - return eEnumerateDirectoryResultNext; - - case eEnumerateDirectoryResultQuit: // Stop directory enumerations at any level - if (buf) - free (buf); - return eEnumerateDirectoryResultQuit; - } - } - } + case eEnumerateDirectoryResultQuit: // Stop directory enumerations at + // any level if (buf) - { - free (buf); - } - } -#endif + free(buf); + return eEnumerateDirectoryResultQuit; + } + } + if (buf) { + free(buf); + } } - // By default when exiting a directory, we tell the parent enumeration - // to continue enumerating. - return eEnumerateDirectoryResultNext; +#endif + // By default when exiting a directory, we tell the parent enumeration + // to continue enumerating. + return eEnumerateDirectoryResultNext; } FileSpec::EnumerateDirectoryResult -FileSpec::EnumerateDirectory -( - const char *dir_path, - bool find_directories, - bool find_files, - bool find_other, - EnumerateDirectoryCallbackType callback, - void *callback_baton -) -{ - return ForEachItemInDirectory(dir_path, - [&find_directories, &find_files, &find_other, &callback, &callback_baton] - (FileType file_type, const FileSpec &file_spec) { - switch (file_type) - { - case FileType::eFileTypeDirectory: - if (find_directories) - return callback(callback_baton, file_type, file_spec); - break; - case FileType::eFileTypeRegular: - if (find_files) - return callback(callback_baton, file_type, file_spec); - break; - default: - if (find_other) - return callback(callback_baton, file_type, file_spec); - break; - } - return eEnumerateDirectoryResultNext; - }); -} - -FileSpec -FileSpec::CopyByAppendingPathComponent (const char *new_path) const -{ - FileSpec ret = *this; - ret.AppendPathComponent(new_path); - return ret; +FileSpec::EnumerateDirectory(llvm::StringRef dir_path, bool find_directories, + bool find_files, bool find_other, + EnumerateDirectoryCallbackType callback, + void *callback_baton) { + return ForEachItemInDirectory( + dir_path, + [&find_directories, &find_files, &find_other, &callback, + &callback_baton](FileType file_type, const FileSpec &file_spec) { + switch (file_type) { + case FileType::eFileTypeDirectory: + if (find_directories) + return callback(callback_baton, file_type, file_spec); + break; + case FileType::eFileTypeRegular: + if (find_files) + return callback(callback_baton, file_type, file_spec); + break; + default: + if (find_other) + return callback(callback_baton, file_type, file_spec); + break; + } + return eEnumerateDirectoryResultNext; + }); } FileSpec -FileSpec::CopyByRemovingLastPathComponent () const -{ - const bool resolve = false; - if (m_filename.IsEmpty() && m_directory.IsEmpty()) - return FileSpec("",resolve); - if (m_directory.IsEmpty()) - return FileSpec("",resolve); - if (m_filename.IsEmpty()) - { - const char* dir_cstr = m_directory.GetCString(); - const char* last_slash_ptr = ::strrchr(dir_cstr, '/'); - - // check for obvious cases before doing the full thing - if (!last_slash_ptr) - return FileSpec("",resolve); - if (last_slash_ptr == dir_cstr) - return FileSpec("/",resolve); - - size_t last_slash_pos = last_slash_ptr - dir_cstr+1; - ConstString new_path(dir_cstr,last_slash_pos); - return FileSpec(new_path.GetCString(),resolve); +FileSpec::CopyByAppendingPathComponent(llvm::StringRef component) const { + FileSpec ret = *this; + ret.AppendPathComponent(component); + return ret; +} + +FileSpec FileSpec::CopyByRemovingLastPathComponent() const { + // CLEANUP: Use StringRef for string handling. + const bool resolve = false; + if (m_filename.IsEmpty() && m_directory.IsEmpty()) + return FileSpec("", resolve); + if (m_directory.IsEmpty()) + return FileSpec("", resolve); + if (m_filename.IsEmpty()) { + const char *dir_cstr = m_directory.GetCString(); + const char *last_slash_ptr = ::strrchr(dir_cstr, '/'); + + // check for obvious cases before doing the full thing + if (!last_slash_ptr) + return FileSpec("", resolve); + if (last_slash_ptr == dir_cstr) + return FileSpec("/", resolve); + + size_t last_slash_pos = last_slash_ptr - dir_cstr + 1; + ConstString new_path(dir_cstr, last_slash_pos); + return FileSpec(new_path.GetCString(), resolve); + } else + return FileSpec(m_directory.GetCString(), resolve); +} + +ConstString FileSpec::GetLastPathComponent() const { + // CLEANUP: Use StringRef for string handling. + if (m_filename) + return m_filename; + if (m_directory) { + const char *dir_cstr = m_directory.GetCString(); + const char *last_slash_ptr = ::strrchr(dir_cstr, '/'); + if (last_slash_ptr == NULL) + return m_directory; + if (last_slash_ptr == dir_cstr) { + if (last_slash_ptr[1] == 0) + return ConstString(last_slash_ptr); + else + return ConstString(last_slash_ptr + 1); } - else - return FileSpec(m_directory.GetCString(),resolve); -} - -ConstString -FileSpec::GetLastPathComponent () const -{ - if (m_filename) - return m_filename; - if (m_directory) - { - const char* dir_cstr = m_directory.GetCString(); - const char* last_slash_ptr = ::strrchr(dir_cstr, '/'); - if (last_slash_ptr == NULL) - return m_directory; - if (last_slash_ptr == dir_cstr) - { - if (last_slash_ptr[1] == 0) - return ConstString(last_slash_ptr); - else - return ConstString(last_slash_ptr+1); - } - if (last_slash_ptr[1] != 0) - return ConstString(last_slash_ptr+1); - const char* penultimate_slash_ptr = last_slash_ptr; - while (*penultimate_slash_ptr) - { - --penultimate_slash_ptr; - if (penultimate_slash_ptr == dir_cstr) - break; - if (*penultimate_slash_ptr == '/') - break; - } - ConstString result(penultimate_slash_ptr+1,last_slash_ptr-penultimate_slash_ptr); - return result; + if (last_slash_ptr[1] != 0) + return ConstString(last_slash_ptr + 1); + const char *penultimate_slash_ptr = last_slash_ptr; + while (*penultimate_slash_ptr) { + --penultimate_slash_ptr; + if (penultimate_slash_ptr == dir_cstr) + break; + if (*penultimate_slash_ptr == '/') + break; } - return ConstString(); + ConstString result(penultimate_slash_ptr + 1, + last_slash_ptr - penultimate_slash_ptr); + return result; + } + return ConstString(); } -void -FileSpec::PrependPathComponent(const char *new_path) -{ - if (!new_path) return; - const bool resolve = false; - if (m_filename.IsEmpty() && m_directory.IsEmpty()) - { - SetFile(new_path, resolve); - return; - } - StreamString stream; - if (m_filename.IsEmpty()) - stream.Printf("%s/%s", new_path, m_directory.GetCString()); - else if (m_directory.IsEmpty()) - stream.Printf("%s/%s", new_path, m_filename.GetCString()); - else - stream.Printf("%s/%s/%s", new_path, m_directory.GetCString(), m_filename.GetCString()); - SetFile(stream.GetData(), resolve); -} +void FileSpec::PrependPathComponent(llvm::StringRef component) { + if (component.empty()) + return; + + const bool resolve = false; + if (m_filename.IsEmpty() && m_directory.IsEmpty()) { + SetFile(component, resolve); + return; + } + + char sep = GetPreferredPathSeparator(m_syntax); + std::string result; + if (m_filename.IsEmpty()) + result = llvm::join_items(sep, component, m_directory.GetStringRef()); + else if (m_directory.IsEmpty()) + result = llvm::join_items(sep, component, m_filename.GetStringRef()); + else + result = llvm::join_items(sep, component, m_directory.GetStringRef(), + m_filename.GetStringRef()); -void -FileSpec::PrependPathComponent(const std::string &new_path) -{ - return PrependPathComponent(new_path.c_str()); + SetFile(result, resolve); } -void -FileSpec::PrependPathComponent(const FileSpec &new_path) -{ - return PrependPathComponent(new_path.GetPath(false)); +void FileSpec::PrependPathComponent(const FileSpec &new_path) { + return PrependPathComponent(new_path.GetPath(false)); } -void -FileSpec::AppendPathComponent(const char *new_path) -{ - if (!new_path) return; - - StreamString stream; - if (!m_directory.IsEmpty()) - { - stream.PutCString(m_directory.GetCString()); - if (!IsPathSeparator(m_directory.GetStringRef().back(), m_syntax)) - stream.PutChar(GetPrefferedPathSeparator(m_syntax)); - } +void FileSpec::AppendPathComponent(llvm::StringRef component) { + if (component.empty()) + return; - if (!m_filename.IsEmpty()) - { - stream.PutCString(m_filename.GetCString()); - if (!IsPathSeparator(m_filename.GetStringRef().back(), m_syntax)) - stream.PutChar(GetPrefferedPathSeparator(m_syntax)); - } + std::string result; + if (!m_directory.IsEmpty()) { + result += m_directory.GetStringRef(); + if (!IsPathSeparator(m_directory.GetStringRef().back(), m_syntax)) + result += GetPreferredPathSeparator(m_syntax); + } - stream.PutCString(new_path); + if (!m_filename.IsEmpty()) { + result += m_filename.GetStringRef(); + if (!IsPathSeparator(m_filename.GetStringRef().back(), m_syntax)) + result += GetPreferredPathSeparator(m_syntax); + } - const bool resolve = false; - SetFile(stream.GetData(), resolve, m_syntax); -} + component = component.drop_while( + [this](char c) { return IsPathSeparator(c, m_syntax); }); + + result += component; -void -FileSpec::AppendPathComponent(const std::string &new_path) -{ - return AppendPathComponent(new_path.c_str()); + SetFile(result, false, m_syntax); } -void -FileSpec::AppendPathComponent(const FileSpec &new_path) -{ - return AppendPathComponent(new_path.GetPath(false)); +void FileSpec::AppendPathComponent(const FileSpec &new_path) { + return AppendPathComponent(new_path.GetPath(false)); } -void -FileSpec::RemoveLastPathComponent () -{ - const bool resolve = false; - if (m_filename.IsEmpty() && m_directory.IsEmpty()) - { - SetFile("",resolve); - return; +void FileSpec::RemoveLastPathComponent() { + // CLEANUP: Use StringRef for string handling. + + const bool resolve = false; + if (m_filename.IsEmpty() && m_directory.IsEmpty()) { + SetFile("", resolve); + return; + } + if (m_directory.IsEmpty()) { + SetFile("", resolve); + return; + } + if (m_filename.IsEmpty()) { + const char *dir_cstr = m_directory.GetCString(); + const char *last_slash_ptr = ::strrchr(dir_cstr, '/'); + + // check for obvious cases before doing the full thing + if (!last_slash_ptr) { + SetFile("", resolve); + return; } - if (m_directory.IsEmpty()) - { - SetFile("",resolve); - return; + if (last_slash_ptr == dir_cstr) { + SetFile("/", resolve); + return; } - if (m_filename.IsEmpty()) - { - const char* dir_cstr = m_directory.GetCString(); - const char* last_slash_ptr = ::strrchr(dir_cstr, '/'); - - // check for obvious cases before doing the full thing - if (!last_slash_ptr) - { - SetFile("",resolve); - return; - } - if (last_slash_ptr == dir_cstr) - { - SetFile("/",resolve); - return; - } - size_t last_slash_pos = last_slash_ptr - dir_cstr+1; - ConstString new_path(dir_cstr,last_slash_pos); - SetFile(new_path.GetCString(),resolve); - } - else - SetFile(m_directory.GetCString(),resolve); + size_t last_slash_pos = last_slash_ptr - dir_cstr + 1; + ConstString new_path(dir_cstr, last_slash_pos); + SetFile(new_path.GetCString(), resolve); + } else + SetFile(m_directory.GetCString(), resolve); } //------------------------------------------------------------------ /// Returns true if the filespec represents an implementation source @@ -1616,57 +1344,88 @@ FileSpec::RemoveLastPathComponent () /// \b true if the filespec represents an implementation source /// file, \b false otherwise. //------------------------------------------------------------------ -bool -FileSpec::IsSourceImplementationFile () const -{ - ConstString extension (GetFileNameExtension()); - if (extension) - { - static RegularExpression g_source_file_regex ("^([cC]|[mM]|[mM][mM]|[cC][pP][pP]|[cC]\\+\\+|[cC][xX][xX]|[cC][cC]|[cC][pP]|[sS]|[aA][sS][mM]|[fF]|[fF]77|[fF]90|[fF]95|[fF]03|[fF][oO][rR]|[fF][tT][nN]|[fF][pP][pP]|[aA][dD][aA]|[aA][dD][bB]|[aA][dD][sS])$"); - return g_source_file_regex.Execute (extension.GetCString()); - } +bool FileSpec::IsSourceImplementationFile() const { + ConstString extension(GetFileNameExtension()); + if (!extension) return false; + + static RegularExpression g_source_file_regex(llvm::StringRef( + "^([cC]|[mM]|[mM][mM]|[cC][pP][pP]|[cC]\\+\\+|[cC][xX][xX]|[cC][cC]|[" + "cC][pP]|[sS]|[aA][sS][mM]|[fF]|[fF]77|[fF]90|[fF]95|[fF]03|[fF][oO][" + "rR]|[fF][tT][nN]|[fF][pP][pP]|[aA][dD][aA]|[aA][dD][bB]|[aA][dD][sS])" + "$")); + return g_source_file_regex.Execute(extension.GetStringRef()); } -bool -FileSpec::IsRelative() const -{ - const char *dir = m_directory.GetCString(); - llvm::StringRef directory(dir ? dir : ""); - - if (directory.size() > 0) - { - if (PathSyntaxIsPosix(m_syntax)) - { - // If the path doesn't start with '/' or '~', return true - switch (directory[0]) - { - case '/': - case '~': - return false; - default: - return true; - } - } - else - { - if (directory.size() >= 2 && directory[1] == ':') - return false; - if (directory[0] == '/') - return false; - return true; - } - } - else if (m_filename) - { - // No directory, just a basename, return true +bool FileSpec::IsRelative() const { + const char *dir = m_directory.GetCString(); + llvm::StringRef directory(dir ? dir : ""); + + if (directory.size() > 0) { + if (PathSyntaxIsPosix(m_syntax)) { + // If the path doesn't start with '/' or '~', return true + switch (directory[0]) { + case '/': + case '~': + return false; + default: return true; + } + } else { + if (directory.size() >= 2 && directory[1] == ':') + return false; + if (directory[0] == '/') + return false; + return true; } - return false; + } else if (m_filename) { + // No directory, just a basename, return true + return true; + } + return false; } -bool -FileSpec::IsAbsolute() const -{ - return !FileSpec::IsRelative(); +bool FileSpec::IsAbsolute() const { return !FileSpec::IsRelative(); } + +void llvm::format_provider<FileSpec>::format(const FileSpec &F, + raw_ostream &Stream, + StringRef Style) { + assert( + (Style.empty() || Style.equals_lower("F") || Style.equals_lower("D")) && + "Invalid FileSpec style!"); + + StringRef dir = F.GetDirectory().GetStringRef(); + StringRef file = F.GetFilename().GetStringRef(); + + if (dir.empty() && file.empty()) { + Stream << "(empty)"; + return; + } + + if (Style.equals_lower("F")) { + Stream << (file.empty() ? "(empty)" : file); + return; + } + + // Style is either D or empty, either way we need to print the directory. + if (!dir.empty()) { + // Directory is stored in normalized form, which might be different + // than preferred form. In order to handle this, we need to cut off + // the filename, then denormalize, then write the entire denorm'ed + // directory. + llvm::SmallString<64> denormalized_dir = dir; + Denormalize(denormalized_dir, F.GetPathSyntax()); + Stream << denormalized_dir; + Stream << GetPreferredPathSeparator(F.GetPathSyntax()); + } + + if (Style.equals_lower("D")) { + // We only want to print the directory, so now just exit. + if (dir.empty()) + Stream << "(empty)"; + return; + } + + if (!file.empty()) + Stream << file; } |