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