LLDB  mainline
FileSpec.cpp
Go to the documentation of this file.
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 
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
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.
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 
331 
332 // Directory string get accessor.
334 
335 // Directory string const get accessor.
337 
338 // Filename string get accessor.
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 
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 
383  return ConstString(
384  llvm::sys::path::extension(m_filename.GetStringRef(), m_style));
385 }
386 
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 {
395 }
396 
397 FileSpec
398 FileSpec::CopyByAppendingPathComponent(llvm::StringRef component) const {
399  FileSpec ret = *this;
400  ret.AppendPathComponent(component);
401  return ret;
402 }
403 
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 
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 
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 
441  return AppendPathComponent(new_path.GetPath(false));
442 }
443 
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.
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 
493  if (IsRelative())
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 }
lldb_private::ConstString::MemorySize
size_t MemorySize() const
Get the memory cost of this object.
Definition: ConstString.h:399
RegularExpression.h
lldb_private::FileSpec::GetLastPathComponent
ConstString GetLastPathComponent() const
Definition: FileSpec.cpp:413
lldb_private::RegularExpression
Definition: RegularExpression.h:18
lldb_private::FileSpec::m_filename
ConstString m_filename
The uniqued filename path.
Definition: FileSpec.h:408
lldb_private::ConstString::Compare
static int Compare(ConstString lhs, ConstString rhs, const bool case_sensitive=true)
Compare two string objects.
Definition: ConstString.cpp:259
lldb_private::FileSpec::operator!
bool operator!() const
Logical NOT operator.
Definition: FileSpec.cpp:226
lldb_private::FileSpec::MemorySize
size_t MemorySize() const
Get the memory cost of this object.
Definition: FileSpec.cpp:393
lldb_private::FileSpec::GetPathStyle
Style GetPathStyle() const
Definition: FileSpec.cpp:330
lldb_private::Stream
Definition: Stream.h:28
lldb_private::FileSpec::MakeAbsolute
void MakeAbsolute(const FileSpec &dir)
Make the FileSpec absolute by treating it relative to dir.
Definition: FileSpec.cpp:492
lldb_private::FileSpec::CopyByRemovingLastPathComponent
FileSpec CopyByRemovingLastPathComponent() const
Definition: FileSpec.cpp:404
lldb_private::FileSpec::PrependPathComponent
void PrependPathComponent(llvm::StringRef component)
Definition: FileSpec.cpp:419
lldb_private::FileSpec::operator!=
bool operator!=(const FileSpec &rhs) const
Not equal to operator.
Definition: FileSpec.cpp:244
lldb_private::FileSpec::GetCString
const char * GetCString(bool denormalize=true) const
Definition: FileSpec.cpp:362
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb_private::FileSpec::Compare
static int Compare(const FileSpec &lhs, const FileSpec &rhs, bool full)
Compare two FileSpec objects.
Definition: FileSpec.cpp:272
lldb_private::ConstString::SetString
void SetString(const llvm::StringRef &s)
Definition: ConstString.cpp:306
lldb_private::FileSpec::operator<
bool operator<(const FileSpec &rhs) const
Less than to operator.
Definition: FileSpec.cpp:247
lldb_private::ConstString::GetStringRef
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:202
lldb_private::FileSpec::Match
static bool Match(const FileSpec &pattern, const FileSpec &file)
Match FileSpec pattern against FileSpec file.
Definition: FileSpec.cpp:300
lldb_private::FileSpec::m_directory
ConstString m_directory
The uniqued directory path.
Definition: FileSpec.h:407
lldb_private::FileSpec::DirectoryEquals
bool DirectoryEquals(const FileSpec &other) const
Definition: FileSpec.cpp:228
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::FileSpec::IsSourceImplementationFile
bool IsSourceImplementationFile() const
Returns true if the filespec represents an implementation source file (files with a "....
Definition: FileSpec.cpp:460
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::FileSpec::CopyByAppendingPathComponent
FileSpec CopyByAppendingPathComponent(llvm::StringRef component) const
Definition: FileSpec.cpp:398
lldb_private::FileSpec::GuessPathStyle
static llvm::Optional< Style > GuessPathStyle(llvm::StringRef absolute_path)
Attempt to guess path style for a given path string.
Definition: FileSpec.cpp:308
lldb_private::FileSpec::IsAbsolute
bool IsAbsolute() const
Returns true if the filespec represents an absolute path.
Definition: FileSpec.cpp:477
lldb_private::FileSpec::Clear
void Clear()
Clears the object state.
Definition: FileSpec.cpp:259
lldb_private::FileSpec::Style
llvm::sys::path::Style Style
Definition: FileSpec.h:58
lldb_private::FileSpec::FileEquals
bool FileEquals(const FileSpec &other) const
Definition: FileSpec.cpp:233
lldb_private::ConstString::Clear
void Clear()
Clear this object's state.
Definition: ConstString.h:232
lldb_private::ConstString::Equals
static bool Equals(ConstString lhs, ConstString rhs, const bool case_sensitive=true)
Equal to operator.
Definition: ConstString.cpp:242
lldb_private::FileSpec::IsRelative
bool IsRelative() const
Returns true if the filespec represents a relative path.
Definition: FileSpec.cpp:473
lldb_private::operator<<
Stream & operator<<(Stream &s, const SourceLocationSpec &loc)
Dump a SourceLocationSpec object to a stream.
Definition: SourceLocationSpec.cpp:40
lldb_private::FileSpec::RemoveLastPathComponent
bool RemoveLastPathComponent()
Removes the last path component by replacing the current path with its parent.
Definition: FileSpec.cpp:444
lldb_private::Stream::AsRawOstream
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:357
lldb_private::FileSpec::FileSpec
FileSpec()
Definition: FileSpec.cpp:66
lldb_private::FileSpec::Dump
void Dump(llvm::raw_ostream &s) const
Dump this object to a Stream.
Definition: FileSpec.cpp:322
lldb_private::FileSpec::IsCaseSensitive
bool IsCaseSensitive() const
Case sensitivity of path.
Definition: FileSpec.h:205
lldb_private::FileSpec::m_is_resolved
bool m_is_resolved
True if this path has been resolved.
Definition: FileSpec.h:409
lldb_private::FileSpec::AppendPathComponent
void AppendPathComponent(llvm::StringRef component)
Definition: FileSpec.cpp:433
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
FileSpec.h
lldb_private::RegularExpression::Execute
bool Execute(llvm::StringRef string, llvm::SmallVectorImpl< llvm::StringRef > *matches=nullptr) const
Execute a regular expression match using the compiled regular expression that is already in this obje...
Definition: RegularExpression.cpp:23
lldb_private::FileSpec::GetDirectory
ConstString & GetDirectory()
Directory string get accessor.
Definition: FileSpec.cpp:333
Stream.h
lldb_private::FileSpec::SetFile
void SetFile(llvm::StringRef path, Style style)
Change the file specified with a new path.
Definition: FileSpec.cpp:172
llvm::SmallVectorImpl
Definition: Disassembler.h:42
lldb_private::FileSpec::GetPath
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:346
lldb
Definition: SBAddress.h:15
lldb_private::FileSpec::GetFileNameExtension
ConstString GetFileNameExtension() const
Extract the extension of the file.
Definition: FileSpec.cpp:382
lldb_private::FileSpec::GetFilename
ConstString & GetFilename()
Filename string get accessor.
Definition: FileSpec.cpp:339
lldb_private::FileSpec::Equal
static bool Equal(const FileSpec &a, const FileSpec &b, bool full)
Definition: FileSpec.cpp:293
lldb_private::FileSpec::operator==
bool operator==(const FileSpec &rhs) const
Equal to operator.
Definition: FileSpec.cpp:239
lldb_private::FileSpec::m_style
Style m_style
The syntax that this path uses (e.g. Windows / Posix)
Definition: FileSpec.h:410
lldb_private::FileSpec::GetFileNameStrippingExtension
ConstString GetFileNameStrippingExtension() const
Return the filename without the extension part.
Definition: FileSpec.cpp:387