From 4f67afc3d67d9a68f1b37767c9c2966a775186bd Mon Sep 17 00:00:00 2001 From: Matt Arsenault Date: Tue, 17 Sep 2013 22:30:02 +0000 Subject: FileCheck refactor: use enum instead of bunch of bools git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@190893 91177308-0d34-0410-b5e6-96231b3b80d8 --- utils/FileCheck/FileCheck.cpp | 164 ++++++++++++++++++++++-------------------- 1 file changed, 88 insertions(+), 76 deletions(-) (limited to 'utils/FileCheck/FileCheck.cpp') diff --git a/utils/FileCheck/FileCheck.cpp b/utils/FileCheck/FileCheck.cpp index 37c7874aa2..769749e024 100644 --- a/utils/FileCheck/FileCheck.cpp +++ b/utils/FileCheck/FileCheck.cpp @@ -53,18 +53,25 @@ NoCanonicalizeWhiteSpace("strict-whitespace", // Pattern Handling Code. //===----------------------------------------------------------------------===// +namespace Check { + enum CheckType { + CheckNone = 0, + CheckPlain, + CheckNext, + CheckNot, + CheckDAG, + CheckLabel, + + /// MatchEOF - When set, this pattern only matches the end of file. This is + /// used for trailing CHECK-NOTs. + CheckEOF + }; +} + class Pattern { SMLoc PatternLoc; - /// MatchEOF - When set, this pattern only matches the end of file. This is - /// used for trailing CHECK-NOTs. - bool MatchEOF; - - /// MatchNot - bool MatchNot; - - /// MatchDag - bool MatchDag; + Check::CheckType CheckTy; /// FixedStr - If non-empty, this pattern is a fixed string match with the /// specified fixed string. @@ -89,8 +96,8 @@ class Pattern { public: - Pattern(bool matchEOF = false) - : MatchEOF(matchEOF), MatchNot(false), MatchDag(false) { } + Pattern(Check::CheckType Ty) + : CheckTy(Ty) { } /// getLoc - Return the location in source code. SMLoc getLoc() const { return PatternLoc; } @@ -118,11 +125,7 @@ public: bool hasVariable() const { return !(VariableUses.empty() && VariableDefs.empty()); } - void setMatchNot(bool Not) { MatchNot = Not; } - bool getMatchNot() const { return MatchNot; } - - void setMatchDag(bool Dag) { MatchDag = Dag; } - bool getMatchDag() const { return MatchDag; } + Check::CheckType getCheckTy() const { return CheckTy; } private: static void AddFixedStringToRegEx(StringRef FixedStr, std::string &TheStr); @@ -381,7 +384,7 @@ bool Pattern::EvaluateExpression(StringRef Expr, std::string &Value) const { size_t Pattern::Match(StringRef Buffer, size_t &MatchLen, StringMap &VariableTable) const { // If this is the EOF pattern, match it immediately. - if (MatchEOF) { + if (CheckTy == Check::CheckEOF) { MatchLen = 0; return Buffer.size(); } @@ -593,21 +596,17 @@ struct CheckString { /// Loc - The location in the match file that the check string was specified. SMLoc Loc; - /// IsCheckNext - This is true if this is a CHECK-NEXT: directive (as opposed - /// to a CHECK: directive. - bool IsCheckNext; - - /// IsCheckLabel - This is true if this is a CHECK-LABEL: directive (as - /// opposed to a CHECK: directive. - bool IsCheckLabel; + /// CheckTy - Specify what kind of check this is. e.g. CHECK-NEXT: directive, + /// as opposed to a CHECK: directive. + Check::CheckType CheckTy; /// DagNotStrings - These are all of the strings that are disallowed from /// occurring between this match string and the previous one (or start of /// file). std::vector DagNotStrings; - CheckString(const Pattern &P, SMLoc L, bool isCheckNext, bool isCheckLabel) - : Pat(P), Loc(L), IsCheckNext(isCheckNext), IsCheckLabel(isCheckLabel) {} + CheckString(const Pattern &P, SMLoc L, Check::CheckType Ty) + : Pat(P), Loc(L), CheckTy(Ty) {} /// Check - Match check string and its "not strings" and/or "dag strings". size_t Check(const SourceMgr &SM, StringRef Buffer, bool IsLabel, @@ -666,6 +665,48 @@ static MemoryBuffer *CanonicalizeInputFile(MemoryBuffer *MB, return MB2; } +static bool IsPartOfWord(char c) { + return (isalnum(c) || c == '-' || c == '_'); +} + +static Check::CheckType FindCheckType(StringRef &Buffer, StringRef Prefix) { + char NextChar = Buffer[CheckPrefix.size()]; + + // Verify that the : is present after the prefix. + if (NextChar == ':') { + Buffer = Buffer.substr(CheckPrefix.size() + 1); + return Check::CheckPlain; + } + + if (NextChar != '-') { + Buffer = Buffer.drop_front(1); + return Check::CheckNone; + } + + StringRef Rest = Buffer.drop_front(CheckPrefix.size() + 1); + if (Rest.startswith("NEXT:")) { + Buffer = Rest.drop_front(sizeof("NEXT:") - 1); + return Check::CheckNext; + } + + if (Rest.startswith("NOT:")) { + Buffer = Rest.drop_front(sizeof("NOT:") - 1); + return Check::CheckNot; + } + + if (Rest.startswith("DAG:")) { + Buffer = Rest.drop_front(sizeof("DAG:") - 1); + return Check::CheckDAG; + } + + if (Rest.startswith("LABEL:")) { + Buffer = Rest.drop_front(sizeof("LABEL:") - 1); + return Check::CheckLabel; + } + + Buffer = Buffer.drop_front(1); + return Check::CheckNone; +} /// ReadCheckFile - Read the check file, which specifies the sequence of /// expected strings. The strings are added to the CheckStrings vector. @@ -710,46 +751,21 @@ static bool ReadCheckFile(SourceMgr &SM, const char *CheckPrefixStart = Buffer.data() + (PrefixLoc == 0 ? 0 : 1); - // When we find a check prefix, keep track of whether we find CHECK: or - // CHECK-NEXT: - bool IsCheckNext = false, IsCheckNot = false, IsCheckDag = false, - IsCheckLabel = false; - // Make sure we have actually found our prefix, and not a word containing // our prefix. - if (PrefixLoc != 0 && (isalnum(Buffer[0]) || - Buffer[0] == '-' || - Buffer[0] == '_')) { + if (PrefixLoc != 0 && IsPartOfWord(Buffer[0])) { Buffer = Buffer.substr(CheckPrefix.size()); continue; } - // Verify that the : is present after the prefix. - if (Buffer[CheckPrefix.size()] == ':') { - Buffer = Buffer.substr(CheckPrefix.size()+1); - } else if (Buffer.size() > CheckPrefix.size()+6 && - memcmp(Buffer.data()+CheckPrefix.size(), "-NEXT:", 6) == 0) { - Buffer = Buffer.substr(CheckPrefix.size()+6); - IsCheckNext = true; - } else if (Buffer.size() > CheckPrefix.size()+5 && - memcmp(Buffer.data()+CheckPrefix.size(), "-NOT:", 5) == 0) { - Buffer = Buffer.substr(CheckPrefix.size()+5); - IsCheckNot = true; - } else if (Buffer.size() > CheckPrefix.size()+5 && - memcmp(Buffer.data()+CheckPrefix.size(), "-DAG:", 5) == 0) { - Buffer = Buffer.substr(CheckPrefix.size()+5); - IsCheckDag = true; - } else if (Buffer.size() > CheckPrefix.size()+7 && - memcmp(Buffer.data()+CheckPrefix.size(), "-LABEL:", 7) == 0) { - Buffer = Buffer.substr(CheckPrefix.size()+7); - IsCheckLabel = true; - } else { - Buffer = Buffer.substr(1); + // When we find a check prefix, keep track of what kind of type of CHECK we + // have. + Check::CheckType CheckTy = FindCheckType(Buffer, CheckPrefix); + if (CheckTy == Check::CheckNone) continue; - } - // Okay, we found the prefix, yay. Remember the rest of the line, but - // ignore leading and trailing whitespace. + // Okay, we found the prefix, yay. Remember the rest of the line, but ignore + // leading and trailing whitespace. Buffer = Buffer.substr(Buffer.find_first_not_of(" \t")); // Scan ahead to the end of line. @@ -759,12 +775,12 @@ static bool ReadCheckFile(SourceMgr &SM, SMLoc PatternLoc = SMLoc::getFromPointer(Buffer.data()); // Parse the pattern. - Pattern P; + Pattern P(CheckTy); if (P.ParsePattern(Buffer.substr(0, EOL), SM, LineNumber)) return true; // Verify that CHECK-LABEL lines do not define or use variables - if (IsCheckLabel && P.hasVariable()) { + if ((CheckTy == Check::CheckLabel) && P.hasVariable()) { SM.PrintMessage(SMLoc::getFromPointer(CheckPrefixStart), SourceMgr::DK_Error, "found '"+CheckPrefix+"-LABEL:' with variable definition" @@ -772,13 +788,10 @@ static bool ReadCheckFile(SourceMgr &SM, return true; } - P.setMatchNot(IsCheckNot); - P.setMatchDag(IsCheckDag); - Buffer = Buffer.substr(EOL); // Verify that CHECK-NEXT lines have at least one CHECK line before them. - if (IsCheckNext && CheckStrings.empty()) { + if ((CheckTy == Check::CheckNext) && CheckStrings.empty()) { SM.PrintMessage(SMLoc::getFromPointer(CheckPrefixStart), SourceMgr::DK_Error, "found '"+CheckPrefix+"-NEXT:' without previous '"+ @@ -787,7 +800,7 @@ static bool ReadCheckFile(SourceMgr &SM, } // Handle CHECK-DAG/-NOT. - if (IsCheckDag || IsCheckNot) { + if (CheckTy == Check::CheckDAG || CheckTy == Check::CheckNot) { DagNotMatches.push_back(P); continue; } @@ -795,17 +808,15 @@ static bool ReadCheckFile(SourceMgr &SM, // Okay, add the string we captured to the output vector and move on. CheckStrings.push_back(CheckString(P, PatternLoc, - IsCheckNext, - IsCheckLabel)); + CheckTy)); std::swap(DagNotMatches, CheckStrings.back().DagNotStrings); } // Add an EOF pattern for any trailing CHECK-DAG/-NOTs. if (!DagNotMatches.empty()) { - CheckStrings.push_back(CheckString(Pattern(true), + CheckStrings.push_back(CheckString(Pattern(Check::CheckEOF), SMLoc::getFromPointer(Buffer.data()), - false, - false)); + Check::CheckEOF)); std::swap(DagNotMatches, CheckStrings.back().DagNotStrings); } @@ -902,7 +913,7 @@ size_t CheckString::Check(const SourceMgr &SM, StringRef Buffer, } bool CheckString::CheckNext(const SourceMgr &SM, StringRef Buffer) const { - if (!IsCheckNext) + if (CheckTy != Check::CheckNext) return false; // Count the number of newlines between the previous match and this one. @@ -943,7 +954,7 @@ bool CheckString::CheckNot(const SourceMgr &SM, StringRef Buffer, for (unsigned ChunkNo = 0, e = NotStrings.size(); ChunkNo != e; ++ChunkNo) { const Pattern *Pat = NotStrings[ChunkNo]; - assert(Pat->getMatchNot() && "Expect CHECK-NOT!"); + assert((Pat->getCheckTy() == Check::CheckNot) && "Expect CHECK-NOT!"); size_t MatchLen = 0; size_t Pos = Pat->Match(Buffer, MatchLen, VariableTable); @@ -974,15 +985,16 @@ size_t CheckString::CheckDag(const SourceMgr &SM, StringRef Buffer, ChunkNo != e; ++ChunkNo) { const Pattern &Pat = DagNotStrings[ChunkNo]; - assert((Pat.getMatchDag() ^ Pat.getMatchNot()) && + assert((Pat.getCheckTy() == Check::CheckDAG || + Pat.getCheckTy() == Check::CheckNot) && "Invalid CHECK-DAG or CHECK-NOT!"); - if (Pat.getMatchNot()) { + if (Pat.getCheckTy() == Check::CheckNot) { NotStrings.push_back(&Pat); continue; } - assert(Pat.getMatchDag() && "Expect CHECK-DAG!"); + assert((Pat.getCheckTy() == Check::CheckDAG) && "Expect CHECK-DAG!"); size_t MatchLen = 0, MatchPos; @@ -1100,7 +1112,7 @@ int main(int argc, char **argv) { CheckRegion = Buffer; } else { const CheckString &CheckLabelStr = CheckStrings[j]; - if (!CheckLabelStr.IsCheckLabel) { + if (CheckLabelStr.CheckTy != Check::CheckLabel) { ++j; continue; } -- cgit v1.2.3