Index: tools/clang/include/clang/Frontend/VerifyDiagnosticConsumer.h ================================================================== --- tools/clang/include/clang/Frontend/VerifyDiagnosticConsumer.h +++ tools/clang/include/clang/Frontend/VerifyDiagnosticConsumer.h @@ -10,10 +10,12 @@ #ifndef LLVM_CLANG_FRONTEND_VERIFYDIAGNOSTICSCLIENT_H #define LLVM_CLANG_FRONTEND_VERIFYDIAGNOSTICSCLIENT_H #include "clang/Basic/Diagnostic.h" #include "llvm/ADT/OwningPtr.h" +#include "llvm/ADT/STLExtras.h" +#include namespace clang { class DiagnosticsEngine; class TextDiagnosticBuffer; @@ -66,17 +68,66 @@ /// // expected-error-re {{variable has has type 'struct (.*)'}} /// // expected-error-re {{variable has has type 'struct[[:space:]](.*)'}} /// class VerifyDiagnosticConsumer: public DiagnosticConsumer { public: + /// Directive - Abstract class representing a parsed verify directive. + /// + class Directive { + public: + static Directive *create(bool RegexKind, const SourceLocation &Location, + StringRef Text, unsigned Count); + public: + /// Constant representing one or more matches aka regex "+". + static const unsigned OneOrMoreCount = UINT_MAX; + + SourceLocation Location; + const std::string Text; + unsigned Count; + + virtual ~Directive() { } + + // Returns true if directive text is valid. + // Otherwise returns false and populates E. + virtual bool isValid(std::string &Error) = 0; + + // Returns true on match. + virtual bool match(StringRef S) = 0; + + protected: + Directive(const SourceLocation &Location, StringRef Text, + unsigned Count) + : Location(Location), Text(Text), Count(Count) { } + + private: + Directive(const Directive&); // DO NOT IMPLEMENT + void operator=(const Directive&); // DO NOT IMPLEMENT + }; + + typedef std::vector DirectiveList; + + /// ExpectedData - owns directive objects and deletes on destructor. + /// + struct ExpectedData { + DirectiveList Errors; + DirectiveList Warnings; + DirectiveList Notes; + + ~ExpectedData() { + llvm::DeleteContainerPointers(Errors); + llvm::DeleteContainerPointers(Warnings); + llvm::DeleteContainerPointers(Notes); + } + }; + +private: DiagnosticsEngine &Diags; DiagnosticConsumer *PrimaryClient; bool OwnsPrimaryClient; OwningPtr Buffer; Preprocessor *CurrentPreprocessor; - -private: + ExpectedData ED; FileID FirstErrorFID; // FileID of first diagnostic void CheckDiagnostics(); public: /// Create a new verifying diagnostic client, which will issue errors to Index: tools/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp ================================================================== --- tools/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp +++ tools/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp @@ -16,13 +16,15 @@ #include "clang/Frontend/TextDiagnosticBuffer.h" #include "clang/Lex/Preprocessor.h" #include "llvm/ADT/SmallString.h" #include "llvm/Support/Regex.h" #include "llvm/Support/raw_ostream.h" -#include using namespace clang; +typedef VerifyDiagnosticConsumer::Directive Directive; +typedef VerifyDiagnosticConsumer::DirectiveList DirectiveList; +typedef VerifyDiagnosticConsumer::ExpectedData ExpectedData; VerifyDiagnosticConsumer::VerifyDiagnosticConsumer(DiagnosticsEngine &_Diags) : Diags(_Diags), PrimaryClient(Diags.getClient()), OwnsPrimaryClient(Diags.ownsClient()), Buffer(new TextDiagnosticBuffer()), CurrentPreprocessor(0) @@ -75,102 +77,50 @@ typedef TextDiagnosticBuffer::DiagList DiagList; typedef TextDiagnosticBuffer::const_iterator const_diag_iterator; namespace { -/// Directive - Abstract class representing a parsed verify directive. -/// -class Directive { -public: - static Directive* Create(bool RegexKind, const SourceLocation &Location, - const std::string &Text, unsigned Count); -public: - /// Constant representing one or more matches aka regex "+". - static const unsigned OneOrMoreCount = UINT_MAX; - - SourceLocation Location; - const std::string Text; - unsigned Count; - - virtual ~Directive() { } - - // Returns true if directive text is valid. - // Otherwise returns false and populates E. - virtual bool isValid(std::string &Error) = 0; - - // Returns true on match. - virtual bool Match(const std::string &S) = 0; - -protected: - Directive(const SourceLocation &Location, const std::string &Text, - unsigned Count) - : Location(Location), Text(Text), Count(Count) { } - -private: - Directive(const Directive&); // DO NOT IMPLEMENT - void operator=(const Directive&); // DO NOT IMPLEMENT -}; - /// StandardDirective - Directive with string matching. /// class StandardDirective : public Directive { public: - StandardDirective(const SourceLocation &Location, const std::string &Text, + StandardDirective(const SourceLocation &Location, StringRef Text, unsigned Count) : Directive(Location, Text, Count) { } virtual bool isValid(std::string &Error) { // all strings are considered valid; even empty ones return true; } - virtual bool Match(const std::string &S) { - return S.find(Text) != std::string::npos; + virtual bool match(StringRef S) { + return S.find(Text) != StringRef::npos; } }; /// RegexDirective - Directive with regular-expression matching. /// class RegexDirective : public Directive { public: - RegexDirective(const SourceLocation &Location, const std::string &Text, + RegexDirective(const SourceLocation &Location, StringRef Text, unsigned Count) : Directive(Location, Text, Count), Regex(Text) { } virtual bool isValid(std::string &Error) { if (Regex.isValid(Error)) return true; return false; } - virtual bool Match(const std::string &S) { + virtual bool match(StringRef S) { return Regex.match(S); } private: llvm::Regex Regex; }; -typedef std::vector DirectiveList; - -/// ExpectedData - owns directive objects and deletes on destructor. -/// -struct ExpectedData { - DirectiveList Errors; - DirectiveList Warnings; - DirectiveList Notes; - - ~ExpectedData() { - DirectiveList* Lists[] = { &Errors, &Warnings, &Notes, 0 }; - for (DirectiveList **PL = Lists; *PL; ++PL) { - DirectiveList * const L = *PL; - for (DirectiveList::iterator I = L->begin(), E = L->end(); I != E; ++I) - delete *I; - } - } -}; - class ParseHelper { public: ParseHelper(const char *Begin, const char *End) : Begin(Begin), End(End), C(Begin), P(Begin), PEnd(NULL) { } @@ -239,12 +189,12 @@ /// ParseDirective - Go through the comment and see if it indicates expected /// diagnostics. If so, then put them in the appropriate directive list. /// static void ParseDirective(const char *CommentStart, unsigned CommentLen, - ExpectedData &ED, Preprocessor &PP, - SourceLocation Pos) { + ExpectedData &ED, SourceManager &SM, + SourceLocation Pos, DiagnosticsEngine &Diags) { // A single comment may contain multiple directives. for (ParseHelper PH(CommentStart, CommentStart+CommentLen); !PH.Done();) { // search for token: expected if (!PH.Search("expected")) break; @@ -293,21 +243,21 @@ // skip optional whitespace PH.SkipWhitespace(); // next token: {{ if (!PH.Next("{{")) { - PP.Diag(Pos.getLocWithOffset(PH.C-PH.Begin), - diag::err_verify_missing_start) << KindStr; + Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin), + diag::err_verify_missing_start) << KindStr; continue; } PH.Advance(); const char* const ContentBegin = PH.C; // mark content begin // search for token: }} if (!PH.Search("}}")) { - PP.Diag(Pos.getLocWithOffset(PH.C-PH.Begin), - diag::err_verify_missing_end) << KindStr; + Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin), + diag::err_verify_missing_end) << KindStr; continue; } const char* const ContentEnd = PH.P; // mark content end PH.Advance(); @@ -324,17 +274,17 @@ } if (Text.empty()) Text.assign(ContentBegin, ContentEnd); // construct new directive - Directive *D = Directive::Create(RegexKind, Pos, Text, Count); + Directive *D = Directive::create(RegexKind, Pos, Text, Count); std::string Error; if (D->isValid(Error)) DL->push_back(D); else { - PP.Diag(Pos.getLocWithOffset(ContentBegin-PH.Begin), - diag::err_verify_invalid_content) + Diags.Report(Pos.getLocWithOffset(ContentBegin-PH.Begin), + diag::err_verify_invalid_content) << KindStr << Error; } } } @@ -361,11 +311,12 @@ std::string Comment = PP.getSpelling(Tok); if (Comment.empty()) continue; // Find all expected errors/warnings/notes. - ParseDirective(&Comment[0], Comment.size(), ED, PP, Tok.getLocation()); + ParseDirective(&Comment[0], Comment.size(), ED, SM, Tok.getLocation(), + PP.getDiagnostics()); }; } /// PrintProblem - This takes a diagnostic map of the delta between expected and /// seen diagnostics. If there's anything in it, then something unexpected @@ -437,11 +388,11 @@ unsigned LineNo2 = SourceMgr.getPresumedLineNumber(II->first); if (LineNo1 != LineNo2) continue; const std::string &RightText = II->second; - if (D.Match(RightText)) + if (D.match(RightText)) break; } if (II == IE) { if (D.Count == D.OneOrMoreCount) { if (!FoundOnce) @@ -493,12 +444,10 @@ return NumProblems; } void VerifyDiagnosticConsumer::CheckDiagnostics() { - ExpectedData ED; - // Ensure any diagnostics go to the primary client. bool OwnsCurClient = Diags.ownsClient(); DiagnosticConsumer *CurClient = Diags.takeClient(); Diags.setClient(PrimaryClient, false); @@ -547,11 +496,11 @@ Diags.setClient(PrimaryClient->clone(Diags)); return new VerifyDiagnosticConsumer(Diags); } -Directive* Directive::Create(bool RegexKind, const SourceLocation &Location, - const std::string &Text, unsigned Count) { +Directive *Directive::create(bool RegexKind, const SourceLocation &Location, + StringRef Text, unsigned Count) { if (RegexKind) return new RegexDirective(Location, Text, Count); return new StandardDirective(Location, Text, Count); }