contrib/llvm/tools/clang/lib/Lex/Pragma.cpp

   1 //===--- Pragma.cpp - Pragma registration and handling --------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the PragmaHandler/PragmaTable interfaces and implements
  11 // pragma related methods of the Preprocessor class.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Lex/Pragma.h"
  16 #include "clang/Basic/FileManager.h"
  17 #include "clang/Basic/SourceManager.h"
  18 #include "clang/Lex/HeaderSearch.h"
  19 #include "clang/Lex/LexDiagnostic.h"
  20 #include "clang/Lex/LiteralSupport.h"
  21 #include "clang/Lex/MacroInfo.h"
  22 #include "clang/Lex/Preprocessor.h"
  23 #include "llvm/ADT/STLExtras.h"
  24 #include "llvm/ADT/StringSwitch.h"
  25 #include "llvm/ADT/StringExtras.h"
  26 #include "llvm/Support/CrashRecoveryContext.h"
  27 #include "llvm/Support/ErrorHandling.h"
  28 #include <algorithm>
  29 using namespace clang;
  30
  31 #include "llvm/Support/raw_ostream.h"
  32
  33 // Out-of-line destructor to provide a home for the class.
  34 PragmaHandler::~PragmaHandler() {
  35 }
  36
  37 //===----------------------------------------------------------------------===//
  38 // EmptyPragmaHandler Implementation.
  39 //===----------------------------------------------------------------------===//
  40
  41 EmptyPragmaHandler::EmptyPragmaHandler(StringRef Name) : PragmaHandler(Name) {}
  42
  43 void EmptyPragmaHandler::HandlePragma(Preprocessor &PP,
  44                                       PragmaIntroducerKind Introducer,
  45                                       Token &FirstToken) {}
  46
  47 //===----------------------------------------------------------------------===//
  48 // PragmaNamespace Implementation.
  49 //===----------------------------------------------------------------------===//
  50
  51 PragmaNamespace::~PragmaNamespace() {
  52   llvm::DeleteContainerSeconds(Handlers);
  53 }
  54
  55 /// FindHandler - Check to see if there is already a handler for the
  56 /// specified name.  If not, return the handler for the null identifier if it
  57 /// exists, otherwise return null.  If IgnoreNull is true (the default) then
  58 /// the null handler isn't returned on failure to match.
  59 PragmaHandler *PragmaNamespace::FindHandler(StringRef Name,
  60                                             bool IgnoreNull) const {
  61   if (PragmaHandler *Handler = Handlers.lookup(Name))
  62     return Handler;
  63   return IgnoreNull ? nullptr : Handlers.lookup(StringRef());
  64 }
  65
  66 void PragmaNamespace::AddPragma(PragmaHandler *Handler) {
  67   assert(!Handlers.lookup(Handler->getName()) &&
  68          "A handler with this name is already registered in this namespace");
  69   Handlers[Handler->getName()] = Handler;
  70 }
  71
  72 void PragmaNamespace::RemovePragmaHandler(PragmaHandler *Handler) {
  73   assert(Handlers.lookup(Handler->getName()) &&
  74          "Handler not registered in this namespace");
  75   Handlers.erase(Handler->getName());
  76 }
  77
  78 void PragmaNamespace::HandlePragma(Preprocessor &PP,
  79                                    PragmaIntroducerKind Introducer,
  80                                    Token &Tok) {
  81   // Read the 'namespace' that the directive is in, e.g. STDC.  Do not macro
  82   // expand it, the user can have a STDC #define, that should not affect this.
  83   PP.LexUnexpandedToken(Tok);
  84
  85   // Get the handler for this token.  If there is no handler, ignore the pragma.
  86   PragmaHandler *Handler
  87     = FindHandler(Tok.getIdentifierInfo() ? Tok.getIdentifierInfo()->getName()
  88                                           : StringRef(),
  89                   /*IgnoreNull=*/false);
  90   if (!Handler) {
  91     PP.Diag(Tok, diag::warn_pragma_ignored);
  92     return;
  93   }
  94
  95   // Otherwise, pass it down.
  96   Handler->HandlePragma(PP, Introducer, Tok);
  97 }
  98
  99 //===----------------------------------------------------------------------===//
 100 // Preprocessor Pragma Directive Handling.
 101 //===----------------------------------------------------------------------===//
 102
 103 /// HandlePragmaDirective - The "\#pragma" directive has been parsed.  Lex the
 104 /// rest of the pragma, passing it to the registered pragma handlers.
 105 void Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc,
 106                                          PragmaIntroducerKind Introducer) {
 107   if (Callbacks)
 108     Callbacks->PragmaDirective(IntroducerLoc, Introducer);
 109
 110   if (!PragmasEnabled)
 111     return;
 112
 113   ++NumPragma;
 114
 115   // Invoke the first level of pragma handlers which reads the namespace id.
 116   Token Tok;
 117   PragmaHandlers->HandlePragma(*this, Introducer, Tok);
 118
 119   // If the pragma handler didn't read the rest of the line, consume it now.
 120   if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective())
 121    || (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective))
 122     DiscardUntilEndOfDirective();
 123 }
 124
 125 namespace {
 126 /// \brief Helper class for \see Preprocessor::Handle_Pragma.
 127 class LexingFor_PragmaRAII {
 128   Preprocessor &PP;
 129   bool InMacroArgPreExpansion;
 130   bool Failed;
 131   Token &OutTok;
 132   Token PragmaTok;
 133
 134 public:
 135   LexingFor_PragmaRAII(Preprocessor &PP, bool InMacroArgPreExpansion,
 136                        Token &Tok)
 137     : PP(PP), InMacroArgPreExpansion(InMacroArgPreExpansion),
 138       Failed(false), OutTok(Tok) {
 139     if (InMacroArgPreExpansion) {
 140       PragmaTok = OutTok;
 141       PP.EnableBacktrackAtThisPos();
 142     }
 143   }
 144
 145   ~LexingFor_PragmaRAII() {
 146     if (InMacroArgPreExpansion) {
 147       if (Failed) {
 148         PP.CommitBacktrackedTokens();
 149       } else {
 150         PP.Backtrack();
 151         OutTok = PragmaTok;
 152       }
 153     }
 154   }
 155
 156   void failed() {
 157     Failed = true;
 158   }
 159 };
 160 }
 161
 162 /// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then
 163 /// return the first token after the directive.  The _Pragma token has just
 164 /// been read into 'Tok'.
 165 void Preprocessor::Handle_Pragma(Token &Tok) {
 166
 167   // This works differently if we are pre-expanding a macro argument.
 168   // In that case we don't actually "activate" the pragma now, we only lex it
 169   // until we are sure it is lexically correct and then we backtrack so that
 170   // we activate the pragma whenever we encounter the tokens again in the token
 171   // stream. This ensures that we will activate it in the correct location
 172   // or that we will ignore it if it never enters the token stream, e.g:
 173   //
 174   //     #define EMPTY(x)
 175   //     #define INACTIVE(x) EMPTY(x)
 176   //     INACTIVE(_Pragma("clang diagnostic ignored \"-Wconversion\""))
 177
 178   LexingFor_PragmaRAII _PragmaLexing(*this, InMacroArgPreExpansion, Tok);
 179
 180   // Remember the pragma token location.
 181   SourceLocation PragmaLoc = Tok.getLocation();
 182
 183   // Read the '('.
 184   Lex(Tok);
 185   if (Tok.isNot(tok::l_paren)) {
 186     Diag(PragmaLoc, diag::err__Pragma_malformed);
 187     return _PragmaLexing.failed();
 188   }
 189
 190   // Read the '"..."'.
 191   Lex(Tok);
 192   if (!tok::isStringLiteral(Tok.getKind())) {
 193     Diag(PragmaLoc, diag::err__Pragma_malformed);
 194     // Skip bad tokens, and the ')', if present.
 195     if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::eof))
 196       Lex(Tok);
 197     while (Tok.isNot(tok::r_paren) &&
 198            !Tok.isAtStartOfLine() &&
 199            Tok.isNot(tok::eof))
 200       Lex(Tok);
 201     if (Tok.is(tok::r_paren))
 202       Lex(Tok);
 203     return _PragmaLexing.failed();
 204   }
 205
 206   if (Tok.hasUDSuffix()) {
 207     Diag(Tok, diag::err_invalid_string_udl);
 208     // Skip this token, and the ')', if present.
 209     Lex(Tok);
 210     if (Tok.is(tok::r_paren))
 211       Lex(Tok);
 212     return _PragmaLexing.failed();
 213   }
 214
 215   // Remember the string.
 216   Token StrTok = Tok;
 217
 218   // Read the ')'.
 219   Lex(Tok);
 220   if (Tok.isNot(tok::r_paren)) {
 221     Diag(PragmaLoc, diag::err__Pragma_malformed);
 222     return _PragmaLexing.failed();
 223   }
 224
 225   if (InMacroArgPreExpansion)
 226     return;
 227
 228   SourceLocation RParenLoc = Tok.getLocation();
 229   std::string StrVal = getSpelling(StrTok);
 230
 231   // The _Pragma is lexically sound.  Destringize according to C11 6.10.9.1:
 232   // "The string literal is destringized by deleting any encoding prefix,
 233   // deleting the leading and trailing double-quotes, replacing each escape
 234   // sequence \" by a double-quote, and replacing each escape sequence \\ by a
 235   // single backslash."
 236   if (StrVal[0] == 'L' || StrVal[0] == 'U' ||
 237       (StrVal[0] == 'u' && StrVal[1] != '8'))
 238     StrVal.erase(StrVal.begin());
 239   else if (StrVal[0] == 'u')
 240     StrVal.erase(StrVal.begin(), StrVal.begin() + 2);
 241
 242   if (StrVal[0] == 'R') {
 243     // FIXME: C++11 does not specify how to handle raw-string-literals here.
 244     // We strip off the 'R', the quotes, the d-char-sequences, and the parens.
 245     assert(StrVal[1] == '"' && StrVal[StrVal.size() - 1] == '"' &&
 246            "Invalid raw string token!");
 247
 248     // Measure the length of the d-char-sequence.
 249     unsigned NumDChars = 0;
 250     while (StrVal[2 + NumDChars] != '(') {
 251       assert(NumDChars < (StrVal.size() - 5) / 2 &&
 252              "Invalid raw string token!");
 253       ++NumDChars;
 254     }
 255     assert(StrVal[StrVal.size() - 2 - NumDChars] == ')');
 256
 257     // Remove 'R " d-char-sequence' and 'd-char-sequence "'. We'll replace the
 258     // parens below.
 259     StrVal.erase(0, 2 + NumDChars);
 260     StrVal.erase(StrVal.size() - 1 - NumDChars);
 261   } else {
 262     assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&
 263            "Invalid string token!");
 264
 265     // Remove escaped quotes and escapes.
 266     unsigned ResultPos = 1;
 267     for (unsigned i = 1, e = StrVal.size() - 1; i != e; ++i) {
 268       // Skip escapes.  \\ -> '\' and \" -> '"'.
 269       if (StrVal[i] == '\\' && i + 1 < e &&
 270           (StrVal[i + 1] == '\\' || StrVal[i + 1] == '"'))
 271         ++i;
 272       StrVal[ResultPos++] = StrVal[i];
 273     }
 274     StrVal.erase(StrVal.begin() + ResultPos, StrVal.end() - 1);
 275   }
 276
 277   // Remove the front quote, replacing it with a space, so that the pragma
 278   // contents appear to have a space before them.
 279   StrVal[0] = ' ';
 280
 281   // Replace the terminating quote with a \n.
 282   StrVal[StrVal.size()-1] = '\n';
 283
 284   // Plop the string (including the newline and trailing null) into a buffer
 285   // where we can lex it.
 286   Token TmpTok;
 287   TmpTok.startToken();
 288   CreateString(StrVal, TmpTok);
 289   SourceLocation TokLoc = TmpTok.getLocation();
 290
 291   // Make and enter a lexer object so that we lex and expand the tokens just
 292   // like any others.
 293   Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc,
 294                                         StrVal.size(), *this);
 295
 296   EnterSourceFileWithLexer(TL, nullptr);
 297
 298   // With everything set up, lex this as a #pragma directive.
 299   HandlePragmaDirective(PragmaLoc, PIK__Pragma);
 300
 301   // Finally, return whatever came after the pragma directive.
 302   return Lex(Tok);
 303 }
 304
 305 /// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text
 306 /// is not enclosed within a string literal.
 307 void Preprocessor::HandleMicrosoft__pragma(Token &Tok) {
 308   // Remember the pragma token location.
 309   SourceLocation PragmaLoc = Tok.getLocation();
 310
 311   // Read the '('.
 312   Lex(Tok);
 313   if (Tok.isNot(tok::l_paren)) {
 314     Diag(PragmaLoc, diag::err__Pragma_malformed);
 315     return;
 316   }
 317
 318   // Get the tokens enclosed within the __pragma(), as well as the final ')'.
 319   SmallVector<Token, 32> PragmaToks;
 320   int NumParens = 0;
 321   Lex(Tok);
 322   while (Tok.isNot(tok::eof)) {
 323     PragmaToks.push_back(Tok);
 324     if (Tok.is(tok::l_paren))
 325       NumParens++;
 326     else if (Tok.is(tok::r_paren) && NumParens-- == 0)
 327       break;
 328     Lex(Tok);
 329   }
 330
 331   if (Tok.is(tok::eof)) {
 332     Diag(PragmaLoc, diag::err_unterminated___pragma);
 333     return;
 334   }
 335
 336   PragmaToks.front().setFlag(Token::LeadingSpace);
 337
 338   // Replace the ')' with an EOD to mark the end of the pragma.
 339   PragmaToks.back().setKind(tok::eod);
 340
 341   Token *TokArray = new Token[PragmaToks.size()];
 342   std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray);
 343
 344   // Push the tokens onto the stack.
 345   EnterTokenStream(TokArray, PragmaToks.size(), true, true);
 346
 347   // With everything set up, lex this as a #pragma directive.
 348   HandlePragmaDirective(PragmaLoc, PIK___pragma);
 349
 350   // Finally, return whatever came after the pragma directive.
 351   return Lex(Tok);
 352 }
 353
 354 /// HandlePragmaOnce - Handle \#pragma once.  OnceTok is the 'once'.
 355 ///
 356 void Preprocessor::HandlePragmaOnce(Token &OnceTok) {
 357   if (isInPrimaryFile()) {
 358     Diag(OnceTok, diag::pp_pragma_once_in_main_file);
 359     return;
 360   }
 361
 362   // Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
 363   // Mark the file as a once-only file now.
 364   HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry());
 365 }
 366
 367 void Preprocessor::HandlePragmaMark() {
 368   assert(CurPPLexer && "No current lexer?");
 369   if (CurLexer)
 370     CurLexer->ReadToEndOfLine();
 371   else
 372     CurPTHLexer->DiscardToEndOfLine();
 373 }
 374
 375
 376 /// HandlePragmaPoison - Handle \#pragma GCC poison.  PoisonTok is the 'poison'.
 377 ///
 378 void Preprocessor::HandlePragmaPoison(Token &PoisonTok) {
 379   Token Tok;
 380
 381   while (1) {
 382     // Read the next token to poison.  While doing this, pretend that we are
 383     // skipping while reading the identifier to poison.
 384     // This avoids errors on code like:
 385     //   #pragma GCC poison X
 386     //   #pragma GCC poison X
 387     if (CurPPLexer) CurPPLexer->LexingRawMode = true;
 388     LexUnexpandedToken(Tok);
 389     if (CurPPLexer) CurPPLexer->LexingRawMode = false;
 390
 391     // If we reached the end of line, we're done.
 392     if (Tok.is(tok::eod)) return;
 393
 394     // Can only poison identifiers.
 395     if (Tok.isNot(tok::raw_identifier)) {
 396       Diag(Tok, diag::err_pp_invalid_poison);
 397       return;
 398     }
 399
 400     // Look up the identifier info for the token.  We disabled identifier lookup
 401     // by saying we're skipping contents, so we need to do this manually.
 402     IdentifierInfo *II = LookUpIdentifierInfo(Tok);
 403
 404     // Already poisoned.
 405     if (II->isPoisoned()) continue;
 406
 407     // If this is a macro identifier, emit a warning.
 408     if (isMacroDefined(II))
 409       Diag(Tok, diag::pp_poisoning_existing_macro);
 410
 411     // Finally, poison it!
 412     II->setIsPoisoned();
 413     if (II->isFromAST())
 414       II->setChangedSinceDeserialization();
 415   }
 416 }
 417
 418 /// HandlePragmaSystemHeader - Implement \#pragma GCC system_header.  We know
 419 /// that the whole directive has been parsed.
 420 void Preprocessor::HandlePragmaSystemHeader(Token &SysHeaderTok) {
 421   if (isInPrimaryFile()) {
 422     Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file);
 423     return;
 424   }
 425
 426   // Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
 427   PreprocessorLexer *TheLexer = getCurrentFileLexer();
 428
 429   // Mark the file as a system header.
 430   HeaderInfo.MarkFileSystemHeader(TheLexer->getFileEntry());
 431
 432
 433   PresumedLoc PLoc = SourceMgr.getPresumedLoc(SysHeaderTok.getLocation());
 434   if (PLoc.isInvalid())
 435     return;
 436
 437   unsigned FilenameID = SourceMgr.getLineTableFilenameID(PLoc.getFilename());
 438
 439   // Notify the client, if desired, that we are in a new source file.
 440   if (Callbacks)
 441     Callbacks->FileChanged(SysHeaderTok.getLocation(),
 442                            PPCallbacks::SystemHeaderPragma, SrcMgr::C_System);
 443
 444   // Emit a line marker.  This will change any source locations from this point
 445   // forward to realize they are in a system header.
 446   // Create a line note with this information.
 447   SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine()+1,
 448                         FilenameID, /*IsEntry=*/false, /*IsExit=*/false,
 449                         /*IsSystem=*/true, /*IsExternC=*/false);
 450 }
 451
 452 /// HandlePragmaDependency - Handle \#pragma GCC dependency "foo" blah.
 453 ///
 454 void Preprocessor::HandlePragmaDependency(Token &DependencyTok) {
 455   Token FilenameTok;
 456   CurPPLexer->LexIncludeFilename(FilenameTok);
 457
 458   // If the token kind is EOD, the error has already been diagnosed.
 459   if (FilenameTok.is(tok::eod))
 460     return;
 461
 462   // Reserve a buffer to get the spelling.
 463   SmallString<128> FilenameBuffer;
 464   bool Invalid = false;
 465   StringRef Filename = getSpelling(FilenameTok, FilenameBuffer, &Invalid);
 466   if (Invalid)
 467     return;
 468
 469   bool isAngled =
 470     GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
 471   // If GetIncludeFilenameSpelling set the start ptr to null, there was an
 472   // error.
 473   if (Filename.empty())
 474     return;
 475
 476   // Search include directories for this file.
 477   const DirectoryLookup *CurDir;
 478   const FileEntry *File =
 479       LookupFile(FilenameTok.getLocation(), Filename, isAngled, nullptr,
 480                  nullptr, CurDir, nullptr, nullptr, nullptr);
 481   if (!File) {
 482     if (!SuppressIncludeNotFoundError)
 483       Diag(FilenameTok, diag::err_pp_file_not_found) << Filename;
 484     return;
 485   }
 486
 487   const FileEntry *CurFile = getCurrentFileLexer()->getFileEntry();
 488
 489   // If this file is older than the file it depends on, emit a diagnostic.
 490   if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) {
 491     // Lex tokens at the end of the message and include them in the message.
 492     std::string Message;
 493     Lex(DependencyTok);
 494     while (DependencyTok.isNot(tok::eod)) {
 495       Message += getSpelling(DependencyTok) + " ";
 496       Lex(DependencyTok);
 497     }
 498
 499     // Remove the trailing ' ' if present.
 500     if (!Message.empty())
 501       Message.erase(Message.end()-1);
 502     Diag(FilenameTok, diag::pp_out_of_date_dependency) << Message;
 503   }
 504 }
 505
 506 /// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro.
 507 /// Return the IdentifierInfo* associated with the macro to push or pop.
 508 IdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) {
 509   // Remember the pragma token location.
 510   Token PragmaTok = Tok;
 511
 512   // Read the '('.
 513   Lex(Tok);
 514   if (Tok.isNot(tok::l_paren)) {
 515     Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
 516       << getSpelling(PragmaTok);
 517     return nullptr;
 518   }
 519
 520   // Read the macro name string.
 521   Lex(Tok);
 522   if (Tok.isNot(tok::string_literal)) {
 523     Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
 524       << getSpelling(PragmaTok);
 525     return nullptr;
 526   }
 527
 528   if (Tok.hasUDSuffix()) {
 529     Diag(Tok, diag::err_invalid_string_udl);
 530     return nullptr;
 531   }
 532
 533   // Remember the macro string.
 534   std::string StrVal = getSpelling(Tok);
 535
 536   // Read the ')'.
 537   Lex(Tok);
 538   if (Tok.isNot(tok::r_paren)) {
 539     Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
 540       << getSpelling(PragmaTok);
 541     return nullptr;
 542   }
 543
 544   assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&
 545          "Invalid string token!");
 546
 547   // Create a Token from the string.
 548   Token MacroTok;
 549   MacroTok.startToken();
 550   MacroTok.setKind(tok::raw_identifier);
 551   CreateString(StringRef(&StrVal[1], StrVal.size() - 2), MacroTok);
 552
 553   // Get the IdentifierInfo of MacroToPushTok.
 554   return LookUpIdentifierInfo(MacroTok);
 555 }
 556
 557 /// \brief Handle \#pragma push_macro.
 558 ///
 559 /// The syntax is:
 560 /// \code
 561 ///   #pragma push_macro("macro")
 562 /// \endcode
 563 void Preprocessor::HandlePragmaPushMacro(Token &PushMacroTok) {
 564   // Parse the pragma directive and get the macro IdentifierInfo*.
 565   IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PushMacroTok);
 566   if (!IdentInfo) return;
 567
 568   // Get the MacroInfo associated with IdentInfo.
 569   MacroInfo *MI = getMacroInfo(IdentInfo);
 570
 571   if (MI) {
 572     // Allow the original MacroInfo to be redefined later.
 573     MI->setIsAllowRedefinitionsWithoutWarning(true);
 574   }
 575
 576   // Push the cloned MacroInfo so we can retrieve it later.
 577   PragmaPushMacroInfo[IdentInfo].push_back(MI);
 578 }
 579
 580 /// \brief Handle \#pragma pop_macro.
 581 ///
 582 /// The syntax is:
 583 /// \code
 584 ///   #pragma pop_macro("macro")
 585 /// \endcode
 586 void Preprocessor::HandlePragmaPopMacro(Token &PopMacroTok) {
 587   SourceLocation MessageLoc = PopMacroTok.getLocation();
 588
 589   // Parse the pragma directive and get the macro IdentifierInfo*.
 590   IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PopMacroTok);
 591   if (!IdentInfo) return;
 592
 593   // Find the vector<MacroInfo*> associated with the macro.
 594   llvm::DenseMap<IdentifierInfo*, std::vector<MacroInfo*> >::iterator iter =
 595     PragmaPushMacroInfo.find(IdentInfo);
 596   if (iter != PragmaPushMacroInfo.end()) {
 597     // Forget the MacroInfo currently associated with IdentInfo.
 598     if (MacroInfo *MI = getMacroInfo(IdentInfo)) {
 599       if (MI->isWarnIfUnused())
 600         WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
 601       appendMacroDirective(IdentInfo, AllocateUndefMacroDirective(MessageLoc));
 602     }
 603
 604     // Get the MacroInfo we want to reinstall.
 605     MacroInfo *MacroToReInstall = iter->second.back();
 606
 607     if (MacroToReInstall)
 608       // Reinstall the previously pushed macro.
 609       appendDefMacroDirective(IdentInfo, MacroToReInstall, MessageLoc);
 610
 611     // Pop PragmaPushMacroInfo stack.
 612     iter->second.pop_back();
 613     if (iter->second.size() == 0)
 614       PragmaPushMacroInfo.erase(iter);
 615   } else {
 616     Diag(MessageLoc, diag::warn_pragma_pop_macro_no_push)
 617       << IdentInfo->getName();
 618   }
 619 }
 620
 621 void Preprocessor::HandlePragmaIncludeAlias(Token &Tok) {
 622   // We will either get a quoted filename or a bracketed filename, and we
 623   // have to track which we got.  The first filename is the source name,
 624   // and the second name is the mapped filename.  If the first is quoted,
 625   // the second must be as well (cannot mix and match quotes and brackets).
 626
 627   // Get the open paren
 628   Lex(Tok);
 629   if (Tok.isNot(tok::l_paren)) {
 630     Diag(Tok, diag::warn_pragma_include_alias_expected) << "(";
 631     return;
 632   }
 633
 634   // We expect either a quoted string literal, or a bracketed name
 635   Token SourceFilenameTok;
 636   CurPPLexer->LexIncludeFilename(SourceFilenameTok);
 637   if (SourceFilenameTok.is(tok::eod)) {
 638     // The diagnostic has already been handled
 639     return;
 640   }
 641
 642   StringRef SourceFileName;
 643   SmallString<128> FileNameBuffer;
 644   if (SourceFilenameTok.is(tok::string_literal) ||
 645       SourceFilenameTok.is(tok::angle_string_literal)) {
 646     SourceFileName = getSpelling(SourceFilenameTok, FileNameBuffer);
 647   } else if (SourceFilenameTok.is(tok::less)) {
 648     // This could be a path instead of just a name
 649     FileNameBuffer.push_back('<');
 650     SourceLocation End;
 651     if (ConcatenateIncludeName(FileNameBuffer, End))
 652       return; // Diagnostic already emitted
 653     SourceFileName = FileNameBuffer;
 654   } else {
 655     Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
 656     return;
 657   }
 658   FileNameBuffer.clear();
 659
 660   // Now we expect a comma, followed by another include name
 661   Lex(Tok);
 662   if (Tok.isNot(tok::comma)) {
 663     Diag(Tok, diag::warn_pragma_include_alias_expected) << ",";
 664     return;
 665   }
 666
 667   Token ReplaceFilenameTok;
 668   CurPPLexer->LexIncludeFilename(ReplaceFilenameTok);
 669   if (ReplaceFilenameTok.is(tok::eod)) {
 670     // The diagnostic has already been handled
 671     return;
 672   }
 673
 674   StringRef ReplaceFileName;
 675   if (ReplaceFilenameTok.is(tok::string_literal) ||
 676       ReplaceFilenameTok.is(tok::angle_string_literal)) {
 677     ReplaceFileName = getSpelling(ReplaceFilenameTok, FileNameBuffer);
 678   } else if (ReplaceFilenameTok.is(tok::less)) {
 679     // This could be a path instead of just a name
 680     FileNameBuffer.push_back('<');
 681     SourceLocation End;
 682     if (ConcatenateIncludeName(FileNameBuffer, End))
 683       return; // Diagnostic already emitted
 684     ReplaceFileName = FileNameBuffer;
 685   } else {
 686     Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
 687     return;
 688   }
 689
 690   // Finally, we expect the closing paren
 691   Lex(Tok);
 692   if (Tok.isNot(tok::r_paren)) {
 693     Diag(Tok, diag::warn_pragma_include_alias_expected) << ")";
 694     return;
 695   }
 696
 697   // Now that we have the source and target filenames, we need to make sure
 698   // they're both of the same type (angled vs non-angled)
 699   StringRef OriginalSource = SourceFileName;
 700
 701   bool SourceIsAngled =
 702     GetIncludeFilenameSpelling(SourceFilenameTok.getLocation(),
 703                                 SourceFileName);
 704   bool ReplaceIsAngled =
 705     GetIncludeFilenameSpelling(ReplaceFilenameTok.getLocation(),
 706                                 ReplaceFileName);
 707   if (!SourceFileName.empty() && !ReplaceFileName.empty() &&
 708       (SourceIsAngled != ReplaceIsAngled)) {
 709     unsigned int DiagID;
 710     if (SourceIsAngled)
 711       DiagID = diag::warn_pragma_include_alias_mismatch_angle;
 712     else
 713       DiagID = diag::warn_pragma_include_alias_mismatch_quote;
 714
 715     Diag(SourceFilenameTok.getLocation(), DiagID)
 716       << SourceFileName
 717       << ReplaceFileName;
 718
 719     return;
 720   }
 721
 722   // Now we can let the include handler know about this mapping
 723   getHeaderSearchInfo().AddIncludeAlias(OriginalSource, ReplaceFileName);
 724 }
 725
 726 /// AddPragmaHandler - Add the specified pragma handler to the preprocessor.
 727 /// If 'Namespace' is non-null, then it is a token required to exist on the
 728 /// pragma line before the pragma string starts, e.g. "STDC" or "GCC".
 729 void Preprocessor::AddPragmaHandler(StringRef Namespace,
 730                                     PragmaHandler *Handler) {
 731   PragmaNamespace *InsertNS = PragmaHandlers.get();
 732
 733   // If this is specified to be in a namespace, step down into it.
 734   if (!Namespace.empty()) {
 735     // If there is already a pragma handler with the name of this namespace,
 736     // we either have an error (directive with the same name as a namespace) or
 737     // we already have the namespace to insert into.
 738     if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) {
 739       InsertNS = Existing->getIfNamespace();
 740       assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma"
 741              " handler with the same name!");
 742     } else {
 743       // Otherwise, this namespace doesn't exist yet, create and insert the
 744       // handler for it.
 745       InsertNS = new PragmaNamespace(Namespace);
 746       PragmaHandlers->AddPragma(InsertNS);
 747     }
 748   }
 749
 750   // Check to make sure we don't already have a pragma for this identifier.
 751   assert(!InsertNS->FindHandler(Handler->getName()) &&
 752          "Pragma handler already exists for this identifier!");
 753   InsertNS->AddPragma(Handler);
 754 }
 755
 756 /// RemovePragmaHandler - Remove the specific pragma handler from the
 757 /// preprocessor. If \arg Namespace is non-null, then it should be the
 758 /// namespace that \arg Handler was added to. It is an error to remove
 759 /// a handler that has not been registered.
 760 void Preprocessor::RemovePragmaHandler(StringRef Namespace,
 761                                        PragmaHandler *Handler) {
 762   PragmaNamespace *NS = PragmaHandlers.get();
 763
 764   // If this is specified to be in a namespace, step down into it.
 765   if (!Namespace.empty()) {
 766     PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace);
 767     assert(Existing && "Namespace containing handler does not exist!");
 768
 769     NS = Existing->getIfNamespace();
 770     assert(NS && "Invalid namespace, registered as a regular pragma handler!");
 771   }
 772
 773   NS->RemovePragmaHandler(Handler);
 774
 775   // If this is a non-default namespace and it is now empty, remove it.
 776   if (NS != PragmaHandlers.get() && NS->IsEmpty()) {
 777     PragmaHandlers->RemovePragmaHandler(NS);
 778     delete NS;
 779   }
 780 }
 781
 782 bool Preprocessor::LexOnOffSwitch(tok::OnOffSwitch &Result) {
 783   Token Tok;
 784   LexUnexpandedToken(Tok);
 785
 786   if (Tok.isNot(tok::identifier)) {
 787     Diag(Tok, diag::ext_on_off_switch_syntax);
 788     return true;
 789   }
 790   IdentifierInfo *II = Tok.getIdentifierInfo();
 791   if (II->isStr("ON"))
 792     Result = tok::OOS_ON;
 793   else if (II->isStr("OFF"))
 794     Result = tok::OOS_OFF;
 795   else if (II->isStr("DEFAULT"))
 796     Result = tok::OOS_DEFAULT;
 797   else {
 798     Diag(Tok, diag::ext_on_off_switch_syntax);
 799     return true;
 800   }
 801
 802   // Verify that this is followed by EOD.
 803   LexUnexpandedToken(Tok);
 804   if (Tok.isNot(tok::eod))
 805     Diag(Tok, diag::ext_pragma_syntax_eod);
 806   return false;
 807 }
 808
 809 namespace {
 810 /// PragmaOnceHandler - "\#pragma once" marks the file as atomically included.
 811 struct PragmaOnceHandler : public PragmaHandler {
 812   PragmaOnceHandler() : PragmaHandler("once") {}
 813   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
 814                     Token &OnceTok) override {
 815     PP.CheckEndOfDirective("pragma once");
 816     PP.HandlePragmaOnce(OnceTok);
 817   }
 818 };
 819
 820 /// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the
 821 /// rest of the line is not lexed.
 822 struct PragmaMarkHandler : public PragmaHandler {
 823   PragmaMarkHandler() : PragmaHandler("mark") {}
 824   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
 825                     Token &MarkTok) override {
 826     PP.HandlePragmaMark();
 827   }
 828 };
 829
 830 /// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable.
 831 struct PragmaPoisonHandler : public PragmaHandler {
 832   PragmaPoisonHandler() : PragmaHandler("poison") {}
 833   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
 834                     Token &PoisonTok) override {
 835     PP.HandlePragmaPoison(PoisonTok);
 836   }
 837 };
 838
 839 /// PragmaSystemHeaderHandler - "\#pragma system_header" marks the current file
 840 /// as a system header, which silences warnings in it.
 841 struct PragmaSystemHeaderHandler : public PragmaHandler {
 842   PragmaSystemHeaderHandler() : PragmaHandler("system_header") {}
 843   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
 844                     Token &SHToken) override {
 845     PP.HandlePragmaSystemHeader(SHToken);
 846     PP.CheckEndOfDirective("pragma");
 847   }
 848 };
 849 struct PragmaDependencyHandler : public PragmaHandler {
 850   PragmaDependencyHandler() : PragmaHandler("dependency") {}
 851   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
 852                     Token &DepToken) override {
 853     PP.HandlePragmaDependency(DepToken);
 854   }
 855 };
 856
 857 struct PragmaDebugHandler : public PragmaHandler {
 858   PragmaDebugHandler() : PragmaHandler("__debug") {}
 859   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
 860                     Token &DepToken) override {
 861     Token Tok;
 862     PP.LexUnexpandedToken(Tok);
 863     if (Tok.isNot(tok::identifier)) {
 864       PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
 865       return;
 866     }
 867     IdentifierInfo *II = Tok.getIdentifierInfo();
 868
 869     if (II->isStr("assert")) {
 870       llvm_unreachable("This is an assertion!");
 871     } else if (II->isStr("crash")) {
 872       LLVM_BUILTIN_TRAP;
 873     } else if (II->isStr("parser_crash")) {
 874       Token Crasher;
 875       Crasher.startToken();
 876       Crasher.setKind(tok::annot_pragma_parser_crash);
 877       Crasher.setAnnotationRange(SourceRange(Tok.getLocation()));
 878       PP.EnterToken(Crasher);
 879     } else if (II->isStr("dump")) {
 880       Token Identifier;
 881       PP.LexUnexpandedToken(Identifier);
 882       if (auto *DumpII = Identifier.getIdentifierInfo()) {
 883         Token DumpAnnot;
 884         DumpAnnot.startToken();
 885         DumpAnnot.setKind(tok::annot_pragma_dump);
 886         DumpAnnot.setAnnotationRange(
 887             SourceRange(Tok.getLocation(), Identifier.getLocation()));
 888         DumpAnnot.setAnnotationValue(DumpII);
 889         PP.DiscardUntilEndOfDirective();
 890         PP.EnterToken(DumpAnnot);
 891       } else {
 892         PP.Diag(Identifier, diag::warn_pragma_debug_missing_argument)
 893             << II->getName();
 894       }
 895     } else if (II->isStr("llvm_fatal_error")) {
 896       llvm::report_fatal_error("#pragma clang __debug llvm_fatal_error");
 897     } else if (II->isStr("llvm_unreachable")) {
 898       llvm_unreachable("#pragma clang __debug llvm_unreachable");
 899     } else if (II->isStr("macro")) {
 900       Token MacroName;
 901       PP.LexUnexpandedToken(MacroName);
 902       auto *MacroII = MacroName.getIdentifierInfo();
 903       if (MacroII)
 904         PP.dumpMacroInfo(MacroII);
 905       else
 906         PP.Diag(MacroName, diag::warn_pragma_debug_missing_argument)
 907             << II->getName();
 908     } else if (II->isStr("overflow_stack")) {
 909       DebugOverflowStack();
 910     } else if (II->isStr("handle_crash")) {
 911       llvm::CrashRecoveryContext *CRC =llvm::CrashRecoveryContext::GetCurrent();
 912       if (CRC)
 913         CRC->HandleCrash();
 914     } else if (II->isStr("captured")) {
 915       HandleCaptured(PP);
 916     } else {
 917       PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
 918         << II->getName();
 919     }
 920
 921     PPCallbacks *Callbacks = PP.getPPCallbacks();
 922     if (Callbacks)
 923       Callbacks->PragmaDebug(Tok.getLocation(), II->getName());
 924   }
 925
 926   void HandleCaptured(Preprocessor &PP) {
 927     // Skip if emitting preprocessed output.
 928     if (PP.isPreprocessedOutput())
 929       return;
 930
 931     Token Tok;
 932     PP.LexUnexpandedToken(Tok);
 933
 934     if (Tok.isNot(tok::eod)) {
 935       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol)
 936         << "pragma clang __debug captured";
 937       return;
 938     }
 939
 940     SourceLocation NameLoc = Tok.getLocation();
 941     MutableArrayRef<Token> Toks(
 942         PP.getPreprocessorAllocator().Allocate<Token>(1), 1);
 943     Toks[0].startToken();
 944     Toks[0].setKind(tok::annot_pragma_captured);
 945     Toks[0].setLocation(NameLoc);
 946
 947     PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
 948   }
 949
 950 // Disable MSVC warning about runtime stack overflow.
 951 #ifdef _MSC_VER
 952     #pragma warning(disable : 4717)
 953 #endif
 954   static void DebugOverflowStack() {
 955     void (*volatile Self)() = DebugOverflowStack;
 956     Self();
 957   }
 958 #ifdef _MSC_VER
 959     #pragma warning(default : 4717)
 960 #endif
 961
 962 };
 963
 964 /// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"'
 965 struct PragmaDiagnosticHandler : public PragmaHandler {
 966 private:
 967   const char *Namespace;
 968 public:
 969   explicit PragmaDiagnosticHandler(const char *NS) :
 970     PragmaHandler("diagnostic"), Namespace(NS) {}
 971   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
 972                     Token &DiagToken) override {
 973     SourceLocation DiagLoc = DiagToken.getLocation();
 974     Token Tok;
 975     PP.LexUnexpandedToken(Tok);
 976     if (Tok.isNot(tok::identifier)) {
 977       PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
 978       return;
 979     }
 980     IdentifierInfo *II = Tok.getIdentifierInfo();
 981     PPCallbacks *Callbacks = PP.getPPCallbacks();
 982
 983     if (II->isStr("pop")) {
 984       if (!PP.getDiagnostics().popMappings(DiagLoc))
 985         PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
 986       else if (Callbacks)
 987         Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace);
 988       return;
 989     } else if (II->isStr("push")) {
 990       PP.getDiagnostics().pushMappings(DiagLoc);
 991       if (Callbacks)
 992         Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace);
 993       return;
 994     }
 995
 996     diag::Severity SV = llvm::StringSwitch<diag::Severity>(II->getName())
 997                             .Case("ignored", diag::Severity::Ignored)
 998                             .Case("warning", diag::Severity::Warning)
 999                             .Case("error", diag::Severity::Error)
1000                             .Case("fatal", diag::Severity::Fatal)
1001                             .Default(diag::Severity());
1002
1003     if (SV == diag::Severity()) {
1004       PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1005       return;
1006     }
1007
1008     PP.LexUnexpandedToken(Tok);
1009     SourceLocation StringLoc = Tok.getLocation();
1010
1011     std::string WarningName;
1012     if (!PP.FinishLexStringLiteral(Tok, WarningName, "pragma diagnostic",
1013                                    /*MacroExpansion=*/false))
1014       return;
1015
1016     if (Tok.isNot(tok::eod)) {
1017       PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
1018       return;
1019     }
1020
1021     if (WarningName.size() < 3 || WarningName[0] != '-' ||
1022         (WarningName[1] != 'W' && WarningName[1] != 'R')) {
1023       PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option);
1024       return;
1025     }
1026
1027     diag::Flavor Flavor = WarningName[1] == 'W' ? diag::Flavor::WarningOrError
1028                                                 : diag::Flavor::Remark;
1029     StringRef Group = StringRef(WarningName).substr(2);
1030     bool unknownDiag = false;
1031     if (Group == "everything") {
1032       // Special handling for pragma clang diagnostic ... "-Weverything".
1033       // There is no formal group named "everything", so there has to be a
1034       // special case for it.
1035       PP.getDiagnostics().setSeverityForAll(Flavor, SV, DiagLoc);
1036     } else
1037       unknownDiag = PP.getDiagnostics().setSeverityForGroup(Flavor, Group, SV,
1038                                                             DiagLoc);
1039     if (unknownDiag)
1040       PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning)
1041         << WarningName;
1042     else if (Callbacks)
1043       Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName);
1044   }
1045 };
1046
1047 /// "\#pragma warning(...)".  MSVC's diagnostics do not map cleanly to clang's
1048 /// diagnostics, so we don't really implement this pragma.  We parse it and
1049 /// ignore it to avoid -Wunknown-pragma warnings.
1050 struct PragmaWarningHandler : public PragmaHandler {
1051   PragmaWarningHandler() : PragmaHandler("warning") {}
1052
1053   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1054                     Token &Tok) override {
1055     // Parse things like:
1056     // warning(push, 1)
1057     // warning(pop)
1058     // warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9)
1059     SourceLocation DiagLoc = Tok.getLocation();
1060     PPCallbacks *Callbacks = PP.getPPCallbacks();
1061
1062     PP.Lex(Tok);
1063     if (Tok.isNot(tok::l_paren)) {
1064       PP.Diag(Tok, diag::warn_pragma_warning_expected) << "(";
1065       return;
1066     }
1067
1068     PP.Lex(Tok);
1069     IdentifierInfo *II = Tok.getIdentifierInfo();
1070
1071     if (II && II->isStr("push")) {
1072       // #pragma warning( push[ ,n ] )
1073       int Level = -1;
1074       PP.Lex(Tok);
1075       if (Tok.is(tok::comma)) {
1076         PP.Lex(Tok);
1077         uint64_t Value;
1078         if (Tok.is(tok::numeric_constant) &&
1079             PP.parseSimpleIntegerLiteral(Tok, Value))
1080           Level = int(Value);
1081         if (Level < 0 || Level > 4) {
1082           PP.Diag(Tok, diag::warn_pragma_warning_push_level);
1083           return;
1084         }
1085       }
1086       if (Callbacks)
1087         Callbacks->PragmaWarningPush(DiagLoc, Level);
1088     } else if (II && II->isStr("pop")) {
1089       // #pragma warning( pop )
1090       PP.Lex(Tok);
1091       if (Callbacks)
1092         Callbacks->PragmaWarningPop(DiagLoc);
1093     } else {
1094       // #pragma warning( warning-specifier : warning-number-list
1095       //                  [; warning-specifier : warning-number-list...] )
1096       while (true) {
1097         II = Tok.getIdentifierInfo();
1098         if (!II && !Tok.is(tok::numeric_constant)) {
1099           PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1100           return;
1101         }
1102
1103         // Figure out which warning specifier this is.
1104         bool SpecifierValid;
1105         StringRef Specifier;
1106         llvm::SmallString<1> SpecifierBuf;
1107         if (II) {
1108           Specifier = II->getName();
1109           SpecifierValid = llvm::StringSwitch<bool>(Specifier)
1110                                .Cases("default", "disable", "error", "once",
1111                                       "suppress", true)
1112                                .Default(false);
1113           // If we read a correct specifier, snatch next token (that should be
1114           // ":", checked later).
1115           if (SpecifierValid)
1116             PP.Lex(Tok);
1117         } else {
1118           // Token is a numeric constant. It should be either 1, 2, 3 or 4.
1119           uint64_t Value;
1120           Specifier = PP.getSpelling(Tok, SpecifierBuf);
1121           if (PP.parseSimpleIntegerLiteral(Tok, Value)) {
1122             SpecifierValid = (Value >= 1) && (Value <= 4);
1123           } else
1124             SpecifierValid = false;
1125           // Next token already snatched by parseSimpleIntegerLiteral.
1126         }
1127
1128         if (!SpecifierValid) {
1129           PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1130           return;
1131         }
1132         if (Tok.isNot(tok::colon)) {
1133           PP.Diag(Tok, diag::warn_pragma_warning_expected) << ":";
1134           return;
1135         }
1136
1137         // Collect the warning ids.
1138         SmallVector<int, 4> Ids;
1139         PP.Lex(Tok);
1140         while (Tok.is(tok::numeric_constant)) {
1141           uint64_t Value;
1142           if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 ||
1143               Value > INT_MAX) {
1144             PP.Diag(Tok, diag::warn_pragma_warning_expected_number);
1145             return;
1146           }
1147           Ids.push_back(int(Value));
1148         }
1149         if (Callbacks)
1150           Callbacks->PragmaWarning(DiagLoc, Specifier, Ids);
1151
1152         // Parse the next specifier if there is a semicolon.
1153         if (Tok.isNot(tok::semi))
1154           break;
1155         PP.Lex(Tok);
1156       }
1157     }
1158
1159     if (Tok.isNot(tok::r_paren)) {
1160       PP.Diag(Tok, diag::warn_pragma_warning_expected) << ")";
1161       return;
1162     }
1163
1164     PP.Lex(Tok);
1165     if (Tok.isNot(tok::eod))
1166       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma warning";
1167   }
1168 };
1169
1170 /// PragmaIncludeAliasHandler - "\#pragma include_alias("...")".
1171 struct PragmaIncludeAliasHandler : public PragmaHandler {
1172   PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {}
1173   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1174                     Token &IncludeAliasTok) override {
1175     PP.HandlePragmaIncludeAlias(IncludeAliasTok);
1176   }
1177 };
1178
1179 /// PragmaMessageHandler - Handle the microsoft and gcc \#pragma message
1180 /// extension.  The syntax is:
1181 /// \code
1182 ///   #pragma message(string)
1183 /// \endcode
1184 /// OR, in GCC mode:
1185 /// \code
1186 ///   #pragma message string
1187 /// \endcode
1188 /// string is a string, which is fully macro expanded, and permits string
1189 /// concatenation, embedded escape characters, etc... See MSDN for more details.
1190 /// Also handles \#pragma GCC warning and \#pragma GCC error which take the same
1191 /// form as \#pragma message.
1192 struct PragmaMessageHandler : public PragmaHandler {
1193 private:
1194   const PPCallbacks::PragmaMessageKind Kind;
1195   const StringRef Namespace;
1196
1197   static const char* PragmaKind(PPCallbacks::PragmaMessageKind Kind,
1198                                 bool PragmaNameOnly = false) {
1199     switch (Kind) {
1200       case PPCallbacks::PMK_Message:
1201         return PragmaNameOnly ? "message" : "pragma message";
1202       case PPCallbacks::PMK_Warning:
1203         return PragmaNameOnly ? "warning" : "pragma warning";
1204       case PPCallbacks::PMK_Error:
1205         return PragmaNameOnly ? "error" : "pragma error";
1206     }
1207     llvm_unreachable("Unknown PragmaMessageKind!");
1208   }
1209
1210 public:
1211   PragmaMessageHandler(PPCallbacks::PragmaMessageKind Kind,
1212                        StringRef Namespace = StringRef())
1213     : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind), Namespace(Namespace) {}
1214
1215   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1216                     Token &Tok) override {
1217     SourceLocation MessageLoc = Tok.getLocation();
1218     PP.Lex(Tok);
1219     bool ExpectClosingParen = false;
1220     switch (Tok.getKind()) {
1221     case tok::l_paren:
1222       // We have a MSVC style pragma message.
1223       ExpectClosingParen = true;
1224       // Read the string.
1225       PP.Lex(Tok);
1226       break;
1227     case tok::string_literal:
1228       // We have a GCC style pragma message, and we just read the string.
1229       break;
1230     default:
1231       PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind;
1232       return;
1233     }
1234
1235     std::string MessageString;
1236     if (!PP.FinishLexStringLiteral(Tok, MessageString, PragmaKind(Kind),
1237                                    /*MacroExpansion=*/true))
1238       return;
1239
1240     if (ExpectClosingParen) {
1241       if (Tok.isNot(tok::r_paren)) {
1242         PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1243         return;
1244       }
1245       PP.Lex(Tok);  // eat the r_paren.
1246     }
1247
1248     if (Tok.isNot(tok::eod)) {
1249       PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1250       return;
1251     }
1252
1253     // Output the message.
1254     PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error)
1255                           ? diag::err_pragma_message
1256                           : diag::warn_pragma_message) << MessageString;
1257
1258     // If the pragma is lexically sound, notify any interested PPCallbacks.
1259     if (PPCallbacks *Callbacks = PP.getPPCallbacks())
1260       Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString);
1261   }
1262 };
1263
1264 /// PragmaPushMacroHandler - "\#pragma push_macro" saves the value of the
1265 /// macro on the top of the stack.
1266 struct PragmaPushMacroHandler : public PragmaHandler {
1267   PragmaPushMacroHandler() : PragmaHandler("push_macro") {}
1268   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1269                     Token &PushMacroTok) override {
1270     PP.HandlePragmaPushMacro(PushMacroTok);
1271   }
1272 };
1273
1274
1275 /// PragmaPopMacroHandler - "\#pragma pop_macro" sets the value of the
1276 /// macro to the value on the top of the stack.
1277 struct PragmaPopMacroHandler : public PragmaHandler {
1278   PragmaPopMacroHandler() : PragmaHandler("pop_macro") {}
1279   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1280                     Token &PopMacroTok) override {
1281     PP.HandlePragmaPopMacro(PopMacroTok);
1282   }
1283 };
1284
1285 // Pragma STDC implementations.
1286
1287 /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...".
1288 struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler {
1289   PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {}
1290   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1291                     Token &Tok) override {
1292     tok::OnOffSwitch OOS;
1293     if (PP.LexOnOffSwitch(OOS))
1294      return;
1295     if (OOS == tok::OOS_ON)
1296       PP.Diag(Tok, diag::warn_stdc_fenv_access_not_supported);
1297   }
1298 };
1299
1300 /// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...".
1301 struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler {
1302   PragmaSTDC_CX_LIMITED_RANGEHandler()
1303     : PragmaHandler("CX_LIMITED_RANGE") {}
1304   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1305                     Token &Tok) override {
1306     tok::OnOffSwitch OOS;
1307     PP.LexOnOffSwitch(OOS);
1308   }
1309 };
1310
1311 /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...".
1312 struct PragmaSTDC_UnknownHandler : public PragmaHandler {
1313   PragmaSTDC_UnknownHandler() {}
1314   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1315                     Token &UnknownTok) override {
1316     // C99 6.10.6p2, unknown forms are not allowed.
1317     PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored);
1318   }
1319 };
1320
1321 /// PragmaARCCFCodeAuditedHandler -
1322 ///   \#pragma clang arc_cf_code_audited begin/end
1323 struct PragmaARCCFCodeAuditedHandler : public PragmaHandler {
1324   PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {}
1325   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1326                     Token &NameTok) override {
1327     SourceLocation Loc = NameTok.getLocation();
1328     bool IsBegin;
1329
1330     Token Tok;
1331
1332     // Lex the 'begin' or 'end'.
1333     PP.LexUnexpandedToken(Tok);
1334     const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1335     if (BeginEnd && BeginEnd->isStr("begin")) {
1336       IsBegin = true;
1337     } else if (BeginEnd && BeginEnd->isStr("end")) {
1338       IsBegin = false;
1339     } else {
1340       PP.Diag(Tok.getLocation(), diag::err_pp_arc_cf_code_audited_syntax);
1341       return;
1342     }
1343
1344     // Verify that this is followed by EOD.
1345     PP.LexUnexpandedToken(Tok);
1346     if (Tok.isNot(tok::eod))
1347       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1348
1349     // The start location of the active audit.
1350     SourceLocation BeginLoc = PP.getPragmaARCCFCodeAuditedLoc();
1351
1352     // The start location we want after processing this.
1353     SourceLocation NewLoc;
1354
1355     if (IsBegin) {
1356       // Complain about attempts to re-enter an audit.
1357       if (BeginLoc.isValid()) {
1358         PP.Diag(Loc, diag::err_pp_double_begin_of_arc_cf_code_audited);
1359         PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1360       }
1361       NewLoc = Loc;
1362     } else {
1363       // Complain about attempts to leave an audit that doesn't exist.
1364       if (!BeginLoc.isValid()) {
1365         PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited);
1366         return;
1367       }
1368       NewLoc = SourceLocation();
1369     }
1370
1371     PP.setPragmaARCCFCodeAuditedLoc(NewLoc);
1372   }
1373 };
1374
1375 /// PragmaAssumeNonNullHandler -
1376 ///   \#pragma clang assume_nonnull begin/end
1377 struct PragmaAssumeNonNullHandler : public PragmaHandler {
1378   PragmaAssumeNonNullHandler() : PragmaHandler("assume_nonnull") {}
1379   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1380                     Token &NameTok) override {
1381     SourceLocation Loc = NameTok.getLocation();
1382     bool IsBegin;
1383
1384     Token Tok;
1385
1386     // Lex the 'begin' or 'end'.
1387     PP.LexUnexpandedToken(Tok);
1388     const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1389     if (BeginEnd && BeginEnd->isStr("begin")) {
1390       IsBegin = true;
1391     } else if (BeginEnd && BeginEnd->isStr("end")) {
1392       IsBegin = false;
1393     } else {
1394       PP.Diag(Tok.getLocation(), diag::err_pp_assume_nonnull_syntax);
1395       return;
1396     }
1397
1398     // Verify that this is followed by EOD.
1399     PP.LexUnexpandedToken(Tok);
1400     if (Tok.isNot(tok::eod))
1401       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1402
1403     // The start location of the active audit.
1404     SourceLocation BeginLoc = PP.getPragmaAssumeNonNullLoc();
1405
1406     // The start location we want after processing this.
1407     SourceLocation NewLoc;
1408
1409     if (IsBegin) {
1410       // Complain about attempts to re-enter an audit.
1411       if (BeginLoc.isValid()) {
1412         PP.Diag(Loc, diag::err_pp_double_begin_of_assume_nonnull);
1413         PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1414       }
1415       NewLoc = Loc;
1416     } else {
1417       // Complain about attempts to leave an audit that doesn't exist.
1418       if (!BeginLoc.isValid()) {
1419         PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull);
1420         return;
1421       }
1422       NewLoc = SourceLocation();
1423     }
1424
1425     PP.setPragmaAssumeNonNullLoc(NewLoc);
1426   }
1427 };
1428
1429 /// \brief Handle "\#pragma region [...]"
1430 ///
1431 /// The syntax is
1432 /// \code
1433 ///   #pragma region [optional name]
1434 ///   #pragma endregion [optional comment]
1435 /// \endcode
1436 ///
1437 /// \note This is
1438 /// <a href="http://msdn.microsoft.com/en-us/library/b6xkz944(v=vs.80).aspx">editor-only</a>
1439 /// pragma, just skipped by compiler.
1440 struct PragmaRegionHandler : public PragmaHandler {
1441   PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) { }
1442
1443   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1444                     Token &NameTok) override {
1445     // #pragma region: endregion matches can be verified
1446     // __pragma(region): no sense, but ignored by msvc
1447     // _Pragma is not valid for MSVC, but there isn't any point
1448     // to handle a _Pragma differently.
1449   }
1450 };
1451
1452 }  // end anonymous namespace
1453
1454
1455 /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas:
1456 /// \#pragma GCC poison/system_header/dependency and \#pragma once.
1457 void Preprocessor::RegisterBuiltinPragmas() {
1458   AddPragmaHandler(new PragmaOnceHandler());
1459   AddPragmaHandler(new PragmaMarkHandler());
1460   AddPragmaHandler(new PragmaPushMacroHandler());
1461   AddPragmaHandler(new PragmaPopMacroHandler());
1462   AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message));
1463
1464   // #pragma GCC ...
1465   AddPragmaHandler("GCC", new PragmaPoisonHandler());
1466   AddPragmaHandler("GCC", new PragmaSystemHeaderHandler());
1467   AddPragmaHandler("GCC", new PragmaDependencyHandler());
1468   AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC"));
1469   AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning,
1470                                                    "GCC"));
1471   AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error,
1472                                                    "GCC"));
1473   // #pragma clang ...
1474   AddPragmaHandler("clang", new PragmaPoisonHandler());
1475   AddPragmaHandler("clang", new PragmaSystemHeaderHandler());
1476   AddPragmaHandler("clang", new PragmaDebugHandler());
1477   AddPragmaHandler("clang", new PragmaDependencyHandler());
1478   AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang"));
1479   AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler());
1480   AddPragmaHandler("clang", new PragmaAssumeNonNullHandler());
1481
1482   AddPragmaHandler("STDC", new PragmaSTDC_FENV_ACCESSHandler());
1483   AddPragmaHandler("STDC", new PragmaSTDC_CX_LIMITED_RANGEHandler());
1484   AddPragmaHandler("STDC", new PragmaSTDC_UnknownHandler());
1485
1486   // MS extensions.
1487   if (LangOpts.MicrosoftExt) {
1488     AddPragmaHandler(new PragmaWarningHandler());
1489     AddPragmaHandler(new PragmaIncludeAliasHandler());
1490     AddPragmaHandler(new PragmaRegionHandler("region"));
1491     AddPragmaHandler(new PragmaRegionHandler("endregion"));
1492   }
1493
1494   // Pragmas added by plugins
1495   for (PragmaHandlerRegistry::iterator it = PragmaHandlerRegistry::begin(),
1496                                        ie = PragmaHandlerRegistry::end();
1497        it != ie; ++it) {
1498     AddPragmaHandler(it->instantiate().release());
1499   }
1500 }
1501
1502 /// Ignore all pragmas, useful for modes such as -Eonly which would otherwise
1503 /// warn about those pragmas being unknown.
1504 void Preprocessor::IgnorePragmas() {
1505   AddPragmaHandler(new EmptyPragmaHandler());
1506   // Also ignore all pragmas in all namespaces created
1507   // in Preprocessor::RegisterBuiltinPragmas().
1508   AddPragmaHandler("GCC", new EmptyPragmaHandler());
1509   AddPragmaHandler("clang", new EmptyPragmaHandler());
1510   if (PragmaHandler *NS = PragmaHandlers->FindHandler("STDC")) {
1511     // Preprocessor::RegisterBuiltinPragmas() already registers
1512     // PragmaSTDC_UnknownHandler as the empty handler, so remove it first,
1513     // otherwise there will be an assert about a duplicate handler.
1514     PragmaNamespace *STDCNamespace = NS->getIfNamespace();
1515     assert(STDCNamespace &&
1516            "Invalid namespace, registered as a regular pragma handler!");
1517     if (PragmaHandler *Existing = STDCNamespace->FindHandler("", false)) {
1518       RemovePragmaHandler("STDC", Existing);
1519       delete Existing;
1520     }
1521   }
1522   AddPragmaHandler("STDC", new EmptyPragmaHandler());
1523 }