#ifndef LLVM_SYSTEM_PATH_H
#define LLVM_SYSTEM_PATH_H
+#include "llvm/ADT/StringRef.h"
#include "llvm/System/TimeValue.h"
-#include "llvm/Support/raw_ostream.h"
#include <set>
#include <string>
#include <vector>
-#include <iosfwd>
namespace llvm {
namespace sys {
/// platform independent and eliminates many of the unix-specific fields.
/// However, to support llvm-ar, the mode, user, and group fields are
/// retained. These pertain to unix security and may not have a meaningful
- /// value on non-Unix platforms. However, the other fields fields should
+ /// value on non-Unix platforms. However, the other fields should
/// always be applicable on all platforms. The structure is filled in by
/// the PathWithStatus class.
/// @brief File status structure
/// between processes.
/// @returns The dynamic link library suffix for the current platform.
/// @brief Return the dynamic link library suffix.
- static std::string GetDLLSuffix();
+ static StringRef GetDLLSuffix();
/// GetMainExecutable - Return the path to the main executable, given the
/// value of argv[0] from program startup and the address of main itself.
+ /// In extremis, this function may fail and return an empty path.
static Path GetMainExecutable(const char *argv0, void *MainAddr);
/// This is one of the very few ways in which a path can be constructed
Path() : path() {}
Path(const Path &that) : path(that.path) {}
- /// This constructor will accept a std::string as a path. No checking is
- /// done on this path to determine if it is valid. To determine validity
- /// of the path, use the isValid method.
+ /// This constructor will accept a char* or std::string as a path. No
+ /// checking is done on this path to determine if it is valid. To
+ /// determine validity of the path, use the isValid method.
/// @param p The path to assign.
/// @brief Construct a Path from a string.
- explicit Path(const std::string& p);
+ explicit Path(StringRef p);
/// This constructor will accept a character range as a path. No checking
/// is done on this path to determine if it is valid. To determine
}
/// Makes a copy of \p that to \p this.
- /// @param \p that A std::string denoting the path
+ /// @param that A StringRef denoting the path
/// @returns \p this
/// @brief Assignment Operator
- Path &operator=(const std::string &that);
+ Path &operator=(StringRef that);
/// Compares \p this Path with \p that Path for equality.
/// @returns true if \p this and \p that refer to the same thing.
/// Compares \p this Path with \p that Path for inequality.
/// @returns true if \p this and \p that refer to different things.
/// @brief Inequality Operator
- bool operator!=(const Path &that) const;
+ bool operator!=(const Path &that) const { return !(*this == that); }
/// 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.
/// @brief Determines if the path name is empty (invalid).
bool isEmpty() const { return path.empty(); }
- /// This function returns the current contents of the path as a
- /// std::string. This allows the underlying path string to be manipulated.
- /// @returns std::string containing the path name.
- /// @brief Returns the path as a std::string.
- const std::string &toString() const { return path; }
-
- /// This function returns the last component of the path name. The last
+ /// This function returns the last component of the path name. The last
/// component is the file or directory name occuring after the last
/// directory separator. If no directory separator is present, the entire
/// path name is returned (i.e. same as toString).
- /// @returns std::string containing the last component of the path name.
+ /// @returns StringRef containing the last component of the path name.
/// @brief Returns the last component of the path name.
- std::string getLast() const;
+ StringRef getLast() const;
/// This function strips off the path and suffix of the file or directory
/// name and returns just the basename. For example /a/foo.bar would cause
/// this function to return "foo".
- /// @returns std::string containing the basename of the path
+ /// @returns StringRef containing the basename of the path
/// @brief Get the base name of the path
- std::string getBasename() const;
+ StringRef getBasename() const;
/// This function strips off the suffix of the path beginning with the
/// path separator ('/' on Unix, '\' on Windows) and returns the result.
- std::string getDirname() const;
+ StringRef getDirname() const;
/// This function strips off the path and basename(up to and
/// including the last dot) of the file or directory name and
/// returns just the suffix. For example /a/foo.bar would cause
/// this function to return "bar".
- /// @returns std::string containing the suffix of the path
+ /// @returns StringRef containing the suffix of the path
/// @brief Get the suffix of the path
- std::string getSuffix() const;
+ StringRef getSuffix() const;
/// Obtain a 'C' string for the path name.
/// @returns a 'C' string containing the path name.
/// @brief Returns the path as a C string.
const char *c_str() const { return path.c_str(); }
+ const std::string &str() const { return path; }
+
/// size - Return the length in bytes of this path name.
size_t size() const { return path.size(); }
/// @name Disk Accessors
/// @{
public:
- /// 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 isRootDirectory() const;
-
/// This function determines if the path name is absolute, as opposed to
/// relative.
/// @brief Determine if the path is absolute.
/// cases (file not found, file not accessible, etc.) it returns false.
/// @returns true if the magic number of the file matches \p magic.
/// @brief Determine if file has a specific magic number
- bool hasMagicNumber(const std::string& magic) const;
+ bool hasMagicNumber(StringRef magic) const;
/// This function retrieves the first \p len bytes of the file associated
/// with \p this. These bytes are returned as the "magic number" in the
/// native Dynamic Library (shared library, shared object) by looking at
/// the file's magic number. The Path object must reference a file, not a
/// directory.
- /// @return strue if the file starts with the magid number for a native
+ /// @returns true if the file starts with the magic number for a native
/// shared library.
- /// @brief Determine if the path reference a dynamic library.
+ /// @brief Determine if the path references a dynamic library.
bool isDynamicLibrary() const;
+ /// This function determines if the path name in the object references a
+ /// native object file by looking at it's magic number. The term object
+ /// file is defined as "an organized collection of separate, named
+ /// sequences of binary data." This covers the obvious file formats such
+ /// as COFF and ELF, but it also includes llvm ir bitcode, archives,
+ /// libraries, etc...
+ /// @returns true if the file starts with the magic number for an object
+ /// file.
+ /// @brief Determine if the path references an object file.
+ bool isObjectFile() const;
+
/// This function determines if the path name references an existing file
/// or directory in the file system.
/// @returns true if the pathname references an existing file or
/// in the file system.
bool canWrite() const;
+ /// This function checks that what we're trying to work only on a regular
+ /// file. Check for things like /dev/null, any block special file, or
+ /// other things that aren't "regular" regular files.
+ /// @returns true if the file is S_ISREG.
+ /// @brief Determines if the file is a regular file
+ bool isRegularFile() const;
+
/// This function determines if the path name references an executable
/// file in the file system. This function checks for the existence and
/// executability (by the current program) of the file.
/// Path object takes on the path value of \p unverified_path
/// @returns true if the path was set, false otherwise.
/// @param unverified_path The path to be set in Path object.
- /// @brief Set a full path from a std::string
- bool set(const std::string& unverified_path);
+ /// @brief Set a full path from a StringRef
+ bool set(StringRef unverified_path);
/// One path component is removed from the Path. If only one component is
/// present in the path, the Path object becomes empty. If the Path object
/// needed.
/// @returns false if the path component could not be added.
/// @brief Appends one path component to the Path.
- bool appendComponent( const std::string& component );
+ bool appendComponent(StringRef component);
/// 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
/// become invalid for the host operating system, false is returned.
/// @returns false if the suffix could not be added, true if it was.
/// @brief Adds a period and the \p suffix to the end of the pathname.
- bool appendSuffix(const std::string& suffix);
+ bool appendSuffix(StringRef suffix);
/// The suffix of the filename is erased. The suffix begins with and
/// includes the last . character in the filename after the last directory
/// @name Data
/// @{
protected:
+ // Our win32 implementation relies on this string being mutable.
mutable std::string path; ///< Storage for the path name.
PathWithStatus(const Path &other)
: Path(other), status(), fsIsValid(false) {}
- /// This constructor will accept a std::string as a path. No checking is
- /// done on this path to determine if it is valid. To determine validity
- /// of the path, use the isValid method.
+ /// This constructor will accept a char* or std::string as a path. No
+ /// checking is done on this path to determine if it is valid. To
+ /// determine validity of the path, use the isValid method.
/// @brief Construct a Path from a string.
explicit PathWithStatus(
- const std::string& p ///< The path to assign.
+ StringRef p ///< The path to assign.
) : Path(p), status(), fsIsValid(false) {}
/// This constructor will accept a character range as a path. No checking
extern const char PathSeparator;
}
-inline raw_ostream& operator<<(raw_ostream& strm, const sys::Path& aPath) {
- strm << aPath.toString();
- return strm;
-}
-
-inline raw_ostream& operator<<(raw_ostream& strm,
- const sys::PathWithStatus& aPath) {
- strm << static_cast<const sys::Path&>(aPath);
- return strm;
-}
-
-std::ostream& operator<<(std::ostream& strm, const sys::Path& aPath);
-inline std::ostream& operator<<(std::ostream& strm,
- const sys::PathWithStatus& aPath) {
- strm << static_cast<const sys::Path&>(aPath);
- return strm;
-}
-
}
#endif
projects / oota-llvm.git / blobdiff