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() {}
-
- /// Creates a path from char*
- /// @brief char* converter
- Path ( const char * name ) : std::string(name) {
- assert(is_valid());
- }
-
- /// @brief std::string converter
- Path ( const std::string& name ) : std::string(name){
- assert(is_valid());
- };
-
- /// 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) {}
-
- /// Releases storage associated with the Path object
- /// @brief Destructor
- ~Path ( void ) {};
-
- /// @}
- /// @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;
- }
-
- /// 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 ) ;
- }
-
- /// 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 );
- }
-
- /// @}
- /// @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;
-
- /// @returns true if the path could reference a file
- /// @brief Determines if the path is valid for a file reference.
- bool is_file() const;
-
- /// @returns true if the path could reference a directory
- /// @brief Determines if the path is valid for a directory reference.
- bool is_directory() const;
-
- /// @brief Fills and zero terminates a buffer with the path
- void fill( char* buffer, unsigned len ) const;
-
- /// @}
- /// @name Mutators
- /// @{
- public:
- /// This ensures that the pathname is terminated with a /
- /// @brief Make the path reference a directory.
- void make_directory();
-
- /// This ensures that the pathname is not terminated with a /
- /// @brief Makes the path reference a file.
- void make_file();
+ 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();
- /// the file system.
+ /// 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();
+
+ /// 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();
+
+ /// 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();
+
+ /// 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();
+
+ /// 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();
+
+ /// 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();
+
+ /// 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() {}
+
+ /// 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);
+
+ /// @}
+ /// @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;
+ }
+
+ /// 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) ;
+ }
+
+ /// 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 );
+ }
+
+ /// 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 );
+ }
+
+ /// @}
+ /// @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;
+
+ /// 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;
+
+ /// 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(); }
- /// The \p dirname is added to the end of the Path.
+ /// 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 );
+
+ /// 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.
- /// Find library.
- void find_lib( const char * file );
- /// @}
+ /// @}
};
}
}
--- /dev/null
+//===- 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
--- /dev/null
+//===- 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
//===----------------------------------------------------------------------===//
//=== 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
// 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
//===----------------------------------------------------------------------===//
bool
-Path::is_valid() const {
- if ( empty() ) return false;
- return true;
-}
-
-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;
+Path::is_file() 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 );
+bool
+Path::is_directory() const {
+ return (is_valid() && path[path.length()-1] == '/');
}
-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
--- /dev/null
+//===- 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
//===----------------------------------------------------------------------===//
//=== 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>
+
+namespace llvm {
+using namespace sys;
+
+Path::Path(std::string unverified_path)
+ : path(unverified_path)
+{
+ if (unverified_path.empty())
+ return;
+ if (this->is_valid())
+ return;
+ // oops, not valid.
+ path.clear();
+ ThrowErrno(unverified_path + ": path is not valid");
+}
+
+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::is_file() const {
- if (!empty() && ((*this)[length()-1] != '/'))
- return true;
- return false;
+Path::exists() const {
+ return 0 == access(path.c_str(), F_OK );
}
bool
-Path::is_directory() const {
- if ((!empty()) && ((*this)[length()-1] == '/'))
- return true;
- return false;
+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 );
}
-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( );
+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);
}
-void
-Path::remove() {
- if ( is_directory() ) {
- if ( exists() )
- this->remove_directory( );
- } else if ( is_file() )
- if ( exists() )
- this->remove_file( );
+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::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 );
+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;
}
-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);
+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;
}
-void
-Path::create_directories() {
- char pathname[MAXPATHLEN];
- this->fill(pathname,MAXPATHLEN);
- int lastchar = this->length() - 1 ;
- if (pathname[lastchar] == '/')
- pathname[lastchar] = 0;
+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;
+}
- 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 = '/';
+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;
}
-void
-Path::remove_directory()
-{
+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];
- this->fill(pathname,MAXPATHLEN);
- int lastchar = this->length() - 1 ;
+ path.copy(pathname,MAXPATHLEN);
+
+ // Null-terminate the last component
+ int lastchar = path.length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
- if ( 0 != rmdir(pathname))
- ThrowErrno(pathname);
+
+ // 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;
}
-void
+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
//===----------------------------------------------------------------------===//
//=== 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>
+
+namespace llvm {
+using namespace sys;
+
+Path::Path(std::string unverified_path)
+ : path(unverified_path)
+{
+ if (unverified_path.empty())
+ return;
+ if (this->is_valid())
+ return;
+ // oops, not valid.
+ path.clear();
+ ThrowErrno(unverified_path + ": path is not valid");
+}
+
+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::is_file() const {
- if (!empty() && ((*this)[length()-1] != '/'))
- return true;
- return false;
+Path::exists() const {
+ return 0 == access(path.c_str(), F_OK );
}
bool
-Path::is_directory() const {
- if ((!empty()) && ((*this)[length()-1] == '/'))
- return true;
- return false;
+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 );
}
-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( );
+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);
}
-void
-Path::remove() {
- if ( is_directory() ) {
- if ( exists() )
- this->remove_directory( );
- } else if ( is_file() )
- if ( exists() )
- this->remove_file( );
+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::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 );
+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;
}
-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);
+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;
}
-void
-Path::create_directories() {
- char pathname[MAXPATHLEN];
- this->fill(pathname,MAXPATHLEN);
- int lastchar = this->length() - 1 ;
- if (pathname[lastchar] == '/')
- pathname[lastchar] = 0;
+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;
+}
- 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 = '/';
+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;
}
-void
-Path::remove_directory()
-{
+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];
- this->fill(pathname,MAXPATHLEN);
- int lastchar = this->length() - 1 ;
+ path.copy(pathname,MAXPATHLEN);
+
+ // Null-terminate the last component
+ int lastchar = path.length() - 1 ;
if (pathname[lastchar] == '/')
pathname[lastchar] = 0;
- if ( 0 != rmdir(pathname))
- ThrowErrno(pathname);
+
+ // 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;
}
-void
+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
projects / oota-llvm.git / commitdiff