maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lldb/source/Utility/FileSpec.cpp

967 lines
32 KiB
C++
Raw Blame History

//===-- FileSpec.cpp --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/TildeExpressionResolver.h"
#include "llvm/ADT/SmallString.h" // for SmallString
#include "llvm/ADT/SmallVector.h" // for SmallVectorTemplat...
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Triple.h" // for Triple
#include "llvm/ADT/Twine.h" // for Twine
#include "llvm/Config/llvm-config.h" // for LLVM_ON_WIN32
#include "llvm/Support/ErrorOr.h" // for ErrorOr
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/Program.h"
#include "llvm/Support/raw_ostream.h" // for raw_ostream, fs
#include <algorithm> // for replace, min, unique
#include <system_error> // for error_code
#include <vector> // for vector
#include <assert.h> // for assert
#include <stdio.h> // for size_t, NULL, snpr...
#include <string.h> // for strcmp
using namespace lldb;
using namespace lldb_private;
namespace {
static constexpr FileSpec::PathSyntax GetNativeSyntax() {
#if defined(LLVM_ON_WIN32)
return FileSpec::ePathSyntaxWindows;
#else
return FileSpec::ePathSyntaxPosix;
#endif
}
bool PathSyntaxIsPosix(FileSpec::PathSyntax syntax) {
return (syntax == FileSpec::ePathSyntaxPosix ||
(syntax == FileSpec::ePathSyntaxHostNative &&
GetNativeSyntax() == FileSpec::ePathSyntaxPosix));
}
const char *GetPathSeparators(FileSpec::PathSyntax syntax) {
return PathSyntaxIsPosix(syntax) ? "/" : "\\/";
}
char GetPreferredPathSeparator(FileSpec::PathSyntax syntax) {
return GetPathSeparators(syntax)[0];
}
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 Denormalize(llvm::SmallVectorImpl<char> &path,
FileSpec::PathSyntax syntax) {
if (PathSyntaxIsPosix(syntax))
return;
std::replace(path.begin(), path.end(), '/', '\\');
}
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;
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 (pos == llvm::StringRef::npos ||
(pos == 1 && IsPathSeparator(str[0], syntax)))
return 0;
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;
// 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 "/"
if (str.size() > 0 && IsPathSeparator(str[0], syntax))
return 0;
return llvm::StringRef::npos;
}
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);
// 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;
if (end_pos == 1 && root_dir_pos == 0 && filename_was_sep)
return llvm::StringRef::npos;
return end_pos;
}
} // end anonymous namespace
void FileSpec::Resolve(llvm::SmallVectorImpl<char> &path) {
if (path.empty())
return;
llvm::SmallString<32> Source(path.begin(), path.end());
StandardTildeExpressionResolver Resolver;
Resolver.ResolveFullPath(Source, path);
// 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());
}
}
FileSpec::FileSpec() : m_syntax(GetNativeSyntax()) {}
//------------------------------------------------------------------
// Default constructor that can take an optional full path to a
// file on disk.
//------------------------------------------------------------------
FileSpec::FileSpec(llvm::StringRef path, bool resolve_path, PathSyntax syntax)
: m_syntax(syntax) {
SetFile(path, resolve_path, syntax);
}
FileSpec::FileSpec(llvm::StringRef path, bool resolve_path,
const llvm::Triple &Triple)
: FileSpec{path, resolve_path,
Triple.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) {}
//------------------------------------------------------------------
// Copy constructor
//------------------------------------------------------------------
FileSpec::FileSpec(const FileSpec *rhs) : m_directory(), m_filename() {
if (rhs)
*this = *rhs;
}
//------------------------------------------------------------------
// Virtual destructor in case anyone inherits from this class.
//------------------------------------------------------------------
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;
}
//------------------------------------------------------------------
// Update the contents of this object with a new path. The path will
// be split up into a directory and filename and stored as uniqued
// string values for quick comparison and efficient memory usage.
//------------------------------------------------------------------
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) ? GetNativeSyntax() : syntax;
if (pathname.empty())
return;
llvm::SmallString<64> resolved(pathname);
if (resolve) {
FileSpec::Resolve(resolved);
m_is_resolved = true;
}
Normalize(resolved, m_syntax);
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;
}
m_directory.SetString(resolve_path_ref.substr(0, dir_end));
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(llvm::StringRef path, bool resolve,
const llvm::Triple &Triple) {
return SetFile(path, resolve,
Triple.isOSWindows() ? ePathSyntaxWindows : ePathSyntaxPosix);
}
//----------------------------------------------------------------------
// Convert to pointer operator. This allows code to check any FileSpec
// objects to see if they contain anything valid using code such as:
//
// if (file_spec)
// {}
//----------------------------------------------------------------------
FileSpec::operator bool() const { return m_filename || m_directory; }
//----------------------------------------------------------------------
// Logical NOT operator. This allows code to check any FileSpec
// objects to see if they are invalid using code such as:
//
// if (!file_spec)
// {}
//----------------------------------------------------------------------
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::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);
}
//------------------------------------------------------------------
// Not equal to operator
//------------------------------------------------------------------
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;
}
//------------------------------------------------------------------
// Dump a FileSpec object to a stream
//------------------------------------------------------------------
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();
}
//------------------------------------------------------------------
// Compare two FileSpec objects. If "full" is true, then both
// the directory and the filename must match. If "full" is false,
// then the directory names for "a" and "b" are only compared if
// they are both non-empty. This allows a FileSpec object to only
// contain a filename and it can match FileSpec objects that have
// matching filenames with different paths.
//
// 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);
}
bool FileSpec::Equal(const FileSpec &a, const FileSpec &b, bool full,
bool remove_backups) {
static ConstString g_dot_string(".");
static ConstString g_dot_dot_string("..");
// case sensitivity of equality test
const bool case_sensitive = a.IsCaseSensitive() || b.IsCaseSensitive();
bool filenames_equal = ConstString::Equals(a.m_filename,
b.m_filename,
case_sensitive);
// The only way two FileSpecs can be equal if their filenames are
// unequal is if we are removing backups and one or the other filename
// is a backup string:
if (!filenames_equal && !remove_backups)
return false;
bool last_component_is_dot = ConstString::Equals(a.m_filename, g_dot_string)
|| ConstString::Equals(a.m_filename,
g_dot_dot_string)
|| ConstString::Equals(b.m_filename,
g_dot_string)
|| ConstString::Equals(b.m_filename,
g_dot_dot_string);
if (!filenames_equal && !last_component_is_dot)
return false;
if (!full && (a.GetDirectory().IsEmpty() || b.GetDirectory().IsEmpty()))
return filenames_equal;
if (remove_backups == false)
return a == b;
if (a == b)
return true;
return Equal(a.GetNormalizedPath(), b.GetNormalizedPath(), full, false);
}
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;
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);
}
}
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.
}
if (!processed.empty()) {
processed.pop_back();
continue; // Dots. Go one level up if we can.
}
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);
}
//------------------------------------------------------------------
// Dump the object to the supplied stream. If the object contains
// 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);
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 { return llvm::sys::fs::exists(GetPath()); }
bool FileSpec::Readable() const {
return GetPermissions() & llvm::sys::fs::perms::all_read;
}
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;
}
bool FileSpec::ResolvePath() {
if (m_is_resolved)
return true; // We have already resolved this path
// SetFile(...) will set m_is_resolved correctly if it can resolve the path
SetFile(GetPath(false), true);
return m_is_resolved;
}
uint64_t FileSpec::GetByteSize() const {
uint64_t Size = 0;
if (llvm::sys::fs::file_size(GetPath(), Size))
return 0;
return Size;
}
FileSpec::PathSyntax FileSpec::GetPathSyntax() const { return m_syntax; }
uint32_t FileSpec::GetPermissions() const {
namespace fs = llvm::sys::fs;
fs::file_status st;
if (fs::status(GetPath(), st, false))
return fs::perms::perms_not_known;
return st.permissions();
}
//------------------------------------------------------------------
// Directory string get accessor.
//------------------------------------------------------------------
ConstString &FileSpec::GetDirectory() { return m_directory; }
//------------------------------------------------------------------
// Directory string const get accessor.
//------------------------------------------------------------------
const ConstString &FileSpec::GetDirectory() const { return m_directory; }
//------------------------------------------------------------------
// Filename string get accessor.
//------------------------------------------------------------------
ConstString &FileSpec::GetFilename() { return m_filename; }
//------------------------------------------------------------------
// Filename string const get accessor.
//------------------------------------------------------------------
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());
}
std::string FileSpec::GetPath(bool denormalize) const {
llvm::SmallString<64> result;
GetPath(result, denormalize);
return std::string(result.begin(), result.end());
}
const char *FileSpec::GetCString(bool denormalize) const {
return ConstString{GetPath(denormalize)}.AsCString(NULL);
}
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::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();
}
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);
}
//------------------------------------------------------------------
// 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();
}
void FileSpec::EnumerateDirectory(llvm::StringRef dir_path,
bool find_directories, bool find_files,
bool find_other,
EnumerateDirectoryCallbackType callback,
void *callback_baton) {
namespace fs = llvm::sys::fs;
std::error_code EC;
fs::recursive_directory_iterator Iter(dir_path, EC);
fs::recursive_directory_iterator End;
for (; Iter != End && !EC; Iter.increment(EC)) {
const auto &Item = *Iter;
fs::file_status Status;
if ((EC = Item.status(Status)))
break;
if (!find_files && fs::is_regular_file(Status))
continue;
if (!find_directories && fs::is_directory(Status))
continue;
if (!find_other && fs::is_other(Status))
continue;
FileSpec Spec(Item.path(), false);
auto Result = callback(callback_baton, Status.type(), Spec);
if (Result == eEnumerateDirectoryResultQuit)
return;
if (Result == eEnumerateDirectoryResultNext) {
// Default behavior is to recurse. Opt out if the callback doesn't want
// this behavior.
Iter.no_push();
}
}
}
FileSpec
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);
}
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;
}
return ConstString();
}
static std::string
join_path_components(FileSpec::PathSyntax syntax,
const std::vector<llvm::StringRef> components) {
std::string result;
for (size_t i = 0; i < components.size(); ++i) {
if (components[i].empty())
continue;
result += components[i];
if (i != components.size() - 1 &&
!IsPathSeparator(components[i].back(), syntax))
result += GetPreferredPathSeparator(syntax);
}
return result;
}
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;
}
std::string result =
join_path_components(m_syntax, {component, m_directory.GetStringRef(),
m_filename.GetStringRef()});
SetFile(result, resolve, m_syntax);
}
void FileSpec::PrependPathComponent(const FileSpec &new_path) {
return PrependPathComponent(new_path.GetPath(false));
}
void FileSpec::AppendPathComponent(llvm::StringRef component) {
if (component.empty())
return;
component = component.drop_while(
[this](char c) { return IsPathSeparator(c, m_syntax); });
std::string result =
join_path_components(m_syntax, {m_directory.GetStringRef(),
m_filename.GetStringRef(), component});
SetFile(result, false, m_syntax);
}
void FileSpec::AppendPathComponent(const FileSpec &new_path) {
return AppendPathComponent(new_path.GetPath(false));
}
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 (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);
}
//------------------------------------------------------------------
/// Returns true if the filespec represents an implementation source
/// file (files with a ".c", ".cpp", ".m", ".mm" (many more)
/// extension).
///
/// @return
/// \b true if the filespec represents an implementation source
/// file, \b false otherwise.
//------------------------------------------------------------------
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
return true;
}
return false;
}
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;
}
Reference in New Issue View Git Blame Copy Permalink