lldb/source/Utility/FileSpec.cpp

   1 //===-- FileSpec.cpp ------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Utility/FileSpec.h"
  10 #include "lldb/Utility/RegularExpression.h"
  11 #include "lldb/Utility/Stream.h"
  12
  13 #include "llvm/ADT/SmallString.h"
  14 #include "llvm/ADT/SmallVector.h"
  15 #include "llvm/ADT/StringRef.h"
  16 #include "llvm/ADT/Triple.h"
  17 #include "llvm/ADT/Twine.h"
  18 #include "llvm/Support/ErrorOr.h"
  19 #include "llvm/Support/FileSystem.h"
  20 #include "llvm/Support/Program.h"
  21 #include "llvm/Support/raw_ostream.h"
  22
  23 #include <algorithm>
  24 #include <system_error>
  25 #include <vector>
  26
  27 #include <cassert>
  28 #include <climits>
  29 #include <cstdio>
  30 #include <cstring>
  31
  32 using namespace lldb;
  33 using namespace lldb_private;
  34
  35 namespace {
  36
  37 static constexpr FileSpec::Style GetNativeStyle() {
  38 #if defined(_WIN32)
  39   return FileSpec::Style::windows;
  40 #else
  41   return FileSpec::Style::posix;
  42 #endif
  43 }
  44
  45 bool PathStyleIsPosix(FileSpec::Style style) {
  46   return llvm::sys::path::is_style_posix(style);
  47 }
  48
  49 const char *GetPathSeparators(FileSpec::Style style) {
  50   return llvm::sys::path::get_separator(style).data();
  51 }
  52
  53 char GetPreferredPathSeparator(FileSpec::Style style) {
  54   return GetPathSeparators(style)[0];
  55 }
  56
  57 void Denormalize(llvm::SmallVectorImpl<char> &path, FileSpec::Style style) {
  58   if (PathStyleIsPosix(style))
  59     return;
  60
  61   std::replace(path.begin(), path.end(), '/', '\\');
  62 }
  63
  64 } // end anonymous namespace
  65
  66 FileSpec::FileSpec() : m_style(GetNativeStyle()) {}
  67
  68 // Default constructor that can take an optional full path to a file on disk.
  69 FileSpec::FileSpec(llvm::StringRef path, Style style) : m_style(style) {
  70   SetFile(path, style);
  71 }
  72
  73 FileSpec::FileSpec(llvm::StringRef path, const llvm::Triple &triple)
  74     : FileSpec{path, triple.isOSWindows() ? Style::windows : Style::posix} {}
  75
  76 namespace {
  77 /// Safely get a character at the specified index.
  78 ///
  79 /// \param[in] path
  80 ///     A full, partial, or relative path to a file.
  81 ///
  82 /// \param[in] i
  83 ///     An index into path which may or may not be valid.
  84 ///
  85 /// \return
  86 ///   The character at index \a i if the index is valid, or 0 if
  87 ///   the index is not valid.
  88 inline char safeCharAtIndex(const llvm::StringRef &path, size_t i) {
  89   if (i < path.size())
  90     return path[i];
  91   return 0;
  92 }
  93
  94 /// Check if a path needs to be normalized.
  95 ///
  96 /// Check if a path needs to be normalized. We currently consider a
  97 /// path to need normalization if any of the following are true
  98 ///  - path contains "/./"
  99 ///  - path contains "/../"
 100 ///  - path contains "//"
 101 ///  - path ends with "/"
 102 /// Paths that start with "./" or with "../" are not considered to
 103 /// need normalization since we aren't trying to resolve the path,
 104 /// we are just trying to remove redundant things from the path.
 105 ///
 106 /// \param[in] path
 107 ///     A full, partial, or relative path to a file.
 108 ///
 109 /// \return
 110 ///   Returns \b true if the path needs to be normalized.
 111 bool needsNormalization(const llvm::StringRef &path) {
 112   if (path.empty())
 113     return false;
 114   // We strip off leading "." values so these paths need to be normalized
 115   if (path[0] == '.')
 116     return true;
 117   for (auto i = path.find_first_of("\\/"); i != llvm::StringRef::npos;
 118        i = path.find_first_of("\\/", i + 1)) {
 119     const auto next = safeCharAtIndex(path, i+1);
 120     switch (next) {
 121       case 0:
 122         // path separator char at the end of the string which should be
 123         // stripped unless it is the one and only character
 124         return i > 0;
 125       case '/':
 126       case '\\':
 127         // two path separator chars in the middle of a path needs to be
 128         // normalized
 129         if (i > 0)
 130           return true;
 131         ++i;
 132         break;
 133
 134       case '.': {
 135           const auto next_next = safeCharAtIndex(path, i+2);
 136           switch (next_next) {
 137             default: break;
 138             case 0: return true; // ends with "/."
 139             case '/':
 140             case '\\':
 141               return true; // contains "/./"
 142             case '.': {
 143               const auto next_next_next = safeCharAtIndex(path, i+3);
 144               switch (next_next_next) {
 145                 default: break;
 146                 case 0: return true; // ends with "/.."
 147                 case '/':
 148                 case '\\':
 149                   return true; // contains "/../"
 150               }
 151               break;
 152             }
 153           }
 154         }
 155         break;
 156
 157       default:
 158         break;
 159     }
 160   }
 161   return false;
 162 }
 163
 164
 165 }
 166
 167 void FileSpec::SetFile(llvm::StringRef pathname) { SetFile(pathname, m_style); }
 168
 169 // Update the contents of this object with a new path. The path will be split
 170 // up into a directory and filename and stored as uniqued string values for
 171 // quick comparison and efficient memory usage.
 172 void FileSpec::SetFile(llvm::StringRef pathname, Style style) {
 173   m_filename.Clear();
 174   m_directory.Clear();
 175   m_is_resolved = false;
 176   m_style = (style == Style::native) ? GetNativeStyle() : style;
 177
 178   if (pathname.empty())
 179     return;
 180
 181   llvm::SmallString<128> resolved(pathname);
 182
 183   // Normalize the path by removing ".", ".." and other redundant components.
 184   if (needsNormalization(resolved))
 185     llvm::sys::path::remove_dots(resolved, true, m_style);
 186
 187   // Normalize back slashes to forward slashes
 188   if (m_style == Style::windows)
 189     std::replace(resolved.begin(), resolved.end(), '\\', '/');
 190
 191   if (resolved.empty()) {
 192     // If we have no path after normalization set the path to the current
 193     // directory. This matches what python does and also a few other path
 194     // utilities.
 195     m_filename.SetString(".");
 196     return;
 197   }
 198
 199   // Split path into filename and directory. We rely on the underlying char
 200   // pointer to be nullptr when the components are empty.
 201   llvm::StringRef filename = llvm::sys::path::filename(resolved, m_style);
 202   if(!filename.empty())
 203     m_filename.SetString(filename);
 204
 205   llvm::StringRef directory = llvm::sys::path::parent_path(resolved, m_style);
 206   if(!directory.empty())
 207     m_directory.SetString(directory);
 208 }
 209
 210 void FileSpec::SetFile(llvm::StringRef path, const llvm::Triple &triple) {
 211   return SetFile(path, triple.isOSWindows() ? Style::windows : Style::posix);
 212 }
 213
 214 // Convert to pointer operator. This allows code to check any FileSpec objects
 215 // to see if they contain anything valid using code such as:
 216 //
 217 //  if (file_spec)
 218 //  {}
 219 FileSpec::operator bool() const { return m_filename || m_directory; }
 220
 221 // Logical NOT operator. This allows code to check any FileSpec objects to see
 222 // if they are invalid using code such as:
 223 //
 224 //  if (!file_spec)
 225 //  {}
 226 bool FileSpec::operator!() const { return !m_directory && !m_filename; }
 227
 228 bool FileSpec::DirectoryEquals(const FileSpec &rhs) const {
 229   const bool case_sensitive = IsCaseSensitive() || rhs.IsCaseSensitive();
 230   return ConstString::Equals(m_directory, rhs.m_directory, case_sensitive);
 231 }
 232
 233 bool FileSpec::FileEquals(const FileSpec &rhs) const {
 234   const bool case_sensitive = IsCaseSensitive() || rhs.IsCaseSensitive();
 235   return ConstString::Equals(m_filename, rhs.m_filename, case_sensitive);
 236 }
 237
 238 // Equal to operator
 239 bool FileSpec::operator==(const FileSpec &rhs) const {
 240   return FileEquals(rhs) && DirectoryEquals(rhs);
 241 }
 242
 243 // Not equal to operator
 244 bool FileSpec::operator!=(const FileSpec &rhs) const { return !(*this == rhs); }
 245
 246 // Less than operator
 247 bool FileSpec::operator<(const FileSpec &rhs) const {
 248   return FileSpec::Compare(*this, rhs, true) < 0;
 249 }
 250
 251 // Dump a FileSpec object to a stream
 252 Stream &lldb_private::operator<<(Stream &s, const FileSpec &f) {
 253   f.Dump(s.AsRawOstream());
 254   return s;
 255 }
 256
 257 // Clear this object by releasing both the directory and filename string values
 258 // and making them both the empty string.
 259 void FileSpec::Clear() {
 260   m_directory.Clear();
 261   m_filename.Clear();
 262 }
 263
 264 // Compare two FileSpec objects. If "full" is true, then both the directory and
 265 // the filename must match. If "full" is false, then the directory names for
 266 // "a" and "b" are only compared if they are both non-empty. This allows a
 267 // FileSpec object to only contain a filename and it can match FileSpec objects
 268 // that have matching filenames with different paths.
 269 //
 270 // Return -1 if the "a" is less than "b", 0 if "a" is equal to "b" and "1" if
 271 // "a" is greater than "b".
 272 int FileSpec::Compare(const FileSpec &a, const FileSpec &b, bool full) {
 273   int result = 0;
 274
 275   // case sensitivity of compare
 276   const bool case_sensitive = a.IsCaseSensitive() || b.IsCaseSensitive();
 277
 278   // If full is true, then we must compare both the directory and filename.
 279
 280   // If full is false, then if either directory is empty, then we match on the
 281   // basename only, and if both directories have valid values, we still do a
 282   // full compare. This allows for matching when we just have a filename in one
 283   // of the FileSpec objects.
 284
 285   if (full || (a.m_directory && b.m_directory)) {
 286     result = ConstString::Compare(a.m_directory, b.m_directory, case_sensitive);
 287     if (result)
 288       return result;
 289   }
 290   return ConstString::Compare(a.m_filename, b.m_filename, case_sensitive);
 291 }
 292
 293 bool FileSpec::Equal(const FileSpec &a, const FileSpec &b, bool full) {
 294   if (full || (a.GetDirectory() && b.GetDirectory()))
 295     return a == b;
 296
 297   return a.FileEquals(b);
 298 }
 299
 300 bool FileSpec::Match(const FileSpec &pattern, const FileSpec &file) {
 301   if (pattern.GetDirectory())
 302     return pattern == file;
 303   if (pattern.GetFilename())
 304     return pattern.FileEquals(file);
 305   return true;
 306 }
 307
 308 llvm::Optional<FileSpec::Style> FileSpec::GuessPathStyle(llvm::StringRef absolute_path) {
 309   if (absolute_path.startswith("/"))
 310     return Style::posix;
 311   if (absolute_path.startswith(R"(\\)"))
 312     return Style::windows;
 313   if (absolute_path.size() >= 3 && llvm::isAlpha(absolute_path[0]) &&
 314       absolute_path.substr(1, 2) == R"(:\)")
 315     return Style::windows;
 316   return llvm::None;
 317 }
 318
 319 // Dump the object to the supplied stream. If the object contains a valid
 320 // directory name, it will be displayed followed by a directory delimiter, and
 321 // the filename.
 322 void FileSpec::Dump(llvm::raw_ostream &s) const {
 323   std::string path{GetPath(true)};
 324   s << path;
 325   char path_separator = GetPreferredPathSeparator(m_style);
 326   if (!m_filename && !path.empty() && path.back() != path_separator)
 327     s << path_separator;
 328 }
 329
 330 FileSpec::Style FileSpec::GetPathStyle() const { return m_style; }
 331
 332 // Directory string get accessor.
 333 ConstString &FileSpec::GetDirectory() { return m_directory; }
 334
 335 // Directory string const get accessor.
 336 ConstString FileSpec::GetDirectory() const { return m_directory; }
 337
 338 // Filename string get accessor.
 339 ConstString &FileSpec::GetFilename() { return m_filename; }
 340
 341 // Filename string const get accessor.
 342 ConstString FileSpec::GetFilename() const { return m_filename; }
 343
 344 // Extract the directory and path into a fixed buffer. This is needed as the
 345 // directory and path are stored in separate string values.
 346 size_t FileSpec::GetPath(char *path, size_t path_max_len,
 347                          bool denormalize) const {
 348   if (!path)
 349     return 0;
 350
 351   std::string result = GetPath(denormalize);
 352   ::snprintf(path, path_max_len, "%s", result.c_str());
 353   return std::min(path_max_len - 1, result.length());
 354 }
 355
 356 std::string FileSpec::GetPath(bool denormalize) const {
 357   llvm::SmallString<64> result;
 358   GetPath(result, denormalize);
 359   return std::string(result.begin(), result.end());
 360 }
 361
 362 const char *FileSpec::GetCString(bool denormalize) const {
 363   return ConstString{GetPath(denormalize)}.AsCString(nullptr);
 364 }
 365
 366 void FileSpec::GetPath(llvm::SmallVectorImpl<char> &path,
 367                        bool denormalize) const {
 368   path.append(m_directory.GetStringRef().begin(),
 369               m_directory.GetStringRef().end());
 370   // Since the path was normalized and all paths use '/' when stored in these
 371   // objects, we don't need to look for the actual syntax specific path
 372   // separator, we just look for and insert '/'.
 373   if (m_directory && m_filename && m_directory.GetStringRef().back() != '/' &&
 374       m_filename.GetStringRef().back() != '/')
 375     path.insert(path.end(), '/');
 376   path.append(m_filename.GetStringRef().begin(),
 377               m_filename.GetStringRef().end());
 378   if (denormalize && !path.empty())
 379     Denormalize(path, m_style);
 380 }
 381
 382 ConstString FileSpec::GetFileNameExtension() const {
 383   return ConstString(
 384       llvm::sys::path::extension(m_filename.GetStringRef(), m_style));
 385 }
 386
 387 ConstString FileSpec::GetFileNameStrippingExtension() const {
 388   return ConstString(llvm::sys::path::stem(m_filename.GetStringRef(), m_style));
 389 }
 390
 391 // Return the size in bytes that this object takes in memory. This returns the
 392 // size in bytes of this object, not any shared string values it may refer to.
 393 size_t FileSpec::MemorySize() const {
 394   return m_filename.MemorySize() + m_directory.MemorySize();
 395 }
 396
 397 FileSpec
 398 FileSpec::CopyByAppendingPathComponent(llvm::StringRef component) const {
 399   FileSpec ret = *this;
 400   ret.AppendPathComponent(component);
 401   return ret;
 402 }
 403
 404 FileSpec FileSpec::CopyByRemovingLastPathComponent() const {
 405   llvm::SmallString<64> current_path;
 406   GetPath(current_path, false);
 407   if (llvm::sys::path::has_parent_path(current_path, m_style))
 408     return FileSpec(llvm::sys::path::parent_path(current_path, m_style),
 409                     m_style);
 410   return *this;
 411 }
 412
 413 ConstString FileSpec::GetLastPathComponent() const {
 414   llvm::SmallString<64> current_path;
 415   GetPath(current_path, false);
 416   return ConstString(llvm::sys::path::filename(current_path, m_style));
 417 }
 418
 419 void FileSpec::PrependPathComponent(llvm::StringRef component) {
 420   llvm::SmallString<64> new_path(component);
 421   llvm::SmallString<64> current_path;
 422   GetPath(current_path, false);
 423   llvm::sys::path::append(new_path,
 424                           llvm::sys::path::begin(current_path, m_style),
 425                           llvm::sys::path::end(current_path), m_style);
 426   SetFile(new_path, m_style);
 427 }
 428
 429 void FileSpec::PrependPathComponent(const FileSpec &new_path) {
 430   return PrependPathComponent(new_path.GetPath(false));
 431 }
 432
 433 void FileSpec::AppendPathComponent(llvm::StringRef component) {
 434   llvm::SmallString<64> current_path;
 435   GetPath(current_path, false);
 436   llvm::sys::path::append(current_path, m_style, component);
 437   SetFile(current_path, m_style);
 438 }
 439
 440 void FileSpec::AppendPathComponent(const FileSpec &new_path) {
 441   return AppendPathComponent(new_path.GetPath(false));
 442 }
 443
 444 bool FileSpec::RemoveLastPathComponent() {
 445   llvm::SmallString<64> current_path;
 446   GetPath(current_path, false);
 447   if (llvm::sys::path::has_parent_path(current_path, m_style)) {
 448     SetFile(llvm::sys::path::parent_path(current_path, m_style));
 449     return true;
 450   }
 451   return false;
 452 }
 453 /// Returns true if the filespec represents an implementation source
 454 /// file (files with a ".c", ".cpp", ".m", ".mm" (many more)
 455 /// extension).
 456 ///
 457 /// \return
 458 ///     \b true if the filespec represents an implementation source
 459 ///     file, \b false otherwise.
 460 bool FileSpec::IsSourceImplementationFile() const {
 461   ConstString extension(GetFileNameExtension());
 462   if (!extension)
 463     return false;
 464
 465   static RegularExpression g_source_file_regex(llvm::StringRef(
 466       "^.([cC]|[mM]|[mM][mM]|[cC][pP][pP]|[cC]\\+\\+|[cC][xX][xX]|[cC][cC]|["
 467       "cC][pP]|[sS]|[aA][sS][mM]|[fF]|[fF]77|[fF]90|[fF]95|[fF]03|[fF][oO]["
 468       "rR]|[fF][tT][nN]|[fF][pP][pP]|[aA][dD][aA]|[aA][dD][bB]|[aA][dD][sS])"
 469       "$"));
 470   return g_source_file_regex.Execute(extension.GetStringRef());
 471 }
 472
 473 bool FileSpec::IsRelative() const {
 474   return !IsAbsolute();
 475 }
 476
 477 bool FileSpec::IsAbsolute() const {
 478   llvm::SmallString<64> current_path;
 479   GetPath(current_path, false);
 480
 481   // Early return if the path is empty.
 482   if (current_path.empty())
 483     return false;
 484
 485   // We consider paths starting with ~ to be absolute.
 486   if (current_path[0] == '~')
 487     return true;
 488
 489   return llvm::sys::path::is_absolute(current_path, m_style);
 490 }
 491
 492 void FileSpec::MakeAbsolute(const FileSpec &dir) {
 493   if (IsRelative())
 494     PrependPathComponent(dir);
 495 }
 496
 497 void llvm::format_provider<FileSpec>::format(const FileSpec &F,
 498                                              raw_ostream &Stream,
 499                                              StringRef Style) {
 500   assert((Style.empty() || Style.equals_insensitive("F") ||
 501           Style.equals_insensitive("D")) &&
 502          "Invalid FileSpec style!");
 503
 504   StringRef dir = F.GetDirectory().GetStringRef();
 505   StringRef file = F.GetFilename().GetStringRef();
 506
 507   if (dir.empty() && file.empty()) {
 508     Stream << "(empty)";
 509     return;
 510   }
 511
 512   if (Style.equals_insensitive("F")) {
 513     Stream << (file.empty() ? "(empty)" : file);
 514     return;
 515   }
 516
 517   // Style is either D or empty, either way we need to print the directory.
 518   if (!dir.empty()) {
 519     // Directory is stored in normalized form, which might be different than
 520     // preferred form.  In order to handle this, we need to cut off the
 521     // filename, then denormalize, then write the entire denorm'ed directory.
 522     llvm::SmallString<64> denormalized_dir = dir;
 523     Denormalize(denormalized_dir, F.GetPathStyle());
 524     Stream << denormalized_dir;
 525     Stream << GetPreferredPathSeparator(F.GetPathStyle());
 526   }
 527
 528   if (Style.equals_insensitive("D")) {
 529     // We only want to print the directory, so now just exit.
 530     if (dir.empty())
 531       Stream << "(empty)";
 532     return;
 533   }
 534
 535   if (!file.empty())
 536     Stream << file;
 537 }
 538
 539 void llvm::yaml::ScalarEnumerationTraits<FileSpecStyle>::enumeration(
 540     IO &io, FileSpecStyle &value) {
 541   io.enumCase(value, "windows", FileSpecStyle(FileSpec::Style::windows));
 542   io.enumCase(value, "posix", FileSpecStyle(FileSpec::Style::posix));
 543   io.enumCase(value, "native", FileSpecStyle(FileSpec::Style::native));
 544 }
 545
 546 void llvm::yaml::MappingTraits<FileSpec>::mapping(IO &io, FileSpec &f) {
 547   io.mapRequired("directory", f.m_directory);
 548   io.mapRequired("file", f.m_filename);
 549   io.mapRequired("resolved", f.m_is_resolved);
 550   FileSpecStyle style = f.m_style;
 551   io.mapRequired("style", style);
 552   f.m_style = style;
 553 }