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 absolute_path.substr(1, 2) == R"(:/)")) 316 return Style::windows; 317 return llvm::None; 318 } 319 320 // Dump the object to the supplied stream. If the object contains a valid 321 // directory name, it will be displayed followed by a directory delimiter, and 322 // the filename. 323 void FileSpec::Dump(llvm::raw_ostream &s) const { 324 std::string path{GetPath(true)}; 325 s << path; 326 char path_separator = GetPreferredPathSeparator(m_style); 327 if (!m_filename && !path.empty() && path.back() != path_separator) 328 s << path_separator; 329 } 330 331 FileSpec::Style FileSpec::GetPathStyle() const { return m_style; } 332 333 // Directory string get accessor. 334 ConstString &FileSpec::GetDirectory() { return m_directory; } 335 336 // Directory string const get accessor. 337 ConstString FileSpec::GetDirectory() const { return m_directory; } 338 339 // Filename string get accessor. 340 ConstString &FileSpec::GetFilename() { return m_filename; } 341 342 // Filename string const get accessor. 343 ConstString FileSpec::GetFilename() const { return m_filename; } 344 345 // Extract the directory and path into a fixed buffer. This is needed as the 346 // directory and path are stored in separate string values. 347 size_t FileSpec::GetPath(char *path, size_t path_max_len, 348 bool denormalize) const { 349 if (!path) 350 return 0; 351 352 std::string result = GetPath(denormalize); 353 ::snprintf(path, path_max_len, "%s", result.c_str()); 354 return std::min(path_max_len - 1, result.length()); 355 } 356 357 std::string FileSpec::GetPath(bool denormalize) const { 358 llvm::SmallString<64> result; 359 GetPath(result, denormalize); 360 return static_cast<std::string>(result); 361 } 362 363 const char *FileSpec::GetCString(bool denormalize) const { 364 return ConstString{GetPath(denormalize)}.AsCString(nullptr); 365 } 366 367 void FileSpec::GetPath(llvm::SmallVectorImpl<char> &path, 368 bool denormalize) const { 369 path.append(m_directory.GetStringRef().begin(), 370 m_directory.GetStringRef().end()); 371 // Since the path was normalized and all paths use '/' when stored in these 372 // objects, we don't need to look for the actual syntax specific path 373 // separator, we just look for and insert '/'. 374 if (m_directory && m_filename && m_directory.GetStringRef().back() != '/' && 375 m_filename.GetStringRef().back() != '/') 376 path.insert(path.end(), '/'); 377 path.append(m_filename.GetStringRef().begin(), 378 m_filename.GetStringRef().end()); 379 if (denormalize && !path.empty()) 380 Denormalize(path, m_style); 381 } 382 383 ConstString FileSpec::GetFileNameExtension() const { 384 return ConstString( 385 llvm::sys::path::extension(m_filename.GetStringRef(), m_style)); 386 } 387 388 ConstString FileSpec::GetFileNameStrippingExtension() const { 389 return ConstString(llvm::sys::path::stem(m_filename.GetStringRef(), m_style)); 390 } 391 392 // Return the size in bytes that this object takes in memory. This returns the 393 // size in bytes of this object, not any shared string values it may refer to. 394 size_t FileSpec::MemorySize() const { 395 return m_filename.MemorySize() + m_directory.MemorySize(); 396 } 397 398 FileSpec 399 FileSpec::CopyByAppendingPathComponent(llvm::StringRef component) const { 400 FileSpec ret = *this; 401 ret.AppendPathComponent(component); 402 return ret; 403 } 404 405 FileSpec FileSpec::CopyByRemovingLastPathComponent() const { 406 llvm::SmallString<64> current_path; 407 GetPath(current_path, false); 408 if (llvm::sys::path::has_parent_path(current_path, m_style)) 409 return FileSpec(llvm::sys::path::parent_path(current_path, m_style), 410 m_style); 411 return *this; 412 } 413 414 ConstString FileSpec::GetLastPathComponent() const { 415 llvm::SmallString<64> current_path; 416 GetPath(current_path, false); 417 return ConstString(llvm::sys::path::filename(current_path, m_style)); 418 } 419 420 void FileSpec::PrependPathComponent(llvm::StringRef component) { 421 llvm::SmallString<64> new_path(component); 422 llvm::SmallString<64> current_path; 423 GetPath(current_path, false); 424 llvm::sys::path::append(new_path, 425 llvm::sys::path::begin(current_path, m_style), 426 llvm::sys::path::end(current_path), m_style); 427 SetFile(new_path, m_style); 428 } 429 430 void FileSpec::PrependPathComponent(const FileSpec &new_path) { 431 return PrependPathComponent(new_path.GetPath(false)); 432 } 433 434 void FileSpec::AppendPathComponent(llvm::StringRef component) { 435 llvm::SmallString<64> current_path; 436 GetPath(current_path, false); 437 llvm::sys::path::append(current_path, m_style, component); 438 SetFile(current_path, m_style); 439 } 440 441 void FileSpec::AppendPathComponent(const FileSpec &new_path) { 442 return AppendPathComponent(new_path.GetPath(false)); 443 } 444 445 bool FileSpec::RemoveLastPathComponent() { 446 llvm::SmallString<64> current_path; 447 GetPath(current_path, false); 448 if (llvm::sys::path::has_parent_path(current_path, m_style)) { 449 SetFile(llvm::sys::path::parent_path(current_path, m_style)); 450 return true; 451 } 452 return false; 453 } 454 /// Returns true if the filespec represents an implementation source 455 /// file (files with a ".c", ".cpp", ".m", ".mm" (many more) 456 /// extension). 457 /// 458 /// \return 459 /// \b true if the filespec represents an implementation source 460 /// file, \b false otherwise. 461 bool FileSpec::IsSourceImplementationFile() const { 462 ConstString extension(GetFileNameExtension()); 463 if (!extension) 464 return false; 465 466 static RegularExpression g_source_file_regex(llvm::StringRef( 467 "^.([cC]|[mM]|[mM][mM]|[cC][pP][pP]|[cC]\\+\\+|[cC][xX][xX]|[cC][cC]|[" 468 "cC][pP]|[sS]|[aA][sS][mM]|[fF]|[fF]77|[fF]90|[fF]95|[fF]03|[fF][oO][" 469 "rR]|[fF][tT][nN]|[fF][pP][pP]|[aA][dD][aA]|[aA][dD][bB]|[aA][dD][sS])" 470 "$")); 471 return g_source_file_regex.Execute(extension.GetStringRef()); 472 } 473 474 bool FileSpec::IsRelative() const { 475 return !IsAbsolute(); 476 } 477 478 bool FileSpec::IsAbsolute() const { 479 llvm::SmallString<64> current_path; 480 GetPath(current_path, false); 481 482 // Early return if the path is empty. 483 if (current_path.empty()) 484 return false; 485 486 // We consider paths starting with ~ to be absolute. 487 if (current_path[0] == '~') 488 return true; 489 490 return llvm::sys::path::is_absolute(current_path, m_style); 491 } 492 493 void FileSpec::MakeAbsolute(const FileSpec &dir) { 494 if (IsRelative()) 495 PrependPathComponent(dir); 496 } 497 498 void llvm::format_provider<FileSpec>::format(const FileSpec &F, 499 raw_ostream &Stream, 500 StringRef Style) { 501 assert((Style.empty() || Style.equals_insensitive("F") || 502 Style.equals_insensitive("D")) && 503 "Invalid FileSpec style!"); 504 505 StringRef dir = F.GetDirectory().GetStringRef(); 506 StringRef file = F.GetFilename().GetStringRef(); 507 508 if (dir.empty() && file.empty()) { 509 Stream << "(empty)"; 510 return; 511 } 512 513 if (Style.equals_insensitive("F")) { 514 Stream << (file.empty() ? "(empty)" : file); 515 return; 516 } 517 518 // Style is either D or empty, either way we need to print the directory. 519 if (!dir.empty()) { 520 // Directory is stored in normalized form, which might be different than 521 // preferred form. In order to handle this, we need to cut off the 522 // filename, then denormalize, then write the entire denorm'ed directory. 523 llvm::SmallString<64> denormalized_dir = dir; 524 Denormalize(denormalized_dir, F.GetPathStyle()); 525 Stream << denormalized_dir; 526 Stream << GetPreferredPathSeparator(F.GetPathStyle()); 527 } 528 529 if (Style.equals_insensitive("D")) { 530 // We only want to print the directory, so now just exit. 531 if (dir.empty()) 532 Stream << "(empty)"; 533 return; 534 } 535 536 if (!file.empty()) 537 Stream << file; 538 } 539 540 void llvm::yaml::ScalarEnumerationTraits<FileSpecStyle>::enumeration( 541 IO &io, FileSpecStyle &value) { 542 io.enumCase(value, "windows", FileSpecStyle(FileSpec::Style::windows)); 543 io.enumCase(value, "posix", FileSpecStyle(FileSpec::Style::posix)); 544 io.enumCase(value, "native", FileSpecStyle(FileSpec::Style::native)); 545 } 546 547 void llvm::yaml::MappingTraits<FileSpec>::mapping(IO &io, FileSpec &f) { 548 io.mapRequired("directory", f.m_directory); 549 io.mapRequired("file", f.m_filename); 550 io.mapRequired("resolved", f.m_is_resolved); 551 FileSpecStyle style = f.m_style; 552 io.mapRequired("style", style); 553 f.m_style = style; 554 } 555