From e95e7d5d646d760bf3d6862f8265cc8fb14438f7 Mon Sep 17 00:00:00 2001 From: Eugene Zelenko Date: Wed, 7 Sep 2016 21:53:17 +0000 Subject: Fix some Clang-tidy modernize-use-using and Include What You Use warnings; other minor fixes. Differential revision: https://reviews.llvm.org/D24115 llvm-svn: 280870 --- clang/lib/Lex/Pragma.cpp | 52 ++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 42 insertions(+), 10 deletions(-) (limited to 'clang/lib/Lex/Pragma.cpp') diff --git a/clang/lib/Lex/Pragma.cpp b/clang/lib/Lex/Pragma.cpp index 1ce4b4391f6..459133d5301 100644 --- a/clang/lib/Lex/Pragma.cpp +++ b/clang/lib/Lex/Pragma.cpp @@ -14,18 +14,35 @@ #include "clang/Lex/Pragma.h" #include "clang/Basic/FileManager.h" +#include "clang/Basic/IdentifierTable.h" +#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceManager.h" +#include "clang/Basic/TokenKinds.h" #include "clang/Lex/HeaderSearch.h" #include "clang/Lex/LexDiagnostic.h" -#include "clang/Lex/LiteralSupport.h" #include "clang/Lex/MacroInfo.h" +#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/Preprocessor.h" +#include "clang/Lex/PreprocessorLexer.h" +#include "clang/Lex/PTHLexer.h" +#include "clang/Lex/Token.h" +#include "clang/Lex/TokenLexer.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/SmallString.h" +#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/StringSwitch.h" -#include "llvm/ADT/StringExtras.h" #include "llvm/Support/CrashRecoveryContext.h" +#include "llvm/Support/Compiler.h" #include "llvm/Support/ErrorHandling.h" #include +#include +#include +#include +#include +#include + using namespace clang; // Out-of-line destructor to provide a home for the class. @@ -121,6 +138,7 @@ void Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc, } namespace { + /// \brief Helper class for \see Preprocessor::Handle_Pragma. class LexingFor_PragmaRAII { Preprocessor &PP; @@ -155,7 +173,8 @@ public: Failed = true; } }; -} + +} // end anonymous namespace /// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then /// return the first token after the directive. The _Pragma token has just @@ -372,13 +391,12 @@ void Preprocessor::HandlePragmaMark() { CurPTHLexer->DiscardToEndOfLine(); } - /// HandlePragmaPoison - Handle \#pragma GCC poison. PoisonTok is the 'poison'. /// void Preprocessor::HandlePragmaPoison(Token &PoisonTok) { Token Tok; - while (1) { + while (true) { // Read the next token to poison. While doing this, pretend that we are // skipping while reading the identifier to poison. // This avoids errors on code like: @@ -610,7 +628,7 @@ void Preprocessor::HandlePragmaPopMacro(Token &PopMacroTok) { // Pop PragmaPushMacroInfo stack. iter->second.pop_back(); - if (iter->second.size() == 0) + if (iter->second.empty()) PragmaPushMacroInfo.erase(iter); } else { Diag(MessageLoc, diag::warn_pragma_pop_macro_no_push) @@ -807,6 +825,7 @@ bool Preprocessor::LexOnOffSwitch(tok::OnOffSwitch &Result) { } namespace { + /// PragmaOnceHandler - "\#pragma once" marks the file as atomically included. struct PragmaOnceHandler : public PragmaHandler { PragmaOnceHandler() : PragmaHandler("once") {} @@ -821,6 +840,7 @@ struct PragmaOnceHandler : public PragmaHandler { /// rest of the line is not lexed. struct PragmaMarkHandler : public PragmaHandler { PragmaMarkHandler() : PragmaHandler("mark") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &MarkTok) override { PP.HandlePragmaMark(); @@ -830,6 +850,7 @@ struct PragmaMarkHandler : public PragmaHandler { /// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable. struct PragmaPoisonHandler : public PragmaHandler { PragmaPoisonHandler() : PragmaHandler("poison") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PoisonTok) override { PP.HandlePragmaPoison(PoisonTok); @@ -840,14 +861,17 @@ struct PragmaPoisonHandler : public PragmaHandler { /// as a system header, which silences warnings in it. struct PragmaSystemHeaderHandler : public PragmaHandler { PragmaSystemHeaderHandler() : PragmaHandler("system_header") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &SHToken) override { PP.HandlePragmaSystemHeader(SHToken); PP.CheckEndOfDirective("pragma"); } }; + struct PragmaDependencyHandler : public PragmaHandler { PragmaDependencyHandler() : PragmaHandler("dependency") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DepToken) override { PP.HandlePragmaDependency(DepToken); @@ -856,6 +880,7 @@ struct PragmaDependencyHandler : public PragmaHandler { struct PragmaDebugHandler : public PragmaHandler { PragmaDebugHandler() : PragmaHandler("__debug") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DepToken) override { Token Tok; @@ -965,9 +990,11 @@ struct PragmaDebugHandler : public PragmaHandler { struct PragmaDiagnosticHandler : public PragmaHandler { private: const char *Namespace; + public: explicit PragmaDiagnosticHandler(const char *NS) : PragmaHandler("diagnostic"), Namespace(NS) {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &DiagToken) override { SourceLocation DiagLoc = DiagToken.getLocation(); @@ -1140,7 +1167,7 @@ struct PragmaWarningHandler : public PragmaHandler { while (Tok.is(tok::numeric_constant)) { uint64_t Value; if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 || - Value > INT_MAX) { + Value > std::numeric_limits::max()) { PP.Diag(Tok, diag::warn_pragma_warning_expected_number); return; } @@ -1265,17 +1292,18 @@ public: /// macro on the top of the stack. struct PragmaPushMacroHandler : public PragmaHandler { PragmaPushMacroHandler() : PragmaHandler("push_macro") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PushMacroTok) override { PP.HandlePragmaPushMacro(PushMacroTok); } }; - /// PragmaPopMacroHandler - "\#pragma pop_macro" sets the value of the /// macro to the value on the top of the stack. struct PragmaPopMacroHandler : public PragmaHandler { PragmaPopMacroHandler() : PragmaHandler("pop_macro") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PopMacroTok) override { PP.HandlePragmaPopMacro(PopMacroTok); @@ -1287,6 +1315,7 @@ struct PragmaPopMacroHandler : public PragmaHandler { /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...". struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler { PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { tok::OnOffSwitch OOS; @@ -1301,6 +1330,7 @@ struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler { struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler { PragmaSTDC_CX_LIMITED_RANGEHandler() : PragmaHandler("CX_LIMITED_RANGE") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { tok::OnOffSwitch OOS; @@ -1311,6 +1341,7 @@ struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler { /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...". struct PragmaSTDC_UnknownHandler : public PragmaHandler { PragmaSTDC_UnknownHandler() {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &UnknownTok) override { // C99 6.10.6p2, unknown forms are not allowed. @@ -1322,6 +1353,7 @@ struct PragmaSTDC_UnknownHandler : public PragmaHandler { /// \#pragma clang arc_cf_code_audited begin/end struct PragmaARCCFCodeAuditedHandler : public PragmaHandler { PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &NameTok) override { SourceLocation Loc = NameTok.getLocation(); @@ -1376,6 +1408,7 @@ struct PragmaARCCFCodeAuditedHandler : public PragmaHandler { /// \#pragma clang assume_nonnull begin/end struct PragmaAssumeNonNullHandler : public PragmaHandler { PragmaAssumeNonNullHandler() : PragmaHandler("assume_nonnull") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &NameTok) override { SourceLocation Loc = NameTok.getLocation(); @@ -1449,8 +1482,7 @@ struct PragmaRegionHandler : public PragmaHandler { } }; -} // end anonymous namespace - +} // end anonymous namespace /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas: /// \#pragma GCC poison/system_header/dependency and \#pragma once. -- cgit v1.2.3