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

llvm/include/llvm/System/Path.h

@@ -19,138 +19,392 @@
 namespace llvm {
 namespace sys {
 
-  /// This class provides an abstraction for the name of a path
+  /// This class provides an abstraction for the path to a file or directory 
-  /// to a file or directory in the filesystem and various basic operations
+  /// in the operating system's filesystem and provides various basic operations 
-  /// on it.
+  /// 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 {
+  class Path {
-  /// @name Constructors
+    /// @name Constructors
-  /// @{
+    /// @{
-  public:
+    public:
-    /// Creates a null (empty) path
+      /// Construct a path to the root directory of the file system. The root
-    /// @brief Default Constructor
+      /// directory is a top level directory above which there are no more 
-    Path () : std::string() {}
+      /// 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*
+      /// Construct a path to a unique temporary directory that is created in
-    /// @brief char* converter
+      /// a "standard" place for the operating system. The directory is 
-    Path ( const char * name ) : std::string(name) {
+      /// guaranteed to be created on exit from this function. If the directory 
-      assert(is_valid());
+      /// 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
+      /// Construct a path to the first system library directory. The
-    Path ( const std::string& name ) : std::string(name){
+      /// implementation of Path on a given platform must ensure that this
-      assert(is_valid());
+      /// 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
+      /// Construct a path to the second system library directory. The
-    /// will reference \p the that Path until one of them is modified
+      /// implementation of Path on a given platform must ensure that this
-    /// at which point a full copy is taken before the write.
+      /// directory both exists and also contains standard system libraries
-    /// @brief Copy Constructor
+      /// suitable for linking into programs. Note that the "second" system
-    Path ( const Path & that ) : std::string(that) {}
+      /// 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
+      /// Construct a path to the default LLVM configuration directory. The 
-    /// @brief Destructor
+      /// implementation must ensure that this is a well-known (same on many
-    ~Path ( void ) {};
+      /// 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
-  /// @name Operators
+      /// implementation must ensure that this refers to the "etc" directory of
-  /// @{
+      /// the LLVM installation. This is the location where configuration files
-  public:
+      /// will be located for a particular installation of LLVM on a machine.
-    /// Makes a copy of \p that to \p this with copy-on-write semantics.
+      /// @throws nothing
-    /// @returns \p this
+      /// @brief Construct a path to the LLVM installed configuration directory
-    /// @brief Assignment Operator
+      static Path GetLLVMConfigDir();
-    Path & operator = ( const Path & that ) {
-      this->assign (that);
-      return *this;
-    }
 
-    /// Comparies \p this Path with \p that Path for equality.
+      /// Construct a path to the current user's home directory. The
-    /// @returns true if \p this and \p that refer to the same item.
+      /// implementation must use an operating system specific mechanism for
-    /// @brief Equality Operator
+      /// determining the user's home directory. For example, the environment 
-    bool operator ==( const Path & that ) const {
+      /// variable "HOME" could be used on Unix. If a given operating system 
-      return 0 == this->compare( that ) ;
+      /// 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.
+      /// This is one of the very few ways in which a path can be constructed
-    /// @returns true if \p this and \p that refer to different items.
+      /// with a syntactically invalid name. The only *legal* invalid name is an 
-    /// @brief Inequality Operator
+      /// empty one. Other invalid names are not permitted. Empty paths are
-    bool operator !=( const Path & that ) const {
+      /// provided so that they can be used to indicate null or error results in
-      return 0 != this->compare( that );
+      /// 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
-  /// @name Accessors
+      /// 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
-  public:
+      /// the program. However, if the path is not valid, the Path object will
-    /// @returns true if the path is valid
+      /// be set to an empty string and an exception will be thrown.
-    /// @brief Determines if the path is valid (properly formed) or not.
+      /// @throws std::string if the path string is not legal.
-    bool is_valid() const;
+      /// @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.
+    /// @name Operators
-    bool is_file() const;
+    /// @{
+    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
+      /// Compares \p this Path with \p that Path for equality.
-    /// @brief Determines if the path is valid for a directory reference.
+      /// @returns true if \p this and \p that refer to the same thing.
-    bool is_directory() const;
+      /// @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
+      /// Compares \p this Path with \p that Path for inequality.
-    void fill( char* buffer, unsigned len ) const;
+      /// @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
-  /// @name Mutators
+      /// so that Path objects can be placed into ordered collections (e.g.
-  /// @{
+      /// std::map). The comparison is done lexicographically as defined by
-  public:
+      /// the std::string::compare method.
-      /// This ensures that the pathname is terminated with a /
+      /// @returns true if \p this path is lexicographically less than \p that.
-      /// @brief Make the path reference a directory.
+      /// @throws nothing
-      void make_directory();
+      /// @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.
+    /// @name Accessors
-      void make_file();
+    /// @{
+    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.
+      /// be added to the end of the path.
-      /// @brief Appends the name of a directory.
+      /// @returns false if the directory name could not be added
-      void append_directory( const std::string& dirname ) {
+      /// @throws nothing
-        this->append( dirname );
+      /// @brief Adds the name of a directory to a Path.
-        make_directory();
+      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 ) {
+      bool append_file( const std::string& filename );
-        this->append( filename );
-      }
 
-      /// Directories will have no entries. Files will be zero length. If
+      /// One file component is removed from the Path name. The Path must
-      /// the file or directory already exists, no error results.
+      /// refer to a file (i.e. is_file() returns true). Upon exit, 
-      /// @throws SystemException if any error occurs.
+      /// the Path will refer to the directory above it.
-      /// @brief Causes the file or directory to exist in the filesystem.
+      /// @throws nothing
-      void create( bool create_parents = false );
+      /// @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 );
+      /// A period and the \p suffix are appended to the end of the pathname.
-      void create_directories( void );
+      /// The precondition for this function is that the Path reference a file
-      void create_file( void );
+      /// 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,
+      /// The suffix of the filename is removed. The suffix begins with and
-      /// an error will result. Files will be unlinked, even if another
+      /// includes the last . character in the filename after the last directory 
-      /// process is using them.
+      /// 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 );
+      bool destroy_directory( bool destroy_contents = false );
-      void remove_directory( void );
-      void remove_file( void ); 
 
-      /// Find library.
+      /// This method attempts to destroy the file named by the last item in the 
-      void find_lib( const char * file );
+      /// 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.
+
+    /// @}
   };
 }
 }

llvm/lib/System/AIX/Path.cpp

@@ -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

llvm/lib/System/Darwin/Path.cpp

@@ -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

llvm/lib/System/Linux/Path.cpp

@@ -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

llvm/lib/System/Path.cpp

@@ -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 {
+Path::is_file() const {
-  if ( empty() ) return false;
+  return (is_valid() && path[path.length()-1] != '/');
-  return true;
 }
 
-void 
+bool
-Path::fill( char* buffer, unsigned bufflen ) const {
+Path::is_directory() const {
-  unsigned pathlen = length();
+  return (is_valid() && path[path.length()-1] == '/');
-  assert( bufflen > pathlen && "Insufficient buffer size" );
-  unsigned copylen = pathlen <? (bufflen - 1);
-  this->copy(buffer, copylen, 0 );
-  buffer[ copylen ] = 0;
 }
 
-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

llvm/lib/System/SunOS/Path.cpp

@@ -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

llvm/lib/System/Unix/Path.cpp

@@ -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
+namespace llvm {
-Path::is_file() const {
+using namespace sys;
-  if (!empty() && ((*this)[length()-1] !=  '/'))
-    return true;
-  return false;
-}
 
-bool
+Path::Path(std::string unverified_path) 
-Path::is_directory() const {
+  : path(unverified_path)
-  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()
 {
-  char pathname[MAXPATHLEN];
+  if (unverified_path.empty())
-  this->fill(pathname,MAXPATHLEN);
+    return;
-  int lastchar = this->length() - 1 ; 
+  if (this->is_valid()) 
-  if (pathname[lastchar] == '/') 
+    return;
-    pathname[lastchar] = 0;
+  // oops, not valid.
-  if ( 0 != rmdir(pathname))
+  path.clear();
-    ThrowErrno(pathname);
+  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];
+  // Make sure we're dealing with a file
-  this->fill(pathname,MAXPATHLEN);
+  if (!is_file()) return false; 
-  int lastchar = this->length() - 1 ; 
+
-  if (pathname[lastchar] == '/') 
+  // Create the file
-    pathname[lastchar] = 0;
+  if (0 != creat(path.c_str(), S_IRUSR | S_IWUSR))
-  if (0 != creat(pathname, S_IRUSR | S_IWUSR))
+    ThrowErrno(std::string(path.c_str()) + ": Can't create file");
-    ThrowErrno(pathname);
+
+  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