15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- Pragma.cpp - Pragma registration and handling --------------------===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This file implements the PragmaHandler/PragmaTable interfaces and implements 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// pragma related methods of the Preprocessor class. 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Lex/Pragma.h" 1655fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "clang/Basic/FileManager.h" 1755fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "clang/Basic/SourceManager.h" 185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Lex/HeaderSearch.h" 1955fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "clang/Lex/LexDiagnostic.h" 20a9d9145741ef77db45890911674705b81605b10bChris Lattner#include "clang/Lex/LiteralSupport.h" 21f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner#include "clang/Lex/MacroInfo.h" 2255fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "clang/Lex/Preprocessor.h" 232ee042dee9f7693665e28463955401905474a284Reid Kleckner#include "llvm/ADT/STLExtras.h" 242ee042dee9f7693665e28463955401905474a284Reid Kleckner#include "llvm/ADT/StringSwitch.h" 25b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar#include "llvm/ADT/StringExtras.h" 26ff759a66526d6a985fb4efae69c6b798d83364dfDaniel Dunbar#include "llvm/Support/CrashRecoveryContext.h" 275505413ee8e4e2924f52ba81181071f3a492e7d9Daniel Dunbar#include "llvm/Support/ErrorHandling.h" 282e22253e03e175144aeb9d13350a12fd83f858beDouglas Gregor#include <algorithm> 295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 312ee042dee9f7693665e28463955401905474a284Reid Kleckner#include "llvm/Support/raw_ostream.h" 322ee042dee9f7693665e28463955401905474a284Reid Kleckner 335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Out-of-line destructor to provide a home for the class. 345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerPragmaHandler::~PragmaHandler() { 355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 38c72cc5072cdc1a1a6e05f9d0f962f293a69248c4Daniel Dunbar// EmptyPragmaHandler Implementation. 39c72cc5072cdc1a1a6e05f9d0f962f293a69248c4Daniel Dunbar//===----------------------------------------------------------------------===// 40c72cc5072cdc1a1a6e05f9d0f962f293a69248c4Daniel Dunbar 41a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga NainarEmptyPragmaHandler::EmptyPragmaHandler(StringRef Name) : PragmaHandler(Name) {} 42c72cc5072cdc1a1a6e05f9d0f962f293a69248c4Daniel Dunbar 4380c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregorvoid EmptyPragmaHandler::HandlePragma(Preprocessor &PP, 4480c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregor PragmaIntroducerKind Introducer, 4580c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregor Token &FirstToken) {} 46c72cc5072cdc1a1a6e05f9d0f962f293a69248c4Daniel Dunbar 47c72cc5072cdc1a1a6e05f9d0f962f293a69248c4Daniel Dunbar//===----------------------------------------------------------------------===// 485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// PragmaNamespace Implementation. 495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerPragmaNamespace::~PragmaNamespace() { 52651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines llvm::DeleteContainerSeconds(Handlers); 535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// FindHandler - Check to see if there is already a handler for the 565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// specified name. If not, return the handler for the null identifier if it 575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// exists, otherwise return null. If IgnoreNull is true (the default) then 585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// the null handler isn't returned on failure to match. 595f9e272e632e951b1efe824cd16acb4d96077930Chris LattnerPragmaHandler *PragmaNamespace::FindHandler(StringRef Name, 605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer bool IgnoreNull) const { 619b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis if (PragmaHandler *Handler = Handlers.lookup(Name)) 629b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis return Handler; 636bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return IgnoreNull ? nullptr : Handlers.lookup(StringRef()); 649b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis} 651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 669b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidisvoid PragmaNamespace::AddPragma(PragmaHandler *Handler) { 679b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis assert(!Handlers.lookup(Handler->getName()) && 689b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis "A handler with this name is already registered in this namespace"); 69176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Handlers[Handler->getName()] = Handler; 705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 724095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbarvoid PragmaNamespace::RemovePragmaHandler(PragmaHandler *Handler) { 739b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis assert(Handlers.lookup(Handler->getName()) && 749b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis "Handler not registered in this namespace"); 759b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis Handlers.erase(Handler->getName()); 764095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar} 774095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar 7880c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregorvoid PragmaNamespace::HandlePragma(Preprocessor &PP, 7980c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregor PragmaIntroducerKind Introducer, 8080c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregor Token &Tok) { 815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Read the 'namespace' that the directive is in, e.g. STDC. Do not macro 825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // expand it, the user can have a STDC #define, that should not affect this. 835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PP.LexUnexpandedToken(Tok); 841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the handler for this token. If there is no handler, ignore the pragma. 869b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis PragmaHandler *Handler 879b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis = FindHandler(Tok.getIdentifierInfo() ? Tok.getIdentifierInfo()->getName() 885f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner : StringRef(), 899b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis /*IgnoreNull=*/false); 906bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (!Handler) { 91af7cdf45da4925f788e87a4c318ee67404646088Chris Lattner PP.Diag(Tok, diag::warn_pragma_ignored); 92af7cdf45da4925f788e87a4c318ee67404646088Chris Lattner return; 93af7cdf45da4925f788e87a4c318ee67404646088Chris Lattner } 941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Otherwise, pass it down. 9680c60f72848896f867f6b7e664e7060d9e78f019Douglas Gregor Handler->HandlePragma(PP, Introducer, Tok); 975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Preprocessor Pragma Directive Handling. 1015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 103b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// HandlePragmaDirective - The "\#pragma" directive has been parsed. Lex the 1045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// rest of the pragma, passing it to the registered pragma handlers. 1050189fd61ec72d86e008aa5615be80581f84cf703Enea Zaffanellavoid Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc, 1060189fd61ec72d86e008aa5615be80581f84cf703Enea Zaffanella PragmaIntroducerKind Introducer) { 1070189fd61ec72d86e008aa5615be80581f84cf703Enea Zaffanella if (Callbacks) 1080189fd61ec72d86e008aa5615be80581f84cf703Enea Zaffanella Callbacks->PragmaDirective(IntroducerLoc, Introducer); 1090189fd61ec72d86e008aa5615be80581f84cf703Enea Zaffanella 1106fe6a49c4058211ff4489023c78615ec0266c5ffJordan Rose if (!PragmasEnabled) 1116fe6a49c4058211ff4489023c78615ec0266c5ffJordan Rose return; 1126fe6a49c4058211ff4489023c78615ec0266c5ffJordan Rose 1135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ++NumPragma; 1141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Invoke the first level of pragma handlers which reads the namespace id. 116d217773f106856a11879ec79dc468efefaf2ee75Chris Lattner Token Tok; 1170189fd61ec72d86e008aa5615be80581f84cf703Enea Zaffanella PragmaHandlers->HandlePragma(*this, Introducer, Tok); 1181eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the pragma handler didn't read the rest of the line, consume it now. 120b2eb53d9fd973a1a02e05e67a3307b3efd12eff2Peter Collingbourne if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective()) 121b2eb53d9fd973a1a02e05e67a3307b3efd12eff2Peter Collingbourne || (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective)) 1225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer DiscardUntilEndOfDirective(); 1235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12514e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidisnamespace { 12614e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis/// \brief Helper class for \see Preprocessor::Handle_Pragma. 12714e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidisclass LexingFor_PragmaRAII { 12814e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis Preprocessor &PP; 12914e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis bool InMacroArgPreExpansion; 13014e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis bool Failed; 13114e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis Token &OutTok; 13214e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis Token PragmaTok; 13314e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis 13414e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidispublic: 13514e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis LexingFor_PragmaRAII(Preprocessor &PP, bool InMacroArgPreExpansion, 13614e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis Token &Tok) 13714e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis : PP(PP), InMacroArgPreExpansion(InMacroArgPreExpansion), 13814e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis Failed(false), OutTok(Tok) { 13914e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis if (InMacroArgPreExpansion) { 14014e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis PragmaTok = OutTok; 14114e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis PP.EnableBacktrackAtThisPos(); 14214e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis } 14314e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis } 14414e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis 14514e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis ~LexingFor_PragmaRAII() { 14614e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis if (InMacroArgPreExpansion) { 14714e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis if (Failed) { 14814e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis PP.CommitBacktrackedTokens(); 14914e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis } else { 15014e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis PP.Backtrack(); 15114e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis OutTok = PragmaTok; 15214e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis } 15314e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis } 15414e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis } 15514e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis 15614e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis void failed() { 15714e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis Failed = true; 15814e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis } 15914e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis}; 16014e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis} 16114e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis 1625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then 1635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// return the first token after the directive. The _Pragma token has just 1645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// been read into 'Tok'. 165d217773f106856a11879ec79dc468efefaf2ee75Chris Lattnervoid Preprocessor::Handle_Pragma(Token &Tok) { 16614e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis 16714e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis // This works differently if we are pre-expanding a macro argument. 16814e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis // In that case we don't actually "activate" the pragma now, we only lex it 16914e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis // until we are sure it is lexically correct and then we backtrack so that 17014e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis // we activate the pragma whenever we encounter the tokens again in the token 17114e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis // stream. This ensures that we will activate it in the correct location 17214e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis // or that we will ignore it if it never enters the token stream, e.g: 17314e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis // 17414e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis // #define EMPTY(x) 17514e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis // #define INACTIVE(x) EMPTY(x) 17614e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis // INACTIVE(_Pragma("clang diagnostic ignored \"-Wconversion\"")) 17714e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis 17814e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis LexingFor_PragmaRAII _PragmaLexing(*this, InMacroArgPreExpansion, Tok); 17914e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis 1805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Remember the pragma token location. 1815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer SourceLocation PragmaLoc = Tok.getLocation(); 1821eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Read the '('. 1845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Lex(Tok); 1853692b09faa9fe346f39bc922db6dce48cdcc3f63Chris Lattner if (Tok.isNot(tok::l_paren)) { 1863692b09faa9fe346f39bc922db6dce48cdcc3f63Chris Lattner Diag(PragmaLoc, diag::err__Pragma_malformed); 18714e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis return _PragmaLexing.failed(); 1883692b09faa9fe346f39bc922db6dce48cdcc3f63Chris Lattner } 1895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Read the '"..."'. 1915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Lex(Tok); 1920b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith if (!tok::isStringLiteral(Tok.getKind())) { 1933692b09faa9fe346f39bc922db6dce48cdcc3f63Chris Lattner Diag(PragmaLoc, diag::err__Pragma_malformed); 194a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar // Skip bad tokens, and the ')', if present. 195176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::eof)) 19699831e4677a7e2e051af636221694d60ba31fcdbRichard Smith Lex(Tok); 197a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar while (Tok.isNot(tok::r_paren) && 198a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar !Tok.isAtStartOfLine() && 199a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar Tok.isNot(tok::eof)) 200a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar Lex(Tok); 20199831e4677a7e2e051af636221694d60ba31fcdbRichard Smith if (Tok.is(tok::r_paren)) 20299831e4677a7e2e051af636221694d60ba31fcdbRichard Smith Lex(Tok); 20314e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis return _PragmaLexing.failed(); 20499831e4677a7e2e051af636221694d60ba31fcdbRichard Smith } 20599831e4677a7e2e051af636221694d60ba31fcdbRichard Smith 20699831e4677a7e2e051af636221694d60ba31fcdbRichard Smith if (Tok.hasUDSuffix()) { 20799831e4677a7e2e051af636221694d60ba31fcdbRichard Smith Diag(Tok, diag::err_invalid_string_udl); 20899831e4677a7e2e051af636221694d60ba31fcdbRichard Smith // Skip this token, and the ')', if present. 20999831e4677a7e2e051af636221694d60ba31fcdbRichard Smith Lex(Tok); 21099831e4677a7e2e051af636221694d60ba31fcdbRichard Smith if (Tok.is(tok::r_paren)) 21199831e4677a7e2e051af636221694d60ba31fcdbRichard Smith Lex(Tok); 21214e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis return _PragmaLexing.failed(); 2133692b09faa9fe346f39bc922db6dce48cdcc3f63Chris Lattner } 2141eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Remember the string. 21614e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis Token StrTok = Tok; 2175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Read the ')'. 2195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Lex(Tok); 2203692b09faa9fe346f39bc922db6dce48cdcc3f63Chris Lattner if (Tok.isNot(tok::r_paren)) { 2213692b09faa9fe346f39bc922db6dce48cdcc3f63Chris Lattner Diag(PragmaLoc, diag::err__Pragma_malformed); 22214e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis return _PragmaLexing.failed(); 2233692b09faa9fe346f39bc922db6dce48cdcc3f63Chris Lattner } 2241eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 22514e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis if (InMacroArgPreExpansion) 22614e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis return; 22714e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis 228e7fb48466afcbf2c4ccdfa658824282fdc3c512cChris Lattner SourceLocation RParenLoc = Tok.getLocation(); 22914e645557ae91c6770d62beb00a1c522e0bfd5d6Argyrios Kyrtzidis std::string StrVal = getSpelling(StrTok); 2301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2310b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith // The _Pragma is lexically sound. Destringize according to C11 6.10.9.1: 2320b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith // "The string literal is destringized by deleting any encoding prefix, 233a9d9145741ef77db45890911674705b81605b10bChris Lattner // deleting the leading and trailing double-quotes, replacing each escape 234a9d9145741ef77db45890911674705b81605b10bChris Lattner // sequence \" by a double-quote, and replacing each escape sequence \\ by a 235a9d9145741ef77db45890911674705b81605b10bChris Lattner // single backslash." 2360b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith if (StrVal[0] == 'L' || StrVal[0] == 'U' || 2370b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith (StrVal[0] == 'u' && StrVal[1] != '8')) 2385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer StrVal.erase(StrVal.begin()); 2390b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith else if (StrVal[0] == 'u') 2400b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith StrVal.erase(StrVal.begin(), StrVal.begin() + 2); 2410b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith 2420b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith if (StrVal[0] == 'R') { 2430b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith // FIXME: C++11 does not specify how to handle raw-string-literals here. 2440b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith // We strip off the 'R', the quotes, the d-char-sequences, and the parens. 2450b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith assert(StrVal[1] == '"' && StrVal[StrVal.size() - 1] == '"' && 2460b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith "Invalid raw string token!"); 2470b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith 2480b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith // Measure the length of the d-char-sequence. 2490b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith unsigned NumDChars = 0; 2500b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith while (StrVal[2 + NumDChars] != '(') { 2510b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith assert(NumDChars < (StrVal.size() - 5) / 2 && 2520b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith "Invalid raw string token!"); 2530b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith ++NumDChars; 2540b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith } 2550b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith assert(StrVal[StrVal.size() - 2 - NumDChars] == ')'); 2560b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith 2570b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith // Remove 'R " d-char-sequence' and 'd-char-sequence "'. We'll replace the 2580b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith // parens below. 2590b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith StrVal.erase(0, 2 + NumDChars); 2600b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith StrVal.erase(StrVal.size() - 1 - NumDChars); 2610b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith } else { 2620b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' && 2630b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith "Invalid string token!"); 2640b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith 2650b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith // Remove escaped quotes and escapes. 266269cc2daf3a36ad878ea1d4cb356aa38311f6e2dBenjamin Kramer unsigned ResultPos = 1; 26748b80c78b02efd7c4a7e3a7530d05b8aa9d3b649Reid Kleckner for (unsigned i = 1, e = StrVal.size() - 1; i != e; ++i) { 26848b80c78b02efd7c4a7e3a7530d05b8aa9d3b649Reid Kleckner // Skip escapes. \\ -> '\' and \" -> '"'. 26948b80c78b02efd7c4a7e3a7530d05b8aa9d3b649Reid Kleckner if (StrVal[i] == '\\' && i + 1 < e && 27048b80c78b02efd7c4a7e3a7530d05b8aa9d3b649Reid Kleckner (StrVal[i + 1] == '\\' || StrVal[i + 1] == '"')) 27148b80c78b02efd7c4a7e3a7530d05b8aa9d3b649Reid Kleckner ++i; 27248b80c78b02efd7c4a7e3a7530d05b8aa9d3b649Reid Kleckner StrVal[ResultPos++] = StrVal[i]; 2730b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith } 27448b80c78b02efd7c4a7e3a7530d05b8aa9d3b649Reid Kleckner StrVal.erase(StrVal.begin() + ResultPos, StrVal.end() - 1); 2750b91cc47a5642de2e1f567fe0f29420acdcdebbeRichard Smith } 2761eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Remove the front quote, replacing it with a space, so that the pragma 2785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // contents appear to have a space before them. 2795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer StrVal[0] = ' '; 2801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2811fa495304c81e03f07f278a47b5efe9317104aabChris Lattner // Replace the terminating quote with a \n. 2825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer StrVal[StrVal.size()-1] = '\n'; 2831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 284a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne // Plop the string (including the newline and trailing null) into a buffer 285a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne // where we can lex it. 286a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne Token TmpTok; 287a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne TmpTok.startToken(); 288374b3837d676133fcc1eb70a25c8baf8ec4a5c4aDmitri Gribenko CreateString(StrVal, TmpTok); 289a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne SourceLocation TokLoc = TmpTok.getLocation(); 290a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne 291a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne // Make and enter a lexer object so that we lex and expand the tokens just 292a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne // like any others. 293a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc, 294a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne StrVal.size(), *this); 295a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne 2966bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines EnterSourceFileWithLexer(TL, nullptr); 297a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne 298a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne // With everything set up, lex this as a #pragma directive. 2990189fd61ec72d86e008aa5615be80581f84cf703Enea Zaffanella HandlePragmaDirective(PragmaLoc, PIK__Pragma); 3001ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall 3011ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall // Finally, return whatever came after the pragma directive. 3021ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall return Lex(Tok); 3031ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall} 3041ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall 3051ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall/// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text 3061ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall/// is not enclosed within a string literal. 3071ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCallvoid Preprocessor::HandleMicrosoft__pragma(Token &Tok) { 3081ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall // Remember the pragma token location. 3091ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall SourceLocation PragmaLoc = Tok.getLocation(); 3101ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall 3111ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall // Read the '('. 3121ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall Lex(Tok); 3131ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall if (Tok.isNot(tok::l_paren)) { 3141ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall Diag(PragmaLoc, diag::err__Pragma_malformed); 3151ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall return; 3161ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall } 3171ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall 318a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne // Get the tokens enclosed within the __pragma(), as well as the final ')'. 3195f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<Token, 32> PragmaToks; 3201ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall int NumParens = 0; 3211ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall Lex(Tok); 3221ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall while (Tok.isNot(tok::eof)) { 323a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne PragmaToks.push_back(Tok); 3241ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall if (Tok.is(tok::l_paren)) 3251ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall NumParens++; 3261ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall else if (Tok.is(tok::r_paren) && NumParens-- == 0) 3271ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall break; 3281ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall Lex(Tok); 3291ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall } 3301ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall 3313da92a9d21f707c164797dd967ba894b2282b343John McCall if (Tok.is(tok::eof)) { 3323da92a9d21f707c164797dd967ba894b2282b343John McCall Diag(PragmaLoc, diag::err_unterminated___pragma); 3333da92a9d21f707c164797dd967ba894b2282b343John McCall return; 3343da92a9d21f707c164797dd967ba894b2282b343John McCall } 3353da92a9d21f707c164797dd967ba894b2282b343John McCall 336a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne PragmaToks.front().setFlag(Token::LeadingSpace); 3371ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall 33884021556baceb76eedf7d44be8ba71d9b8cfaccePeter Collingbourne // Replace the ')' with an EOD to mark the end of the pragma. 33984021556baceb76eedf7d44be8ba71d9b8cfaccePeter Collingbourne PragmaToks.back().setKind(tok::eod); 3401ef8a2e7675f3d8b6e8d9963b00378086e1dcdc7John McCall 341a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne Token *TokArray = new Token[PragmaToks.size()]; 342a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray); 3431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 344a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne // Push the tokens onto the stack. 345a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne EnterTokenStream(TokArray, PragmaToks.size(), true, true); 3465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // With everything set up, lex this as a #pragma directive. 3480189fd61ec72d86e008aa5615be80581f84cf703Enea Zaffanella HandlePragmaDirective(PragmaLoc, PIK___pragma); 3495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 350a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne // Finally, return whatever came after the pragma directive. 351a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne return Lex(Tok); 352a5ef584fd3d18da0c98342b4b6453948b7eb30d3Peter Collingbourne} 3535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 354b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// HandlePragmaOnce - Handle \#pragma once. OnceTok is the 'once'. 3555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 356d217773f106856a11879ec79dc468efefaf2ee75Chris Lattnervoid Preprocessor::HandlePragmaOnce(Token &OnceTok) { 3575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (isInPrimaryFile()) { 3585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(OnceTok, diag::pp_pragma_once_in_main_file); 3595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return; 3605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc. 3635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Mark the file as a once-only file now. 3642b2453a7d8fe732561795431f39ceb2b2a832d84Chris Lattner HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry()); 3655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3672243449253475574fc6f14986ff8f7fce5d46799Chris Lattnervoid Preprocessor::HandlePragmaMark() { 36817ff58a63197b398ae52697b088dc0fb8b255519Ted Kremenek assert(CurPPLexer && "No current lexer?"); 3696896a371e302c63ce3d4a99ad2c32e42dde6a9e4Chris Lattner if (CurLexer) 3706896a371e302c63ce3d4a99ad2c32e42dde6a9e4Chris Lattner CurLexer->ReadToEndOfLine(); 3716896a371e302c63ce3d4a99ad2c32e42dde6a9e4Chris Lattner else 3726896a371e302c63ce3d4a99ad2c32e42dde6a9e4Chris Lattner CurPTHLexer->DiscardToEndOfLine(); 3732243449253475574fc6f14986ff8f7fce5d46799Chris Lattner} 3742243449253475574fc6f14986ff8f7fce5d46799Chris Lattner 3752243449253475574fc6f14986ff8f7fce5d46799Chris Lattner 376b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// HandlePragmaPoison - Handle \#pragma GCC poison. PoisonTok is the 'poison'. 3775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 378d217773f106856a11879ec79dc468efefaf2ee75Chris Lattnervoid Preprocessor::HandlePragmaPoison(Token &PoisonTok) { 379d217773f106856a11879ec79dc468efefaf2ee75Chris Lattner Token Tok; 3805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer while (1) { 3825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Read the next token to poison. While doing this, pretend that we are 3835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // skipping while reading the identifier to poison. 3845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // This avoids errors on code like: 3855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // #pragma GCC poison X 3865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // #pragma GCC poison X 38768a91d5736c2c03d60a9d1c59d08191b8e0d6c52Ted Kremenek if (CurPPLexer) CurPPLexer->LexingRawMode = true; 3885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer LexUnexpandedToken(Tok); 38968a91d5736c2c03d60a9d1c59d08191b8e0d6c52Ted Kremenek if (CurPPLexer) CurPPLexer->LexingRawMode = false; 3901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If we reached the end of line, we're done. 39284021556baceb76eedf7d44be8ba71d9b8cfaccePeter Collingbourne if (Tok.is(tok::eod)) return; 3931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Can only poison identifiers. 395c4bf2b9afb7d47445a9dc6bc848657098a4e3851Abramo Bagnara if (Tok.isNot(tok::raw_identifier)) { 3965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(Tok, diag::err_pp_invalid_poison); 3975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return; 3985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3991eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Look up the identifier info for the token. We disabled identifier lookup 4015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // by saying we're skipping contents, so we need to do this manually. 4025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer IdentifierInfo *II = LookUpIdentifierInfo(Tok); 4031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Already poisoned. 4055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (II->isPoisoned()) continue; 4061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is a macro identifier, emit a warning. 408b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar if (isMacroDefined(II)) 4095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(Tok, diag::pp_poisoning_existing_macro); 4101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Finally, poison it! 4125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer II->setIsPoisoned(); 413eee242ff426bf79149f221798966e58688383c1eDouglas Gregor if (II->isFromAST()) 414eee242ff426bf79149f221798966e58688383c1eDouglas Gregor II->setChangedSinceDeserialization(); 4155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 418b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// HandlePragmaSystemHeader - Implement \#pragma GCC system_header. We know 4195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// that the whole directive has been parsed. 420d217773f106856a11879ec79dc468efefaf2ee75Chris Lattnervoid Preprocessor::HandlePragmaSystemHeader(Token &SysHeaderTok) { 4215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (isInPrimaryFile()) { 4225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file); 4235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return; 4245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc. 42735c10c25ddec4effbd26dead23ea5b04ee32f45aTed Kremenek PreprocessorLexer *TheLexer = getCurrentFileLexer(); 4281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Mark the file as a system header. 4302b2453a7d8fe732561795431f39ceb2b2a832d84Chris Lattner HeaderInfo.MarkFileSystemHeader(TheLexer->getFileEntry()); 4311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4336896a371e302c63ce3d4a99ad2c32e42dde6a9e4Chris Lattner PresumedLoc PLoc = SourceMgr.getPresumedLoc(SysHeaderTok.getLocation()); 434cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor if (PLoc.isInvalid()) 435cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor return; 436cb7b1e17b63967317ab5cc55682168cf0380519aDouglas Gregor 43765aa6885818d4b4eea2e5a9d12085b2398148662Jay Foad unsigned FilenameID = SourceMgr.getLineTableFilenameID(PLoc.getFilename()); 4381eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 439784c257c8f5c3a737b0ae1dceb5d54d29b6637cfChris Lattner // Notify the client, if desired, that we are in a new source file. 440784c257c8f5c3a737b0ae1dceb5d54d29b6637cfChris Lattner if (Callbacks) 441784c257c8f5c3a737b0ae1dceb5d54d29b6637cfChris Lattner Callbacks->FileChanged(SysHeaderTok.getLocation(), 442784c257c8f5c3a737b0ae1dceb5d54d29b6637cfChris Lattner PPCallbacks::SystemHeaderPragma, SrcMgr::C_System); 443784c257c8f5c3a737b0ae1dceb5d54d29b6637cfChris Lattner 4446896a371e302c63ce3d4a99ad2c32e42dde6a9e4Chris Lattner // Emit a line marker. This will change any source locations from this point 4456896a371e302c63ce3d4a99ad2c32e42dde6a9e4Chris Lattner // forward to realize they are in a system header. 4466896a371e302c63ce3d4a99ad2c32e42dde6a9e4Chris Lattner // Create a line note with this information. 447142b35e25b579e2a883d6ca37c3c1121f562f242Jordan Rose SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine()+1, 448142b35e25b579e2a883d6ca37c3c1121f562f242Jordan Rose FilenameID, /*IsEntry=*/false, /*IsExit=*/false, 449142b35e25b579e2a883d6ca37c3c1121f562f242Jordan Rose /*IsSystem=*/true, /*IsExternC=*/false); 4505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 452b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// HandlePragmaDependency - Handle \#pragma GCC dependency "foo" blah. 4535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 454d217773f106856a11879ec79dc468efefaf2ee75Chris Lattnervoid Preprocessor::HandlePragmaDependency(Token &DependencyTok) { 455d217773f106856a11879ec79dc468efefaf2ee75Chris Lattner Token FilenameTok; 45668a91d5736c2c03d60a9d1c59d08191b8e0d6c52Ted Kremenek CurPPLexer->LexIncludeFilename(FilenameTok); 4575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 45884021556baceb76eedf7d44be8ba71d9b8cfaccePeter Collingbourne // If the token kind is EOD, the error has already been diagnosed. 45984021556baceb76eedf7d44be8ba71d9b8cfaccePeter Collingbourne if (FilenameTok.is(tok::eod)) 4605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return; 4611eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Reserve a buffer to get the spelling. 463f7ccbad5d9949e7ddd1cbef43d482553b811e026Dylan Noblesmith SmallString<128> FilenameBuffer; 464453091cc2082e207ea2c2dda645a9bc01b37fb0cDouglas Gregor bool Invalid = false; 4655f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner StringRef Filename = getSpelling(FilenameTok, FilenameBuffer, &Invalid); 466453091cc2082e207ea2c2dda645a9bc01b37fb0cDouglas Gregor if (Invalid) 467453091cc2082e207ea2c2dda645a9bc01b37fb0cDouglas Gregor return; 4681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 469a139481e62fdb209d9d87a54a5733f989d2e8d51Chris Lattner bool isAngled = 470a139481e62fdb209d9d87a54a5733f989d2e8d51Chris Lattner GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename); 4715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If GetIncludeFilenameSpelling set the start ptr to null, there was an 4725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // error. 473a139481e62fdb209d9d87a54a5733f989d2e8d51Chris Lattner if (Filename.empty()) 4745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return; 4751eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Search include directories for this file. 4775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const DirectoryLookup *CurDir; 478176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const FileEntry *File = 479176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LookupFile(FilenameTok.getLocation(), Filename, isAngled, nullptr, 480176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines nullptr, CurDir, nullptr, nullptr, nullptr); 4816bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (!File) { 482f84139a1331c63c998e8b7d54148c75ac0b48ccdEli Friedman if (!SuppressIncludeNotFoundError) 483f84139a1331c63c998e8b7d54148c75ac0b48ccdEli Friedman Diag(FilenameTok, diag::err_pp_file_not_found) << Filename; 48456b05c8829efd13b7e5b333f8f587c71d025c67dChris Lattner return; 48556b05c8829efd13b7e5b333f8f587c71d025c67dChris Lattner } 4861eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4872b2453a7d8fe732561795431f39ceb2b2a832d84Chris Lattner const FileEntry *CurFile = getCurrentFileLexer()->getFileEntry(); 4885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this file is older than the file it depends on, emit a diagnostic. 4905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) { 4915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Lex tokens at the end of the message and include them in the message. 4925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::string Message; 4935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Lex(DependencyTok); 49484021556baceb76eedf7d44be8ba71d9b8cfaccePeter Collingbourne while (DependencyTok.isNot(tok::eod)) { 4955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Message += getSpelling(DependencyTok) + " "; 4965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Lex(DependencyTok); 4975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 49996de25986d28171945db96a6c6a54f91fd12ae4bChris Lattner // Remove the trailing ' ' if present. 50096de25986d28171945db96a6c6a54f91fd12ae4bChris Lattner if (!Message.empty()) 50196de25986d28171945db96a6c6a54f91fd12ae4bChris Lattner Message.erase(Message.end()-1); 50256b05c8829efd13b7e5b333f8f587c71d025c67dChris Lattner Diag(FilenameTok, diag::pp_out_of_date_dependency) << Message; 5035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 5045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 5055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 5067adf79a620cb7fbde0608e21727425930676b7dbReid Kleckner/// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro. 507f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner/// Return the IdentifierInfo* associated with the macro to push or pop. 508f47724bf78299c7a50f008e0443c5f9f9f279ddcChris LattnerIdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) { 509f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Remember the pragma token location. 510f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner Token PragmaTok = Tok; 511f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 512f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Read the '('. 513f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner Lex(Tok); 514f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner if (Tok.isNot(tok::l_paren)) { 515f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) 516f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner << getSpelling(PragmaTok); 5176bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 518f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner } 519f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 520f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Read the macro name string. 521f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner Lex(Tok); 522f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner if (Tok.isNot(tok::string_literal)) { 523f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) 524f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner << getSpelling(PragmaTok); 5256bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 526f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner } 527f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 52899831e4677a7e2e051af636221694d60ba31fcdbRichard Smith if (Tok.hasUDSuffix()) { 52999831e4677a7e2e051af636221694d60ba31fcdbRichard Smith Diag(Tok, diag::err_invalid_string_udl); 5306bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 53199831e4677a7e2e051af636221694d60ba31fcdbRichard Smith } 53299831e4677a7e2e051af636221694d60ba31fcdbRichard Smith 533f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Remember the macro string. 534f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner std::string StrVal = getSpelling(Tok); 535f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 536f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Read the ')'. 537f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner Lex(Tok); 538f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner if (Tok.isNot(tok::r_paren)) { 539f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) 540f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner << getSpelling(PragmaTok); 5416bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines return nullptr; 542f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner } 543f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 544f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' && 545f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner "Invalid string token!"); 546f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 547f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Create a Token from the string. 548f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner Token MacroTok; 549f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner MacroTok.startToken(); 550c4bf2b9afb7d47445a9dc6bc848657098a4e3851Abramo Bagnara MacroTok.setKind(tok::raw_identifier); 551374b3837d676133fcc1eb70a25c8baf8ec4a5c4aDmitri Gribenko CreateString(StringRef(&StrVal[1], StrVal.size() - 2), MacroTok); 552f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 553f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Get the IdentifierInfo of MacroToPushTok. 554f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner return LookUpIdentifierInfo(MacroTok); 555f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner} 556f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 557b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// \brief Handle \#pragma push_macro. 558b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// 559f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner/// The syntax is: 560b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// \code 561e74dc199e95cc523c8806e0de41d8814e8bc5c42Dmitri Gribenko/// #pragma push_macro("macro") 562b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// \endcode 563f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattnervoid Preprocessor::HandlePragmaPushMacro(Token &PushMacroTok) { 564f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Parse the pragma directive and get the macro IdentifierInfo*. 565f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PushMacroTok); 566f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner if (!IdentInfo) return; 567f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 568f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Get the MacroInfo associated with IdentInfo. 569f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner MacroInfo *MI = getMacroInfo(IdentInfo); 570f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 571f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner if (MI) { 572f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Allow the original MacroInfo to be redefined later. 573f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner MI->setIsAllowRedefinitionsWithoutWarning(true); 574f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner } 575f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 576f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Push the cloned MacroInfo so we can retrieve it later. 5779818a1d443e97677dd3422305de9cc2b1fb2a8c1Argyrios Kyrtzidis PragmaPushMacroInfo[IdentInfo].push_back(MI); 578f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner} 579f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 580b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// \brief Handle \#pragma pop_macro. 581b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// 582f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner/// The syntax is: 583b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// \code 584f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner/// #pragma pop_macro("macro") 585b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// \endcode 586f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattnervoid Preprocessor::HandlePragmaPopMacro(Token &PopMacroTok) { 587f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner SourceLocation MessageLoc = PopMacroTok.getLocation(); 588f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 589f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Parse the pragma directive and get the macro IdentifierInfo*. 590f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PopMacroTok); 591f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner if (!IdentInfo) return; 592f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 593f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Find the vector<MacroInfo*> associated with the macro. 594f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner llvm::DenseMap<IdentifierInfo*, std::vector<MacroInfo*> >::iterator iter = 595f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner PragmaPushMacroInfo.find(IdentInfo); 596f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner if (iter != PragmaPushMacroInfo.end()) { 5978a64bb58c3b24d7d97895e435bbc0965c99bd3beAlexander Kornienko // Forget the MacroInfo currently associated with IdentInfo. 598b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar if (MacroInfo *MI = getMacroInfo(IdentInfo)) { 599c56fff7fd231aebf4b152f60f8f11ef91835c48aArgyrios Kyrtzidis if (MI->isWarnIfUnused()) 600c56fff7fd231aebf4b152f60f8f11ef91835c48aArgyrios Kyrtzidis WarnUnusedMacroLocs.erase(MI->getDefinitionLoc()); 601c56fff7fd231aebf4b152f60f8f11ef91835c48aArgyrios Kyrtzidis appendMacroDirective(IdentInfo, AllocateUndefMacroDirective(MessageLoc)); 6020827408865e32789e0ec4b8113a302ccdc531423Argyrios Kyrtzidis } 603f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 604f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Get the MacroInfo we want to reinstall. 605f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner MacroInfo *MacroToReInstall = iter->second.back(); 606f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 607b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar if (MacroToReInstall) 608e40c4238a572bf8241a04e0005f70550cbfc1cfbAlexander Kornienko // Reinstall the previously pushed macro. 609b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar appendDefMacroDirective(IdentInfo, MacroToReInstall, MessageLoc); 610f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 611f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner // Pop PragmaPushMacroInfo stack. 612f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner iter->second.pop_back(); 613f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner if (iter->second.size() == 0) 614f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner PragmaPushMacroInfo.erase(iter); 615f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner } else { 616f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner Diag(MessageLoc, diag::warn_pragma_pop_macro_no_push) 617f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner << IdentInfo->getName(); 618f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner } 619f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner} 6205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6214c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballmanvoid Preprocessor::HandlePragmaIncludeAlias(Token &Tok) { 6224c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // We will either get a quoted filename or a bracketed filename, and we 6234c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // have to track which we got. The first filename is the source name, 6244c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // and the second name is the mapped filename. If the first is quoted, 6254c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // the second must be as well (cannot mix and match quotes and brackets). 6264c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 6274c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // Get the open paren 6284c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman Lex(Tok); 6294c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman if (Tok.isNot(tok::l_paren)) { 6304c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman Diag(Tok, diag::warn_pragma_include_alias_expected) << "("; 6314c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman return; 6324c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman } 6334c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 6344c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // We expect either a quoted string literal, or a bracketed name 6354c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman Token SourceFilenameTok; 6364c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman CurPPLexer->LexIncludeFilename(SourceFilenameTok); 6374c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman if (SourceFilenameTok.is(tok::eod)) { 6384c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // The diagnostic has already been handled 6394c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman return; 6404c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman } 6414c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 6424c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman StringRef SourceFileName; 6434c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman SmallString<128> FileNameBuffer; 6444c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman if (SourceFilenameTok.is(tok::string_literal) || 6454c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman SourceFilenameTok.is(tok::angle_string_literal)) { 6464c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman SourceFileName = getSpelling(SourceFilenameTok, FileNameBuffer); 6474c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman } else if (SourceFilenameTok.is(tok::less)) { 6484c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // This could be a path instead of just a name 6494c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman FileNameBuffer.push_back('<'); 6504c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman SourceLocation End; 6514c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman if (ConcatenateIncludeName(FileNameBuffer, End)) 6524c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman return; // Diagnostic already emitted 6533ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar SourceFileName = FileNameBuffer; 6544c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman } else { 6554c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman Diag(Tok, diag::warn_pragma_include_alias_expected_filename); 6564c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman return; 6574c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman } 6584c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman FileNameBuffer.clear(); 6594c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 6604c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // Now we expect a comma, followed by another include name 6614c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman Lex(Tok); 6624c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman if (Tok.isNot(tok::comma)) { 6634c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman Diag(Tok, diag::warn_pragma_include_alias_expected) << ","; 6644c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman return; 6654c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman } 6664c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 6674c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman Token ReplaceFilenameTok; 6684c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman CurPPLexer->LexIncludeFilename(ReplaceFilenameTok); 6694c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman if (ReplaceFilenameTok.is(tok::eod)) { 6704c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // The diagnostic has already been handled 6714c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman return; 6724c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman } 6734c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 6744c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman StringRef ReplaceFileName; 6754c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman if (ReplaceFilenameTok.is(tok::string_literal) || 6764c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman ReplaceFilenameTok.is(tok::angle_string_literal)) { 6774c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman ReplaceFileName = getSpelling(ReplaceFilenameTok, FileNameBuffer); 6784c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman } else if (ReplaceFilenameTok.is(tok::less)) { 6794c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // This could be a path instead of just a name 6804c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman FileNameBuffer.push_back('<'); 6814c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman SourceLocation End; 6824c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman if (ConcatenateIncludeName(FileNameBuffer, End)) 6834c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman return; // Diagnostic already emitted 6843ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar ReplaceFileName = FileNameBuffer; 6854c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman } else { 6864c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman Diag(Tok, diag::warn_pragma_include_alias_expected_filename); 6874c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman return; 6884c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman } 6894c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 6904c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // Finally, we expect the closing paren 6914c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman Lex(Tok); 6924c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman if (Tok.isNot(tok::r_paren)) { 6934c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman Diag(Tok, diag::warn_pragma_include_alias_expected) << ")"; 6944c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman return; 6954c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman } 6964c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 6974c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // Now that we have the source and target filenames, we need to make sure 6984c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // they're both of the same type (angled vs non-angled) 6994c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman StringRef OriginalSource = SourceFileName; 7004c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 7014c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman bool SourceIsAngled = 7024c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman GetIncludeFilenameSpelling(SourceFilenameTok.getLocation(), 7034c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman SourceFileName); 7044c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman bool ReplaceIsAngled = 7054c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman GetIncludeFilenameSpelling(ReplaceFilenameTok.getLocation(), 7064c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman ReplaceFileName); 7074c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman if (!SourceFileName.empty() && !ReplaceFileName.empty() && 7084c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman (SourceIsAngled != ReplaceIsAngled)) { 7094c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman unsigned int DiagID; 7104c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman if (SourceIsAngled) 7114c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman DiagID = diag::warn_pragma_include_alias_mismatch_angle; 7124c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman else 7134c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman DiagID = diag::warn_pragma_include_alias_mismatch_quote; 7144c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 7154c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman Diag(SourceFilenameTok.getLocation(), DiagID) 7164c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman << SourceFileName 7174c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman << ReplaceFileName; 7184c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 7194c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman return; 7204c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman } 7214c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 7224c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman // Now we can let the include handler know about this mapping 7234c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman getHeaderSearchInfo().AddIncludeAlias(OriginalSource, ReplaceFileName); 7244c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman} 7254c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 7265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// AddPragmaHandler - Add the specified pragma handler to the preprocessor. 7275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// If 'Namespace' is non-null, then it is a token required to exist on the 7285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// pragma line before the pragma string starts, e.g. "STDC" or "GCC". 7295f9e272e632e951b1efe824cd16acb4d96077930Chris Lattnervoid Preprocessor::AddPragmaHandler(StringRef Namespace, 7305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PragmaHandler *Handler) { 731176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines PragmaNamespace *InsertNS = PragmaHandlers.get(); 7321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is specified to be in a namespace, step down into it. 7349b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis if (!Namespace.empty()) { 7355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If there is already a pragma handler with the name of this namespace, 7365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // we either have an error (directive with the same name as a namespace) or 7375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // we already have the namespace to insert into. 7389b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) { 7395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InsertNS = Existing->getIfNamespace(); 7406bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma" 7415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer " handler with the same name!"); 7425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 7435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Otherwise, this namespace doesn't exist yet, create and insert the 7445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // handler for it. 7459b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis InsertNS = new PragmaNamespace(Namespace); 7465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PragmaHandlers->AddPragma(InsertNS); 7475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 7485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 7491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Check to make sure we don't already have a pragma for this identifier. 7515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(!InsertNS->FindHandler(Handler->getName()) && 7525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer "Pragma handler already exists for this identifier!"); 7535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InsertNS->AddPragma(Handler); 7545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 7555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7564095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar/// RemovePragmaHandler - Remove the specific pragma handler from the 7574095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar/// preprocessor. If \arg Namespace is non-null, then it should be the 7584095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar/// namespace that \arg Handler was added to. It is an error to remove 7594095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar/// a handler that has not been registered. 7605f9e272e632e951b1efe824cd16acb4d96077930Chris Lattnervoid Preprocessor::RemovePragmaHandler(StringRef Namespace, 7614095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar PragmaHandler *Handler) { 762176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines PragmaNamespace *NS = PragmaHandlers.get(); 7631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7644095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar // If this is specified to be in a namespace, step down into it. 7659b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis if (!Namespace.empty()) { 7669b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace); 7674095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar assert(Existing && "Namespace containing handler does not exist!"); 7684095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar 7694095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar NS = Existing->getIfNamespace(); 7704095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar assert(NS && "Invalid namespace, registered as a regular pragma handler!"); 7714095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar } 7724095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar 7734095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar NS->RemovePragmaHandler(Handler); 7741eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 775176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // If this is a non-default namespace and it is now empty, remove it. 776176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (NS != PragmaHandlers.get() && NS->IsEmpty()) { 7774095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar PragmaHandlers->RemovePragmaHandler(NS); 778ce52bb3dec520ef94574280ac3ef8ad63f4f1ce2Argyrios Kyrtzidis delete NS; 779ce52bb3dec520ef94574280ac3ef8ad63f4f1ce2Argyrios Kyrtzidis } 7804095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar} 7814095080aff204008eefb26b100906c6ca2bc4bb6Daniel Dunbar 7829d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbournebool Preprocessor::LexOnOffSwitch(tok::OnOffSwitch &Result) { 7839d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne Token Tok; 7849d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne LexUnexpandedToken(Tok); 7859d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne 7869d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne if (Tok.isNot(tok::identifier)) { 7879d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne Diag(Tok, diag::ext_on_off_switch_syntax); 7889d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne return true; 7899d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne } 7909d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne IdentifierInfo *II = Tok.getIdentifierInfo(); 7919d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne if (II->isStr("ON")) 7929d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne Result = tok::OOS_ON; 7939d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne else if (II->isStr("OFF")) 7949d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne Result = tok::OOS_OFF; 7959d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne else if (II->isStr("DEFAULT")) 7969d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne Result = tok::OOS_DEFAULT; 7979d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne else { 7989d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne Diag(Tok, diag::ext_on_off_switch_syntax); 7999d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne return true; 8009d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne } 8019d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne 80284021556baceb76eedf7d44be8ba71d9b8cfaccePeter Collingbourne // Verify that this is followed by EOD. 8039d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne LexUnexpandedToken(Tok); 80484021556baceb76eedf7d44be8ba71d9b8cfaccePeter Collingbourne if (Tok.isNot(tok::eod)) 80584021556baceb76eedf7d44be8ba71d9b8cfaccePeter Collingbourne Diag(Tok, diag::ext_pragma_syntax_eod); 8069d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne return false; 8079d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne} 8089d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne 8095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencernamespace { 810b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// PragmaOnceHandler - "\#pragma once" marks the file as atomically included. 8115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerstruct PragmaOnceHandler : public PragmaHandler { 8129b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis PragmaOnceHandler() : PragmaHandler("once") {} 813651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 814651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &OnceTok) override { 81535410d5cbbb18735d76e00496540d416dc49b577Chris Lattner PP.CheckEndOfDirective("pragma once"); 8165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PP.HandlePragmaOnce(OnceTok); 8175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}; 8195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 820b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the 8212243449253475574fc6f14986ff8f7fce5d46799Chris Lattner/// rest of the line is not lexed. 8222243449253475574fc6f14986ff8f7fce5d46799Chris Lattnerstruct PragmaMarkHandler : public PragmaHandler { 8239b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis PragmaMarkHandler() : PragmaHandler("mark") {} 824651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 825651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &MarkTok) override { 8262243449253475574fc6f14986ff8f7fce5d46799Chris Lattner PP.HandlePragmaMark(); 8272243449253475574fc6f14986ff8f7fce5d46799Chris Lattner } 8282243449253475574fc6f14986ff8f7fce5d46799Chris Lattner}; 8292243449253475574fc6f14986ff8f7fce5d46799Chris Lattner 830b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable. 8315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerstruct PragmaPoisonHandler : public PragmaHandler { 8329b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis PragmaPoisonHandler() : PragmaHandler("poison") {} 833651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 834651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &PoisonTok) override { 8355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PP.HandlePragmaPoison(PoisonTok); 8365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}; 8385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 839b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// PragmaSystemHeaderHandler - "\#pragma system_header" marks the current file 8402243449253475574fc6f14986ff8f7fce5d46799Chris Lattner/// as a system header, which silences warnings in it. 8415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerstruct PragmaSystemHeaderHandler : public PragmaHandler { 8429b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis PragmaSystemHeaderHandler() : PragmaHandler("system_header") {} 843651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 844651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &SHToken) override { 8455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PP.HandlePragmaSystemHeader(SHToken); 84635410d5cbbb18735d76e00496540d416dc49b577Chris Lattner PP.CheckEndOfDirective("pragma"); 8475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}; 8495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerstruct PragmaDependencyHandler : public PragmaHandler { 8509b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis PragmaDependencyHandler() : PragmaHandler("dependency") {} 851651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 852651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &DepToken) override { 8535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PP.HandlePragmaDependency(DepToken); 8545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer}; 8561eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 857abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbarstruct PragmaDebugHandler : public PragmaHandler { 858abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar PragmaDebugHandler() : PragmaHandler("__debug") {} 859651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 860651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &DepToken) override { 861abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar Token Tok; 862abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar PP.LexUnexpandedToken(Tok); 863abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar if (Tok.isNot(tok::identifier)) { 8646493a4d7129673f7878da2382dedf4f9abc57e4cDouglas Gregor PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); 865abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar return; 866abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar } 867abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar IdentifierInfo *II = Tok.getIdentifierInfo(); 868abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar 8695505413ee8e4e2924f52ba81181071f3a492e7d9Daniel Dunbar if (II->isStr("assert")) { 870b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("This is an assertion!"); 871abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar } else if (II->isStr("crash")) { 872377da4c6b78c0130fb6141313636c8fda7b60b72David Blaikie LLVM_BUILTIN_TRAP; 873e75d9cfbf41a0ee9e456a665776f91fdd9773b36David Blaikie } else if (II->isStr("parser_crash")) { 874e75d9cfbf41a0ee9e456a665776f91fdd9773b36David Blaikie Token Crasher; 8753ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar Crasher.startToken(); 876e75d9cfbf41a0ee9e456a665776f91fdd9773b36David Blaikie Crasher.setKind(tok::annot_pragma_parser_crash); 8773ea9e33ea25e0c2b12db56418ba3f994eb662c04Pirama Arumuga Nainar Crasher.setAnnotationRange(SourceRange(Tok.getLocation())); 878e75d9cfbf41a0ee9e456a665776f91fdd9773b36David Blaikie PP.EnterToken(Crasher); 8795505413ee8e4e2924f52ba81181071f3a492e7d9Daniel Dunbar } else if (II->isStr("llvm_fatal_error")) { 8805505413ee8e4e2924f52ba81181071f3a492e7d9Daniel Dunbar llvm::report_fatal_error("#pragma clang __debug llvm_fatal_error"); 8815505413ee8e4e2924f52ba81181071f3a492e7d9Daniel Dunbar } else if (II->isStr("llvm_unreachable")) { 8825505413ee8e4e2924f52ba81181071f3a492e7d9Daniel Dunbar llvm_unreachable("#pragma clang __debug llvm_unreachable"); 883b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar } else if (II->isStr("macro")) { 884b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar Token MacroName; 885b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar PP.LexUnexpandedToken(MacroName); 886b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar auto *MacroII = MacroName.getIdentifierInfo(); 887b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar if (MacroII) 888b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar PP.dumpMacroInfo(MacroII); 889b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar else 890b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar PP.Diag(MacroName, diag::warn_pragma_diagnostic_invalid); 8915505413ee8e4e2924f52ba81181071f3a492e7d9Daniel Dunbar } else if (II->isStr("overflow_stack")) { 8925505413ee8e4e2924f52ba81181071f3a492e7d9Daniel Dunbar DebugOverflowStack(); 893ff759a66526d6a985fb4efae69c6b798d83364dfDaniel Dunbar } else if (II->isStr("handle_crash")) { 894ff759a66526d6a985fb4efae69c6b798d83364dfDaniel Dunbar llvm::CrashRecoveryContext *CRC =llvm::CrashRecoveryContext::GetCurrent(); 895ff759a66526d6a985fb4efae69c6b798d83364dfDaniel Dunbar if (CRC) 896ff759a66526d6a985fb4efae69c6b798d83364dfDaniel Dunbar CRC->HandleCrash(); 89785192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj } else if (II->isStr("captured")) { 89885192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj HandleCaptured(PP); 8995505413ee8e4e2924f52ba81181071f3a492e7d9Daniel Dunbar } else { 9005505413ee8e4e2924f52ba81181071f3a492e7d9Daniel Dunbar PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command) 9015505413ee8e4e2924f52ba81181071f3a492e7d9Daniel Dunbar << II->getName(); 902abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar } 90385192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj 90485192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj PPCallbacks *Callbacks = PP.getPPCallbacks(); 90585192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj if (Callbacks) 90685192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj Callbacks->PragmaDebug(Tok.getLocation(), II->getName()); 90785192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj } 90885192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj 90985192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj void HandleCaptured(Preprocessor &PP) { 91085192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj // Skip if emitting preprocessed output. 91185192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj if (PP.isPreprocessedOutput()) 91285192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj return; 91385192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj 91485192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj Token Tok; 91585192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj PP.LexUnexpandedToken(Tok); 91685192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj 91785192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj if (Tok.isNot(tok::eod)) { 91885192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) 91985192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj << "pragma clang __debug captured"; 92085192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj return; 92185192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj } 92285192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj 92385192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj SourceLocation NameLoc = Tok.getLocation(); 92485192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj Token *Toks = PP.getPreprocessorAllocator().Allocate<Token>(1); 92585192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj Toks->startToken(); 92685192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj Toks->setKind(tok::annot_pragma_captured); 92785192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj Toks->setLocation(NameLoc); 92885192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj 92985192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, 93085192c7fe187d5486e12dbc6960af28f16a558a0Tareq A. Siraj /*OwnsTokens=*/false); 931abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar } 932abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar 9331066c6c7c4d5186c2434b90b054c302564f98080Francois Pichet// Disable MSVC warning about runtime stack overflow. 9341066c6c7c4d5186c2434b90b054c302564f98080Francois Pichet#ifdef _MSC_VER 9351066c6c7c4d5186c2434b90b054c302564f98080Francois Pichet #pragma warning(disable : 4717) 9361066c6c7c4d5186c2434b90b054c302564f98080Francois Pichet#endif 937651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines static void DebugOverflowStack() { 938651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void (*volatile Self)() = DebugOverflowStack; 939651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Self(); 940abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar } 9411066c6c7c4d5186c2434b90b054c302564f98080Francois Pichet#ifdef _MSC_VER 9421066c6c7c4d5186c2434b90b054c302564f98080Francois Pichet #pragma warning(default : 4717) 9431066c6c7c4d5186c2434b90b054c302564f98080Francois Pichet#endif 9441066c6c7c4d5186c2434b90b054c302564f98080Francois Pichet 945abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar}; 946abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar 947b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"' 948edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattnerstruct PragmaDiagnosticHandler : public PragmaHandler { 949c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregorprivate: 950c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor const char *Namespace; 95104ae2df026b275aae5dddfc0db5ca55ff4e62179Chris Lattnerpublic: 952c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor explicit PragmaDiagnosticHandler(const char *NS) : 953c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor PragmaHandler("diagnostic"), Namespace(NS) {} 954651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 955651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &DiagToken) override { 9560827408865e32789e0ec4b8113a302ccdc531423Argyrios Kyrtzidis SourceLocation DiagLoc = DiagToken.getLocation(); 957edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner Token Tok; 958edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner PP.LexUnexpandedToken(Tok); 959edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner if (Tok.isNot(tok::identifier)) { 9606493a4d7129673f7878da2382dedf4f9abc57e4cDouglas Gregor PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); 961edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner return; 962edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner } 963edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner IdentifierInfo *II = Tok.getIdentifierInfo(); 964c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor PPCallbacks *Callbacks = PP.getPPCallbacks(); 9651eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 966c568f1e98938584c0ef0b12ae5018ff7d90a4072Stephen Hines if (II->isStr("pop")) { 9670827408865e32789e0ec4b8113a302ccdc531423Argyrios Kyrtzidis if (!PP.getDiagnostics().popMappings(DiagLoc)) 9686493a4d7129673f7878da2382dedf4f9abc57e4cDouglas Gregor PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop); 969c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor else if (Callbacks) 970c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace); 9716493a4d7129673f7878da2382dedf4f9abc57e4cDouglas Gregor return; 9726493a4d7129673f7878da2382dedf4f9abc57e4cDouglas Gregor } else if (II->isStr("push")) { 9730827408865e32789e0ec4b8113a302ccdc531423Argyrios Kyrtzidis PP.getDiagnostics().pushMappings(DiagLoc); 974c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor if (Callbacks) 975c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace); 97604ae2df026b275aae5dddfc0db5ca55ff4e62179Chris Lattner return; 977c568f1e98938584c0ef0b12ae5018ff7d90a4072Stephen Hines } 978c568f1e98938584c0ef0b12ae5018ff7d90a4072Stephen Hines 979c568f1e98938584c0ef0b12ae5018ff7d90a4072Stephen Hines diag::Severity SV = llvm::StringSwitch<diag::Severity>(II->getName()) 980c568f1e98938584c0ef0b12ae5018ff7d90a4072Stephen Hines .Case("ignored", diag::Severity::Ignored) 981c568f1e98938584c0ef0b12ae5018ff7d90a4072Stephen Hines .Case("warning", diag::Severity::Warning) 982c568f1e98938584c0ef0b12ae5018ff7d90a4072Stephen Hines .Case("error", diag::Severity::Error) 983c568f1e98938584c0ef0b12ae5018ff7d90a4072Stephen Hines .Case("fatal", diag::Severity::Fatal) 984c568f1e98938584c0ef0b12ae5018ff7d90a4072Stephen Hines .Default(diag::Severity()); 985c568f1e98938584c0ef0b12ae5018ff7d90a4072Stephen Hines 986c568f1e98938584c0ef0b12ae5018ff7d90a4072Stephen Hines if (SV == diag::Severity()) { 9876493a4d7129673f7878da2382dedf4f9abc57e4cDouglas Gregor PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid); 988edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner return; 989edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner } 9901eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 991edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner PP.LexUnexpandedToken(Tok); 99202a176871d91bba3004e4f94b2d4d588ae4b2122Andy Gibbs SourceLocation StringLoc = Tok.getLocation(); 993edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner 99402a176871d91bba3004e4f94b2d4d588ae4b2122Andy Gibbs std::string WarningName; 99597f8461a2c553f68a258612d2322e4281c3f0915Andy Gibbs if (!PP.FinishLexStringLiteral(Tok, WarningName, "pragma diagnostic", 99697f8461a2c553f68a258612d2322e4281c3f0915Andy Gibbs /*MacroExpansion=*/false)) 997edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner return; 9981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 99984021556baceb76eedf7d44be8ba71d9b8cfaccePeter Collingbourne if (Tok.isNot(tok::eod)) { 1000edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token); 1001edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner return; 1002edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner } 10031eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1004edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner if (WarningName.size() < 3 || WarningName[0] != '-' || 1005176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines (WarningName[1] != 'W' && WarningName[1] != 'R')) { 100602a176871d91bba3004e4f94b2d4d588ae4b2122Andy Gibbs PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option); 1007edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner return; 1008edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner } 10091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1010176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (PP.getDiagnostics().setSeverityForGroup( 1011176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines WarningName[1] == 'W' ? diag::Flavor::WarningOrError 1012176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines : diag::Flavor::Remark, 1013176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines WarningName.substr(2), SV, DiagLoc)) 101402a176871d91bba3004e4f94b2d4d588ae4b2122Andy Gibbs PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning) 101502a176871d91bba3004e4f94b2d4d588ae4b2122Andy Gibbs << WarningName; 1016c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor else if (Callbacks) 1017c568f1e98938584c0ef0b12ae5018ff7d90a4072Stephen Hines Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName); 1018edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner } 1019edaf877d2469147ba818187a3e57a00b3f73b123Chris Lattner}; 10201eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10212ee042dee9f7693665e28463955401905474a284Reid Kleckner/// "\#pragma warning(...)". MSVC's diagnostics do not map cleanly to clang's 10222ee042dee9f7693665e28463955401905474a284Reid Kleckner/// diagnostics, so we don't really implement this pragma. We parse it and 10232ee042dee9f7693665e28463955401905474a284Reid Kleckner/// ignore it to avoid -Wunknown-pragma warnings. 10242ee042dee9f7693665e28463955401905474a284Reid Klecknerstruct PragmaWarningHandler : public PragmaHandler { 10252ee042dee9f7693665e28463955401905474a284Reid Kleckner PragmaWarningHandler() : PragmaHandler("warning") {} 10262ee042dee9f7693665e28463955401905474a284Reid Kleckner 1027651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 1028651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &Tok) override { 10292ee042dee9f7693665e28463955401905474a284Reid Kleckner // Parse things like: 10302ee042dee9f7693665e28463955401905474a284Reid Kleckner // warning(push, 1) 10312ee042dee9f7693665e28463955401905474a284Reid Kleckner // warning(pop) 1032faea5bfd7583fe259b352b350bb5689f8c96de17John Thompson // warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9) 10332ee042dee9f7693665e28463955401905474a284Reid Kleckner SourceLocation DiagLoc = Tok.getLocation(); 10342ee042dee9f7693665e28463955401905474a284Reid Kleckner PPCallbacks *Callbacks = PP.getPPCallbacks(); 10352ee042dee9f7693665e28463955401905474a284Reid Kleckner 10362ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Lex(Tok); 10372ee042dee9f7693665e28463955401905474a284Reid Kleckner if (Tok.isNot(tok::l_paren)) { 10382ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Diag(Tok, diag::warn_pragma_warning_expected) << "("; 10392ee042dee9f7693665e28463955401905474a284Reid Kleckner return; 10402ee042dee9f7693665e28463955401905474a284Reid Kleckner } 10412ee042dee9f7693665e28463955401905474a284Reid Kleckner 10422ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Lex(Tok); 10432ee042dee9f7693665e28463955401905474a284Reid Kleckner IdentifierInfo *II = Tok.getIdentifierInfo(); 10442ee042dee9f7693665e28463955401905474a284Reid Kleckner 1045b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar if (II && II->isStr("push")) { 10462ee042dee9f7693665e28463955401905474a284Reid Kleckner // #pragma warning( push[ ,n ] ) 104772c26c0d47eb850db18b784403260bce0632c478Reid Kleckner int Level = -1; 10482ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Lex(Tok); 10492ee042dee9f7693665e28463955401905474a284Reid Kleckner if (Tok.is(tok::comma)) { 10502ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Lex(Tok); 1051651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines uint64_t Value; 1052651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (Tok.is(tok::numeric_constant) && 1053651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines PP.parseSimpleIntegerLiteral(Tok, Value)) 1054651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Level = int(Value); 105572c26c0d47eb850db18b784403260bce0632c478Reid Kleckner if (Level < 0 || Level > 4) { 10562ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Diag(Tok, diag::warn_pragma_warning_push_level); 10572ee042dee9f7693665e28463955401905474a284Reid Kleckner return; 10582ee042dee9f7693665e28463955401905474a284Reid Kleckner } 10592ee042dee9f7693665e28463955401905474a284Reid Kleckner } 10602ee042dee9f7693665e28463955401905474a284Reid Kleckner if (Callbacks) 10612ee042dee9f7693665e28463955401905474a284Reid Kleckner Callbacks->PragmaWarningPush(DiagLoc, Level); 1062b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar } else if (II && II->isStr("pop")) { 10632ee042dee9f7693665e28463955401905474a284Reid Kleckner // #pragma warning( pop ) 10642ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Lex(Tok); 10652ee042dee9f7693665e28463955401905474a284Reid Kleckner if (Callbacks) 10662ee042dee9f7693665e28463955401905474a284Reid Kleckner Callbacks->PragmaWarningPop(DiagLoc); 10672ee042dee9f7693665e28463955401905474a284Reid Kleckner } else { 10682ee042dee9f7693665e28463955401905474a284Reid Kleckner // #pragma warning( warning-specifier : warning-number-list 10692ee042dee9f7693665e28463955401905474a284Reid Kleckner // [; warning-specifier : warning-number-list...] ) 10702ee042dee9f7693665e28463955401905474a284Reid Kleckner while (true) { 10712ee042dee9f7693665e28463955401905474a284Reid Kleckner II = Tok.getIdentifierInfo(); 1072b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar if (!II && !Tok.is(tok::numeric_constant)) { 10732ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid); 10742ee042dee9f7693665e28463955401905474a284Reid Kleckner return; 10752ee042dee9f7693665e28463955401905474a284Reid Kleckner } 10762ee042dee9f7693665e28463955401905474a284Reid Kleckner 10772ee042dee9f7693665e28463955401905474a284Reid Kleckner // Figure out which warning specifier this is. 1078b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar bool SpecifierValid; 1079b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar StringRef Specifier; 1080b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar llvm::SmallString<1> SpecifierBuf; 1081b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar if (II) { 1082b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar Specifier = II->getName(); 1083b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar SpecifierValid = llvm::StringSwitch<bool>(Specifier) 1084b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar .Cases("default", "disable", "error", "once", 1085b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar "suppress", true) 1086b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar .Default(false); 1087b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar // If we read a correct specifier, snatch next token (that should be 1088b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar // ":", checked later). 1089b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar if (SpecifierValid) 1090b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar PP.Lex(Tok); 1091b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar } else { 1092b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar // Token is a numeric constant. It should be either 1, 2, 3 or 4. 1093b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar uint64_t Value; 1094b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar Specifier = PP.getSpelling(Tok, SpecifierBuf); 1095b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar if (PP.parseSimpleIntegerLiteral(Tok, Value)) { 1096b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar SpecifierValid = (Value >= 1) && (Value <= 4); 1097b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar } else 1098b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar SpecifierValid = false; 1099b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar // Next token already snatched by parseSimpleIntegerLiteral. 1100b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar } 1101b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar 11022ee042dee9f7693665e28463955401905474a284Reid Kleckner if (!SpecifierValid) { 11032ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid); 11042ee042dee9f7693665e28463955401905474a284Reid Kleckner return; 11052ee042dee9f7693665e28463955401905474a284Reid Kleckner } 11062ee042dee9f7693665e28463955401905474a284Reid Kleckner if (Tok.isNot(tok::colon)) { 11072ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Diag(Tok, diag::warn_pragma_warning_expected) << ":"; 11082ee042dee9f7693665e28463955401905474a284Reid Kleckner return; 11092ee042dee9f7693665e28463955401905474a284Reid Kleckner } 11102ee042dee9f7693665e28463955401905474a284Reid Kleckner 11112ee042dee9f7693665e28463955401905474a284Reid Kleckner // Collect the warning ids. 11122ee042dee9f7693665e28463955401905474a284Reid Kleckner SmallVector<int, 4> Ids; 11132ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Lex(Tok); 11142ee042dee9f7693665e28463955401905474a284Reid Kleckner while (Tok.is(tok::numeric_constant)) { 1115651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines uint64_t Value; 1116651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 || 1117651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Value > INT_MAX) { 11182ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Diag(Tok, diag::warn_pragma_warning_expected_number); 11192ee042dee9f7693665e28463955401905474a284Reid Kleckner return; 11202ee042dee9f7693665e28463955401905474a284Reid Kleckner } 1121651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Ids.push_back(int(Value)); 11222ee042dee9f7693665e28463955401905474a284Reid Kleckner } 11232ee042dee9f7693665e28463955401905474a284Reid Kleckner if (Callbacks) 11242ee042dee9f7693665e28463955401905474a284Reid Kleckner Callbacks->PragmaWarning(DiagLoc, Specifier, Ids); 11252ee042dee9f7693665e28463955401905474a284Reid Kleckner 11262ee042dee9f7693665e28463955401905474a284Reid Kleckner // Parse the next specifier if there is a semicolon. 11272ee042dee9f7693665e28463955401905474a284Reid Kleckner if (Tok.isNot(tok::semi)) 11282ee042dee9f7693665e28463955401905474a284Reid Kleckner break; 11292ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Lex(Tok); 11302ee042dee9f7693665e28463955401905474a284Reid Kleckner } 11312ee042dee9f7693665e28463955401905474a284Reid Kleckner } 11322ee042dee9f7693665e28463955401905474a284Reid Kleckner 11332ee042dee9f7693665e28463955401905474a284Reid Kleckner if (Tok.isNot(tok::r_paren)) { 11342ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Diag(Tok, diag::warn_pragma_warning_expected) << ")"; 11352ee042dee9f7693665e28463955401905474a284Reid Kleckner return; 11362ee042dee9f7693665e28463955401905474a284Reid Kleckner } 11372ee042dee9f7693665e28463955401905474a284Reid Kleckner 11382ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Lex(Tok); 11392ee042dee9f7693665e28463955401905474a284Reid Kleckner if (Tok.isNot(tok::eod)) 11402ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma warning"; 11412ee042dee9f7693665e28463955401905474a284Reid Kleckner } 11422ee042dee9f7693665e28463955401905474a284Reid Kleckner}; 11432ee042dee9f7693665e28463955401905474a284Reid Kleckner 1144b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// PragmaIncludeAliasHandler - "\#pragma include_alias("...")". 11454c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballmanstruct PragmaIncludeAliasHandler : public PragmaHandler { 11464c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {} 1147651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 1148651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &IncludeAliasTok) override { 11492ee042dee9f7693665e28463955401905474a284Reid Kleckner PP.HandlePragmaIncludeAlias(IncludeAliasTok); 11504c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman } 11514c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman}; 11524c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman 1153076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs/// PragmaMessageHandler - Handle the microsoft and gcc \#pragma message 1154076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs/// extension. The syntax is: 1155076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs/// \code 1156076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs/// #pragma message(string) 1157076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs/// \endcode 1158076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs/// OR, in GCC mode: 1159076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs/// \code 1160076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs/// #pragma message string 1161076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs/// \endcode 1162076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs/// string is a string, which is fully macro expanded, and permits string 1163076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs/// concatenation, embedded escape characters, etc... See MSDN for more details. 1164076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs/// Also handles \#pragma GCC warning and \#pragma GCC error which take the same 1165076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs/// form as \#pragma message. 1166abfe094ce71c42656dcb84a3bdc3e79cb3c16fc3Chris Lattnerstruct PragmaMessageHandler : public PragmaHandler { 1167076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbsprivate: 1168076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs const PPCallbacks::PragmaMessageKind Kind; 1169076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs const StringRef Namespace; 1170076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs 1171076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs static const char* PragmaKind(PPCallbacks::PragmaMessageKind Kind, 1172076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs bool PragmaNameOnly = false) { 1173076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs switch (Kind) { 1174076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs case PPCallbacks::PMK_Message: 1175076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs return PragmaNameOnly ? "message" : "pragma message"; 1176076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs case PPCallbacks::PMK_Warning: 1177076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs return PragmaNameOnly ? "warning" : "pragma warning"; 1178076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs case PPCallbacks::PMK_Error: 1179076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs return PragmaNameOnly ? "error" : "pragma error"; 1180076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs } 1181076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs llvm_unreachable("Unknown PragmaMessageKind!"); 1182076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs } 1183076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs 1184076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbspublic: 1185076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs PragmaMessageHandler(PPCallbacks::PragmaMessageKind Kind, 1186076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs StringRef Namespace = StringRef()) 1187076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind), Namespace(Namespace) {} 1188076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs 1189651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 1190651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &Tok) override { 1191076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs SourceLocation MessageLoc = Tok.getLocation(); 1192076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs PP.Lex(Tok); 1193076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs bool ExpectClosingParen = false; 1194076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs switch (Tok.getKind()) { 1195076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs case tok::l_paren: 1196076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs // We have a MSVC style pragma message. 1197076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs ExpectClosingParen = true; 1198076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs // Read the string. 1199076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs PP.Lex(Tok); 1200076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs break; 1201076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs case tok::string_literal: 1202076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs // We have a GCC style pragma message, and we just read the string. 1203076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs break; 1204076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs default: 1205076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind; 1206076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs return; 1207076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs } 1208076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs 1209076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs std::string MessageString; 1210076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs if (!PP.FinishLexStringLiteral(Tok, MessageString, PragmaKind(Kind), 1211076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs /*MacroExpansion=*/true)) 1212076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs return; 1213076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs 1214076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs if (ExpectClosingParen) { 1215076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs if (Tok.isNot(tok::r_paren)) { 1216076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind; 1217076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs return; 1218076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs } 1219076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs PP.Lex(Tok); // eat the r_paren. 1220076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs } 1221076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs 1222076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs if (Tok.isNot(tok::eod)) { 1223076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind; 1224076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs return; 1225076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs } 1226076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs 1227076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs // Output the message. 1228076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error) 1229076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs ? diag::err_pragma_message 1230076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs : diag::warn_pragma_message) << MessageString; 1231076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs 1232076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs // If the pragma is lexically sound, notify any interested PPCallbacks. 1233076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs if (PPCallbacks *Callbacks = PP.getPPCallbacks()) 1234076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString); 1235abfe094ce71c42656dcb84a3bdc3e79cb3c16fc3Chris Lattner } 1236abfe094ce71c42656dcb84a3bdc3e79cb3c16fc3Chris Lattner}; 1237abfe094ce71c42656dcb84a3bdc3e79cb3c16fc3Chris Lattner 1238b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// PragmaPushMacroHandler - "\#pragma push_macro" saves the value of the 1239f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner/// macro on the top of the stack. 1240f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattnerstruct PragmaPushMacroHandler : public PragmaHandler { 1241f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner PragmaPushMacroHandler() : PragmaHandler("push_macro") {} 1242651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 1243651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &PushMacroTok) override { 1244f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner PP.HandlePragmaPushMacro(PushMacroTok); 1245f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner } 1246f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner}; 1247f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 1248f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 1249b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// PragmaPopMacroHandler - "\#pragma pop_macro" sets the value of the 1250f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner/// macro to the value on the top of the stack. 1251f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattnerstruct PragmaPopMacroHandler : public PragmaHandler { 1252f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner PragmaPopMacroHandler() : PragmaHandler("pop_macro") {} 1253651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 1254651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &PopMacroTok) override { 1255f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner PP.HandlePragmaPopMacro(PopMacroTok); 1256f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner } 1257f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner}; 1258f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner 1259062f23246510393c19b537b68ec88b6a08ee8996Chris Lattner// Pragma STDC implementations. 12606c5cf4a2e234923ab66127de0874a71cb6bfdd83Chris Lattner 1261b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...". 1262062f23246510393c19b537b68ec88b6a08ee8996Chris Lattnerstruct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler { 12639b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {} 1264651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 1265651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &Tok) override { 12669d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne tok::OnOffSwitch OOS; 12679d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne if (PP.LexOnOffSwitch(OOS)) 12689d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne return; 12699d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne if (OOS == tok::OOS_ON) 12704d8aac3778b40c161bed9964125948ee01c08821Chris Lattner PP.Diag(Tok, diag::warn_stdc_fenv_access_not_supported); 1271062f23246510393c19b537b68ec88b6a08ee8996Chris Lattner } 1272062f23246510393c19b537b68ec88b6a08ee8996Chris Lattner}; 12731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1274b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...". 1275062f23246510393c19b537b68ec88b6a08ee8996Chris Lattnerstruct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler { 12769b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis PragmaSTDC_CX_LIMITED_RANGEHandler() 12779b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis : PragmaHandler("CX_LIMITED_RANGE") {} 1278651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 1279651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &Tok) override { 12809d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne tok::OnOffSwitch OOS; 12819d3f5f7550a2fab4178ed01425758c349b73a609Peter Collingbourne PP.LexOnOffSwitch(OOS); 1282062f23246510393c19b537b68ec88b6a08ee8996Chris Lattner } 1283062f23246510393c19b537b68ec88b6a08ee8996Chris Lattner}; 12841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1285b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// PragmaSTDC_UnknownHandler - "\#pragma STDC ...". 1286062f23246510393c19b537b68ec88b6a08ee8996Chris Lattnerstruct PragmaSTDC_UnknownHandler : public PragmaHandler { 12879b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis PragmaSTDC_UnknownHandler() {} 1288651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 1289651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &UnknownTok) override { 12906c5cf4a2e234923ab66127de0874a71cb6bfdd83Chris Lattner // C99 6.10.6p2, unknown forms are not allowed. 1291f545be5552b6fd40a4c766fbf82dab0ab5305790Chris Lattner PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored); 1292062f23246510393c19b537b68ec88b6a08ee8996Chris Lattner } 1293062f23246510393c19b537b68ec88b6a08ee8996Chris Lattner}; 12941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 12958dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall/// PragmaARCCFCodeAuditedHandler - 1296b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// \#pragma clang arc_cf_code_audited begin/end 12978dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCallstruct PragmaARCCFCodeAuditedHandler : public PragmaHandler { 12988dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {} 1299651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 1300651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &NameTok) override { 13018dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall SourceLocation Loc = NameTok.getLocation(); 13028dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall bool IsBegin; 13038dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall 13048dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall Token Tok; 13058dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall 13068dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall // Lex the 'begin' or 'end'. 13078dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall PP.LexUnexpandedToken(Tok); 13088dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo(); 13098dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall if (BeginEnd && BeginEnd->isStr("begin")) { 13108dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall IsBegin = true; 13118dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall } else if (BeginEnd && BeginEnd->isStr("end")) { 13128dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall IsBegin = false; 13138dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall } else { 13148dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall PP.Diag(Tok.getLocation(), diag::err_pp_arc_cf_code_audited_syntax); 13158dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall return; 13168dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall } 13178dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall 13188dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall // Verify that this is followed by EOD. 13198dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall PP.LexUnexpandedToken(Tok); 13208dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall if (Tok.isNot(tok::eod)) 13218dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma"; 13228dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall 13238dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall // The start location of the active audit. 13248dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall SourceLocation BeginLoc = PP.getPragmaARCCFCodeAuditedLoc(); 13258dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall 13268dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall // The start location we want after processing this. 13278dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall SourceLocation NewLoc; 13288dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall 13298dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall if (IsBegin) { 13308dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall // Complain about attempts to re-enter an audit. 13318dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall if (BeginLoc.isValid()) { 13328dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall PP.Diag(Loc, diag::err_pp_double_begin_of_arc_cf_code_audited); 13338dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall PP.Diag(BeginLoc, diag::note_pragma_entered_here); 13348dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall } 13358dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall NewLoc = Loc; 13368dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall } else { 13378dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall // Complain about attempts to leave an audit that doesn't exist. 13388dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall if (!BeginLoc.isValid()) { 13398dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited); 13408dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall return; 13418dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall } 13428dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall NewLoc = SourceLocation(); 13438dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall } 13448dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall 13458dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall PP.setPragmaARCCFCodeAuditedLoc(NewLoc); 13468dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall } 13478dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall}; 13488dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall 1349a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar/// PragmaAssumeNonNullHandler - 1350a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar/// \#pragma clang assume_nonnull begin/end 1351a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainarstruct PragmaAssumeNonNullHandler : public PragmaHandler { 1352a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar PragmaAssumeNonNullHandler() : PragmaHandler("assume_nonnull") {} 1353a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 1354a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar Token &NameTok) override { 1355a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar SourceLocation Loc = NameTok.getLocation(); 1356a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar bool IsBegin; 1357a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar 1358a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar Token Tok; 1359a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar 1360a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar // Lex the 'begin' or 'end'. 1361a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar PP.LexUnexpandedToken(Tok); 1362a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo(); 1363a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar if (BeginEnd && BeginEnd->isStr("begin")) { 1364a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar IsBegin = true; 1365a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar } else if (BeginEnd && BeginEnd->isStr("end")) { 1366a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar IsBegin = false; 1367a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar } else { 1368a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar PP.Diag(Tok.getLocation(), diag::err_pp_assume_nonnull_syntax); 1369a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar return; 1370a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar } 1371a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar 1372a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar // Verify that this is followed by EOD. 1373a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar PP.LexUnexpandedToken(Tok); 1374a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar if (Tok.isNot(tok::eod)) 1375a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma"; 1376a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar 1377a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar // The start location of the active audit. 1378a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar SourceLocation BeginLoc = PP.getPragmaAssumeNonNullLoc(); 1379a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar 1380a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar // The start location we want after processing this. 1381a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar SourceLocation NewLoc; 1382a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar 1383a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar if (IsBegin) { 1384a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar // Complain about attempts to re-enter an audit. 1385a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar if (BeginLoc.isValid()) { 1386a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar PP.Diag(Loc, diag::err_pp_double_begin_of_assume_nonnull); 1387a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar PP.Diag(BeginLoc, diag::note_pragma_entered_here); 1388a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar } 1389a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar NewLoc = Loc; 1390a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar } else { 1391a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar // Complain about attempts to leave an audit that doesn't exist. 1392a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar if (!BeginLoc.isValid()) { 1393a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull); 1394a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar return; 1395a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar } 1396a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar NewLoc = SourceLocation(); 1397a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar } 1398a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar 1399a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar PP.setPragmaAssumeNonNullLoc(NewLoc); 1400a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar } 1401a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar}; 1402a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar 1403ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer/// \brief Handle "\#pragma region [...]" 1404ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer/// 1405ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer/// The syntax is 1406ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer/// \code 1407ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer/// #pragma region [optional name] 1408ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer/// #pragma endregion [optional comment] 1409ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer/// \endcode 1410ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer/// 1411ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer/// \note This is 1412ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer/// <a href="http://msdn.microsoft.com/en-us/library/b6xkz944(v=vs.80).aspx">editor-only</a> 1413ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer/// pragma, just skipped by compiler. 1414ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemerstruct PragmaRegionHandler : public PragmaHandler { 1415ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) { } 1416ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer 1417651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 1418651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines Token &NameTok) override { 1419ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer // #pragma region: endregion matches can be verified 1420ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer // __pragma(region): no sense, but ignored by msvc 1421ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer // _Pragma is not valid for MSVC, but there isn't any point 1422ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer // to handle a _Pragma differently. 1423ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer } 1424ad5f8336f96911805bb625cc4fb1a4487745508aDavid Majnemer}; 1425fafd101e6b557595ffbb5e9e9b47a3fc0385dc19Aaron Ballman 14265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} // end anonymous namespace 14275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 14285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 14295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// RegisterBuiltinPragmas - Install the standard preprocessor pragmas: 1430b6e95b7752893f66e9d067b4287dff2dbf4a5802James Dennett/// \#pragma GCC poison/system_header/dependency and \#pragma once. 14315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid Preprocessor::RegisterBuiltinPragmas() { 14329b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis AddPragmaHandler(new PragmaOnceHandler()); 14339b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis AddPragmaHandler(new PragmaMarkHandler()); 1434f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner AddPragmaHandler(new PragmaPushMacroHandler()); 1435f47724bf78299c7a50f008e0443c5f9f9f279ddcChris Lattner AddPragmaHandler(new PragmaPopMacroHandler()); 1436076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message)); 14371eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1438e8fa06e07363b6d5e6c371bbd454d51bab78d01dChris Lattner // #pragma GCC ... 14399b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis AddPragmaHandler("GCC", new PragmaPoisonHandler()); 14409b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis AddPragmaHandler("GCC", new PragmaSystemHeaderHandler()); 14419b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis AddPragmaHandler("GCC", new PragmaDependencyHandler()); 1442c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC")); 1443076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning, 1444076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs "GCC")); 1445076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error, 1446076eea20b80024fc63bbd71fb019375983680ea6Andy Gibbs "GCC")); 1447e8fa06e07363b6d5e6c371bbd454d51bab78d01dChris Lattner // #pragma clang ... 14489b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis AddPragmaHandler("clang", new PragmaPoisonHandler()); 14499b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis AddPragmaHandler("clang", new PragmaSystemHeaderHandler()); 1450abf7b72a965efba4a5ac6f85c66d5aba0c83f972Daniel Dunbar AddPragmaHandler("clang", new PragmaDebugHandler()); 14519b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis AddPragmaHandler("clang", new PragmaDependencyHandler()); 1452c09ce1224dedc470fce9747e5936ff83cc6762ebDouglas Gregor AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang")); 14538dfac0baaf0f81d3945bcb306480e358ba8d1f08John McCall AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler()); 1454a4de17562d13d7a8188108243c4cfbd52f33229aPirama Arumuga Nainar AddPragmaHandler("clang", new PragmaAssumeNonNullHandler()); 14559b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis 14569b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis AddPragmaHandler("STDC", new PragmaSTDC_FENV_ACCESSHandler()); 14579b36c3f0de0105e903130bbda3c4aea7d792c0afArgyrios Kyrtzidis AddPragmaHandler("STDC", new PragmaSTDC_CX_LIMITED_RANGEHandler()); 1458062f23246510393c19b537b68ec88b6a08ee8996Chris Lattner AddPragmaHandler("STDC", new PragmaSTDC_UnknownHandler()); 14591eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1460636c5ef6572e899d36cec1b0023fb28ba65189e1Chris Lattner // MS extensions. 14614e4d08403ca5cfd4d558fa2936215d3a4e5a528dDavid Blaikie if (LangOpts.MicrosoftExt) { 14622ee042dee9f7693665e28463955401905474a284Reid Kleckner AddPragmaHandler(new PragmaWarningHandler()); 14634c55c54db8e676aa3e042188773d9d82d59fff91Aaron Ballman AddPragmaHandler(new PragmaIncludeAliasHandler()); 1464fafd101e6b557595ffbb5e9e9b47a3fc0385dc19Aaron Ballman AddPragmaHandler(new PragmaRegionHandler("region")); 1465fafd101e6b557595ffbb5e9e9b47a3fc0385dc19Aaron Ballman AddPragmaHandler(new PragmaRegionHandler("endregion")); 1466abfe094ce71c42656dcb84a3bdc3e79cb3c16fc3Chris Lattner } 14675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 14686bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines 14696bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines/// Ignore all pragmas, useful for modes such as -Eonly which would otherwise 14706bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines/// warn about those pragmas being unknown. 14716bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hinesvoid Preprocessor::IgnorePragmas() { 14726bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines AddPragmaHandler(new EmptyPragmaHandler()); 14736bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // Also ignore all pragmas in all namespaces created 14746bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // in Preprocessor::RegisterBuiltinPragmas(). 14756bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines AddPragmaHandler("GCC", new EmptyPragmaHandler()); 14766bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines AddPragmaHandler("clang", new EmptyPragmaHandler()); 14776bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (PragmaHandler *NS = PragmaHandlers->FindHandler("STDC")) { 14786bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // Preprocessor::RegisterBuiltinPragmas() already registers 14796bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // PragmaSTDC_UnknownHandler as the empty handler, so remove it first, 14806bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines // otherwise there will be an assert about a duplicate handler. 14816bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines PragmaNamespace *STDCNamespace = NS->getIfNamespace(); 14826bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines assert(STDCNamespace && 14836bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines "Invalid namespace, registered as a regular pragma handler!"); 14846bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines if (PragmaHandler *Existing = STDCNamespace->FindHandler("", false)) { 14856bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines RemovePragmaHandler("STDC", Existing); 14866bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines delete Existing; 14876bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines } 14886bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines } 14896bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines AddPragmaHandler("STDC", new EmptyPragmaHandler()); 14906bcf27bb9a4b5c3f79cb44c0e4654a6d7619ad89Stephen Hines} 1491