contrib/llvm/tools/lldb/source/Host/common/FileSpec.cpp

   1 //===-- FileSpec.cpp --------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10
  11 #include <dirent.h>
  12 #include <fcntl.h>
  13 #include <libgen.h>
  14 #include <sys/stat.h>
  15 #include <set>
  16 #include <string.h>
  17 #include <fstream>
  18
  19 #include "lldb/Host/Config.h" // Have to include this before we test the define...
  20 #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
  21 #include <pwd.h>
  22 #endif
  23
  24 #include "llvm/ADT/StringRef.h"
  25 #include "llvm/Support/Path.h"
  26 #include "llvm/Support/Program.h"
  27
  28 #include "lldb/Host/File.h"
  29 #include "lldb/Host/FileSpec.h"
  30 #include "lldb/Core/DataBufferHeap.h"
  31 #include "lldb/Core/DataBufferMemoryMap.h"
  32 #include "lldb/Core/RegularExpression.h"
  33 #include "lldb/Core/Stream.h"
  34 #include "lldb/Host/Host.h"
  35 #include "lldb/Utility/CleanUp.h"
  36
  37 using namespace lldb;
  38 using namespace lldb_private;
  39
  40 static bool
  41 GetFileStats (const FileSpec *file_spec, struct stat *stats_ptr)
  42 {
  43     char resolved_path[PATH_MAX];
  44     if (file_spec->GetPath (resolved_path, sizeof(resolved_path)))
  45         return ::stat (resolved_path, stats_ptr) == 0;
  46     return false;
  47 }
  48
  49 #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
  50
  51 static const char*
  52 GetCachedGlobTildeSlash()
  53 {
  54     static std::string g_tilde;
  55     if (g_tilde.empty())
  56     {
  57         struct passwd *user_entry;
  58         user_entry = getpwuid(geteuid());
  59         if (user_entry != NULL)
  60             g_tilde = user_entry->pw_dir;
  61
  62         if (g_tilde.empty())
  63             return NULL;
  64     }
  65     return g_tilde.c_str();
  66 }
  67
  68 #endif // #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
  69
  70 // Resolves the username part of a path of the form ~user/other/directories, and
  71 // writes the result into dst_path.
  72 // Returns 0 if there WAS a ~ in the path but the username couldn't be resolved.
  73 // Otherwise returns the number of characters copied into dst_path.  If the return
  74 // is >= dst_len, then the resolved path is too long...
  75 size_t
  76 FileSpec::ResolveUsername (const char *src_path, char *dst_path, size_t dst_len)
  77 {
  78     if (src_path == NULL || src_path[0] == '\0')
  79         return 0;
  80
  81 #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
  82
  83     char user_home[PATH_MAX];
  84     const char *user_name;
  85
  86
  87     // If there's no ~, then just copy src_path straight to dst_path (they may be the same string...)
  88     if (src_path[0] != '~')
  89     {
  90         size_t len = strlen (src_path);
  91         if (len >= dst_len)
  92         {
  93             ::bcopy (src_path, dst_path, dst_len - 1);
  94             dst_path[dst_len] = '\0';
  95         }
  96         else
  97             ::bcopy (src_path, dst_path, len + 1);
  98
  99         return len;
 100     }
 101
 102     const char *first_slash = ::strchr (src_path, '/');
 103     char remainder[PATH_MAX];
 104
 105     if (first_slash == NULL)
 106     {
 107         // The whole name is the username (minus the ~):
 108         user_name = src_path + 1;
 109         remainder[0] = '\0';
 110     }
 111     else
 112     {
 113         size_t user_name_len = first_slash - src_path - 1;
 114         ::memcpy (user_home, src_path + 1, user_name_len);
 115         user_home[user_name_len] = '\0';
 116         user_name = user_home;
 117
 118         ::strcpy (remainder, first_slash);
 119     }
 120
 121     if (user_name == NULL)
 122         return 0;
 123     // User name of "" means the current user...
 124
 125     struct passwd *user_entry;
 126     const char *home_dir = NULL;
 127
 128     if (user_name[0] == '\0')
 129     {
 130         home_dir = GetCachedGlobTildeSlash();
 131     }
 132     else
 133     {
 134         user_entry = ::getpwnam (user_name);
 135         if (user_entry != NULL)
 136             home_dir = user_entry->pw_dir;
 137     }
 138
 139     if (home_dir == NULL)
 140         return 0;
 141     else
 142         return ::snprintf (dst_path, dst_len, "%s%s", home_dir, remainder);
 143 #else
 144     // Resolving home directories is not supported, just copy the path...
 145     return ::snprintf (dst_path, dst_len, "%s", src_path);
 146 #endif // #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
 147 }
 148
 149 size_t
 150 FileSpec::ResolvePartialUsername (const char *partial_name, StringList &matches)
 151 {
 152 #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
 153     size_t extant_entries = matches.GetSize();
 154
 155     setpwent();
 156     struct passwd *user_entry;
 157     const char *name_start = partial_name + 1;
 158     std::set<std::string> name_list;
 159
 160     while ((user_entry = getpwent()) != NULL)
 161     {
 162         if (strstr(user_entry->pw_name, name_start) == user_entry->pw_name)
 163         {
 164             std::string tmp_buf("~");
 165             tmp_buf.append(user_entry->pw_name);
 166             tmp_buf.push_back('/');
 167             name_list.insert(tmp_buf);
 168         }
 169     }
 170     std::set<std::string>::iterator pos, end = name_list.end();
 171     for (pos = name_list.begin(); pos != end; pos++)
 172     {
 173         matches.AppendString((*pos).c_str());
 174     }
 175     return matches.GetSize() - extant_entries;
 176 #else
 177     // Resolving home directories is not supported, just copy the path...
 178     return 0;
 179 #endif // #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
 180 }
 181
 182
 183
 184 size_t
 185 FileSpec::Resolve (const char *src_path, char *dst_path, size_t dst_len)
 186 {
 187     if (src_path == NULL || src_path[0] == '\0')
 188         return 0;
 189
 190     // Glob if needed for ~/, otherwise copy in case src_path is same as dst_path...
 191     char unglobbed_path[PATH_MAX];
 192 #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
 193     if (src_path[0] == '~')
 194     {
 195         size_t return_count = ResolveUsername(src_path, unglobbed_path, sizeof(unglobbed_path));
 196
 197         // If we couldn't find the user referred to, or the resultant path was too long,
 198         // then just copy over the src_path.
 199         if (return_count == 0 || return_count >= sizeof(unglobbed_path))
 200             ::snprintf (unglobbed_path, sizeof(unglobbed_path), "%s", src_path);
 201     }
 202     else
 203 #endif // #ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
 204     {
 205         ::snprintf(unglobbed_path, sizeof(unglobbed_path), "%s", src_path);
 206     }
 207
 208     // Now resolve the path if needed
 209     char resolved_path[PATH_MAX];
 210     if (::realpath (unglobbed_path, resolved_path))
 211     {
 212         // Success, copy the resolved path
 213         return ::snprintf(dst_path, dst_len, "%s", resolved_path);
 214     }
 215     else
 216     {
 217         // Failed, just copy the unglobbed path
 218         return ::snprintf(dst_path, dst_len, "%s", unglobbed_path);
 219     }
 220 }
 221
 222 FileSpec::FileSpec() :
 223     m_directory(),
 224     m_filename()
 225 {
 226 }
 227
 228 //------------------------------------------------------------------
 229 // Default constructor that can take an optional full path to a
 230 // file on disk.
 231 //------------------------------------------------------------------
 232 FileSpec::FileSpec(const char *pathname, bool resolve_path) :
 233     m_directory(),
 234     m_filename(),
 235     m_is_resolved(false)
 236 {
 237     if (pathname && pathname[0])
 238         SetFile(pathname, resolve_path);
 239 }
 240
 241 //------------------------------------------------------------------
 242 // Copy constructor
 243 //------------------------------------------------------------------
 244 FileSpec::FileSpec(const FileSpec& rhs) :
 245     m_directory (rhs.m_directory),
 246     m_filename (rhs.m_filename),
 247     m_is_resolved (rhs.m_is_resolved)
 248 {
 249 }
 250
 251 //------------------------------------------------------------------
 252 // Copy constructor
 253 //------------------------------------------------------------------
 254 FileSpec::FileSpec(const FileSpec* rhs) :
 255     m_directory(),
 256     m_filename()
 257 {
 258     if (rhs)
 259         *this = *rhs;
 260 }
 261
 262 //------------------------------------------------------------------
 263 // Virtual destrcuctor in case anyone inherits from this class.
 264 //------------------------------------------------------------------
 265 FileSpec::~FileSpec()
 266 {
 267 }
 268
 269 //------------------------------------------------------------------
 270 // Assignment operator.
 271 //------------------------------------------------------------------
 272 const FileSpec&
 273 FileSpec::operator= (const FileSpec& rhs)
 274 {
 275     if (this != &rhs)
 276     {
 277         m_directory = rhs.m_directory;
 278         m_filename = rhs.m_filename;
 279         m_is_resolved = rhs.m_is_resolved;
 280     }
 281     return *this;
 282 }
 283
 284 //------------------------------------------------------------------
 285 // Update the contents of this object with a new path. The path will
 286 // be split up into a directory and filename and stored as uniqued
 287 // string values for quick comparison and efficient memory usage.
 288 //------------------------------------------------------------------
 289 void
 290 FileSpec::SetFile (const char *pathname, bool resolve)
 291 {
 292     m_filename.Clear();
 293     m_directory.Clear();
 294     m_is_resolved = false;
 295     if (pathname == NULL || pathname[0] == '\0')
 296         return;
 297
 298     char resolved_path[PATH_MAX];
 299     bool path_fit = true;
 300
 301     if (resolve)
 302     {
 303         path_fit = (FileSpec::Resolve (pathname, resolved_path, sizeof(resolved_path)) < sizeof(resolved_path) - 1);
 304         m_is_resolved = path_fit;
 305     }
 306     else
 307     {
 308         // Copy the path because "basename" and "dirname" want to muck with the
 309         // path buffer
 310         if (::strlen (pathname) > sizeof(resolved_path) - 1)
 311             path_fit = false;
 312         else
 313             ::strcpy (resolved_path, pathname);
 314     }
 315
 316
 317     if (path_fit)
 318     {
 319         char *filename = ::basename (resolved_path);
 320         if (filename)
 321         {
 322             m_filename.SetCString (filename);
 323             // Truncate the basename off the end of the resolved path
 324
 325             // Only attempt to get the dirname if it looks like we have a path
 326             if (strchr(resolved_path, '/'))
 327             {
 328                 char *directory = ::dirname (resolved_path);
 329
 330                 // Make sure we didn't get our directory resolved to "." without having
 331                 // specified
 332                 if (directory)
 333                     m_directory.SetCString(directory);
 334                 else
 335                 {
 336                     char *last_resolved_path_slash = strrchr(resolved_path, '/');
 337                     if (last_resolved_path_slash)
 338                     {
 339                         *last_resolved_path_slash = '\0';
 340                         m_directory.SetCString(resolved_path);
 341                     }
 342                 }
 343             }
 344         }
 345         else
 346             m_directory.SetCString(resolved_path);
 347     }
 348 }
 349
 350 //----------------------------------------------------------------------
 351 // Convert to pointer operator. This allows code to check any FileSpec
 352 // objects to see if they contain anything valid using code such as:
 353 //
 354 //  if (file_spec)
 355 //  {}
 356 //----------------------------------------------------------------------
 357 FileSpec::operator bool() const
 358 {
 359     return m_filename || m_directory;
 360 }
 361
 362 //----------------------------------------------------------------------
 363 // Logical NOT operator. This allows code to check any FileSpec
 364 // objects to see if they are invalid using code such as:
 365 //
 366 //  if (!file_spec)
 367 //  {}
 368 //----------------------------------------------------------------------
 369 bool
 370 FileSpec::operator!() const
 371 {
 372     return !m_directory && !m_filename;
 373 }
 374
 375 //------------------------------------------------------------------
 376 // Equal to operator
 377 //------------------------------------------------------------------
 378 bool
 379 FileSpec::operator== (const FileSpec& rhs) const
 380 {
 381     if (m_filename == rhs.m_filename)
 382     {
 383         if (m_directory == rhs.m_directory)
 384             return true;
 385
 386         // TODO: determine if we want to keep this code in here.
 387         // The code below was added to handle a case where we were
 388         // trying to set a file and line breakpoint and one path
 389         // was resolved, and the other not and the directory was
 390         // in a mount point that resolved to a more complete path:
 391         // "/tmp/a.c" == "/private/tmp/a.c". I might end up pulling
 392         // this out...
 393         if (IsResolved() && rhs.IsResolved())
 394         {
 395             // Both paths are resolved, no need to look further...
 396             return false;
 397         }
 398
 399         FileSpec resolved_lhs(*this);
 400
 401         // If "this" isn't resolved, resolve it
 402         if (!IsResolved())
 403         {
 404             if (resolved_lhs.ResolvePath())
 405             {
 406                 // This path wasn't resolved but now it is. Check if the resolved
 407                 // directory is the same as our unresolved directory, and if so,
 408                 // we can mark this object as resolved to avoid more future resolves
 409                 m_is_resolved = (m_directory == resolved_lhs.m_directory);
 410             }
 411             else
 412                 return false;
 413         }
 414
 415         FileSpec resolved_rhs(rhs);
 416         if (!rhs.IsResolved())
 417         {
 418             if (resolved_rhs.ResolvePath())
 419             {
 420                 // rhs's path wasn't resolved but now it is. Check if the resolved
 421                 // directory is the same as rhs's unresolved directory, and if so,
 422                 // we can mark this object as resolved to avoid more future resolves
 423                 rhs.m_is_resolved = (rhs.m_directory == resolved_rhs.m_directory);
 424             }
 425             else
 426                 return false;
 427         }
 428
 429         // If we reach this point in the code we were able to resolve both paths
 430         // and since we only resolve the paths if the basenames are equal, then
 431         // we can just check if both directories are equal...
 432         return resolved_lhs.GetDirectory() == resolved_rhs.GetDirectory();
 433     }
 434     return false;
 435 }
 436
 437 //------------------------------------------------------------------
 438 // Not equal to operator
 439 //------------------------------------------------------------------
 440 bool
 441 FileSpec::operator!= (const FileSpec& rhs) const
 442 {
 443     return !(*this == rhs);
 444 }
 445
 446 //------------------------------------------------------------------
 447 // Less than operator
 448 //------------------------------------------------------------------
 449 bool
 450 FileSpec::operator< (const FileSpec& rhs) const
 451 {
 452     return FileSpec::Compare(*this, rhs, true) < 0;
 453 }
 454
 455 //------------------------------------------------------------------
 456 // Dump a FileSpec object to a stream
 457 //------------------------------------------------------------------
 458 Stream&
 459 lldb_private::operator << (Stream &s, const FileSpec& f)
 460 {
 461     f.Dump(&s);
 462     return s;
 463 }
 464
 465 //------------------------------------------------------------------
 466 // Clear this object by releasing both the directory and filename
 467 // string values and making them both the empty string.
 468 //------------------------------------------------------------------
 469 void
 470 FileSpec::Clear()
 471 {
 472     m_directory.Clear();
 473     m_filename.Clear();
 474 }
 475
 476 //------------------------------------------------------------------
 477 // Compare two FileSpec objects. If "full" is true, then both
 478 // the directory and the filename must match. If "full" is false,
 479 // then the directory names for "a" and "b" are only compared if
 480 // they are both non-empty. This allows a FileSpec object to only
 481 // contain a filename and it can match FileSpec objects that have
 482 // matching filenames with different paths.
 483 //
 484 // Return -1 if the "a" is less than "b", 0 if "a" is equal to "b"
 485 // and "1" if "a" is greater than "b".
 486 //------------------------------------------------------------------
 487 int
 488 FileSpec::Compare(const FileSpec& a, const FileSpec& b, bool full)
 489 {
 490     int result = 0;
 491
 492     // If full is true, then we must compare both the directory and filename.
 493
 494     // If full is false, then if either directory is empty, then we match on
 495     // the basename only, and if both directories have valid values, we still
 496     // do a full compare. This allows for matching when we just have a filename
 497     // in one of the FileSpec objects.
 498
 499     if (full || (a.m_directory && b.m_directory))
 500     {
 501         result = ConstString::Compare(a.m_directory, b.m_directory);
 502         if (result)
 503             return result;
 504     }
 505     return ConstString::Compare (a.m_filename, b.m_filename);
 506 }
 507
 508 bool
 509 FileSpec::Equal (const FileSpec& a, const FileSpec& b, bool full)
 510 {
 511     if (!full && (a.GetDirectory().IsEmpty() || b.GetDirectory().IsEmpty()))
 512         return a.m_filename == b.m_filename;
 513     else
 514         return a == b;
 515 }
 516
 517
 518
 519 //------------------------------------------------------------------
 520 // Dump the object to the supplied stream. If the object contains
 521 // a valid directory name, it will be displayed followed by a
 522 // directory delimiter, and the filename.
 523 //------------------------------------------------------------------
 524 void
 525 FileSpec::Dump(Stream *s) const
 526 {
 527     static ConstString g_slash_only ("/");
 528     if (s)
 529     {
 530         m_directory.Dump(s);
 531         if (m_directory && m_directory != g_slash_only)
 532             s->PutChar('/');
 533         m_filename.Dump(s);
 534     }
 535 }
 536
 537 //------------------------------------------------------------------
 538 // Returns true if the file exists.
 539 //------------------------------------------------------------------
 540 bool
 541 FileSpec::Exists () const
 542 {
 543     struct stat file_stats;
 544     return GetFileStats (this, &file_stats);
 545 }
 546
 547 bool
 548 FileSpec::ResolveExecutableLocation ()
 549 {
 550     if (!m_directory)
 551     {
 552         const char *file_cstr = m_filename.GetCString();
 553         if (file_cstr)
 554         {
 555             const std::string file_str (file_cstr);
 556             llvm::sys::Path path = llvm::sys::Program::FindProgramByName (file_str);
 557             const std::string &path_str = path.str();
 558             llvm::StringRef dir_ref = llvm::sys::path::parent_path(path_str);
 559             //llvm::StringRef dir_ref = path.getDirname();
 560             if (! dir_ref.empty())
 561             {
 562                 // FindProgramByName returns "." if it can't find the file.
 563                 if (strcmp (".", dir_ref.data()) == 0)
 564                     return false;
 565
 566                 m_directory.SetCString (dir_ref.data());
 567                 if (Exists())
 568                     return true;
 569                 else
 570                 {
 571                     // If FindProgramByName found the file, it returns the directory + filename in its return results.
 572                     // We need to separate them.
 573                     FileSpec tmp_file (dir_ref.data(), false);
 574                     if (tmp_file.Exists())
 575                     {
 576                         m_directory = tmp_file.m_directory;
 577                         return true;
 578                     }
 579                 }
 580             }
 581         }
 582     }
 583
 584     return false;
 585 }
 586
 587 bool
 588 FileSpec::ResolvePath ()
 589 {
 590     if (m_is_resolved)
 591         return true;    // We have already resolved this path
 592
 593     char path_buf[PATH_MAX];
 594     if (!GetPath (path_buf, PATH_MAX))
 595         return false;
 596     // SetFile(...) will set m_is_resolved correctly if it can resolve the path
 597     SetFile (path_buf, true);
 598     return m_is_resolved;
 599 }
 600
 601 uint64_t
 602 FileSpec::GetByteSize() const
 603 {
 604     struct stat file_stats;
 605     if (GetFileStats (this, &file_stats))
 606         return file_stats.st_size;
 607     return 0;
 608 }
 609
 610 FileSpec::FileType
 611 FileSpec::GetFileType () const
 612 {
 613     struct stat file_stats;
 614     if (GetFileStats (this, &file_stats))
 615     {
 616         mode_t file_type = file_stats.st_mode & S_IFMT;
 617         switch (file_type)
 618         {
 619         case S_IFDIR:   return eFileTypeDirectory;
 620         case S_IFIFO:   return eFileTypePipe;
 621         case S_IFREG:   return eFileTypeRegular;
 622         case S_IFSOCK:  return eFileTypeSocket;
 623         case S_IFLNK:   return eFileTypeSymbolicLink;
 624         default:
 625             break;
 626         }
 627         return eFileTypeUnknown;
 628     }
 629     return eFileTypeInvalid;
 630 }
 631
 632 TimeValue
 633 FileSpec::GetModificationTime () const
 634 {
 635     TimeValue mod_time;
 636     struct stat file_stats;
 637     if (GetFileStats (this, &file_stats))
 638         mod_time.OffsetWithSeconds(file_stats.st_mtime);
 639     return mod_time;
 640 }
 641
 642 //------------------------------------------------------------------
 643 // Directory string get accessor.
 644 //------------------------------------------------------------------
 645 ConstString &
 646 FileSpec::GetDirectory()
 647 {
 648     return m_directory;
 649 }
 650
 651 //------------------------------------------------------------------
 652 // Directory string const get accessor.
 653 //------------------------------------------------------------------
 654 const ConstString &
 655 FileSpec::GetDirectory() const
 656 {
 657     return m_directory;
 658 }
 659
 660 //------------------------------------------------------------------
 661 // Filename string get accessor.
 662 //------------------------------------------------------------------
 663 ConstString &
 664 FileSpec::GetFilename()
 665 {
 666     return m_filename;
 667 }
 668
 669 //------------------------------------------------------------------
 670 // Filename string const get accessor.
 671 //------------------------------------------------------------------
 672 const ConstString &
 673 FileSpec::GetFilename() const
 674 {
 675     return m_filename;
 676 }
 677
 678 //------------------------------------------------------------------
 679 // Extract the directory and path into a fixed buffer. This is
 680 // needed as the directory and path are stored in separate string
 681 // values.
 682 //------------------------------------------------------------------
 683 size_t
 684 FileSpec::GetPath(char *path, size_t path_max_len) const
 685 {
 686     if (path_max_len)
 687     {
 688         const char *dirname = m_directory.GetCString();
 689         const char *filename = m_filename.GetCString();
 690         if (dirname)
 691         {
 692             if (filename)
 693                 return ::snprintf (path, path_max_len, "%s/%s", dirname, filename);
 694             else
 695                 return ::snprintf (path, path_max_len, "%s", dirname);
 696         }
 697         else if (filename)
 698         {
 699             return ::snprintf (path, path_max_len, "%s", filename);
 700         }
 701     }
 702     if (path)
 703         path[0] = '\0';
 704     return 0;
 705 }
 706
 707 std::string
 708 FileSpec::GetPath (void) const
 709 {
 710     static ConstString g_slash_only ("/");
 711     std::string path;
 712     const char *dirname = m_directory.GetCString();
 713     const char *filename = m_filename.GetCString();
 714     if (dirname)
 715     {
 716         path.append (dirname);
 717         if (filename && m_directory != g_slash_only)
 718             path.append ("/");
 719     }
 720     if (filename)
 721         path.append (filename);
 722     return path;
 723 }
 724
 725 ConstString
 726 FileSpec::GetFileNameExtension () const
 727 {
 728     if (m_filename)
 729     {
 730         const char *filename = m_filename.GetCString();
 731         const char* dot_pos = strrchr(filename, '.');
 732         if (dot_pos && dot_pos[1] != '\0')
 733             return ConstString(dot_pos+1);
 734     }
 735     return ConstString();
 736 }
 737
 738 ConstString
 739 FileSpec::GetFileNameStrippingExtension () const
 740 {
 741     const char *filename = m_filename.GetCString();
 742     if (filename == NULL)
 743         return ConstString();
 744
 745     const char* dot_pos = strrchr(filename, '.');
 746     if (dot_pos == NULL)
 747         return m_filename;
 748
 749     return ConstString(filename, dot_pos-filename);
 750 }
 751
 752 //------------------------------------------------------------------
 753 // Returns a shared pointer to a data buffer that contains all or
 754 // part of the contents of a file. The data is memory mapped and
 755 // will lazily page in data from the file as memory is accessed.
 756 // The data that is mappped will start "file_offset" bytes into the
 757 // file, and "file_size" bytes will be mapped. If "file_size" is
 758 // greater than the number of bytes available in the file starting
 759 // at "file_offset", the number of bytes will be appropriately
 760 // truncated. The final number of bytes that get mapped can be
 761 // verified using the DataBuffer::GetByteSize() function.
 762 //------------------------------------------------------------------
 763 DataBufferSP
 764 FileSpec::MemoryMapFileContents(off_t file_offset, size_t file_size) const
 765 {
 766     DataBufferSP data_sp;
 767     std::unique_ptr<DataBufferMemoryMap> mmap_data(new DataBufferMemoryMap());
 768     if (mmap_data.get())
 769     {
 770         const size_t mapped_length = mmap_data->MemoryMapFromFileSpec (this, file_offset, file_size);
 771         if (((file_size == SIZE_MAX) && (mapped_length > 0)) || (mapped_length >= file_size))
 772             data_sp.reset(mmap_data.release());
 773     }
 774     return data_sp;
 775 }
 776
 777
 778 //------------------------------------------------------------------
 779 // Return the size in bytes that this object takes in memory. This
 780 // returns the size in bytes of this object, not any shared string
 781 // values it may refer to.
 782 //------------------------------------------------------------------
 783 size_t
 784 FileSpec::MemorySize() const
 785 {
 786     return m_filename.MemorySize() + m_directory.MemorySize();
 787 }
 788
 789
 790 size_t
 791 FileSpec::ReadFileContents (off_t file_offset, void *dst, size_t dst_len, Error *error_ptr) const
 792 {
 793     Error error;
 794     size_t bytes_read = 0;
 795     char resolved_path[PATH_MAX];
 796     if (GetPath(resolved_path, sizeof(resolved_path)))
 797     {
 798         File file;
 799         error = file.Open(resolved_path, File::eOpenOptionRead);
 800         if (error.Success())
 801         {
 802             off_t file_offset_after_seek = file_offset;
 803             bytes_read = dst_len;
 804             error = file.Read(dst, bytes_read, file_offset_after_seek);
 805         }
 806     }
 807     else
 808     {
 809         error.SetErrorString("invalid file specification");
 810     }
 811     if (error_ptr)
 812         *error_ptr = error;
 813     return bytes_read;
 814 }
 815
 816 //------------------------------------------------------------------
 817 // Returns a shared pointer to a data buffer that contains all or
 818 // part of the contents of a file. The data copies into a heap based
 819 // buffer that lives in the DataBuffer shared pointer object returned.
 820 // The data that is cached will start "file_offset" bytes into the
 821 // file, and "file_size" bytes will be mapped. If "file_size" is
 822 // greater than the number of bytes available in the file starting
 823 // at "file_offset", the number of bytes will be appropriately
 824 // truncated. The final number of bytes that get mapped can be
 825 // verified using the DataBuffer::GetByteSize() function.
 826 //------------------------------------------------------------------
 827 DataBufferSP
 828 FileSpec::ReadFileContents (off_t file_offset, size_t file_size, Error *error_ptr) const
 829 {
 830     Error error;
 831     DataBufferSP data_sp;
 832     char resolved_path[PATH_MAX];
 833     if (GetPath(resolved_path, sizeof(resolved_path)))
 834     {
 835         File file;
 836         error = file.Open(resolved_path, File::eOpenOptionRead);
 837         if (error.Success())
 838         {
 839             const bool null_terminate = false;
 840             error = file.Read (file_size, file_offset, null_terminate, data_sp);
 841         }
 842     }
 843     else
 844     {
 845         error.SetErrorString("invalid file specification");
 846     }
 847     if (error_ptr)
 848         *error_ptr = error;
 849     return data_sp;
 850 }
 851
 852 DataBufferSP
 853 FileSpec::ReadFileContentsAsCString(Error *error_ptr)
 854 {
 855     Error error;
 856     DataBufferSP data_sp;
 857     char resolved_path[PATH_MAX];
 858     if (GetPath(resolved_path, sizeof(resolved_path)))
 859     {
 860         File file;
 861         error = file.Open(resolved_path, File::eOpenOptionRead);
 862         if (error.Success())
 863         {
 864             off_t offset = 0;
 865             size_t length = SIZE_MAX;
 866             const bool null_terminate = true;
 867             error = file.Read (length, offset, null_terminate, data_sp);
 868         }
 869     }
 870     else
 871     {
 872         error.SetErrorString("invalid file specification");
 873     }
 874     if (error_ptr)
 875         *error_ptr = error;
 876     return data_sp;
 877 }
 878
 879 size_t
 880 FileSpec::ReadFileLines (STLStringArray &lines)
 881 {
 882     lines.clear();
 883     char path[PATH_MAX];
 884     if (GetPath(path, sizeof(path)))
 885     {
 886         std::ifstream file_stream (path);
 887
 888         if (file_stream)
 889         {
 890             std::string line;
 891             while (getline (file_stream, line))
 892                 lines.push_back (line);
 893         }
 894     }
 895     return lines.size();
 896 }
 897
 898 FileSpec::EnumerateDirectoryResult
 899 FileSpec::EnumerateDirectory
 900 (
 901     const char *dir_path,
 902     bool find_directories,
 903     bool find_files,
 904     bool find_other,
 905     EnumerateDirectoryCallbackType callback,
 906     void *callback_baton
 907 )
 908 {
 909     if (dir_path && dir_path[0])
 910     {
 911         lldb_utility::CleanUp <DIR *, int> dir_path_dir (opendir(dir_path), NULL, closedir);
 912         if (dir_path_dir.is_valid())
 913         {
 914             long path_max = fpathconf (dirfd (dir_path_dir.get()), _PC_NAME_MAX);
 915 #if defined (__APPLE_) && defined (__DARWIN_MAXPATHLEN)
 916             if (path_max < __DARWIN_MAXPATHLEN)
 917                 path_max = __DARWIN_MAXPATHLEN;
 918 #endif
 919             struct dirent *buf, *dp;
 920             buf = (struct dirent *) malloc (offsetof (struct dirent, d_name) + path_max + 1);
 921
 922             while (buf && readdir_r(dir_path_dir.get(), buf, &dp) == 0 && dp)
 923             {
 924                 // Only search directories
 925                 if (dp->d_type == DT_DIR || dp->d_type == DT_UNKNOWN)
 926                 {
 927                     size_t len = strlen(dp->d_name);
 928
 929                     if (len == 1 && dp->d_name[0] == '.')
 930                         continue;
 931
 932                     if (len == 2 && dp->d_name[0] == '.' && dp->d_name[1] == '.')
 933                         continue;
 934                 }
 935
 936                 bool call_callback = false;
 937                 FileSpec::FileType file_type = eFileTypeUnknown;
 938
 939                 switch (dp->d_type)
 940                 {
 941                 default:
 942                 case DT_UNKNOWN:    file_type = eFileTypeUnknown;       call_callback = true;               break;
 943                 case DT_FIFO:       file_type = eFileTypePipe;          call_callback = find_other;         break;
 944                 case DT_CHR:        file_type = eFileTypeOther;         call_callback = find_other;         break;
 945                 case DT_DIR:        file_type = eFileTypeDirectory;     call_callback = find_directories;   break;
 946                 case DT_BLK:        file_type = eFileTypeOther;         call_callback = find_other;         break;
 947                 case DT_REG:        file_type = eFileTypeRegular;       call_callback = find_files;         break;
 948                 case DT_LNK:        file_type = eFileTypeSymbolicLink;  call_callback = find_other;         break;
 949                 case DT_SOCK:       file_type = eFileTypeSocket;        call_callback = find_other;         break;
 950 #if !defined(__OpenBSD__)
 951                 case DT_WHT:        file_type = eFileTypeOther;         call_callback = find_other;         break;
 952 #endif
 953                 }
 954
 955                 if (call_callback)
 956                 {
 957                     char child_path[PATH_MAX];
 958                     const int child_path_len = ::snprintf (child_path, sizeof(child_path), "%s/%s", dir_path, dp->d_name);
 959                     if (child_path_len < (int)(sizeof(child_path) - 1))
 960                     {
 961                         // Don't resolve the file type or path
 962                         FileSpec child_path_spec (child_path, false);
 963
 964                         EnumerateDirectoryResult result = callback (callback_baton, file_type, child_path_spec);
 965
 966                         switch (result)
 967                         {
 968                         case eEnumerateDirectoryResultNext:
 969                             // Enumerate next entry in the current directory. We just
 970                             // exit this switch and will continue enumerating the
 971                             // current directory as we currently are...
 972                             break;
 973
 974                         case eEnumerateDirectoryResultEnter: // Recurse into the current entry if it is a directory or symlink, or next if not
 975                             if (FileSpec::EnumerateDirectory (child_path,
 976                                                               find_directories,
 977                                                               find_files,
 978                                                               find_other,
 979                                                               callback,
 980                                                               callback_baton) == eEnumerateDirectoryResultQuit)
 981                             {
 982                                 // The subdirectory returned Quit, which means to
 983                                 // stop all directory enumerations at all levels.
 984                                 if (buf)
 985                                     free (buf);
 986                                 return eEnumerateDirectoryResultQuit;
 987                             }
 988                             break;
 989
 990                         case eEnumerateDirectoryResultExit:  // Exit from the current directory at the current level.
 991                             // Exit from this directory level and tell parent to
 992                             // keep enumerating.
 993                             if (buf)
 994                                 free (buf);
 995                             return eEnumerateDirectoryResultNext;
 996
 997                         case eEnumerateDirectoryResultQuit:  // Stop directory enumerations at any level
 998                             if (buf)
 999                                 free (buf);
1000                             return eEnumerateDirectoryResultQuit;
1001                         }
1002                     }
1003                 }
1004             }
1005             if (buf)
1006             {
1007                 free (buf);
1008             }
1009         }
1010     }
1011     // By default when exiting a directory, we tell the parent enumeration
1012     // to continue enumerating.
1013     return eEnumerateDirectoryResultNext;
1014 }
1015
1016 //------------------------------------------------------------------
1017 /// Returns true if the filespec represents an implementation source
1018 /// file (files with a ".c", ".cpp", ".m", ".mm" (many more)
1019 /// extension).
1020 ///
1021 /// @return
1022 ///     \b true if the filespec represents an implementation source
1023 ///     file, \b false otherwise.
1024 //------------------------------------------------------------------
1025 bool
1026 FileSpec::IsSourceImplementationFile () const
1027 {
1028     ConstString extension (GetFileNameExtension());
1029     if (extension)
1030     {
1031         static RegularExpression g_source_file_regex ("^(c|m|mm|cpp|c\\+\\+|cxx|cc|cp|s|asm|f|f77|f90|f95|f03|for|ftn|fpp|ada|adb|ads)$",
1032                                                       REG_EXTENDED | REG_ICASE);
1033         return g_source_file_regex.Execute (extension.GetCString());
1034     }
1035     return false;
1036 }
1037
1038 bool
1039 FileSpec::IsRelativeToCurrentWorkingDirectory () const
1040 {
1041     const char *directory = m_directory.GetCString();
1042     if (directory && directory[0])
1043     {
1044         // If the path doesn't start with '/' or '~', return true
1045         switch (directory[0])
1046         {
1047         case '/':
1048         case '~':
1049             return false;
1050         default:
1051             return true;
1052         }
1053     }
1054     else if (m_filename)
1055     {
1056         // No directory, just a basename, return true
1057         return true;
1058     }
1059     return false;
1060 }