maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revise the design of the Path concept per peer review. Too many changes to 

note individually but these essence of it is to not derive from
std::string, clarify the interface, and provide better documentation.
There is now also (untested) implementations for AIX, Darwin, and SunOS.

llvm-svn: 16078
This commit is contained in:
Reid Spencer 2004-08-29 05:24:01 +00:00
parent c227d73e5f
commit 6df221d50a
7 changed files with 798 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

464
llvm/include/llvm/System/Path.h
View File

@ -19,138 +19,392 @@
namespace llvm {
namespace sys {
/// This class provides an abstraction for the name of a path
/// to a file or directory in the filesystem and various basic operations
/// on it.
/// This class provides an abstraction for the path to a file or directory
/// in the operating system's filesystem and provides various basic operations
/// on it. Note that this class only represents the name of a path to a file
/// or directory which may or may not be valid for a given machine's file
/// system. A Path ensures that the name it encapsulates is syntactical valid
/// for the operating system it is running on but does not ensure correctness
/// for any particular file system. A Path either references a file or a
/// directory and the distinction is consistently maintained. Most operations
/// on the class have invariants that require the Path object to be either a
/// file path or a directory path, but not both. Those operations will also
/// leave the object as either a file path or object path. There is exactly
/// one invalid Path which is the empty path. The class should never allow any
/// other syntactically invalid non-empty path name to be assigned. Empty
/// paths are required in order to indicate an error result. If the path is
/// empty, the is_valid operation will return false. All operations will fail
/// if is_valid is false. Operations that change the path will either return
/// false if it would cause a syntactically invalid path name (in which case
/// the Path object is left unchanged) or throw an std::string exception
/// indicating the error.
/// @since 1.4
/// @brief An abstraction for operating system paths.
class Path : public std::string {
/// @name Constructors
/// @{
public:
/// Creates a null (empty) path
/// @brief Default Constructor
Path () : std::string() {}
class Path {
/// @name Constructors
/// @{
public:
/// Construct a path to the root directory of the file system. The root
/// directory is a top level directory above which there are no more
/// directories. For example, on UNIX, the root directory is /. On Windows
/// it is C:\. Other operating systems may have different notions of
/// what the root directory is.
/// @throws nothing
static Path GetRootDirectory();
/// Creates a path from char*
/// @brief char* converter
Path ( const char * name ) : std::string(name) {
assert(is_valid());
}
/// Construct a path to a unique temporary directory that is created in
/// a "standard" place for the operating system. The directory is
/// guaranteed to be created on exit from this function. If the directory
/// cannot be created, the function will throw an exception.
/// @throws std::string indicating why the directory could not be created.
/// @brief Constrct a path to an new, unique, existing temporary
/// directory.
static Path GetTemporaryDirectory();
/// @brief std::string converter
Path ( const std::string& name ) : std::string(name){
assert(is_valid());
};
/// Construct a path to the first system library directory. The
/// implementation of Path on a given platform must ensure that this
/// directory both exists and also contains standard system libraries
/// suitable for linking into programs.
/// @throws nothing
/// @brief Construct a path to the first system library directory
static Path GetSystemLibraryPath1();
/// Copies the path with copy-on-write semantics. The \p this Path
/// will reference \p the that Path until one of them is modified
/// at which point a full copy is taken before the write.
/// @brief Copy Constructor
Path ( const Path & that ) : std::string(that) {}
/// Construct a path to the second system library directory. The
/// implementation of Path on a given platform must ensure that this
/// directory both exists and also contains standard system libraries
/// suitable for linking into programs. Note that the "second" system
/// library directory may or may not be different from the first.
/// @throws nothing
/// @brief Construct a path to the second system library directory
static Path GetSystemLibraryPath2();
/// Releases storage associated with the Path object
/// @brief Destructor
~Path ( void ) {};
/// Construct a path to the default LLVM configuration directory. The
/// implementation must ensure that this is a well-known (same on many
/// systems) directory in which llvm configuration files exist. For
/// example, on Unix, the /etc/llvm directory has been selected.
/// @throws nothing
/// @brief Construct a path to the default LLVM configuration directory
static Path GetLLVMDefaultConfigDir();
/// @}
/// @name Operators
/// @{
public:
/// Makes a copy of \p that to \p this with copy-on-write semantics.
/// @returns \p this
/// @brief Assignment Operator
Path & operator = ( const Path & that ) {
this->assign (that);
return *this;
}
/// Construct a path to the LLVM installed configuration directory. The
/// implementation must ensure that this refers to the "etc" directory of
/// the LLVM installation. This is the location where configuration files
/// will be located for a particular installation of LLVM on a machine.
/// @throws nothing
/// @brief Construct a path to the LLVM installed configuration directory
static Path GetLLVMConfigDir();
/// Comparies \p this Path with \p that Path for equality.
/// @returns true if \p this and \p that refer to the same item.
/// @brief Equality Operator
bool operator ==( const Path & that ) const {
return 0 == this->compare( that ) ;
}
/// Construct a path to the current user's home directory. The
/// implementation must use an operating system specific mechanism for
/// determining the user's home directory. For example, the environment
/// variable "HOME" could be used on Unix. If a given operating system
/// does not have the concept of a user's home directory, this static
/// constructor must provide the same result as GetRootDirectory.
/// @throws nothing
/// @brief Construct a path to the current user's "home" directory
static Path GetUserHomeDirectory();
/// Comparies \p this Path with \p that Path for inequality.
/// @returns true if \p this and \p that refer to different items.
/// @brief Inequality Operator
bool operator !=( const Path & that ) const {
return 0 != this->compare( that );
}
/// This is one of the very few ways in which a path can be constructed
/// with a syntactically invalid name. The only *legal* invalid name is an
/// empty one. Other invalid names are not permitted. Empty paths are
/// provided so that they can be used to indicate null or error results in
/// other lib/System functionality.
/// @throws nothing
/// @brief Construct an empty (and invalid) path.
Path() : path() {}
/// @}
/// @name Accessors
/// @{
public:
/// @returns true if the path is valid
/// @brief Determines if the path is valid (properly formed) or not.
bool is_valid() const;
/// This constructor will accept a std::string as a path but if verifies
/// that the path string has a legal syntax for the operating system on
/// which it is running. This allows a path to be taken in from outside
/// the program. However, if the path is not valid, the Path object will
/// be set to an empty string and an exception will be thrown.
/// @throws std::string if the path string is not legal.
/// @param unvalidated_path The path to verify and assign.
/// @brief Construct a Path from a string.
explicit Path(std::string unverified_path);
/// @returns true if the path could reference a file
/// @brief Determines if the path is valid for a file reference.
bool is_file() const;
/// @}
/// @name Operators
/// @{
public:
/// Makes a copy of \p that to \p this.
/// @returns \p this
/// @throws nothing
/// @brief Assignment Operator
Path & operator = ( const Path & that ) {
path = that.path;
return *this;
}
/// @returns true if the path could reference a directory
/// @brief Determines if the path is valid for a directory reference.
bool is_directory() const;
/// Compares \p this Path with \p that Path for equality.
/// @returns true if \p this and \p that refer to the same thing.
/// @throws nothing
/// @brief Equality Operator
bool operator == (const Path& that) const {
return 0 == path.compare(that.path) ;
}
/// @brief Fills and zero terminates a buffer with the path
void fill( char* buffer, unsigned len ) const;
/// Compares \p this Path with \p that Path for inequality.
/// @returns true if \p this and \p that refer to different things.
/// @throws nothing
/// @brief Inequality Operator
bool operator !=( const Path & that ) const {
return 0 != path.compare( that.path );
}
/// @}
/// @name Mutators
/// @{
public:
/// This ensures that the pathname is terminated with a /
/// @brief Make the path reference a directory.
void make_directory();
/// Determines if \p this Path is less than \p that Path. This is required
/// so that Path objects can be placed into ordered collections (e.g.
/// std::map). The comparison is done lexicographically as defined by
/// the std::string::compare method.
/// @returns true if \p this path is lexicographically less than \p that.
/// @throws nothing
/// @brief Less Than Operator
bool operator< (const Path& that) const {
return 0 > path.compare( that.path );
}
/// This ensures that the pathname is not terminated with a /
/// @brief Makes the path reference a file.
void make_file();
/// @}
/// @name Accessors
/// @{
public:
/// This function will use an operating system specific algorithm to
/// determine if the current value of \p this is a syntactically valid
/// path name for the operating system. The path name does not need to
/// exist, validity is simply syntactical. Empty paths are always invalid.
/// @returns true iff the path name is syntactically legal for the
/// host operating system.
/// @brief Determine if a path is syntactically valid or not.
bool is_valid() const;
/// the file system.
/// This function determines if the contents of the path name are
/// empty. That is, the path has a zero length.
/// @returns true iff the path is empty.
/// @brief Determines if the path name is empty (invalid).
bool is_empty() const { return path.empty(); }
/// This function determines if the path name in this object is intended
/// to reference a legal file name (as opposed to a directory name). This
/// function does not verify anything with the file system, it merely
/// determines if the syntax of the path represents a file name or not.
/// @returns true if this path name references a file.
/// @brief Determines if the path name references a file.
bool is_file() const;
/// This function determines if the path name in this object is intended
/// to reference a legal directory name (as opposed to a file name). This
/// function does not verify anything with the file system, it merely
/// determines if the syntax of the path represents a directory name or
/// not.
/// @returns true if the path name references a directory
/// @brief Determines if the path name references a directory.
bool is_directory() const;
/// This function determines if the path name in this object references
/// the root (top level directory) of the file system. The details of what
/// is considered the "root" may vary from system to system so this method
/// will do the necessary checking.
/// @returns true iff the path name references the root directory.
/// @brief Determines if the path references the root directory.
bool is_root_directory() const;
/// This function determines if the path name references an existing file
/// or directory in the file system. Unlike is_file and is_directory, this
/// function actually checks for the existence of the file or directory.
/// @returns true if the pathname references an existing file.
/// @brief Determines if the path is a file or directory in
bool exists();
/// the file system.
bool exists() const;
/// The \p dirname is added to the end of the Path.
/// This function determines if the path name references a readable file
/// or directory in the file system. Unlike is_file and is_directory, this
/// function actually checks for the existence and readability (by the
/// current program) of the file or directory.
/// @returns true if the pathname references a readable file.
/// @brief Determines if the path is a readable file or directory
/// in the file system.
bool readable() const;
/// This function determines if the path name references a writable file
/// or directory in the file system. Unlike is_file and is_directory, this
/// function actually checks for the existence and writability (by the
/// current program) of the file or directory.
/// @returns true if the pathname references a writable file.
/// @brief Determines if the path is a writable file or directory
/// in the file system.
bool writable() const;
/// This function determines if the path name references an executable
/// file in the file system. Unlike is_file and is_directory, this
/// function actually checks for the existence and executability (by
/// the current program) of the file.
/// @returns true if the pathname references an executable file.
/// @brief Determines if the path is an executable file in the file
/// system.
bool executable() const;
/// This function returns the current contents of the path as a
/// std::string. This allows the underlying path string to be manipulated
/// by other software.
/// @returns std::string containing the path name.
/// @brief Returns the path as a std::string.
std::string get() const { return path; }
/// This function returns the last component of the path name. If the
/// is_directory() function would return true then this returns the name
/// of the last directory in the path. If the is_file() function would
/// return true then this function returns the name of the file without
/// any of the preceding directories.
/// @returns std::string containing the last component of the path name.
/// @brief Returns the last component of the path name.
std::string getLast() const;
/// @returns a c string containing the path name.
/// @brief Returns the path as a C string.
const char* const c_str() const { return path.c_str(); }
/// @}
/// @name Mutators
/// @{
public:
/// The path name is cleared and becomes empty. This is an invalid
/// path name but is the *only* invalid path name. This is provided
/// so that path objects can be used to indicate the lack of a
/// valid path being found.
void clear() { path.clear(); }
/// This method attempts to set the Path object to \p unverified_path
/// and interpret the name as a directory name. The \p unverified_path
/// is verified. If verification succeeds then \p unverified_path
/// is accepted as a directory and true is returned. Otherwise,
/// the Path object remains unchanged and false is returned.
/// @returns true if the path was set, false otherwise.
/// @param unverified_path The path to be set in Path object.
/// @throws nothing
/// @brief Set a full path from a std::string
bool set_directory(const std::string& unverified_path);
/// This method attempts to set the Path object to \p unverified_path
/// and interpret the name as a file name. The \p unverified_path
/// is verified. If verification succeeds then \p unverified_path
/// is accepted as a file name and true is returned. Otherwise,
/// the Path object remains unchanged and false is returned.
/// @returns true if the path was set, false otherwise.
/// @param unverified_path The path to be set in Path object.
/// @throws nothing
/// @brief Set a full path from a std::string
bool set_file(const std::string& unverified_path);
/// The \p dirname is added to the end of the Path if it is a legal
/// directory name for the operating system. The precondition for this
/// function is that the Path must reference a directory name (i.e.
/// is_directory() returns true).
/// @param dirname A string providing the directory name to
/// be appended to the path.
/// @brief Appends the name of a directory.
void append_directory( const std::string& dirname ) {
this->append( dirname );
make_directory();
}
/// be added to the end of the path.
/// @returns false if the directory name could not be added
/// @throws nothing
/// @brief Adds the name of a directory to a Path.
bool append_directory( const std::string& dirname );
/// The \p filename is added to the end of the Path.
/// One directory component is removed from the Path name. The Path must
/// refer to a non-root directory name (i.e. is_directory() returns true
/// but is_root_directory() returns false). Upon exit, the Path will
/// refer to the directory above it.
/// @throws nothing
/// @returns false if the directory name could not be removed.
/// @brief Removes the last directory component of the Path.
bool elide_directory();
/// The \p filename is added to the end of the Path if it is a legal
/// directory name for the operating system. The precondition for this
/// function is that the Path reference a directory name (i.e.
/// is_directory() returns true).
/// @throws nothing
/// @returns false if the file name could not be added.
/// @brief Appends the name of a file.
void append_file( const std::string& filename ) {
this->append( filename );
}
bool append_file( const std::string& filename );
/// Directories will have no entries. Files will be zero length. If
/// the file or directory already exists, no error results.
/// @throws SystemException if any error occurs.
/// @brief Causes the file or directory to exist in the filesystem.
void create( bool create_parents = false );
/// One file component is removed from the Path name. The Path must
/// refer to a file (i.e. is_file() returns true). Upon exit,
/// the Path will refer to the directory above it.
/// @throws nothing
/// @returns false if the file name could not be removed
/// @brief Removes the last file component of the path.
bool elide_file();
void create_directory( void );
void create_directories( void );
void create_file( void );
/// A period and the \p suffix are appended to the end of the pathname.
/// The precondition for this function is that the Path reference a file
/// name (i.e. is_file() returns true). If the Path is not a file, no
/// action is taken and the function returns false. If the path would
/// become invalid for the host operating system, false is returned.
/// @returns false if the suffix could not be added, true if it was.
/// @throws nothing
/// @brief Adds a period and the \p suffix to the end of the pathname.
bool append_suffix(const std::string& suffix);
/// Directories must be empty before they can be removed. If not,
/// an error will result. Files will be unlinked, even if another
/// process is using them.
/// The suffix of the filename is removed. The suffix begins with and
/// includes the last . character in the filename after the last directory
/// separator and extends until the end of the name. If no . character is
/// after the last directory separator, then the file name is left
/// unchanged (i.e. it was already without a suffix) but the function return
/// false.
/// @returns false if there was no suffix to remove, true otherwise.
/// @throws nothing
/// @brief Remove the suffix from a path name.
bool elide_suffix();
/// This method attempts to create a directory in the file system with the
/// same name as the Path object. The \p create_parents parameter controls
/// whether intermediate directories are created or not. if \p
/// create_parents is true, then an attempt will be made to create all
/// intermediate directories. If \p create_parents is false, then only the
/// final directory component of the Path name will be created. The
/// created directory will have no entries.
/// @returns false if the Path does not reference a directory, true
/// otherwise.
/// @param create_parents Determines whether non-existent directory
/// components other than the last one (the "parents") are created or not.
/// @throws std::string if an error occurs.
/// @brief Create the directory this Path refers to.
bool create_directory( bool create_parents = false );
/// This method attempts to create a file in the file system with the same
/// name as the Path object. The intermediate directories must all exist
/// at the time this method is called. Use create_directories to
/// accomplish that. The created file will be empty upon return from this
/// function.
/// @returns false if the Path does not reference a file, true otherwise.
/// @throws std::string if an error occurs.
/// @brief Create the file this Path refers to.
bool create_file();
/// This method attempts to destroy the directory named by the last in
/// the Path name. If \p remove_contents is false, an attempt will be
/// made to remove just the directory that this Path object refers to
/// (the final Path component). If \p remove_contents is true, an attempt
/// will be made to remove the entire contents of the directory,
/// recursively.
/// @param destroy_contents Indicates whether the contents of a destroyed
/// directory should also be destroyed (recursively).
/// @returns false if the Path does not refer to a directory, true
/// otherwise.
/// @throws std::string if there is an error.
/// @brief Removes the file or directory from the filesystem.
void remove( void );
void remove_directory( void );
void remove_file( void );
bool destroy_directory( bool destroy_contents = false );
/// Find library.
void find_lib( const char * file );
/// @}
/// This method attempts to destroy the file named by the last item in the
/// Path name.
/// @returns false if the Path does not refer to a file, true otherwise.
/// @throws std::string if there is an error.
/// @brief Destroy the file this Path refers to.
bool destroy_file();
/// @}
/// @name Data
/// @{
private:
std::string path; ///< Platform agnostic storage for the path name.
/// @}
};
}
}

36
llvm/lib/System/AIX/Path.cpp Normal file
View File

@ -0,0 +1,36 @@
//===- llvm/System/AIX/Path.cpp - AIX Path Implementation -------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file provides the AIX specific implementation of the Path class.
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only AIX specific code
//=== and must not be generic UNIX code (see ../Unix/Path.cpp)
//===----------------------------------------------------------------------===//
// Include the generic unix implementation
#include "../Unix/Path.cpp"
namespace llvm {
using namespace sys;
bool
Path::is_valid() const {
if (path.empty())
return false;
if (path.length() >= MAXPATHLEN)
return false;
return true;
}
}
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab

36
llvm/lib/System/Darwin/Path.cpp Normal file
View File

@ -0,0 +1,36 @@
//===- llvm/System/Darwin/Path.cpp - Linux Path Implementation --*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file provides the Darwin specific implementation of the Path class.
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only Darwin specific code
//=== and must not be generic UNIX code (see ../Unix/Path.cpp)
//===----------------------------------------------------------------------===//
// Include the generic unix implementation
#include "../Unix/Path.cpp"
namespace llvm {
using namespace sys;
bool
Path::is_valid() const {
if (path.empty())
return false;
if (path.length() >= MAXPATHLEN)
return false;
return true;
}
}
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab

22
llvm/lib/System/Linux/Path.cpp
View File

@ -13,8 +13,26 @@
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only Linux specific code
//=== and must not be generic UNIX code (see ../Unix)
//=== and must not be generic UNIX code (see ../Unix/Path.cpp)
//===----------------------------------------------------------------------===//
// Th..Th..Th..Tha's All Folks!
// Include the generic Unix implementation
#include "../Unix/Path.cpp"
namespace llvm {
using namespace sys;
bool
Path::is_valid() const {
if (path.empty())
return false;
char pathname[MAXPATHLEN];
if (0 == realpath(path.c_str(), pathname))
if (errno != EACCES && errno != EIO && errno != ENOENT && errno != ENOTDIR)
return false;
return true;
}
}
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab

35
llvm/lib/System/Path.cpp
View File

@ -10,10 +10,11 @@
// This header file implements the operating system Path concept.
//
//===----------------------------------------------------------------------===//
#include "llvm/System/Path.h"
namespace llvm {
namespace sys {
using namespace sys;
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only TRULY operating system
@ -21,40 +22,18 @@ namespace sys {
//===----------------------------------------------------------------------===//
bool
Path::is_valid() const {
if ( empty() ) return false;
return true;
Path::is_file() const {
return (is_valid() && path[path.length()-1] != '/');
}
void
Path::fill( char* buffer, unsigned bufflen ) const {
unsigned pathlen = length();
assert( bufflen > pathlen && "Insufficient buffer size" );
unsigned copylen = pathlen <? (bufflen - 1);
this->copy(buffer, copylen, 0 );
buffer[ copylen ] = 0;
bool
Path::is_directory() const {
return (is_valid() && path[path.length()-1] == '/');
}
void
Path::make_directory() {
char end[2];
end[0] = '/';
end[1] = 0;
if ( empty() )
this->assign( end );
else if ( (*this)[length()-1] != '/')
this->append( end );
}
void
Path::make_file() {
if ( (*this)[length()-1] == '/')
this->erase( this->length()-1, 1 );
}
// Include the truly platform-specific parts of this class.
#include "platform/Path.cpp"
}
}
// vim: sw=2

38
llvm/lib/System/SunOS/Path.cpp Normal file
View File

@ -0,0 +1,38 @@
//===- llvm/System/SunOS/Path.cpp - SunOS Path Implementation ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file provides the SunOS specific implementation of the Path class.
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only SunOS specific code
//=== and must not be generic UNIX code (see ../Unix/Path.cpp)
//===----------------------------------------------------------------------===//
// Include the generic Unix implementation
#include "../Unix/Path.cpp"
namespace llvm {
using namespace sys;
bool
Path::is_valid() const {
if (path.empty())
return false;
char pathname[MAXPATHLEN];
if (0 == realpath(path.c_str(), pathname))
if (errno != EACCES && errno != EIO && errno != ENOENT && errno != ENOTDIR)
return false;
return true;
}
}
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab

409
llvm/lib/System/Unix/Path.cpp
View File

@ -13,126 +13,321 @@
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only generic UNIX code that
//=== is guaranteed to work on all UNIX variants.
//=== is guaranteed to work on *all* UNIX variants.
//===----------------------------------------------------------------------===//
#include "Unix.h"
#include <sys/stat.h>
#include <fcntl.h>
#include <Config/config.h>
bool
Path::is_file() const {
if (!empty() && ((*this)[length()-1] != '/'))
return true;
return false;
}
namespace llvm {
using namespace sys;
bool
Path::is_directory() const {
if ((!empty()) && ((*this)[length()-1] == '/'))
return true;
return false;
}
void
Path::create( bool create_parents) {
if ( is_directory() ) {
if ( create_parents )
this->create_directories( );
this->create_directory( );
} else if ( is_file() ) {
if ( create_parents )
this->create_directories( );
this->create_file( );
}
}
void
Path::remove() {
if ( is_directory() ) {
if ( exists() )
this->remove_directory( );
} else if ( is_file() )
if ( exists() )
this->remove_file( );
}
bool
Path::exists() {
char pathname[MAXPATHLEN];
this->fill(pathname,MAXPATHLEN);
int lastchar = this->length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
return 0 == access(pathname, F_OK );
}
void
Path::create_directory( ) {
char pathname[MAXPATHLEN];
this->fill(pathname,MAXPATHLEN);
int lastchar = this->length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
if (0 != mkdir(pathname, S_IRWXU | S_IRWXG))
ThrowErrno(pathname);
}
void
Path::create_directories() {
char pathname[MAXPATHLEN];
this->fill(pathname,MAXPATHLEN);
int lastchar = this->length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
char * next = index(pathname,'/');
if ( pathname[0] == '/')
next = index(&pathname[1],'/');
while ( next != 0 )
{
*next = 0;
if (0 != access(pathname, F_OK | R_OK))
if (0 != mkdir(pathname, S_IRWXU | S_IRWXG))
ThrowErrno(pathname);
char* save = next;
next = index(pathname,'/');
*save = '/';
}
}
void
Path::remove_directory()
Path::Path(std::string unverified_path)
: path(unverified_path)
{
char pathname[MAXPATHLEN];
this->fill(pathname,MAXPATHLEN);
int lastchar = this->length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
if ( 0 != rmdir(pathname))
ThrowErrno(pathname);
if (unverified_path.empty())
return;
if (this->is_valid())
return;
// oops, not valid.
path.clear();
ThrowErrno(unverified_path + ": path is not valid");
}
void
Path
Path::GetRootDirectory() {
Path result;
result.set_directory("/");
return result;
}
Path
Path::GetTemporaryDirectory() {
char pathname[MAXPATHLEN];
strcpy(pathname,"/tmp/llvm_XXXXXX");
if (0 == mkdtemp(pathname))
ThrowErrno(std::string(pathname) + ": Can't create temporary directory");
Path result;
result.set_directory(pathname);
assert(result.is_valid() && "mkdtemp didn't create a valid pathname!");
return result;
}
Path
Path::GetSystemLibraryPath1() {
return Path("/lib/");
}
Path
Path::GetSystemLibraryPath2() {
return Path("/usr/lib/");
}
Path
Path::GetLLVMDefaultConfigDir() {
return Path("/etc/llvm/");
}
Path
Path::GetLLVMConfigDir() {
Path result;
if (result.set_directory(LLVM_ETCDIR))
return result;
return GetLLVMDefaultConfigDir();
}
Path
Path::GetUserHomeDirectory() {
const char* home = getenv("HOME");
if (home) {
Path result;
if (result.set_directory(home))
return result;
}
return GetRootDirectory();
}
bool
Path::exists() const {
return 0 == access(path.c_str(), F_OK );
}
bool
Path::readable() const {
return 0 == access(path.c_str(), F_OK | R_OK );
}
bool
Path::writable() const {
return 0 == access(path.c_str(), F_OK | W_OK );
}
bool
Path::executable() const {
return 0 == access(path.c_str(), R_OK | X_OK );
}
std::string
Path::getLast() const {
// Find the last slash
size_t pos = path.rfind('/');
// Handle the corner cases
if (pos == std::string::npos)
return path;
// If the last character is a slash
if (pos == path.length()-1) {
// Find the second to last slash
size_t pos2 = path.rfind('/', pos-1);
if (pos2 == std::string::npos)
return path.substr(0,pos);
else
return path.substr(pos2+1,pos-pos2-1);
}
// Return everything after the last slash
return path.substr(pos+1);
}
bool
Path::set_directory(const std::string& a_path) {
if (a_path.size() == 0)
return false;
Path save(*this);
path = a_path;
size_t last = a_path.size() -1;
if (last != 0 && a_path[last] != '/')
path += '/';
if (!is_valid()) {
path = save.path;
return false;
}
return true;
}
bool
Path::set_file(const std::string& a_path) {
if (a_path.size() == 0)
return false;
Path save(*this);
path = a_path;
size_t last = a_path.size() - 1;
while (last > 0 && a_path[last] == '/')
last--;
path.erase(last+1);
if (!is_valid()) {
path = save.path;
return false;
}
return true;
}
bool
Path::append_directory(const std::string& dir) {
if (is_file())
return false;
Path save(*this);
path += dir;
path += "/";
if (!is_valid()) {
path = save.path;
return false;
}
return true;
}
bool
Path::elide_directory() {
if (is_file())
return false;
size_t slashpos = path.rfind('/',path.size());
if (slashpos == 0 || slashpos == std::string::npos)
return false;
if (slashpos == path.size() - 1)
slashpos = path.rfind('/',slashpos-1);
if (slashpos == std::string::npos)
return false;
path.erase(slashpos);
return true;
}
bool
Path::append_file(const std::string& file) {
if (!is_directory())
return false;
Path save(*this);
path += file;
if (!is_valid()) {
path = save.path;
return false;
}
return true;
}
bool
Path::elide_file() {
if (is_directory())
return false;
size_t slashpos = path.rfind('/',path.size());
if (slashpos == std::string::npos)
return false;
path.erase(slashpos+1);
return true;
}
bool
Path::append_suffix(const std::string& suffix) {
if (is_directory())
return false;
Path save(*this);
path.append(".");
path.append(suffix);
if (!is_valid()) {
path = save.path;
return false;
}
return true;
}
bool
Path::elide_suffix() {
if (is_directory()) return false;
size_t dotpos = path.rfind('.',path.size());
size_t slashpos = path.rfind('/',path.size());
if (slashpos != std::string::npos && dotpos != std::string::npos &&
dotpos > slashpos) {
path.erase(dotpos, path.size()-dotpos);
return true;
}
return false;
}
bool
Path::create_directory( bool create_parents) {
// Make sure we're dealing with a directory
if (!is_directory()) return false;
// Get a writeable copy of the path name
char pathname[MAXPATHLEN];
path.copy(pathname,MAXPATHLEN);
// Null-terminate the last component
int lastchar = path.length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
// If we're supposed to create intermediate directories
if ( create_parents ) {
// Find the end of the initial name component
char * next = strchr(pathname,'/');
if ( pathname[0] == '/')
next = strchr(&pathname[1],'/');
// Loop through the directory components until we're done
while ( next != 0 ) {
*next = 0;
if (0 != access(pathname, F_OK | R_OK | W_OK))
if (0 != mkdir(pathname, S_IRWXU | S_IRWXG))
ThrowErrno(std::string(pathname) + ": Can't create directory");
char* save = next;
next = strchr(pathname,'/');
*save = '/';
}
} else if (0 != mkdir(pathname, S_IRWXU | S_IRWXG)) {
ThrowErrno(std::string(pathname) + ": Can't create directory");
}
return true;
}
bool
Path::create_file() {
char pathname[MAXPATHLEN];
this->fill(pathname,MAXPATHLEN);
int lastchar = this->length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
if (0 != creat(pathname, S_IRUSR | S_IWUSR))
ThrowErrno(pathname);
// Make sure we're dealing with a file
if (!is_file()) return false;
// Create the file
if (0 != creat(path.c_str(), S_IRUSR | S_IWUSR))
ThrowErrno(std::string(path.c_str()) + ": Can't create file");
return true;
}
bool
Path::destroy_directory(bool remove_contents) {
// Make sure we're dealing with a directory
if (!is_directory()) return false;
// If it doesn't exist, we're done.
if (!exists()) return true;
if (remove_contents) {
// Recursively descend the directory to remove its content
std::string cmd("/bin/rm -rf ");
cmd += path;
system(cmd.c_str());
} else {
// Otherwise, try to just remove the one directory
char pathname[MAXPATHLEN];
path.copy(pathname,MAXPATHLEN);
int lastchar = path.length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
if ( 0 != rmdir(pathname))
ThrowErrno(std::string(pathname) + ": Can't destroy directory");
}
return true;
}
bool
Path::destroy_file() {
if (!is_file()) return false;
if (0 != unlink(path.c_str()))
ThrowErrno(std::string(path.c_str()) + ": Can't destroy file");
return true;
}
void
Path::remove_file() {
char pathname[MAXPATHLEN];
this->fill(pathname,MAXPATHLEN);
int lastchar = this->length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
if (0 != unlink(pathname))
ThrowErrno(pathname);
}
// vim: sw=2