7481c20f09
and "/private/tmp/a.c". This was done by adding a "mutable bool m_is_resolved;" member to FileSpec and then modifying the equal operator to check if the filenames are equal, and if they are, then check the directories. If they are not equal, then both paths are checked to see if they have been resolved. If they have been resolved, we resolve the paths in temporary FileSpec objects and set each of the m_is_resolved bools to try (for lhs and rhs) if the paths match what is contained in the path. This allows us to do more intelligent compares without having to resolve all paths found in the debug info (which can quickly get costly if the files are on remote NFS mounts). llvm-svn: 118387
802 lines
25 KiB
C++
802 lines
25 KiB
C++
//===-- FileSpec.cpp --------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
#include <fcntl.h>
|
|
#include <libgen.h>
|
|
#include <stdlib.h>
|
|
#include <sys/param.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <pwd.h>
|
|
|
|
#include <fstream>
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/System/Path.h"
|
|
#include "llvm/System/Program.h"
|
|
|
|
#include "lldb/Core/FileSpec.h"
|
|
#include "lldb/Core/DataBufferHeap.h"
|
|
#include "lldb/Core/DataBufferMemoryMap.h"
|
|
#include "lldb/Core/Stream.h"
|
|
#include "lldb/Host/Host.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
using namespace std;
|
|
|
|
static bool
|
|
GetFileStats (const FileSpec *file_spec, struct stat *stats_ptr)
|
|
{
|
|
char resolved_path[PATH_MAX];
|
|
if (file_spec->GetPath(&resolved_path[0], sizeof(resolved_path)))
|
|
return ::stat (resolved_path, stats_ptr) == 0;
|
|
return false;
|
|
}
|
|
|
|
static const char*
|
|
GetCachedGlobTildeSlash()
|
|
{
|
|
static std::string g_tilde;
|
|
if (g_tilde.empty())
|
|
{
|
|
struct passwd *user_entry;
|
|
user_entry = getpwuid(geteuid());
|
|
if (user_entry != NULL)
|
|
g_tilde = user_entry->pw_dir;
|
|
|
|
if (g_tilde.empty())
|
|
return NULL;
|
|
}
|
|
return g_tilde.c_str();
|
|
}
|
|
|
|
// Resolves the username part of a path of the form ~user/other/directories, and
|
|
// writes the result into dst_path.
|
|
// Returns 0 if there WAS a ~ in the path but the username couldn't be resolved.
|
|
// Otherwise returns the number of characters copied into dst_path. If the return
|
|
// is >= dst_len, then the resolved path is too long...
|
|
size_t
|
|
FileSpec::ResolveUsername (const char *src_path, char *dst_path, size_t dst_len)
|
|
{
|
|
char user_home[PATH_MAX];
|
|
const char *user_name;
|
|
|
|
if (src_path == NULL || src_path[0] == '\0')
|
|
return 0;
|
|
|
|
// If there's no ~, then just copy src_path straight to dst_path (they may be the same string...)
|
|
if (src_path[0] != '~')
|
|
{
|
|
size_t len = strlen (src_path);
|
|
if (len >= dst_len)
|
|
{
|
|
::bcopy (src_path, dst_path, dst_len - 1);
|
|
dst_path[dst_len] = '\0';
|
|
}
|
|
else
|
|
::bcopy (src_path, dst_path, len + 1);
|
|
|
|
return len;
|
|
}
|
|
|
|
const char *first_slash = ::strchr (src_path, '/');
|
|
char remainder[PATH_MAX];
|
|
|
|
if (first_slash == NULL)
|
|
{
|
|
// The whole name is the username (minus the ~):
|
|
user_name = src_path + 1;
|
|
remainder[0] = '\0';
|
|
}
|
|
else
|
|
{
|
|
int user_name_len = first_slash - src_path - 1;
|
|
::memcpy (user_home, src_path + 1, user_name_len);
|
|
user_home[user_name_len] = '\0';
|
|
user_name = user_home;
|
|
|
|
::strcpy (remainder, first_slash);
|
|
}
|
|
|
|
if (user_name == NULL)
|
|
return 0;
|
|
// User name of "" means the current user...
|
|
|
|
struct passwd *user_entry;
|
|
const char *home_dir = NULL;
|
|
|
|
if (user_name[0] == '\0')
|
|
{
|
|
home_dir = GetCachedGlobTildeSlash();
|
|
}
|
|
else
|
|
{
|
|
user_entry = ::getpwnam (user_name);
|
|
if (user_entry != NULL)
|
|
home_dir = user_entry->pw_dir;
|
|
}
|
|
|
|
if (home_dir == NULL)
|
|
return 0;
|
|
else
|
|
return ::snprintf (dst_path, dst_len, "%s%s", home_dir, remainder);
|
|
}
|
|
|
|
size_t
|
|
FileSpec::Resolve (const char *src_path, char *dst_path, size_t dst_len)
|
|
{
|
|
if (src_path == NULL || src_path[0] == '\0')
|
|
return 0;
|
|
|
|
// Glob if needed for ~/, otherwise copy in case src_path is same as dst_path...
|
|
char unglobbed_path[PATH_MAX];
|
|
if (src_path[0] == '~')
|
|
{
|
|
size_t return_count = ResolveUsername(src_path, unglobbed_path, sizeof(unglobbed_path));
|
|
|
|
// If we couldn't find the user referred to, or the resultant path was too long,
|
|
// then just copy over the src_path.
|
|
if (return_count == 0 || return_count >= sizeof(unglobbed_path))
|
|
::snprintf (unglobbed_path, sizeof(unglobbed_path), "%s", src_path);
|
|
}
|
|
else
|
|
::snprintf(unglobbed_path, sizeof(unglobbed_path), "%s", src_path);
|
|
|
|
// Now resolve the path if needed
|
|
char resolved_path[PATH_MAX];
|
|
if (::realpath (unglobbed_path, resolved_path))
|
|
{
|
|
// Success, copy the resolved path
|
|
return ::snprintf(dst_path, dst_len, "%s", resolved_path);
|
|
}
|
|
else
|
|
{
|
|
// Failed, just copy the unglobbed path
|
|
return ::snprintf(dst_path, dst_len, "%s", unglobbed_path);
|
|
}
|
|
}
|
|
|
|
FileSpec::FileSpec() :
|
|
m_directory(),
|
|
m_filename()
|
|
{
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Default constructor that can take an optional full path to a
|
|
// file on disk.
|
|
//------------------------------------------------------------------
|
|
FileSpec::FileSpec(const char *pathname, bool resolve_path) :
|
|
m_directory(),
|
|
m_filename(),
|
|
m_is_resolved(false)
|
|
{
|
|
if (pathname && pathname[0])
|
|
SetFile(pathname, resolve_path);
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Copy constructor
|
|
//------------------------------------------------------------------
|
|
FileSpec::FileSpec(const FileSpec& rhs) :
|
|
m_directory (rhs.m_directory),
|
|
m_filename (rhs.m_filename),
|
|
m_is_resolved (rhs.m_is_resolved)
|
|
{
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Copy constructor
|
|
//------------------------------------------------------------------
|
|
FileSpec::FileSpec(const FileSpec* rhs) :
|
|
m_directory(),
|
|
m_filename()
|
|
{
|
|
if (rhs)
|
|
*this = *rhs;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Virtual destrcuctor in case anyone inherits from this class.
|
|
//------------------------------------------------------------------
|
|
FileSpec::~FileSpec()
|
|
{
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Assignment operator.
|
|
//------------------------------------------------------------------
|
|
const FileSpec&
|
|
FileSpec::operator= (const FileSpec& rhs)
|
|
{
|
|
if (this != &rhs)
|
|
{
|
|
m_directory = rhs.m_directory;
|
|
m_filename = rhs.m_filename;
|
|
m_is_resolved = rhs.m_is_resolved;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Update the contents of this object with a new path. The path will
|
|
// be split up into a directory and filename and stored as uniqued
|
|
// string values for quick comparison and efficient memory usage.
|
|
//------------------------------------------------------------------
|
|
void
|
|
FileSpec::SetFile (const char *pathname, bool resolve)
|
|
{
|
|
m_filename.Clear();
|
|
m_directory.Clear();
|
|
m_is_resolved = false;
|
|
if (pathname == NULL || pathname[0] == '\0')
|
|
return;
|
|
|
|
char resolved_path[PATH_MAX];
|
|
bool path_fit = true;
|
|
|
|
if (resolve)
|
|
{
|
|
path_fit = (FileSpec::Resolve (pathname, resolved_path, sizeof(resolved_path)) < sizeof(resolved_path) - 1);
|
|
m_is_resolved = path_fit;
|
|
}
|
|
else
|
|
{
|
|
// Copy the path because "basename" and "dirname" want to muck with the
|
|
// path buffer
|
|
if (::strlen (pathname) > sizeof(resolved_path) - 1)
|
|
path_fit = false;
|
|
else
|
|
::strcpy (resolved_path, pathname);
|
|
}
|
|
|
|
|
|
if (path_fit)
|
|
{
|
|
char *filename = ::basename (resolved_path);
|
|
if (filename)
|
|
{
|
|
m_filename.SetCString (filename);
|
|
// Truncate the basename off the end of the resolved path
|
|
|
|
// Only attempt to get the dirname if it looks like we have a path
|
|
if (strchr(resolved_path, '/'))
|
|
{
|
|
char *directory = ::dirname (resolved_path);
|
|
|
|
// Make sure we didn't get our directory resolved to "." without having
|
|
// specified
|
|
if (directory)
|
|
m_directory.SetCString(directory);
|
|
else
|
|
{
|
|
char *last_resolved_path_slash = strrchr(resolved_path, '/');
|
|
if (last_resolved_path_slash)
|
|
{
|
|
*last_resolved_path_slash = '\0';
|
|
m_directory.SetCString(resolved_path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
m_directory.SetCString(resolved_path);
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Convert to pointer operator. This allows code to check any FileSpec
|
|
// objects to see if they contain anything valid using code such as:
|
|
//
|
|
// if (file_spec)
|
|
// {}
|
|
//----------------------------------------------------------------------
|
|
FileSpec::operator
|
|
void*() const
|
|
{
|
|
return (m_directory || m_filename) ? const_cast<FileSpec*>(this) : NULL;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Logical NOT operator. This allows code to check any FileSpec
|
|
// objects to see if they are invalid using code such as:
|
|
//
|
|
// if (!file_spec)
|
|
// {}
|
|
//----------------------------------------------------------------------
|
|
bool
|
|
FileSpec::operator!() const
|
|
{
|
|
return !m_directory && !m_filename;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Equal to operator
|
|
//------------------------------------------------------------------
|
|
bool
|
|
FileSpec::operator== (const FileSpec& rhs) const
|
|
{
|
|
if (m_filename == rhs.m_filename)
|
|
{
|
|
if (m_directory == rhs.m_directory)
|
|
return true;
|
|
|
|
// TODO: determine if we want to keep this code in here.
|
|
// The code below was added to handle a case where we were
|
|
// trying to set a file and line breakpoint and one path
|
|
// was resolved, and the other not and the directory was
|
|
// in a mount point that resolved to a more complete path:
|
|
// "/tmp/a.c" == "/private/tmp/a.c". I might end up pulling
|
|
// this out...
|
|
if (IsResolved() && rhs.IsResolved())
|
|
{
|
|
// Both paths are resolved, no need to look further...
|
|
return false;
|
|
}
|
|
|
|
FileSpec resolved_lhs(*this);
|
|
|
|
// If "this" isn't resolved, resolve it
|
|
if (!IsResolved())
|
|
{
|
|
if (resolved_lhs.ResolvePath())
|
|
{
|
|
// This path wasn't resolved but now it is. Check if the resolved
|
|
// directory is the same as our unresolved directory, and if so,
|
|
// we can mark this object as resolved to avoid more future resolves
|
|
m_is_resolved = (m_directory == resolved_lhs.m_directory);
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
FileSpec resolved_rhs(rhs);
|
|
if (!rhs.IsResolved())
|
|
{
|
|
if (resolved_rhs.ResolvePath())
|
|
{
|
|
// rhs's path wasn't resolved but now it is. Check if the resolved
|
|
// directory is the same as rhs's unresolved directory, and if so,
|
|
// we can mark this object as resolved to avoid more future resolves
|
|
rhs.m_is_resolved = (m_directory == resolved_rhs.m_directory);
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
// If we reach this point in the code we were able to resolve both paths
|
|
// and since we only resolve the paths if the basenames are equal, then
|
|
// we can just check if both directories are equal...
|
|
return resolved_lhs.GetDirectory() == resolved_rhs.GetDirectory();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Not equal to operator
|
|
//------------------------------------------------------------------
|
|
bool
|
|
FileSpec::operator!= (const FileSpec& rhs) const
|
|
{
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Less than operator
|
|
//------------------------------------------------------------------
|
|
bool
|
|
FileSpec::operator< (const FileSpec& rhs) const
|
|
{
|
|
return FileSpec::Compare(*this, rhs, true) < 0;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Dump a FileSpec object to a stream
|
|
//------------------------------------------------------------------
|
|
Stream&
|
|
lldb_private::operator << (Stream &s, const FileSpec& f)
|
|
{
|
|
f.Dump(&s);
|
|
return s;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Clear this object by releasing both the directory and filename
|
|
// string values and making them both the empty string.
|
|
//------------------------------------------------------------------
|
|
void
|
|
FileSpec::Clear()
|
|
{
|
|
m_directory.Clear();
|
|
m_filename.Clear();
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Compare two FileSpec objects. If "full" is true, then both
|
|
// the directory and the filename must match. If "full" is false,
|
|
// then the directory names for "a" and "b" are only compared if
|
|
// they are both non-empty. This allows a FileSpec object to only
|
|
// contain a filename and it can match FileSpec objects that have
|
|
// matching filenames with different paths.
|
|
//
|
|
// Return -1 if the "a" is less than "b", 0 if "a" is equal to "b"
|
|
// and "1" if "a" is greater than "b".
|
|
//------------------------------------------------------------------
|
|
int
|
|
FileSpec::Compare(const FileSpec& a, const FileSpec& b, bool full)
|
|
{
|
|
int result = 0;
|
|
|
|
// If full is true, then we must compare both the directory and filename.
|
|
|
|
// If full is false, then if either directory is empty, then we match on
|
|
// the basename only, and if both directories have valid values, we still
|
|
// do a full compare. This allows for matching when we just have a filename
|
|
// in one of the FileSpec objects.
|
|
|
|
if (full || (a.m_directory && b.m_directory))
|
|
{
|
|
result = ConstString::Compare(a.m_directory, b.m_directory);
|
|
if (result)
|
|
return result;
|
|
}
|
|
return ConstString::Compare (a.m_filename, b.m_filename);
|
|
}
|
|
|
|
bool
|
|
FileSpec::Equal (const FileSpec& a, const FileSpec& b, bool full)
|
|
{
|
|
if (full)
|
|
return a == b;
|
|
else
|
|
return a.m_filename == b.m_filename;
|
|
}
|
|
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
// Dump the object to the supplied stream. If the object contains
|
|
// a valid directory name, it will be displayed followed by a
|
|
// directory delimiter, and the filename.
|
|
//------------------------------------------------------------------
|
|
void
|
|
FileSpec::Dump(Stream *s) const
|
|
{
|
|
if (m_filename)
|
|
m_directory.Dump(s, ""); // Provide a default for m_directory when we dump it in case it is invalid
|
|
|
|
if (m_directory)
|
|
{
|
|
// If dirname was valid, then we need to print a slash between
|
|
// the directory and the filename
|
|
s->PutChar('/');
|
|
}
|
|
m_filename.Dump(s);
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Returns true if the file exists.
|
|
//------------------------------------------------------------------
|
|
bool
|
|
FileSpec::Exists () const
|
|
{
|
|
struct stat file_stats;
|
|
return GetFileStats (this, &file_stats);
|
|
}
|
|
|
|
bool
|
|
FileSpec::ResolveExecutableLocation ()
|
|
{
|
|
if (!m_directory)
|
|
{
|
|
const std::string file_str (m_filename.AsCString());
|
|
llvm::sys::Path path = llvm::sys::Program::FindProgramByName (file_str);
|
|
llvm::StringRef dir_ref = path.getDirname();
|
|
if (! dir_ref.empty())
|
|
{
|
|
// FindProgramByName returns "." if it can't find the file.
|
|
if (strcmp (".", dir_ref.data()) == 0)
|
|
return false;
|
|
|
|
m_directory.SetCString (dir_ref.data());
|
|
if (Exists())
|
|
return true;
|
|
else
|
|
{
|
|
// If FindProgramByName found the file, it returns the directory + filename in its return results.
|
|
// We need to separate them.
|
|
FileSpec tmp_file (dir_ref.data(), false);
|
|
if (tmp_file.Exists())
|
|
{
|
|
m_directory = tmp_file.m_directory;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
FileSpec::ResolvePath ()
|
|
{
|
|
if (m_is_resolved)
|
|
return true; // We have already resolved this path
|
|
|
|
char path_buf[PATH_MAX];
|
|
if (!GetPath (path_buf, PATH_MAX))
|
|
return false;
|
|
// SetFile(...) will set m_is_resolved correctly if it can resolve the path
|
|
SetFile (path_buf, true);
|
|
return m_is_resolved;
|
|
}
|
|
|
|
uint64_t
|
|
FileSpec::GetByteSize() const
|
|
{
|
|
struct stat file_stats;
|
|
if (GetFileStats (this, &file_stats))
|
|
return file_stats.st_size;
|
|
return 0;
|
|
}
|
|
|
|
FileSpec::FileType
|
|
FileSpec::GetFileType () const
|
|
{
|
|
struct stat file_stats;
|
|
if (GetFileStats (this, &file_stats))
|
|
{
|
|
mode_t file_type = file_stats.st_mode & S_IFMT;
|
|
switch (file_type)
|
|
{
|
|
case S_IFDIR: return eFileTypeDirectory;
|
|
case S_IFIFO: return eFileTypePipe;
|
|
case S_IFREG: return eFileTypeRegular;
|
|
case S_IFSOCK: return eFileTypeSocket;
|
|
case S_IFLNK: return eFileTypeSymbolicLink;
|
|
default:
|
|
break;
|
|
}
|
|
return eFileTypeUknown;
|
|
}
|
|
return eFileTypeInvalid;
|
|
}
|
|
|
|
TimeValue
|
|
FileSpec::GetModificationTime () const
|
|
{
|
|
TimeValue mod_time;
|
|
struct stat file_stats;
|
|
if (GetFileStats (this, &file_stats))
|
|
mod_time.OffsetWithSeconds(file_stats.st_mtime);
|
|
return mod_time;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Directory string get accessor.
|
|
//------------------------------------------------------------------
|
|
ConstString &
|
|
FileSpec::GetDirectory()
|
|
{
|
|
return m_directory;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Directory string const get accessor.
|
|
//------------------------------------------------------------------
|
|
const ConstString &
|
|
FileSpec::GetDirectory() const
|
|
{
|
|
return m_directory;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Filename string get accessor.
|
|
//------------------------------------------------------------------
|
|
ConstString &
|
|
FileSpec::GetFilename()
|
|
{
|
|
return m_filename;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Filename string const get accessor.
|
|
//------------------------------------------------------------------
|
|
const ConstString &
|
|
FileSpec::GetFilename() const
|
|
{
|
|
return m_filename;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Extract the directory and path into a fixed buffer. This is
|
|
// needed as the directory and path are stored in separate string
|
|
// values.
|
|
//------------------------------------------------------------------
|
|
size_t
|
|
FileSpec::GetPath(char *path, size_t path_max_len) const
|
|
{
|
|
if (path_max_len)
|
|
{
|
|
const char *dirname = m_directory.GetCString();
|
|
const char *filename = m_filename.GetCString();
|
|
if (dirname)
|
|
{
|
|
if (filename)
|
|
return ::snprintf (path, path_max_len, "%s/%s", dirname, filename);
|
|
else
|
|
return ::snprintf (path, path_max_len, "%s", dirname);
|
|
}
|
|
else if (filename)
|
|
{
|
|
return ::snprintf (path, path_max_len, "%s", filename);
|
|
}
|
|
}
|
|
path[0] = '\0';
|
|
return 0;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Returns a shared pointer to a data buffer that contains all or
|
|
// part of the contents of a file. The data is memory mapped and
|
|
// will lazily page in data from the file as memory is accessed.
|
|
// The data that is mappped will start "file_offset" bytes into the
|
|
// file, and "file_size" bytes will be mapped. If "file_size" is
|
|
// greater than the number of bytes available in the file starting
|
|
// at "file_offset", the number of bytes will be appropriately
|
|
// truncated. The final number of bytes that get mapped can be
|
|
// verified using the DataBuffer::GetByteSize() function.
|
|
//------------------------------------------------------------------
|
|
DataBufferSP
|
|
FileSpec::MemoryMapFileContents(off_t file_offset, size_t file_size) const
|
|
{
|
|
DataBufferSP data_sp;
|
|
auto_ptr<DataBufferMemoryMap> mmap_data(new DataBufferMemoryMap());
|
|
if (mmap_data.get())
|
|
{
|
|
if (mmap_data->MemoryMapFromFileSpec (this, file_offset, file_size) >= file_size)
|
|
data_sp.reset(mmap_data.release());
|
|
}
|
|
return data_sp;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------
|
|
// Return the size in bytes that this object takes in memory. This
|
|
// returns the size in bytes of this object, not any shared string
|
|
// values it may refer to.
|
|
//------------------------------------------------------------------
|
|
size_t
|
|
FileSpec::MemorySize() const
|
|
{
|
|
return m_filename.MemorySize() + m_directory.MemorySize();
|
|
}
|
|
|
|
|
|
size_t
|
|
FileSpec::ReadFileContents (off_t file_offset, void *dst, size_t dst_len) const
|
|
{
|
|
size_t bytes_read = 0;
|
|
char resolved_path[PATH_MAX];
|
|
if (GetPath(resolved_path, sizeof(resolved_path)))
|
|
{
|
|
int fd = ::open (resolved_path, O_RDONLY, 0);
|
|
if (fd != -1)
|
|
{
|
|
struct stat file_stats;
|
|
if (::fstat (fd, &file_stats) == 0)
|
|
{
|
|
// Read bytes directly into our basic_string buffer
|
|
if (file_stats.st_size > 0)
|
|
{
|
|
off_t lseek_result = 0;
|
|
if (file_offset > 0)
|
|
lseek_result = ::lseek (fd, file_offset, SEEK_SET);
|
|
|
|
if (lseek_result == file_offset)
|
|
{
|
|
ssize_t n = ::read (fd, dst, dst_len);
|
|
if (n >= 0)
|
|
bytes_read = n;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
close(fd);
|
|
}
|
|
return bytes_read;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Returns a shared pointer to a data buffer that contains all or
|
|
// part of the contents of a file. The data copies into a heap based
|
|
// buffer that lives in the DataBuffer shared pointer object returned.
|
|
// The data that is cached will start "file_offset" bytes into the
|
|
// file, and "file_size" bytes will be mapped. If "file_size" is
|
|
// greater than the number of bytes available in the file starting
|
|
// at "file_offset", the number of bytes will be appropriately
|
|
// truncated. The final number of bytes that get mapped can be
|
|
// verified using the DataBuffer::GetByteSize() function.
|
|
//------------------------------------------------------------------
|
|
DataBufferSP
|
|
FileSpec::ReadFileContents (off_t file_offset, size_t file_size) const
|
|
{
|
|
DataBufferSP data_sp;
|
|
char resolved_path[PATH_MAX];
|
|
if (GetPath(resolved_path, sizeof(resolved_path)))
|
|
{
|
|
int fd = ::open (resolved_path, O_RDONLY, 0);
|
|
if (fd != -1)
|
|
{
|
|
struct stat file_stats;
|
|
if (::fstat (fd, &file_stats) == 0)
|
|
{
|
|
if (file_stats.st_size > 0)
|
|
{
|
|
off_t lseek_result = 0;
|
|
if (file_offset > 0)
|
|
lseek_result = ::lseek (fd, file_offset, SEEK_SET);
|
|
|
|
if (lseek_result < 0)
|
|
{
|
|
// Get error from errno
|
|
}
|
|
else if (lseek_result == file_offset)
|
|
{
|
|
const size_t bytes_left = file_stats.st_size - file_offset;
|
|
size_t num_bytes_to_read = file_size;
|
|
if (num_bytes_to_read > bytes_left)
|
|
num_bytes_to_read = bytes_left;
|
|
|
|
std::auto_ptr<DataBufferHeap> data_heap_ap;
|
|
data_heap_ap.reset(new DataBufferHeap(num_bytes_to_read, '\0'));
|
|
|
|
if (data_heap_ap.get())
|
|
{
|
|
ssize_t bytesRead = ::read (fd, (void *)data_heap_ap->GetBytes(), data_heap_ap->GetByteSize());
|
|
if (bytesRead >= 0)
|
|
{
|
|
// Make sure we read exactly what we asked for and if we got
|
|
// less, adjust the array
|
|
if ((size_t)bytesRead < data_heap_ap->GetByteSize())
|
|
data_heap_ap->SetByteSize(bytesRead);
|
|
data_sp.reset(data_heap_ap.release());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
close(fd);
|
|
}
|
|
return data_sp;
|
|
}
|
|
|
|
size_t
|
|
FileSpec::ReadFileLines (STLStringArray &lines)
|
|
{
|
|
lines.clear();
|
|
char path[PATH_MAX];
|
|
if (GetPath(path, sizeof(path)))
|
|
{
|
|
ifstream file_stream (path);
|
|
|
|
if (file_stream)
|
|
{
|
|
std::string line;
|
|
while (getline (file_stream, line))
|
|
lines.push_back (line);
|
|
}
|
|
}
|
|
return lines.size();
|
|
}
|