Add a VFSFromYAML class and a parser to create it
Provides a way to create a virtual file system using a YAML file that supports mapping a file to a path on an 'external' file system. The external file system will typically be the 'real' file system, but for testing it can be changed. A future patch will add a clang option to allow the user to specify such a file and overlay it, but for now this code is only exercised by the unit tests. Differential Revision: http://llvm-reviews.chandlerc.com/D2835 llvm-svn: 201905
This commit is contained in:
Ben Langmuir
parent
4845b488f1
commit
d51ba0b39f
|
|
@ -17,6 +17,7 @@
|
|||
#include "llvm/ADT/IntrusiveRefCntPtr.h"
|
||||
#include "llvm/Support/FileSystem.h"
|
||||
#include "llvm/Support/ErrorOr.h"
|
||||
#include "llvm/Support/SourceMgr.h"
|
||||
|
||||
namespace llvm {
|
||||
class MemoryBuffer;
|
||||
|
|
@ -157,6 +158,17 @@ public:
|
|||
OwningPtr<File> &Result) LLVM_OVERRIDE;
|
||||
};
|
||||
|
||||
/// \brief Get a globally unique ID for a virtual file or directory.
|
||||
llvm::sys::fs::UniqueID getNextVirtualUniqueID();
|
||||
|
||||
/// \brief Gets a \p FileSystem for a virtual file system described in YAML
|
||||
/// format.
|
||||
///
|
||||
/// Takes ownership of \p Buffer.
|
||||
IntrusiveRefCntPtr<FileSystem>
|
||||
getVFSFromYAML(llvm::MemoryBuffer *Buffer, llvm::SourceMgr::DiagHandlerTy,
|
||||
IntrusiveRefCntPtr<FileSystem> ExternalFS = getRealFileSystem());
|
||||
|
||||
} // end namespace vfs
|
||||
} // end namespace clang
|
||||
#endif // LLVM_CLANG_BASIC_VIRTUAL_FILE_SYSTEM_H
|
||||
|
|
|
|||
|
|
@ -10,10 +10,14 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "clang/Basic/VirtualFileSystem.h"
|
||||
#include "llvm/ADT/DenseMap.h"
|
||||
#include "llvm/ADT/OwningPtr.h"
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
#include "llvm/ADT/StringExtras.h"
|
||||
#include "llvm/Support/Atomic.h"
|
||||
#include "llvm/Support/MemoryBuffer.h"
|
||||
#include "llvm/Support/SourceMgr.h"
|
||||
#include "llvm/Support/Path.h"
|
||||
#include "llvm/Support/YAMLParser.h"
|
||||
|
||||
using namespace clang;
|
||||
using namespace clang::vfs;
|
||||
|
|
@ -83,6 +87,7 @@ class RealFile : public File {
|
|||
RealFile(int FD) : FD(FD) {
|
||||
assert(FD >= 0 && "Invalid or inactive file descriptor");
|
||||
}
|
||||
|
||||
public:
|
||||
~RealFile();
|
||||
ErrorOr<Status> status() LLVM_OVERRIDE;
|
||||
|
|
@ -91,9 +96,7 @@ public:
|
|||
bool RequiresNullTerminator = true) LLVM_OVERRIDE;
|
||||
error_code close() LLVM_OVERRIDE;
|
||||
};
|
||||
RealFile::~RealFile() {
|
||||
close();
|
||||
}
|
||||
RealFile::~RealFile() { close(); }
|
||||
|
||||
ErrorOr<Status> RealFile::status() {
|
||||
assert(FD != -1 && "cannot stat closed file");
|
||||
|
|
@ -191,3 +194,572 @@ error_code OverlayFileSystem::openFileForRead(const llvm::Twine &Path,
|
|||
}
|
||||
return error_code(errc::no_such_file_or_directory, system_category());
|
||||
}
|
||||
|
||||
//===-----------------------------------------------------------------------===/
|
||||
// VFSFromYAML implementation
|
||||
//===-----------------------------------------------------------------------===/
|
||||
|
||||
// Allow DenseMap<StringRef, ...>. This is useful below because we know all the
|
||||
// strings are literals and will outlive the map, and there is no reason to
|
||||
// store them.
|
||||
namespace llvm {
|
||||
template<>
|
||||
struct DenseMapInfo<StringRef> {
|
||||
// This assumes that "" will never be a valid key.
|
||||
static inline StringRef getEmptyKey() { return StringRef(""); }
|
||||
static inline StringRef getTombstoneKey() { return StringRef(); }
|
||||
static unsigned getHashValue(StringRef Val) { return HashString(Val); }
|
||||
static bool isEqual(StringRef LHS, StringRef RHS) { return LHS == RHS; }
|
||||
};
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
enum EntryKind {
|
||||
EK_Directory,
|
||||
EK_File
|
||||
};
|
||||
|
||||
/// \brief A single file or directory in the VFS.
|
||||
class Entry {
|
||||
EntryKind Kind;
|
||||
std::string Name;
|
||||
|
||||
public:
|
||||
virtual ~Entry();
|
||||
#if LLVM_HAS_RVALUE_REFERENCES
|
||||
Entry(EntryKind K, std::string Name) : Kind(K), Name(std::move(Name)) {}
|
||||
#endif
|
||||
Entry(EntryKind K, StringRef Name) : Kind(K), Name(Name) {}
|
||||
StringRef getName() const { return Name; }
|
||||
EntryKind getKind() const { return Kind; }
|
||||
};
|
||||
|
||||
class DirectoryEntry : public Entry {
|
||||
std::vector<Entry *> Contents;
|
||||
Status S;
|
||||
|
||||
public:
|
||||
virtual ~DirectoryEntry();
|
||||
#if LLVM_HAS_RVALUE_REFERENCES
|
||||
DirectoryEntry(std::string Name, std::vector<Entry *> Contents, Status S)
|
||||
: Entry(EK_Directory, std::move(Name)), Contents(std::move(Contents)),
|
||||
S(std::move(S)) {}
|
||||
#endif
|
||||
DirectoryEntry(StringRef Name, ArrayRef<Entry *> Contents, const Status &S)
|
||||
: Entry(EK_Directory, Name), Contents(Contents), S(S) {}
|
||||
Status getStatus() { return S; }
|
||||
typedef std::vector<Entry *>::iterator iterator;
|
||||
iterator contents_begin() { return Contents.begin(); }
|
||||
iterator contents_end() { return Contents.end(); }
|
||||
static bool classof(const Entry *E) { return E->getKind() == EK_Directory; }
|
||||
};
|
||||
|
||||
class FileEntry : public Entry {
|
||||
std::string ExternalContentsPath;
|
||||
|
||||
public:
|
||||
#if LLVM_HAS_RVALUE_REFERENCES
|
||||
FileEntry(std::string Name, std::string ExternalContentsPath)
|
||||
: Entry(EK_File, std::move(Name)),
|
||||
ExternalContentsPath(std::move(ExternalContentsPath)) {}
|
||||
#endif
|
||||
FileEntry(StringRef Name, StringRef ExternalContentsPath)
|
||||
: Entry(EK_File, Name), ExternalContentsPath(ExternalContentsPath) {}
|
||||
StringRef getExternalContentsPath() const { return ExternalContentsPath; }
|
||||
static bool classof(const Entry *E) { return E->getKind() == EK_File; }
|
||||
};
|
||||
|
||||
/// \brief A virtual file system parsed from a YAML file.
|
||||
///
|
||||
/// Currently, this class allows creating virtual directories and mapping
|
||||
/// virtual file paths to existing external files, available in \c ExternalFS.
|
||||
///
|
||||
/// The basic structure of the parsed file is:
|
||||
/// \verbatim
|
||||
/// {
|
||||
/// 'version': <version number>,
|
||||
/// <optional configuration>
|
||||
/// 'roots': [
|
||||
/// <directory entries>
|
||||
/// ]
|
||||
/// }
|
||||
/// \endverbatim
|
||||
///
|
||||
/// All configuration options are optional.
|
||||
/// 'case-sensitive': <boolean, default=true>
|
||||
///
|
||||
/// Virtual directories are represented as
|
||||
/// \verbatim
|
||||
/// {
|
||||
/// 'type': 'directory',
|
||||
/// 'name': <string>,
|
||||
/// 'contents': [ <file or directory entries> ]
|
||||
/// }
|
||||
/// \endverbatim
|
||||
///
|
||||
/// The default attributes for virtual directories are:
|
||||
/// \verbatim
|
||||
/// MTime = now() when created
|
||||
/// Perms = 0777
|
||||
/// User = Group = 0
|
||||
/// Size = 0
|
||||
/// UniqueID = unspecified unique value
|
||||
/// \endverbatim
|
||||
///
|
||||
/// Re-mapped files are represented as
|
||||
/// \verbatim
|
||||
/// {
|
||||
/// 'type': 'file',
|
||||
/// 'name': <string>,
|
||||
/// 'external-contents': <path to external file>)
|
||||
/// }
|
||||
/// \endverbatim
|
||||
///
|
||||
/// and inherit their attributes from the external contents.
|
||||
///
|
||||
/// In both cases, the 'name' field must be a single path component (containing
|
||||
/// no separators).
|
||||
class VFSFromYAML : public vfs::FileSystem {
|
||||
std::vector<Entry *> Roots; ///< The root(s) of the virtual file system.
|
||||
/// \brief The file system to use for external references.
|
||||
IntrusiveRefCntPtr<FileSystem> ExternalFS;
|
||||
|
||||
/// @name Configuration
|
||||
/// @{
|
||||
|
||||
/// \brief Whether to perform case-sensitive comparisons.
|
||||
///
|
||||
/// Currently, case-insensitive matching only works correctly with ASCII.
|
||||
bool CaseSensitive; ///< Whether to perform case-sensitive comparisons.
|
||||
/// @}
|
||||
|
||||
friend class VFSFromYAMLParser;
|
||||
|
||||
private:
|
||||
VFSFromYAML(IntrusiveRefCntPtr<FileSystem> ExternalFS)
|
||||
: ExternalFS(ExternalFS), CaseSensitive(true) {}
|
||||
|
||||
/// \brief Looks up \p Path in \c Roots.
|
||||
ErrorOr<Entry *> lookupPath(const Twine &Path);
|
||||
|
||||
/// \brief Looks up the path <tt>[Start, End)</tt> in \p From, possibly
|
||||
/// recursing into the contents of \p From if it is a directory.
|
||||
ErrorOr<Entry *> lookupPath(sys::path::const_iterator Start,
|
||||
sys::path::const_iterator End, Entry *From);
|
||||
|
||||
public:
|
||||
~VFSFromYAML();
|
||||
|
||||
/// \brief Parses \p Buffer, which is expected to be in YAML format and
|
||||
/// returns a virtual file system representing its contents.
|
||||
///
|
||||
/// Takes ownership of \p Buffer.
|
||||
static VFSFromYAML *create(MemoryBuffer *Buffer,
|
||||
SourceMgr::DiagHandlerTy DiagHandler,
|
||||
IntrusiveRefCntPtr<FileSystem> ExternalFS);
|
||||
|
||||
ErrorOr<Status> status(const Twine &Path) LLVM_OVERRIDE;
|
||||
error_code openFileForRead(const Twine &Path,
|
||||
OwningPtr<File> &Result) LLVM_OVERRIDE;
|
||||
};
|
||||
|
||||
/// \brief A helper class to hold the common YAML parsing state.
|
||||
class VFSFromYAMLParser {
|
||||
yaml::Stream &Stream;
|
||||
|
||||
void error(yaml::Node *N, const Twine &Msg) {
|
||||
Stream.printError(N, Msg);
|
||||
}
|
||||
|
||||
// false on error
|
||||
bool parseScalarString(yaml::Node *N, StringRef &Result,
|
||||
SmallVectorImpl<char> &Storage) {
|
||||
yaml::ScalarNode *S = dyn_cast<yaml::ScalarNode>(N);
|
||||
if (!S) {
|
||||
error(N, "expected string");
|
||||
return false;
|
||||
}
|
||||
Result = S->getValue(Storage);
|
||||
return true;
|
||||
}
|
||||
|
||||
// false on error
|
||||
bool parseScalarBool(yaml::Node *N, bool &Result) {
|
||||
SmallString<5> Storage;
|
||||
StringRef Value;
|
||||
if (!parseScalarString(N, Value, Storage))
|
||||
return false;
|
||||
|
||||
if (Value.equals_lower("true") || Value.equals_lower("on") ||
|
||||
Value.equals_lower("yes") || Value == "1") {
|
||||
Result = true;
|
||||
return true;
|
||||
} else if (Value.equals_lower("false") || Value.equals_lower("off") ||
|
||||
Value.equals_lower("no") || Value == "0") {
|
||||
Result = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
error(N, "expected boolean value");
|
||||
return false;
|
||||
}
|
||||
|
||||
struct KeyStatus {
|
||||
KeyStatus(bool Required=false) : Required(Required), Seen(false) {}
|
||||
bool Required;
|
||||
bool Seen;
|
||||
};
|
||||
typedef std::pair<StringRef, KeyStatus> KeyStatusPair;
|
||||
|
||||
// false on error
|
||||
bool checkDuplicateOrUnknownKey(yaml::Node *KeyNode, StringRef Key,
|
||||
DenseMap<StringRef, KeyStatus> &Keys) {
|
||||
if (!Keys.count(Key)) {
|
||||
error(KeyNode, "unknown key");
|
||||
return false;
|
||||
}
|
||||
KeyStatus &S = Keys[Key];
|
||||
if (S.Seen) {
|
||||
error(KeyNode, Twine("duplicate key '") + Key + "'");
|
||||
return false;
|
||||
}
|
||||
S.Seen = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
// false on error
|
||||
bool checkMissingKeys(yaml::Node *Obj, DenseMap<StringRef, KeyStatus> &Keys) {
|
||||
for (DenseMap<StringRef, KeyStatus>::iterator I = Keys.begin(),
|
||||
E = Keys.end();
|
||||
I != E; ++I) {
|
||||
if (I->second.Required && !I->second.Seen) {
|
||||
error(Obj, Twine("missing key '") + I->first + "'");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
Entry *parseEntry(yaml::Node *N) {
|
||||
yaml::MappingNode *M = dyn_cast<yaml::MappingNode>(N);
|
||||
if (!M) {
|
||||
error(N, "expected mapping node for file or directory entry");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
KeyStatusPair Fields[] = {
|
||||
KeyStatusPair("name", true),
|
||||
KeyStatusPair("type", true),
|
||||
KeyStatusPair("contents", false),
|
||||
KeyStatusPair("external-contents", false)
|
||||
};
|
||||
|
||||
DenseMap<StringRef, KeyStatus> Keys(
|
||||
&Fields[0], Fields + sizeof(Fields)/sizeof(Fields[0]));
|
||||
|
||||
bool HasContents = false; // external or otherwise
|
||||
std::vector<Entry *> EntryArrayContents;
|
||||
std::string ExternalContentsPath;
|
||||
std::string Name;
|
||||
EntryKind Kind;
|
||||
|
||||
for (yaml::MappingNode::iterator I = M->begin(), E = M->end(); I != E;
|
||||
++I) {
|
||||
StringRef Key;
|
||||
// Reuse the buffer for key and value, since we don't look at key after
|
||||
// parsing value.
|
||||
SmallString<256> Buffer;
|
||||
if (!parseScalarString(I->getKey(), Key, Buffer))
|
||||
return NULL;
|
||||
|
||||
if (!checkDuplicateOrUnknownKey(I->getKey(), Key, Keys))
|
||||
return NULL;
|
||||
|
||||
StringRef Value;
|
||||
if (Key == "name") {
|
||||
if (!parseScalarString(I->getValue(), Value, Buffer))
|
||||
return NULL;
|
||||
Name = Value;
|
||||
if (sys::path::has_parent_path(Name)) {
|
||||
error(I->getValue(), "unexpected path separator in name");
|
||||
return NULL;
|
||||
}
|
||||
} else if (Key == "type") {
|
||||
if (!parseScalarString(I->getValue(), Value, Buffer))
|
||||
return NULL;
|
||||
if (Value == "file")
|
||||
Kind = EK_File;
|
||||
else if (Value == "directory")
|
||||
Kind = EK_Directory;
|
||||
else {
|
||||
error(I->getValue(), "unknown value for 'type'");
|
||||
return NULL;
|
||||
}
|
||||
} else if (Key == "contents") {
|
||||
if (HasContents) {
|
||||
error(I->getKey(),
|
||||
"entry already has 'contents' or 'external-contents'");
|
||||
return NULL;
|
||||
}
|
||||
HasContents = true;
|
||||
yaml::SequenceNode *Contents =
|
||||
dyn_cast<yaml::SequenceNode>(I->getValue());
|
||||
if (!Contents) {
|
||||
// FIXME: this is only for directories, what about files?
|
||||
error(I->getValue(), "expected array");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (yaml::SequenceNode::iterator I = Contents->begin(),
|
||||
E = Contents->end();
|
||||
I != E; ++I) {
|
||||
if (Entry *E = parseEntry(&*I))
|
||||
EntryArrayContents.push_back(E);
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
} else if (Key == "external-contents") {
|
||||
if (HasContents) {
|
||||
error(I->getKey(),
|
||||
"entry already has 'contents' or 'external-contents'");
|
||||
return NULL;
|
||||
}
|
||||
HasContents = true;
|
||||
if (!parseScalarString(I->getValue(), Value, Buffer))
|
||||
return NULL;
|
||||
ExternalContentsPath = Value;
|
||||
} else {
|
||||
llvm_unreachable("key missing from Keys");
|
||||
}
|
||||
}
|
||||
|
||||
if (Stream.failed())
|
||||
return NULL;
|
||||
|
||||
// check for missing keys
|
||||
if (!HasContents) {
|
||||
error(N, "missing key 'contents' or 'external-contents'");
|
||||
return NULL;
|
||||
}
|
||||
if (!checkMissingKeys(N, Keys))
|
||||
return NULL;
|
||||
|
||||
switch (Kind) {
|
||||
case EK_File:
|
||||
return new FileEntry(llvm_move(Name), llvm_move(ExternalContentsPath));
|
||||
case EK_Directory:
|
||||
return new DirectoryEntry(
|
||||
llvm_move(Name), llvm_move(EntryArrayContents),
|
||||
Status("", "", getNextVirtualUniqueID(), sys::TimeValue::now(), 0, 0,
|
||||
0, file_type::directory_file, sys::fs::all_all));
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
VFSFromYAMLParser(yaml::Stream &S) : Stream(S) {}
|
||||
|
||||
// false on error
|
||||
bool parse(yaml::Node *Root, VFSFromYAML *FS) {
|
||||
yaml::MappingNode *Top = dyn_cast<yaml::MappingNode>(Root);
|
||||
if (!Top) {
|
||||
error(Root, "expected mapping node");
|
||||
return false;
|
||||
}
|
||||
|
||||
KeyStatusPair Fields[] = {
|
||||
KeyStatusPair("version", true),
|
||||
KeyStatusPair("case-sensitive", false),
|
||||
KeyStatusPair("roots", true),
|
||||
};
|
||||
|
||||
DenseMap<StringRef, KeyStatus> Keys(
|
||||
&Fields[0], Fields + sizeof(Fields)/sizeof(Fields[0]));
|
||||
|
||||
// Parse configuration and 'roots'
|
||||
for (yaml::MappingNode::iterator I = Top->begin(), E = Top->end(); I != E;
|
||||
++I) {
|
||||
SmallString<10> KeyBuffer;
|
||||
StringRef Key;
|
||||
if (!parseScalarString(I->getKey(), Key, KeyBuffer))
|
||||
return false;
|
||||
|
||||
if (!checkDuplicateOrUnknownKey(I->getKey(), Key, Keys))
|
||||
return false;
|
||||
|
||||
if (Key == "roots") {
|
||||
yaml::SequenceNode *Roots = dyn_cast<yaml::SequenceNode>(I->getValue());
|
||||
if (!Roots) {
|
||||
error(I->getValue(), "expected array");
|
||||
return false;
|
||||
}
|
||||
|
||||
for (yaml::SequenceNode::iterator I = Roots->begin(), E = Roots->end();
|
||||
I != E; ++I) {
|
||||
if (Entry *E = parseEntry(&*I))
|
||||
FS->Roots.push_back(E);
|
||||
else
|
||||
return false;
|
||||
}
|
||||
} else if (Key == "version") {
|
||||
StringRef VersionString;
|
||||
SmallString<4> Storage;
|
||||
if (!parseScalarString(I->getValue(), VersionString, Storage))
|
||||
return false;
|
||||
int Version;
|
||||
if (VersionString.getAsInteger<int>(10, Version)) {
|
||||
error(I->getValue(), "expected integer");
|
||||
return false;
|
||||
}
|
||||
if (Version < 0) {
|
||||
error(I->getValue(), "invalid version number");
|
||||
return false;
|
||||
}
|
||||
if (Version != 0) {
|
||||
error(I->getValue(), "version mismatch, expected 0");
|
||||
return false;
|
||||
}
|
||||
} else if (Key == "case-sensitive") {
|
||||
if (!parseScalarBool(I->getValue(), FS->CaseSensitive))
|
||||
return false;
|
||||
} else {
|
||||
llvm_unreachable("key missing from Keys");
|
||||
}
|
||||
}
|
||||
|
||||
if (Stream.failed())
|
||||
return false;
|
||||
|
||||
if (!checkMissingKeys(Top, Keys))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
};
|
||||
} // end of anonymous namespace
|
||||
|
||||
Entry::~Entry() {}
|
||||
DirectoryEntry::~DirectoryEntry() { llvm::DeleteContainerPointers(Contents); }
|
||||
|
||||
VFSFromYAML::~VFSFromYAML() { llvm::DeleteContainerPointers(Roots); }
|
||||
|
||||
VFSFromYAML *VFSFromYAML::create(MemoryBuffer *Buffer,
|
||||
SourceMgr::DiagHandlerTy DiagHandler,
|
||||
IntrusiveRefCntPtr<FileSystem> ExternalFS) {
|
||||
|
||||
SourceMgr SM;
|
||||
yaml::Stream Stream(Buffer, SM);
|
||||
|
||||
SM.setDiagHandler(DiagHandler);
|
||||
yaml::document_iterator DI = Stream.begin();
|
||||
yaml::Node *Root = DI->getRoot();
|
||||
if (DI == Stream.end() || !Root) {
|
||||
SM.PrintMessage(SMLoc(), SourceMgr::DK_Error, "expected root node");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
VFSFromYAMLParser P(Stream);
|
||||
|
||||
OwningPtr<VFSFromYAML> FS(new VFSFromYAML(ExternalFS));
|
||||
if (!P.parse(Root, FS.get()))
|
||||
return NULL;
|
||||
|
||||
return FS.take();
|
||||
}
|
||||
|
||||
ErrorOr<Entry *> VFSFromYAML::lookupPath(const Twine &Path_) {
|
||||
SmallVector<char, 256> Storage;
|
||||
StringRef Path = Path_.toNullTerminatedStringRef(Storage);
|
||||
|
||||
if (Path.empty())
|
||||
return error_code(errc::invalid_argument, system_category());
|
||||
|
||||
sys::path::const_iterator Start = sys::path::begin(Path);
|
||||
sys::path::const_iterator End = sys::path::end(Path);
|
||||
for (std::vector<Entry *>::iterator I = Roots.begin(), E = Roots.end();
|
||||
I != E; ++I) {
|
||||
ErrorOr<Entry *> Result = lookupPath(Start, End, *I);
|
||||
if (Result || Result.getError() != errc::no_such_file_or_directory)
|
||||
return Result;
|
||||
}
|
||||
return error_code(errc::no_such_file_or_directory, system_category());
|
||||
}
|
||||
|
||||
ErrorOr<Entry *> VFSFromYAML::lookupPath(sys::path::const_iterator Start,
|
||||
sys::path::const_iterator End,
|
||||
Entry *From) {
|
||||
// FIXME: handle . and ..
|
||||
if (CaseSensitive ? !Start->equals(From->getName())
|
||||
: !Start->equals_lower(From->getName()))
|
||||
// failure to match
|
||||
return error_code(errc::no_such_file_or_directory, system_category());
|
||||
|
||||
++Start;
|
||||
|
||||
if (Start == End) {
|
||||
// Match!
|
||||
return From;
|
||||
}
|
||||
|
||||
DirectoryEntry *DE = dyn_cast<DirectoryEntry>(From);
|
||||
if (!DE)
|
||||
return error_code(errc::not_a_directory, system_category());
|
||||
|
||||
for (DirectoryEntry::iterator I = DE->contents_begin(),
|
||||
E = DE->contents_end();
|
||||
I != E; ++I) {
|
||||
ErrorOr<Entry *> Result = lookupPath(Start, End, *I);
|
||||
if (Result || Result.getError() != errc::no_such_file_or_directory)
|
||||
return Result;
|
||||
}
|
||||
return error_code(errc::no_such_file_or_directory, system_category());
|
||||
}
|
||||
|
||||
ErrorOr<Status> VFSFromYAML::status(const Twine &Path) {
|
||||
ErrorOr<Entry *> Result = lookupPath(Path);
|
||||
if (!Result)
|
||||
return Result.getError();
|
||||
|
||||
std::string PathStr(Path.str());
|
||||
if (FileEntry *F = dyn_cast<FileEntry>(*Result)) {
|
||||
ErrorOr<Status> S = ExternalFS->status(F->getExternalContentsPath());
|
||||
if (S) {
|
||||
assert(S->getName() == S->getExternalName() &&
|
||||
S->getName() == F->getExternalContentsPath());
|
||||
S->setName(PathStr);
|
||||
}
|
||||
return S;
|
||||
} else { // directory
|
||||
DirectoryEntry *DE = cast<DirectoryEntry>(*Result);
|
||||
Status S = DE->getStatus();
|
||||
S.setName(PathStr);
|
||||
S.setExternalName(PathStr);
|
||||
return S;
|
||||
}
|
||||
}
|
||||
|
||||
error_code VFSFromYAML::openFileForRead(const Twine &Path,
|
||||
OwningPtr<vfs::File> &Result) {
|
||||
ErrorOr<Entry *> E = lookupPath(Path);
|
||||
if (!E)
|
||||
return E.getError();
|
||||
|
||||
FileEntry *F = dyn_cast<FileEntry>(*E);
|
||||
if (!F) // FIXME: errc::not_a_file?
|
||||
return error_code(errc::invalid_argument, system_category());
|
||||
|
||||
return ExternalFS->openFileForRead(Path, Result);
|
||||
}
|
||||
|
||||
IntrusiveRefCntPtr<FileSystem>
|
||||
vfs::getVFSFromYAML(MemoryBuffer *Buffer, SourceMgr::DiagHandlerTy DiagHandler,
|
||||
IntrusiveRefCntPtr<FileSystem> ExternalFS) {
|
||||
return VFSFromYAML::create(Buffer, DiagHandler, ExternalFS);
|
||||
}
|
||||
|
||||
UniqueID vfs::getNextVirtualUniqueID() {
|
||||
static volatile sys::cas_flag UID = 0;
|
||||
sys::cas_flag ID = llvm::sys::AtomicIncrement(&UID);
|
||||
// The following assumes that uint64_t max will never collide with a real
|
||||
// dev_t value from the OS.
|
||||
return UniqueID(std::numeric_limits<uint64_t>::max(), ID);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,9 @@
|
|||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "clang/Basic/VirtualFileSystem.h"
|
||||
#include "llvm/Support/MemoryBuffer.h"
|
||||
#include "llvm/Support/Path.h"
|
||||
#include "llvm/Support/SourceMgr.h"
|
||||
#include "gtest/gtest.h"
|
||||
#include <map>
|
||||
using namespace clang;
|
||||
|
|
@ -31,7 +33,7 @@ public:
|
|||
|
||||
ErrorOr<vfs::Status> status(const Twine &Path) {
|
||||
std::map<std::string, vfs::Status>::iterator I =
|
||||
FilesAndDirs.find(Path.str());
|
||||
FilesAndDirs.find(Path.str());
|
||||
if (I == FilesAndDirs.end())
|
||||
return error_code(errc::no_such_file_or_directory, posix_category());
|
||||
return I->second;
|
||||
|
|
@ -50,13 +52,13 @@ public:
|
|||
FilesAndDirs[Path] = Status;
|
||||
}
|
||||
|
||||
void addRegularFile(StringRef Path, sys::fs::perms Perms=sys::fs::all_all) {
|
||||
void addRegularFile(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) {
|
||||
vfs::Status S(Path, Path, UniqueID(FSID, FileID++), sys::TimeValue::now(),
|
||||
0, 0, 1024, sys::fs::file_type::regular_file, Perms);
|
||||
addEntry(Path, S);
|
||||
}
|
||||
|
||||
void addDirectory(StringRef Path, sys::fs::perms Perms=sys::fs::all_all) {
|
||||
void addDirectory(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) {
|
||||
vfs::Status S(Path, Path, UniqueID(FSID, FileID++), sys::TimeValue::now(),
|
||||
0, 0, 0, sys::fs::file_type::directory_file, Perms);
|
||||
addEntry(Path, S);
|
||||
|
|
@ -70,7 +72,7 @@ public:
|
|||
};
|
||||
} // end anonymous namespace
|
||||
|
||||
TEST(VirtualFileSystemTest, statusQueries) {
|
||||
TEST(VirtualFileSystemTest, StatusQueries) {
|
||||
IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
|
||||
ErrorOr<vfs::Status> Status((error_code()));
|
||||
|
||||
|
|
@ -110,7 +112,7 @@ TEST(VirtualFileSystemTest, statusQueries) {
|
|||
EXPECT_FALSE(Status->equivalent(*Status2));
|
||||
}
|
||||
|
||||
TEST(VirtualFileSystemTest, baseOnlyOverlay) {
|
||||
TEST(VirtualFileSystemTest, BaseOnlyOverlay) {
|
||||
IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
|
||||
ErrorOr<vfs::Status> Status((error_code()));
|
||||
EXPECT_FALSE(Status = D->status("/foo"));
|
||||
|
|
@ -128,17 +130,18 @@ TEST(VirtualFileSystemTest, baseOnlyOverlay) {
|
|||
EXPECT_TRUE(Status->equivalent(*Status2));
|
||||
}
|
||||
|
||||
TEST(VirtualFileSystemTest, overlayFiles) {
|
||||
TEST(VirtualFileSystemTest, OverlayFiles) {
|
||||
IntrusiveRefCntPtr<DummyFileSystem> Base(new DummyFileSystem());
|
||||
IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
|
||||
IntrusiveRefCntPtr<DummyFileSystem> Top(new DummyFileSystem());
|
||||
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(new vfs::OverlayFileSystem(Base));
|
||||
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
|
||||
new vfs::OverlayFileSystem(Base));
|
||||
O->pushOverlay(Middle);
|
||||
O->pushOverlay(Top);
|
||||
|
||||
ErrorOr<vfs::Status> Status1((error_code())), Status2((error_code())),
|
||||
Status3((error_code())), StatusB((error_code())),
|
||||
StatusM((error_code())), StatusT((error_code()));
|
||||
Status3((error_code())), StatusB((error_code())), StatusM((error_code())),
|
||||
StatusT((error_code()));
|
||||
|
||||
Base->addRegularFile("/foo");
|
||||
StatusB = Base->status("/foo");
|
||||
|
|
@ -165,11 +168,11 @@ TEST(VirtualFileSystemTest, overlayFiles) {
|
|||
EXPECT_FALSE(Status1->equivalent(*Status3));
|
||||
}
|
||||
|
||||
TEST(VirtualFileSystemTest, overlayDirsNonMerged) {
|
||||
TEST(VirtualFileSystemTest, OverlayDirsNonMerged) {
|
||||
IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
|
||||
IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
|
||||
IntrusiveRefCntPtr<vfs::OverlayFileSystem>
|
||||
O(new vfs::OverlayFileSystem(Lower));
|
||||
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
|
||||
new vfs::OverlayFileSystem(Lower));
|
||||
O->pushOverlay(Upper);
|
||||
|
||||
Lower->addDirectory("/lower-only");
|
||||
|
|
@ -189,12 +192,12 @@ TEST(VirtualFileSystemTest, overlayDirsNonMerged) {
|
|||
EXPECT_TRUE(Status1->equivalent(*Status2));
|
||||
}
|
||||
|
||||
TEST(VirtualFileSystemTest, mergedDirPermissions) {
|
||||
TEST(VirtualFileSystemTest, MergedDirPermissions) {
|
||||
// merged directories get the permissions of the upper dir
|
||||
IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
|
||||
IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
|
||||
IntrusiveRefCntPtr<vfs::OverlayFileSystem>
|
||||
O(new vfs::OverlayFileSystem(Lower));
|
||||
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
|
||||
new vfs::OverlayFileSystem(Lower));
|
||||
O->pushOverlay(Upper);
|
||||
|
||||
ErrorOr<vfs::Status> Status((error_code()));
|
||||
|
|
@ -214,3 +217,248 @@ TEST(VirtualFileSystemTest, mergedDirPermissions) {
|
|||
ASSERT_EQ(errc::success, Status.getError());
|
||||
EXPECT_EQ(0200, Status->getPermissions());
|
||||
}
|
||||
|
||||
static int NumDiagnostics = 0;
|
||||
static void CountingDiagHandler(const SMDiagnostic &, void *) {
|
||||
++NumDiagnostics;
|
||||
}
|
||||
|
||||
static IntrusiveRefCntPtr<vfs::FileSystem>
|
||||
getFromYAMLRawString(StringRef Content,
|
||||
IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS) {
|
||||
MemoryBuffer *Buffer = MemoryBuffer::getMemBuffer(Content);
|
||||
return getVFSFromYAML(Buffer, CountingDiagHandler, ExternalFS);
|
||||
}
|
||||
|
||||
static IntrusiveRefCntPtr<vfs::FileSystem> getFromYAMLString(
|
||||
StringRef Content,
|
||||
IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS = new DummyFileSystem()) {
|
||||
std::string VersionPlusContent("{\n 'version':0,\n");
|
||||
VersionPlusContent += Content.slice(Content.find('{') + 1, StringRef::npos);
|
||||
return getFromYAMLRawString(VersionPlusContent, ExternalFS);
|
||||
}
|
||||
|
||||
TEST(VirtualFileSystemTest, BasicVFSFromYAML) {
|
||||
NumDiagnostics = 0;
|
||||
IntrusiveRefCntPtr<vfs::FileSystem> FS;
|
||||
FS = getFromYAMLString("");
|
||||
EXPECT_EQ(NULL, FS.getPtr());
|
||||
FS = getFromYAMLString("[]");
|
||||
EXPECT_EQ(NULL, FS.getPtr());
|
||||
FS = getFromYAMLString("'string'");
|
||||
EXPECT_EQ(NULL, FS.getPtr());
|
||||
EXPECT_EQ(3, NumDiagnostics);
|
||||
}
|
||||
|
||||
TEST(VirtualFileSystemTest, MappedFiles) {
|
||||
NumDiagnostics = 0;
|
||||
IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
|
||||
Lower->addRegularFile("/foo/bar/a");
|
||||
IntrusiveRefCntPtr<vfs::FileSystem> FS =
|
||||
getFromYAMLString("{ 'roots': [\n"
|
||||
"{\n"
|
||||
" 'type': 'directory',\n"
|
||||
" 'name': '/',\n"
|
||||
" 'contents': [ {\n"
|
||||
" 'type': 'file',\n"
|
||||
" 'name': 'file1',\n"
|
||||
" 'external-contents': '/foo/bar/a'\n"
|
||||
" },\n"
|
||||
" {\n"
|
||||
" 'type': 'file',\n"
|
||||
" 'name': 'file2',\n"
|
||||
" 'external-contents': '/foo/b'\n"
|
||||
" }\n"
|
||||
" ]\n"
|
||||
"}\n"
|
||||
"]\n"
|
||||
"}",
|
||||
Lower);
|
||||
ASSERT_TRUE(FS.getPtr());
|
||||
|
||||
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
|
||||
new vfs::OverlayFileSystem(Lower));
|
||||
O->pushOverlay(FS);
|
||||
|
||||
// file
|
||||
ErrorOr<vfs::Status> S = O->status("/file1");
|
||||
ASSERT_EQ(errc::success, S.getError());
|
||||
EXPECT_EQ("/file1", S->getName());
|
||||
EXPECT_EQ("/foo/bar/a", S->getExternalName());
|
||||
|
||||
ErrorOr<vfs::Status> SLower = O->status("/foo/bar/a");
|
||||
EXPECT_EQ("/foo/bar/a", SLower->getName());
|
||||
EXPECT_TRUE(S->equivalent(*SLower));
|
||||
|
||||
// directory
|
||||
S = O->status("/");
|
||||
ASSERT_EQ(errc::success, S.getError());
|
||||
EXPECT_TRUE(S->isDirectory());
|
||||
EXPECT_TRUE(S->equivalent(*O->status("/"))); // non-volatile UniqueID
|
||||
|
||||
// broken mapping
|
||||
EXPECT_EQ(errc::no_such_file_or_directory, O->status("/file2").getError());
|
||||
EXPECT_EQ(0, NumDiagnostics);
|
||||
}
|
||||
|
||||
TEST(VirtualFileSystemTest, CaseInsensitive) {
|
||||
NumDiagnostics = 0;
|
||||
IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
|
||||
Lower->addRegularFile("/foo/bar/a");
|
||||
IntrusiveRefCntPtr<vfs::FileSystem> FS =
|
||||
getFromYAMLString("{ 'case-sensitive': 'false',\n"
|
||||
" 'roots': [\n"
|
||||
"{\n"
|
||||
" 'type': 'directory',\n"
|
||||
" 'name': '/',\n"
|
||||
" 'contents': [ {\n"
|
||||
" 'type': 'file',\n"
|
||||
" 'name': 'XX',\n"
|
||||
" 'external-contents': '/foo/bar/a'\n"
|
||||
" }\n"
|
||||
" ]\n"
|
||||
"}]}",
|
||||
Lower);
|
||||
ASSERT_TRUE(FS.getPtr());
|
||||
|
||||
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
|
||||
new vfs::OverlayFileSystem(Lower));
|
||||
O->pushOverlay(FS);
|
||||
|
||||
ErrorOr<vfs::Status> S = O->status("/XX");
|
||||
ASSERT_EQ(errc::success, S.getError());
|
||||
|
||||
ErrorOr<vfs::Status> SS = O->status("/xx");
|
||||
ASSERT_EQ(errc::success, SS.getError());
|
||||
EXPECT_TRUE(S->equivalent(*SS));
|
||||
SS = O->status("/xX");
|
||||
EXPECT_TRUE(S->equivalent(*SS));
|
||||
SS = O->status("/Xx");
|
||||
EXPECT_TRUE(S->equivalent(*SS));
|
||||
EXPECT_EQ(0, NumDiagnostics);
|
||||
}
|
||||
|
||||
TEST(VirtualFileSystemTest, CaseSensitive) {
|
||||
NumDiagnostics = 0;
|
||||
IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
|
||||
Lower->addRegularFile("/foo/bar/a");
|
||||
IntrusiveRefCntPtr<vfs::FileSystem> FS =
|
||||
getFromYAMLString("{ 'case-sensitive': 'true',\n"
|
||||
" 'roots': [\n"
|
||||
"{\n"
|
||||
" 'type': 'directory',\n"
|
||||
" 'name': '/',\n"
|
||||
" 'contents': [ {\n"
|
||||
" 'type': 'file',\n"
|
||||
" 'name': 'XX',\n"
|
||||
" 'external-contents': '/foo/bar/a'\n"
|
||||
" }\n"
|
||||
" ]\n"
|
||||
"}]}",
|
||||
Lower);
|
||||
ASSERT_TRUE(FS.getPtr());
|
||||
|
||||
IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
|
||||
new vfs::OverlayFileSystem(Lower));
|
||||
O->pushOverlay(FS);
|
||||
|
||||
ErrorOr<vfs::Status> SS = O->status("/xx");
|
||||
EXPECT_EQ(errc::no_such_file_or_directory, SS.getError());
|
||||
SS = O->status("/xX");
|
||||
EXPECT_EQ(errc::no_such_file_or_directory, SS.getError());
|
||||
SS = O->status("/Xx");
|
||||
EXPECT_EQ(errc::no_such_file_or_directory, SS.getError());
|
||||
EXPECT_EQ(0, NumDiagnostics);
|
||||
}
|
||||
|
||||
TEST(VirtualFileSystemTest, IllegalVFSFile) {
|
||||
NumDiagnostics = 0;
|
||||
IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
|
||||
|
||||
// invalid YAML at top-level
|
||||
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString("{]", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
// invalid YAML in roots
|
||||
FS = getFromYAMLString("{ 'roots':[}", Lower);
|
||||
// invalid YAML in directory
|
||||
FS = getFromYAMLString(
|
||||
"{ 'roots':[ { 'name': 'foo', 'type': 'directory', 'contents': [}",
|
||||
Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
|
||||
// invalid configuration
|
||||
FS = getFromYAMLString("{ 'knobular': 'true', 'roots':[] }", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS = getFromYAMLString("{ 'case-sensitive': 'maybe', 'roots':[] }", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
|
||||
// invalid roots
|
||||
FS = getFromYAMLString("{ 'roots':'' }", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS = getFromYAMLString("{ 'roots':{} }", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
|
||||
// invalid entries
|
||||
FS = getFromYAMLString(
|
||||
"{ 'roots':[ { 'type': 'other', 'name': 'me', 'contents': '' }", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': [], "
|
||||
"'external-contents': 'other' }",
|
||||
Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS = getFromYAMLString(
|
||||
"{ 'roots':[ { 'type': 'file', 'name': 'me', 'external-contents': [] }",
|
||||
Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS = getFromYAMLString(
|
||||
"{ 'roots':[ { 'type': 'file', 'name': 'me', 'external-contents': {} }",
|
||||
Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS = getFromYAMLString(
|
||||
"{ 'roots':[ { 'type': 'directory', 'name': 'me', 'contents': {} }",
|
||||
Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS = getFromYAMLString(
|
||||
"{ 'roots':[ { 'type': 'directory', 'name': 'me', 'contents': '' }",
|
||||
Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS = getFromYAMLString(
|
||||
"{ 'roots':[ { 'thingy': 'directory', 'name': 'me', 'contents': [] }",
|
||||
Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
|
||||
// missing mandatory fields
|
||||
FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': 'me' }", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS = getFromYAMLString(
|
||||
"{ 'roots':[ { 'type': 'file', 'external-contents': 'other' }", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS = getFromYAMLString("{ 'roots':[ { 'name': 'me', 'contents': [] }", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
|
||||
// duplicate keys
|
||||
FS = getFromYAMLString("{ 'roots':[], 'roots':[] }", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS = getFromYAMLString(
|
||||
"{ 'case-sensitive':'true', 'case-sensitive':'true', 'roots':[] }",
|
||||
Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS =
|
||||
getFromYAMLString("{ 'roots':[{'name':'me', 'name':'you', 'type':'file', "
|
||||
"'external-contents':'blah' } ] }",
|
||||
Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
|
||||
// missing version
|
||||
FS = getFromYAMLRawString("{ 'roots':[] }", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
|
||||
// bad version number
|
||||
FS = getFromYAMLRawString("{ 'version':'foo', 'roots':[] }", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS = getFromYAMLRawString("{ 'version':-1, 'roots':[] }", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
FS = getFromYAMLRawString("{ 'version':100000, 'roots':[] }", Lower);
|
||||
EXPECT_FALSE(FS.getPtr());
|
||||
EXPECT_EQ(24, NumDiagnostics);
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue