Folks, I was walking down the Clang code to add the vectorizer pragma and found that this parameter is never used. It looks as left-over of when it was deemed important, should we keep this, or remove?
The patch attached intends to remove (until it get used again, at least). Makes sense? cheers, --renato
commit 2c0988e0f2d7d9346b1d83af8ceab50dd7d505b3 Author: Renato Golin <[email protected]> Date: Wed Dec 11 13:43:35 2013 +0000 Remove unused PragmaIntroducerKind parameters diff --git a/include/clang/Lex/PPCallbacks.h b/include/clang/Lex/PPCallbacks.h index f1ed897..ef5ea92 100644 --- a/include/clang/Lex/PPCallbacks.h +++ b/include/clang/Lex/PPCallbacks.h @@ -157,8 +157,7 @@ public: } /// \brief Callback invoked when start reading any pragma directive. - virtual void PragmaDirective(SourceLocation Loc, - PragmaIntroducerKind Introducer) { + virtual void PragmaDirective(SourceLocation Loc) { } /// \brief Callback invoked when a \#pragma comment directive is read. diff --git a/include/clang/Lex/Pragma.h b/include/clang/Lex/Pragma.h index 087448f..52611d1 100644 --- a/include/clang/Lex/Pragma.h +++ b/include/clang/Lex/Pragma.h @@ -25,28 +25,6 @@ namespace clang { class IdentifierInfo; class PragmaNamespace; - /** - * \brief Describes how the pragma was introduced, e.g., with \#pragma, - * _Pragma, or __pragma. - */ - enum PragmaIntroducerKind { - /** - * \brief The pragma was introduced via \#pragma. - */ - PIK_HashPragma, - - /** - * \brief The pragma was introduced via the C99 _Pragma(string-literal). - */ - PIK__Pragma, - - /** - * \brief The pragma was introduced via the Microsoft - * __pragma(token-string). - */ - PIK___pragma - }; - /// PragmaHandler - Instances of this interface defined to handle the various /// pragmas that the language front-end uses. Each handler optionally has a /// name (e.g. "pack") and the HandlePragma method is invoked when a pragma with @@ -64,8 +42,7 @@ public: virtual ~PragmaHandler(); StringRef getName() const { return Name; } - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken) = 0; + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken) = 0; /// getIfNamespace - If this is a namespace, return it. This is equivalent to /// using a dynamic_cast, but doesn't require RTTI. @@ -78,8 +55,7 @@ class EmptyPragmaHandler : public PragmaHandler { public: EmptyPragmaHandler(); - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); }; /// PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas, @@ -114,8 +90,7 @@ public: return Handlers.empty(); } - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); virtual PragmaNamespace *getIfNamespace() { return this; } }; diff --git a/include/clang/Lex/Preprocessor.h b/include/clang/Lex/Preprocessor.h index 2491011..34498cf 100644 --- a/include/clang/Lex/Preprocessor.h +++ b/include/clang/Lex/Preprocessor.h @@ -1538,8 +1538,7 @@ private: void HandleElifDirective(Token &Tok); // Pragmas. - void HandlePragmaDirective(SourceLocation IntroducerLoc, - PragmaIntroducerKind Introducer); + void HandlePragmaDirective(SourceLocation IntroducerLoc); public: void HandlePragmaOnce(Token &OnceTok); void HandlePragmaMark(); diff --git a/lib/Frontend/PrintPreprocessedOutput.cpp b/lib/Frontend/PrintPreprocessedOutput.cpp index f3393bf..e6a6082 100644 --- a/lib/Frontend/PrintPreprocessedOutput.cpp +++ b/lib/Frontend/PrintPreprocessedOutput.cpp @@ -602,8 +602,7 @@ struct UnknownPragmaHandler : public PragmaHandler { UnknownPragmaHandler(const char *prefix, PrintPPOutputPPCallbacks *callbacks) : Prefix(prefix), Callbacks(callbacks) {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &PragmaTok) { + virtual void HandlePragma(Preprocessor &PP, Token &PragmaTok) { // Figure out what line we went to and insert the appropriate number of // newline characters. Callbacks->startNewLineIfNeeded(); diff --git a/lib/Lex/PPDirectives.cpp b/lib/Lex/PPDirectives.cpp index 2aa67fb..98ea4e7 100644 --- a/lib/Lex/PPDirectives.cpp +++ b/lib/Lex/PPDirectives.cpp @@ -818,7 +818,7 @@ void Preprocessor::HandleDirective(Token &Result) { // C99 6.10.6 - Pragma Directive. case tok::pp_pragma: - return HandlePragmaDirective(SavedHash.getLocation(), PIK_HashPragma); + return HandlePragmaDirective(SavedHash.getLocation()); // GNU Extensions. case tok::pp_import: diff --git a/lib/Lex/Pragma.cpp b/lib/Lex/Pragma.cpp index e4059ee..8d2d84b 100644 --- a/lib/Lex/Pragma.cpp +++ b/lib/Lex/Pragma.cpp @@ -39,8 +39,7 @@ PragmaHandler::~PragmaHandler() { EmptyPragmaHandler::EmptyPragmaHandler() {} -void EmptyPragmaHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, +void EmptyPragmaHandler::HandlePragma(Preprocessor &PP, Token &FirstToken) {} //===----------------------------------------------------------------------===// @@ -78,8 +77,7 @@ void PragmaNamespace::RemovePragmaHandler(PragmaHandler *Handler) { Handlers.erase(Handler->getName()); } -void PragmaNamespace::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, +void PragmaNamespace::HandlePragma(Preprocessor &PP, Token &Tok) { // Read the 'namespace' that the directive is in, e.g. STDC. Do not macro // expand it, the user can have a STDC #define, that should not affect this. @@ -96,7 +94,7 @@ void PragmaNamespace::HandlePragma(Preprocessor &PP, } // Otherwise, pass it down. - Handler->HandlePragma(PP, Introducer, Tok); + Handler->HandlePragma(PP, Tok); } //===----------------------------------------------------------------------===// @@ -105,10 +103,9 @@ void PragmaNamespace::HandlePragma(Preprocessor &PP, /// HandlePragmaDirective - The "\#pragma" directive has been parsed. Lex the /// rest of the pragma, passing it to the registered pragma handlers. -void Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc, - PragmaIntroducerKind Introducer) { +void Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc) { if (Callbacks) - Callbacks->PragmaDirective(IntroducerLoc, Introducer); + Callbacks->PragmaDirective(IntroducerLoc); if (!PragmasEnabled) return; @@ -117,7 +114,7 @@ void Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc, // Invoke the first level of pragma handlers which reads the namespace id. Token Tok; - PragmaHandlers->HandlePragma(*this, Introducer, Tok); + PragmaHandlers->HandlePragma(*this, Tok); // If the pragma handler didn't read the rest of the line, consume it now. if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective()) @@ -295,7 +292,7 @@ void Preprocessor::Handle_Pragma(Token &Tok) { EnterSourceFileWithLexer(TL, 0); // With everything set up, lex this as a #pragma directive. - HandlePragmaDirective(PragmaLoc, PIK__Pragma); + HandlePragmaDirective(PragmaLoc); // Finally, return whatever came after the pragma directive. return Lex(Tok); @@ -344,7 +341,7 @@ void Preprocessor::HandleMicrosoft__pragma(Token &Tok) { EnterTokenStream(TokArray, PragmaToks.size(), true, true); // With everything set up, lex this as a #pragma directive. - HandlePragmaDirective(PragmaLoc, PIK___pragma); + HandlePragmaDirective(PragmaLoc); // Finally, return whatever came after the pragma directive. return Lex(Tok); @@ -812,8 +809,7 @@ namespace { /// PragmaOnceHandler - "\#pragma once" marks the file as atomically included. struct PragmaOnceHandler : public PragmaHandler { PragmaOnceHandler() : PragmaHandler("once") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &OnceTok) { + virtual void HandlePragma(Preprocessor &PP, Token &OnceTok) { PP.CheckEndOfDirective("pragma once"); PP.HandlePragmaOnce(OnceTok); } @@ -823,8 +819,7 @@ struct PragmaOnceHandler : public PragmaHandler { /// rest of the line is not lexed. struct PragmaMarkHandler : public PragmaHandler { PragmaMarkHandler() : PragmaHandler("mark") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &MarkTok) { + virtual void HandlePragma(Preprocessor &PP, Token &MarkTok) { PP.HandlePragmaMark(); } }; @@ -832,8 +827,7 @@ struct PragmaMarkHandler : public PragmaHandler { /// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable. struct PragmaPoisonHandler : public PragmaHandler { PragmaPoisonHandler() : PragmaHandler("poison") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &PoisonTok) { + virtual void HandlePragma(Preprocessor &PP, Token &PoisonTok) { PP.HandlePragmaPoison(PoisonTok); } }; @@ -842,24 +836,21 @@ struct PragmaPoisonHandler : public PragmaHandler { /// as a system header, which silences warnings in it. struct PragmaSystemHeaderHandler : public PragmaHandler { PragmaSystemHeaderHandler() : PragmaHandler("system_header") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &SHToken) { + virtual void HandlePragma(Preprocessor &PP, Token &SHToken) { PP.HandlePragmaSystemHeader(SHToken); PP.CheckEndOfDirective("pragma"); } }; struct PragmaDependencyHandler : public PragmaHandler { PragmaDependencyHandler() : PragmaHandler("dependency") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &DepToken) { + virtual void HandlePragma(Preprocessor &PP, Token &DepToken) { PP.HandlePragmaDependency(DepToken); } }; struct PragmaDebugHandler : public PragmaHandler { PragmaDebugHandler() : PragmaHandler("__debug") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &DepToken) { + virtual void HandlePragma(Preprocessor &PP, Token &DepToken) { Token Tok; PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { @@ -942,8 +933,7 @@ private: public: explicit PragmaDiagnosticHandler(const char *NS) : PragmaHandler("diagnostic"), Namespace(NS) {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &DiagToken) { + virtual void HandlePragma(Preprocessor &PP, Token &DiagToken) { SourceLocation DiagLoc = DiagToken.getLocation(); Token Tok; PP.LexUnexpandedToken(Tok); @@ -1031,8 +1021,7 @@ static int LexSimpleInt(Preprocessor &PP, Token &Tok) { struct PragmaWarningHandler : public PragmaHandler { PragmaWarningHandler() : PragmaHandler("warning") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &Tok) { + virtual void HandlePragma(Preprocessor &PP, Token &Tok) { // Parse things like: // warning(push, 1) // warning(pop) @@ -1135,8 +1124,7 @@ struct PragmaWarningHandler : public PragmaHandler { /// PragmaIncludeAliasHandler - "\#pragma include_alias("...")". struct PragmaIncludeAliasHandler : public PragmaHandler { PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &IncludeAliasTok) { + virtual void HandlePragma(Preprocessor &PP, Token &IncludeAliasTok) { PP.HandlePragmaIncludeAlias(IncludeAliasTok); } }; @@ -1177,8 +1165,7 @@ public: StringRef Namespace = StringRef()) : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind), Namespace(Namespace) {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &Tok) { + virtual void HandlePragma(Preprocessor &PP, Token &Tok) { SourceLocation MessageLoc = Tok.getLocation(); PP.Lex(Tok); bool ExpectClosingParen = false; @@ -1230,8 +1217,7 @@ public: /// macro on the top of the stack. struct PragmaPushMacroHandler : public PragmaHandler { PragmaPushMacroHandler() : PragmaHandler("push_macro") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &PushMacroTok) { + virtual void HandlePragma(Preprocessor &PP, Token &PushMacroTok) { PP.HandlePragmaPushMacro(PushMacroTok); } }; @@ -1241,8 +1227,7 @@ struct PragmaPushMacroHandler : public PragmaHandler { /// macro to the value on the top of the stack. struct PragmaPopMacroHandler : public PragmaHandler { PragmaPopMacroHandler() : PragmaHandler("pop_macro") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &PopMacroTok) { + virtual void HandlePragma(Preprocessor &PP, Token &PopMacroTok) { PP.HandlePragmaPopMacro(PopMacroTok); } }; @@ -1252,8 +1237,7 @@ struct PragmaPopMacroHandler : public PragmaHandler { /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...". struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler { PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &Tok) { + virtual void HandlePragma(Preprocessor &PP, Token &Tok) { tok::OnOffSwitch OOS; if (PP.LexOnOffSwitch(OOS)) return; @@ -1266,8 +1250,7 @@ struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler { struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler { PragmaSTDC_CX_LIMITED_RANGEHandler() : PragmaHandler("CX_LIMITED_RANGE") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &Tok) { + virtual void HandlePragma(Preprocessor &PP, Token &Tok) { tok::OnOffSwitch OOS; PP.LexOnOffSwitch(OOS); } @@ -1276,8 +1259,7 @@ struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler { /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...". struct PragmaSTDC_UnknownHandler : public PragmaHandler { PragmaSTDC_UnknownHandler() {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &UnknownTok) { + virtual void HandlePragma(Preprocessor &PP, Token &UnknownTok) { // C99 6.10.6p2, unknown forms are not allowed. PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored); } @@ -1287,8 +1269,7 @@ struct PragmaSTDC_UnknownHandler : public PragmaHandler { /// \#pragma clang arc_cf_code_audited begin/end struct PragmaARCCFCodeAuditedHandler : public PragmaHandler { PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &NameTok) { + virtual void HandlePragma(Preprocessor &PP, Token &NameTok) { SourceLocation Loc = NameTok.getLocation(); bool IsBegin; @@ -1351,8 +1332,7 @@ struct PragmaARCCFCodeAuditedHandler : public PragmaHandler { struct PragmaRegionHandler : public PragmaHandler { PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) { } - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &NameTok) { + virtual void HandlePragma(Preprocessor &PP, Token &NameTok) { // #pragma region: endregion matches can be verified // __pragma(region): no sense, but ignored by msvc // _Pragma is not valid for MSVC, but there isn't any point diff --git a/lib/Parse/ParsePragma.cpp b/lib/Parse/ParsePragma.cpp index 8a374e0..e6767bf 100644 --- a/lib/Parse/ParsePragma.cpp +++ b/lib/Parse/ParsePragma.cpp @@ -185,8 +185,7 @@ void Parser::HandlePragmaOpenCLExtension() { // #pragma GCC visibility comes in two variants: // 'push' '(' [visibility] ')' // 'pop' -void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, +void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP, Token &VisTok) { SourceLocation VisLoc = VisTok.getLocation(); @@ -244,8 +243,7 @@ void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP, // pack '(' [integer] ')' // pack '(' 'show' ')' // pack '(' ('push' | 'pop') [',' identifier] [, integer] ')' -void PragmaPackHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, +void PragmaPackHandler::HandlePragma(Preprocessor &PP, Token &PackTok) { SourceLocation PackLoc = PackTok.getLocation(); @@ -360,8 +358,7 @@ void PragmaPackHandler::HandlePragma(Preprocessor &PP, // #pragma ms_struct on // #pragma ms_struct off -void PragmaMSStructHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, +void PragmaMSStructHandler::HandlePragma(Preprocessor &PP, Token &MSStructTok) { Sema::PragmaMSStructKind Kind = Sema::PMSST_OFF; @@ -472,20 +469,18 @@ static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok, } void PragmaAlignHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, + Token &AlignTok) { ParseAlignPragma(PP, AlignTok, /*IsOptions=*/false); } -void PragmaOptionsHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, +void PragmaOptionsHandler::HandlePragma(Preprocessor &PP, Token &OptionsTok) { ParseAlignPragma(PP, OptionsTok, /*IsOptions=*/true); } // #pragma unused(identifier) void PragmaUnusedHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, Token &UnusedTok) { // FIXME: Should we be expanding macros here? My guess is no. SourceLocation UnusedLoc = UnusedTok.getLocation(); @@ -567,7 +562,6 @@ void PragmaUnusedHandler::HandlePragma(Preprocessor &PP, // #pragma weak identifier // #pragma weak identifier '=' identifier void PragmaWeakHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, Token &WeakTok) { SourceLocation WeakLoc = WeakTok.getLocation(); @@ -628,7 +622,6 @@ void PragmaWeakHandler::HandlePragma(Preprocessor &PP, // #pragma redefine_extname identifier identifier void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, Token &RedefToken) { SourceLocation RedefLoc = RedefToken.getLocation(); @@ -673,8 +666,7 @@ void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP, void -PragmaFPContractHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, +PragmaFPContractHandler::HandlePragma(Preprocessor &PP, Token &Tok) { tok::OnOffSwitch OOS; if (PP.LexOnOffSwitch(OOS)) @@ -695,7 +687,7 @@ PragmaFPContractHandler::HandlePragma(Preprocessor &PP, void PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, + Token &Tok) { PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { @@ -758,7 +750,6 @@ PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP, /// void PragmaNoOpenMPHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, Token &FirstTok) { if (PP.getDiagnostics().getDiagnosticLevel(diag::warn_pragma_omp_ignored, FirstTok.getLocation()) != @@ -775,7 +766,6 @@ PragmaNoOpenMPHandler::HandlePragma(Preprocessor &PP, /// void PragmaOpenMPHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, Token &FirstTok) { SmallVector<Token, 16> Pragma; Token Tok; @@ -810,7 +800,6 @@ PragmaOpenMPHandler::HandlePragma(Preprocessor &PP, /// mismatch in the object file's values for the given name, a LNK2038 error /// is emitted. See MSDN for more details. void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation CommentLoc = Tok.getLocation(); PP.Lex(Tok); @@ -866,7 +855,6 @@ void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP, /// "foo" is a string, which is fully macro expanded, and permits string /// concatenation, embedded escape characters etc. See MSDN for more details. void PragmaCommentHandler::HandlePragma(Preprocessor &PP, - PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation CommentLoc = Tok.getLocation(); PP.Lex(Tok); diff --git a/lib/Parse/ParsePragma.h b/lib/Parse/ParsePragma.h index b41450f..060ea35 100644 --- a/lib/Parse/ParsePragma.h +++ b/lib/Parse/ParsePragma.h @@ -24,93 +24,81 @@ class PragmaAlignHandler : public PragmaHandler { public: explicit PragmaAlignHandler() : PragmaHandler("align") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); }; class PragmaGCCVisibilityHandler : public PragmaHandler { public: explicit PragmaGCCVisibilityHandler() : PragmaHandler("visibility") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); }; class PragmaOptionsHandler : public PragmaHandler { public: explicit PragmaOptionsHandler() : PragmaHandler("options") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); }; class PragmaPackHandler : public PragmaHandler { public: explicit PragmaPackHandler() : PragmaHandler("pack") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); }; class PragmaMSStructHandler : public PragmaHandler { public: explicit PragmaMSStructHandler() : PragmaHandler("ms_struct") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); }; class PragmaUnusedHandler : public PragmaHandler { public: PragmaUnusedHandler() : PragmaHandler("unused") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); }; class PragmaWeakHandler : public PragmaHandler { public: explicit PragmaWeakHandler() : PragmaHandler("weak") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); }; class PragmaRedefineExtnameHandler : public PragmaHandler { public: explicit PragmaRedefineExtnameHandler() : PragmaHandler("redefine_extname") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); }; class PragmaOpenCLExtensionHandler : public PragmaHandler { public: PragmaOpenCLExtensionHandler() : PragmaHandler("EXTENSION") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); }; class PragmaFPContractHandler : public PragmaHandler { public: PragmaFPContractHandler() : PragmaHandler("FP_CONTRACT") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); }; class PragmaNoOpenMPHandler : public PragmaHandler { public: PragmaNoOpenMPHandler() : PragmaHandler("omp") { } - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); }; class PragmaOpenMPHandler : public PragmaHandler { public: PragmaOpenMPHandler() : PragmaHandler("omp") { } - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); }; /// PragmaCommentHandler - "\#pragma comment ...". @@ -118,8 +106,7 @@ class PragmaCommentHandler : public PragmaHandler { public: PragmaCommentHandler(Sema &Actions) : PragmaHandler("comment"), Actions(Actions) {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); private: Sema &Actions; }; @@ -128,8 +115,7 @@ class PragmaDetectMismatchHandler : public PragmaHandler { public: PragmaDetectMismatchHandler(Sema &Actions) : PragmaHandler("detect_mismatch"), Actions(Actions) {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &FirstToken); + virtual void HandlePragma(Preprocessor &PP, Token &FirstToken); private: Sema &Actions; };
_______________________________________________ cfe-commits mailing list [email protected] http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
