diff options
Diffstat (limited to 'contrib/llvm/tools/clang/lib/Lex/Pragma.cpp')
| -rw-r--r-- | contrib/llvm/tools/clang/lib/Lex/Pragma.cpp | 184 |
1 files changed, 97 insertions, 87 deletions
diff --git a/contrib/llvm/tools/clang/lib/Lex/Pragma.cpp b/contrib/llvm/tools/clang/lib/Lex/Pragma.cpp index e4059ee..cf76bdb 100644 --- a/contrib/llvm/tools/clang/lib/Lex/Pragma.cpp +++ b/contrib/llvm/tools/clang/lib/Lex/Pragma.cpp @@ -48,9 +48,7 @@ void EmptyPragmaHandler::HandlePragma(Preprocessor &PP, //===----------------------------------------------------------------------===// PragmaNamespace::~PragmaNamespace() { - for (llvm::StringMap<PragmaHandler*>::iterator - I = Handlers.begin(), E = Handlers.end(); I != E; ++I) - delete I->second; + llvm::DeleteContainerSeconds(Handlers); } /// FindHandler - Check to see if there is already a handler for the @@ -61,7 +59,7 @@ PragmaHandler *PragmaNamespace::FindHandler(StringRef Name, bool IgnoreNull) const { if (PragmaHandler *Handler = Handlers.lookup(Name)) return Handler; - return IgnoreNull ? 0 : Handlers.lookup(StringRef()); + return IgnoreNull ? nullptr : Handlers.lookup(StringRef()); } void PragmaNamespace::AddPragma(PragmaHandler *Handler) { @@ -90,7 +88,7 @@ void PragmaNamespace::HandlePragma(Preprocessor &PP, = FindHandler(Tok.getIdentifierInfo() ? Tok.getIdentifierInfo()->getName() : StringRef(), /*IgnoreNull=*/false); - if (Handler == 0) { + if (!Handler) { PP.Diag(Tok, diag::warn_pragma_ignored); return; } @@ -292,7 +290,7 @@ void Preprocessor::Handle_Pragma(Token &Tok) { Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc, StrVal.size(), *this); - EnterSourceFileWithLexer(TL, 0); + EnterSourceFileWithLexer(TL, nullptr); // With everything set up, lex this as a #pragma directive. HandlePragmaDirective(PragmaLoc, PIK__Pragma); @@ -475,8 +473,9 @@ void Preprocessor::HandlePragmaDependency(Token &DependencyTok) { // Search include directories for this file. const DirectoryLookup *CurDir; const FileEntry *File = LookupFile(FilenameTok.getLocation(), Filename, - isAngled, 0, CurDir, NULL, NULL, NULL); - if (File == 0) { + isAngled, nullptr, CurDir, nullptr, + nullptr, nullptr); + if (!File) { if (!SuppressIncludeNotFoundError) Diag(FilenameTok, diag::err_pp_file_not_found) << Filename; return; @@ -512,7 +511,7 @@ IdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) { if (Tok.isNot(tok::l_paren)) { Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok); - return 0; + return nullptr; } // Read the macro name string. @@ -520,12 +519,12 @@ IdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) { if (Tok.isNot(tok::string_literal)) { Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok); - return 0; + return nullptr; } if (Tok.hasUDSuffix()) { Diag(Tok, diag::err_invalid_string_udl); - return 0; + return nullptr; } // Remember the macro string. @@ -536,7 +535,7 @@ IdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) { if (Tok.isNot(tok::r_paren)) { Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok); - return 0; + return nullptr; } assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' && @@ -738,7 +737,7 @@ void Preprocessor::AddPragmaHandler(StringRef Namespace, // we already have the namespace to insert into. if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) { InsertNS = Existing->getIfNamespace(); - assert(InsertNS != 0 && "Cannot have a pragma namespace and pragma" + assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma" " handler with the same name!"); } else { // Otherwise, this namespace doesn't exist yet, create and insert the @@ -812,8 +811,8 @@ 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) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &OnceTok) override { PP.CheckEndOfDirective("pragma once"); PP.HandlePragmaOnce(OnceTok); } @@ -823,8 +822,8 @@ 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) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &MarkTok) override { PP.HandlePragmaMark(); } }; @@ -832,8 +831,8 @@ 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) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &PoisonTok) override { PP.HandlePragmaPoison(PoisonTok); } }; @@ -842,24 +841,24 @@ 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) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &SHToken) override { PP.HandlePragmaSystemHeader(SHToken); PP.CheckEndOfDirective("pragma"); } }; struct PragmaDependencyHandler : public PragmaHandler { PragmaDependencyHandler() : PragmaHandler("dependency") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &DepToken) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &DepToken) override { PP.HandlePragmaDependency(DepToken); } }; struct PragmaDebugHandler : public PragmaHandler { PragmaDebugHandler() : PragmaHandler("__debug") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &DepToken) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &DepToken) override { Token Tok; PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { @@ -926,8 +925,9 @@ struct PragmaDebugHandler : public PragmaHandler { #ifdef _MSC_VER #pragma warning(disable : 4717) #endif - void DebugOverflowStack() { - DebugOverflowStack(); + static void DebugOverflowStack() { + void (*volatile Self)() = DebugOverflowStack; + Self(); } #ifdef _MSC_VER #pragma warning(default : 4717) @@ -942,8 +942,8 @@ private: public: explicit PragmaDiagnosticHandler(const char *NS) : PragmaHandler("diagnostic"), Namespace(NS) {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &DiagToken) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &DiagToken) override { SourceLocation DiagLoc = DiagToken.getLocation(); Token Tok; PP.LexUnexpandedToken(Tok); @@ -954,16 +954,7 @@ public: IdentifierInfo *II = Tok.getIdentifierInfo(); PPCallbacks *Callbacks = PP.getPPCallbacks(); - diag::Mapping Map; - if (II->isStr("warning")) - Map = diag::MAP_WARNING; - else if (II->isStr("error")) - Map = diag::MAP_ERROR; - else if (II->isStr("ignored")) - Map = diag::MAP_IGNORE; - else if (II->isStr("fatal")) - Map = diag::MAP_FATAL; - else if (II->isStr("pop")) { + if (II->isStr("pop")) { if (!PP.getDiagnostics().popMappings(DiagLoc)) PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop); else if (Callbacks) @@ -974,7 +965,16 @@ public: if (Callbacks) Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace); return; - } else { + } + + diag::Severity SV = llvm::StringSwitch<diag::Severity>(II->getName()) + .Case("ignored", diag::Severity::Ignored) + .Case("warning", diag::Severity::Warning) + .Case("error", diag::Severity::Error) + .Case("fatal", diag::Severity::Fatal) + .Default(diag::Severity()); + + if (SV == diag::Severity()) { PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); return; } @@ -993,46 +993,30 @@ public: } if (WarningName.size() < 3 || WarningName[0] != '-' || - WarningName[1] != 'W') { + (WarningName[1] != 'W' && WarningName[1] != 'R')) { PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option); return; } - if (PP.getDiagnostics().setDiagnosticGroupMapping(WarningName.substr(2), - Map, DiagLoc)) + if (PP.getDiagnostics().setSeverityForGroup( + WarningName[1] == 'W' ? diag::Flavor::WarningOrError + : diag::Flavor::Remark, + WarningName.substr(2), SV, DiagLoc)) PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning) << WarningName; else if (Callbacks) - Callbacks->PragmaDiagnostic(DiagLoc, Namespace, Map, WarningName); + Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName); } }; -// Returns -1 on failure. -static int LexSimpleInt(Preprocessor &PP, Token &Tok) { - assert(Tok.is(tok::numeric_constant)); - SmallString<8> IntegerBuffer; - bool NumberInvalid = false; - StringRef Spelling = PP.getSpelling(Tok, IntegerBuffer, &NumberInvalid); - if (NumberInvalid) - return -1; - NumericLiteralParser Literal(Spelling, Tok.getLocation(), PP); - if (Literal.hadError || !Literal.isIntegerLiteral() || Literal.hasUDSuffix()) - return -1; - llvm::APInt APVal(32, 0); - if (Literal.GetIntegerValue(APVal)) - return -1; - PP.Lex(Tok); - return int(APVal.getLimitedValue(INT_MAX)); -} - /// "\#pragma warning(...)". MSVC's diagnostics do not map cleanly to clang's /// diagnostics, so we don't really implement this pragma. We parse it and /// ignore it to avoid -Wunknown-pragma warnings. struct PragmaWarningHandler : public PragmaHandler { PragmaWarningHandler() : PragmaHandler("warning") {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &Tok) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &Tok) override { // Parse things like: // warning(push, 1) // warning(pop) @@ -1059,8 +1043,10 @@ struct PragmaWarningHandler : public PragmaHandler { PP.Lex(Tok); if (Tok.is(tok::comma)) { PP.Lex(Tok); - if (Tok.is(tok::numeric_constant)) - Level = LexSimpleInt(PP, Tok); + uint64_t Value; + if (Tok.is(tok::numeric_constant) && + PP.parseSimpleIntegerLiteral(Tok, Value)) + Level = int(Value); if (Level < 0 || Level > 4) { PP.Diag(Tok, diag::warn_pragma_warning_push_level); return; @@ -1104,12 +1090,13 @@ struct PragmaWarningHandler : public PragmaHandler { SmallVector<int, 4> Ids; PP.Lex(Tok); while (Tok.is(tok::numeric_constant)) { - int Id = LexSimpleInt(PP, Tok); - if (Id <= 0) { + uint64_t Value; + if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 || + Value > INT_MAX) { PP.Diag(Tok, diag::warn_pragma_warning_expected_number); return; } - Ids.push_back(Id); + Ids.push_back(int(Value)); } if (Callbacks) Callbacks->PragmaWarning(DiagLoc, Specifier, Ids); @@ -1135,8 +1122,8 @@ 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) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &IncludeAliasTok) override { PP.HandlePragmaIncludeAlias(IncludeAliasTok); } }; @@ -1177,8 +1164,8 @@ public: StringRef Namespace = StringRef()) : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind), Namespace(Namespace) {} - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &Tok) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &Tok) override { SourceLocation MessageLoc = Tok.getLocation(); PP.Lex(Tok); bool ExpectClosingParen = false; @@ -1230,8 +1217,8 @@ 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) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &PushMacroTok) override { PP.HandlePragmaPushMacro(PushMacroTok); } }; @@ -1241,8 +1228,8 @@ 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) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &PopMacroTok) override { PP.HandlePragmaPopMacro(PopMacroTok); } }; @@ -1252,8 +1239,8 @@ 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) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &Tok) override { tok::OnOffSwitch OOS; if (PP.LexOnOffSwitch(OOS)) return; @@ -1266,8 +1253,8 @@ 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) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &Tok) override { tok::OnOffSwitch OOS; PP.LexOnOffSwitch(OOS); } @@ -1276,8 +1263,8 @@ 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) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &UnknownTok) override { // C99 6.10.6p2, unknown forms are not allowed. PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored); } @@ -1287,8 +1274,8 @@ 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) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &NameTok) override { SourceLocation Loc = NameTok.getLocation(); bool IsBegin; @@ -1351,8 +1338,8 @@ struct PragmaARCCFCodeAuditedHandler : public PragmaHandler { struct PragmaRegionHandler : public PragmaHandler { PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) { } - virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, - Token &NameTok) { + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &NameTok) override { // #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 @@ -1401,3 +1388,26 @@ void Preprocessor::RegisterBuiltinPragmas() { AddPragmaHandler(new PragmaRegionHandler("endregion")); } } + +/// Ignore all pragmas, useful for modes such as -Eonly which would otherwise +/// warn about those pragmas being unknown. +void Preprocessor::IgnorePragmas() { + AddPragmaHandler(new EmptyPragmaHandler()); + // Also ignore all pragmas in all namespaces created + // in Preprocessor::RegisterBuiltinPragmas(). + AddPragmaHandler("GCC", new EmptyPragmaHandler()); + AddPragmaHandler("clang", new EmptyPragmaHandler()); + if (PragmaHandler *NS = PragmaHandlers->FindHandler("STDC")) { + // Preprocessor::RegisterBuiltinPragmas() already registers + // PragmaSTDC_UnknownHandler as the empty handler, so remove it first, + // otherwise there will be an assert about a duplicate handler. + PragmaNamespace *STDCNamespace = NS->getIfNamespace(); + assert(STDCNamespace && + "Invalid namespace, registered as a regular pragma handler!"); + if (PragmaHandler *Existing = STDCNamespace->FindHandler("", false)) { + RemovePragmaHandler("STDC", Existing); + delete Existing; + } + } + AddPragmaHandler("STDC", new EmptyPragmaHandler()); +} |
