summaryrefslogtreecommitdiffstats
path: root/llvm/lib/Support/SpecialCaseList.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/lib/Support/SpecialCaseList.cpp')
-rw-r--r--llvm/lib/Support/SpecialCaseList.cpp214
1 files changed, 139 insertions, 75 deletions
diff --git a/llvm/lib/Support/SpecialCaseList.cpp b/llvm/lib/Support/SpecialCaseList.cpp
index 05886eaa8ae..25222b04119 100644
--- a/llvm/lib/Support/SpecialCaseList.cpp
+++ b/llvm/lib/Support/SpecialCaseList.cpp
@@ -17,65 +17,72 @@
#include "llvm/Support/SpecialCaseList.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
-#include "llvm/ADT/StringSet.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Regex.h"
-#include "llvm/Support/TrigramIndex.h"
#include <string>
#include <system_error>
#include <utility>
+#include <stdio.h>
namespace llvm {
-/// Represents a set of regular expressions. Regular expressions which are
-/// "literal" (i.e. no regex metacharacters) are stored in Strings, while all
-/// others are represented as a single pipe-separated regex in RegEx. The
-/// reason for doing so is efficiency; StringSet is much faster at matching
-/// literal strings than Regex.
-struct SpecialCaseList::Entry {
- StringSet<> Strings;
- TrigramIndex Trigrams;
- std::unique_ptr<Regex> RegEx;
-
- bool match(StringRef Query) const {
- if (Strings.count(Query))
- return true;
- if (Trigrams.isDefinitelyOut(Query))
- return false;
- return RegEx && RegEx->match(Query);
+bool SpecialCaseList::Matcher::insert(std::string Regexp,
+ std::string &REError) {
+ if (Regex::isLiteralERE(Regexp)) {
+ Strings.insert(Regexp);
+ return true;
+ }
+ Trigrams.insert(Regexp);
+
+ // Replace * with .*
+ for (size_t pos = 0; (pos = Regexp.find('*', pos)) != std::string::npos;
+ pos += strlen(".*")) {
+ Regexp.replace(pos, strlen("*"), ".*");
+ }
+
+ // Check that the regexp is valid.
+ Regex CheckRE(Regexp);
+ if (!CheckRE.isValid(REError))
+ return false;
+
+ if (!UncompiledRegEx.empty())
+ UncompiledRegEx += "|";
+ UncompiledRegEx += "^(" + Regexp + ")$";
+ return true;
+}
+
+void SpecialCaseList::Matcher::compile() {
+ if (!UncompiledRegEx.empty()) {
+ RegEx.reset(new Regex(UncompiledRegEx));
+ UncompiledRegEx.clear();
}
-};
+}
+
+bool SpecialCaseList::Matcher::match(StringRef Query) const {
+ if (Strings.count(Query))
+ return true;
+ if (Trigrams.isDefinitelyOut(Query))
+ return false;
+ return RegEx && RegEx->match(Query);
+}
-SpecialCaseList::SpecialCaseList() : Entries(), Regexps(), IsCompiled(false) {}
+SpecialCaseList::SpecialCaseList() : Sections(), IsCompiled(false) {}
std::unique_ptr<SpecialCaseList>
SpecialCaseList::create(const std::vector<std::string> &Paths,
std::string &Error) {
std::unique_ptr<SpecialCaseList> SCL(new SpecialCaseList());
- for (const auto &Path : Paths) {
- ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
- MemoryBuffer::getFile(Path);
- if (std::error_code EC = FileOrErr.getError()) {
- Error = (Twine("can't open file '") + Path + "': " + EC.message()).str();
- return nullptr;
- }
- std::string ParseError;
- if (!SCL->parse(FileOrErr.get().get(), ParseError)) {
- Error = (Twine("error parsing file '") + Path + "': " + ParseError).str();
- return nullptr;
- }
- }
- SCL->compile();
- return SCL;
+ if (SCL->createInternal(Paths, Error))
+ return SCL;
+ return nullptr;
}
std::unique_ptr<SpecialCaseList> SpecialCaseList::create(const MemoryBuffer *MB,
std::string &Error) {
std::unique_ptr<SpecialCaseList> SCL(new SpecialCaseList());
- if (!SCL->parse(MB, Error))
- return nullptr;
- SCL->compile();
- return SCL;
+ if (SCL->createInternal(MB, Error))
+ return SCL;
+ return nullptr;
}
std::unique_ptr<SpecialCaseList>
@@ -86,15 +93,71 @@ SpecialCaseList::createOrDie(const std::vector<std::string> &Paths) {
report_fatal_error(Error);
}
-bool SpecialCaseList::parse(const MemoryBuffer *MB, std::string &Error) {
+bool SpecialCaseList::createInternal(const std::vector<std::string> &Paths,
+ std::string &Error) {
+ StringMap<size_t> Sections;
+ for (const auto &Path : Paths) {
+ ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
+ MemoryBuffer::getFile(Path);
+ if (std::error_code EC = FileOrErr.getError()) {
+ Error = (Twine("can't open file '") + Path + "': " + EC.message()).str();
+ return false;
+ }
+ std::string ParseError;
+ if (!parse(FileOrErr.get().get(), Sections, ParseError)) {
+ Error = (Twine("error parsing file '") + Path + "': " + ParseError).str();
+ return false;
+ }
+ }
+ compile();
+ return true;
+}
+
+bool SpecialCaseList::createInternal(const MemoryBuffer *MB,
+ std::string &Error) {
+ StringMap<size_t> Sections;
+ if (!parse(MB, Sections, Error))
+ return false;
+ compile();
+ return true;
+}
+
+bool SpecialCaseList::parse(const MemoryBuffer *MB,
+ StringMap<size_t> &SectionsMap,
+ std::string &Error) {
// Iterate through each line in the blacklist file.
SmallVector<StringRef, 16> Lines;
SplitString(MB->getBuffer(), Lines, "\n\r");
+
int LineNo = 1;
+ StringRef Section = "*";
for (auto I = Lines.begin(), E = Lines.end(); I != E; ++I, ++LineNo) {
// Ignore empty lines and lines starting with "#"
if (I->empty() || I->startswith("#"))
continue;
+
+ // Save section names
+ if (I->startswith("[")) {
+ if (!I->endswith("]")) {
+ Error = (Twine("malformed section header on line ") + Twine(LineNo) +
+ ": " + *I).str();
+ return false;
+ }
+
+ Section = I->slice(1, I->size() - 1);
+
+ std::string REError;
+ Regex CheckRE(Section);
+ if (!CheckRE.isValid(REError)) {
+ Error =
+ (Twine("malformed regex for section ") + Section + ": '" + REError)
+ .str();
+ return false;
+ }
+
+ continue;
+ }
+
// Get our prefix and unparsed regexp.
std::pair<StringRef, StringRef> SplitLine = I->split(":");
StringRef Prefix = SplitLine.first;
@@ -109,61 +172,62 @@ bool SpecialCaseList::parse(const MemoryBuffer *MB, std::string &Error) {
std::string Regexp = SplitRegexp.first;
StringRef Category = SplitRegexp.second;
- // See if we can store Regexp in Strings.
- auto &Entry = Entries[Prefix][Category];
- if (Regex::isLiteralERE(Regexp)) {
- Entry.Strings.insert(Regexp);
- continue;
- }
- Entry.Trigrams.insert(Regexp);
-
- // Replace * with .*
- for (size_t pos = 0; (pos = Regexp.find('*', pos)) != std::string::npos;
- pos += strlen(".*")) {
- Regexp.replace(pos, strlen("*"), ".*");
+ // Create this section if it has not been seen before.
+ if (SectionsMap.find(Section) == SectionsMap.end()) {
+ std::unique_ptr<Matcher> M = make_unique<Matcher>();
+ std::string REError;
+ if (!M->insert(Section, REError)) {
+ Error = (Twine("malformed section ") + Section + ": '" + REError).str();
+ return false;
+ }
+ M->compile();
+
+ SectionsMap[Section] = Sections.size();
+ Sections.emplace_back(std::move(M));
}
- // Check that the regexp is valid.
- Regex CheckRE(Regexp);
+ auto &Entry = Sections[SectionsMap[Section]].Entries[Prefix][Category];
std::string REError;
- if (!CheckRE.isValid(REError)) {
+ if (!Entry.insert(std::move(Regexp), REError)) {
Error = (Twine("malformed regex in line ") + Twine(LineNo) + ": '" +
SplitLine.second + "': " + REError).str();
return false;
}
-
- // Add this regexp into the proper group by its prefix.
- if (!Regexps[Prefix][Category].empty())
- Regexps[Prefix][Category] += "|";
- Regexps[Prefix][Category] += "^" + Regexp + "$";
}
return true;
}
void SpecialCaseList::compile() {
assert(!IsCompiled && "compile() should only be called once");
- // Iterate through each of the prefixes, and create Regexs for them.
- for (StringMap<StringMap<std::string>>::const_iterator I = Regexps.begin(),
- E = Regexps.end();
- I != E; ++I) {
- for (StringMap<std::string>::const_iterator II = I->second.begin(),
- IE = I->second.end();
- II != IE; ++II) {
- Entries[I->getKey()][II->getKey()].RegEx.reset(new Regex(II->getValue()));
- }
- }
- Regexps.clear();
+ // Iterate through every section compiling regular expressions for every query
+ // and creating Section entries.
+ for (auto &Section : Sections)
+ for (auto &Prefix : Section.Entries)
+ for (auto &Category : Prefix.getValue())
+ Category.getValue().compile();
+
IsCompiled = true;
}
SpecialCaseList::~SpecialCaseList() {}
-bool SpecialCaseList::inSection(StringRef Section, StringRef Query,
- StringRef Category) const {
+bool SpecialCaseList::inSection(StringRef Section, StringRef Prefix,
+ StringRef Query, StringRef Category) const {
assert(IsCompiled && "SpecialCaseList::compile() was not called!");
- StringMap<StringMap<Entry> >::const_iterator I = Entries.find(Section);
+
+ for (auto &SectionIter : Sections)
+ if (SectionIter.SectionMatcher->match(Section) &&
+ inSection(SectionIter.Entries, Prefix, Query, Category))
+ return true;
+
+ return false;
+}
+
+bool SpecialCaseList::inSection(const SectionEntries &Entries, StringRef Prefix,
+ StringRef Query, StringRef Category) const {
+ SectionEntries::const_iterator I = Entries.find(Prefix);
if (I == Entries.end()) return false;
- StringMap<Entry>::const_iterator II = I->second.find(Category);
+ StringMap<Matcher>::const_iterator II = I->second.find(Category);
if (II == I->second.end()) return false;
return II->getValue().match(Query);
OpenPOWER on IntegriCloud