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/Lex/HeaderSearch.h"
  17 #include "clang/Lex/LiteralSupport.h"
  18 #include "clang/Lex/Preprocessor.h"
  19 #include "clang/Lex/LexDiagnostic.h"
  20 #include "clang/Basic/FileManager.h"
  21 #include "clang/Basic/SourceManager.h"
  22 #include <algorithm>
  23 using namespace clang;
  24
  25 // Out-of-line destructor to provide a home for the class.
  26 PragmaHandler::~PragmaHandler() {
  27 }
  28
  29 //===----------------------------------------------------------------------===//
  30 // PragmaNamespace Implementation.
  31 //===----------------------------------------------------------------------===//
  32
  33
  34 PragmaNamespace::~PragmaNamespace() {
  35   for (unsigned i = 0, e = Handlers.size(); i != e; ++i)
  36     delete Handlers[i];
  37 }
  38
  39 /// FindHandler - Check to see if there is already a handler for the
  40 /// specified name.  If not, return the handler for the null identifier if it
  41 /// exists, otherwise return null.  If IgnoreNull is true (the default) then
  42 /// the null handler isn't returned on failure to match.
  43 PragmaHandler *PragmaNamespace::FindHandler(const IdentifierInfo *Name,
  44                                             bool IgnoreNull) const {
  45   PragmaHandler *NullHandler = 0;
  46   for (unsigned i = 0, e = Handlers.size(); i != e; ++i) {
  47     if (Handlers[i]->getName() == Name)
  48       return Handlers[i];
  49
  50     if (Handlers[i]->getName() == 0)
  51       NullHandler = Handlers[i];
  52   }
  53   return IgnoreNull ? 0 : NullHandler;
  54 }
  55
  56 void PragmaNamespace::RemovePragmaHandler(PragmaHandler *Handler) {
  57   for (unsigned i = 0, e = Handlers.size(); i != e; ++i) {
  58     if (Handlers[i] == Handler) {
  59       Handlers[i] = Handlers.back();
  60       Handlers.pop_back();
  61       return;
  62     }
  63   }
  64   assert(0 && "Handler not registered in this namespace");
  65 }
  66
  67 void PragmaNamespace::HandlePragma(Preprocessor &PP, Token &Tok) {
  68   // Read the 'namespace' that the directive is in, e.g. STDC.  Do not macro
  69   // expand it, the user can have a STDC #define, that should not affect this.
  70   PP.LexUnexpandedToken(Tok);
  71
  72   // Get the handler for this token.  If there is no handler, ignore the pragma.
  73   PragmaHandler *Handler = FindHandler(Tok.getIdentifierInfo(), false);
  74   if (Handler == 0) {
  75     PP.Diag(Tok, diag::warn_pragma_ignored);
  76     return;
  77   }
  78
  79   // Otherwise, pass it down.
  80   Handler->HandlePragma(PP, Tok);
  81 }
  82
  83 //===----------------------------------------------------------------------===//
  84 // Preprocessor Pragma Directive Handling.
  85 //===----------------------------------------------------------------------===//
  86
  87 /// HandlePragmaDirective - The "#pragma" directive has been parsed.  Lex the
  88 /// rest of the pragma, passing it to the registered pragma handlers.
  89 void Preprocessor::HandlePragmaDirective() {
  90   ++NumPragma;
  91
  92   // Invoke the first level of pragma handlers which reads the namespace id.
  93   Token Tok;
  94   PragmaHandlers->HandlePragma(*this, Tok);
  95
  96   // If the pragma handler didn't read the rest of the line, consume it now.
  97   if (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective)
  98     DiscardUntilEndOfDirective();
  99 }
 100
 101 /// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then
 102 /// return the first token after the directive.  The _Pragma token has just
 103 /// been read into 'Tok'.
 104 void Preprocessor::Handle_Pragma(Token &Tok) {
 105   // Remember the pragma token location.
 106   SourceLocation PragmaLoc = Tok.getLocation();
 107
 108   // Read the '('.
 109   Lex(Tok);
 110   if (Tok.isNot(tok::l_paren)) {
 111     Diag(PragmaLoc, diag::err__Pragma_malformed);
 112     return;
 113   }
 114
 115   // Read the '"..."'.
 116   Lex(Tok);
 117   if (Tok.isNot(tok::string_literal) && Tok.isNot(tok::wide_string_literal)) {
 118     Diag(PragmaLoc, diag::err__Pragma_malformed);
 119     return;
 120   }
 121
 122   // Remember the string.
 123   std::string StrVal = getSpelling(Tok);
 124
 125   // Read the ')'.
 126   Lex(Tok);
 127   if (Tok.isNot(tok::r_paren)) {
 128     Diag(PragmaLoc, diag::err__Pragma_malformed);
 129     return;
 130   }
 131
 132   SourceLocation RParenLoc = Tok.getLocation();
 133
 134   // The _Pragma is lexically sound.  Destringize according to C99 6.10.9.1:
 135   // "The string literal is destringized by deleting the L prefix, if present,
 136   // deleting the leading and trailing double-quotes, replacing each escape
 137   // sequence \" by a double-quote, and replacing each escape sequence \\ by a
 138   // single backslash."
 139   if (StrVal[0] == 'L')  // Remove L prefix.
 140     StrVal.erase(StrVal.begin());
 141   assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&
 142          "Invalid string token!");
 143
 144   // Remove the front quote, replacing it with a space, so that the pragma
 145   // contents appear to have a space before them.
 146   StrVal[0] = ' ';
 147
 148   // Replace the terminating quote with a \n.
 149   StrVal[StrVal.size()-1] = '\n';
 150
 151   // Remove escaped quotes and escapes.
 152   for (unsigned i = 0, e = StrVal.size(); i != e-1; ++i) {
 153     if (StrVal[i] == '\\' &&
 154         (StrVal[i+1] == '\\' || StrVal[i+1] == '"')) {
 155       // \\ -> '\' and \" -> '"'.
 156       StrVal.erase(StrVal.begin()+i);
 157       --e;
 158     }
 159   }
 160
 161   // Plop the string (including the newline and trailing null) into a buffer
 162   // where we can lex it.
 163   Token TmpTok;
 164   TmpTok.startToken();
 165   CreateString(&StrVal[0], StrVal.size(), TmpTok);
 166   SourceLocation TokLoc = TmpTok.getLocation();
 167
 168   // Make and enter a lexer object so that we lex and expand the tokens just
 169   // like any others.
 170   Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc,
 171                                         StrVal.size(), *this);
 172
 173   EnterSourceFileWithLexer(TL, 0);
 174
 175   // With everything set up, lex this as a #pragma directive.
 176   HandlePragmaDirective();
 177
 178   // Finally, return whatever came after the pragma directive.
 179   return Lex(Tok);
 180 }
 181
 182
 183
 184 /// HandlePragmaOnce - Handle #pragma once.  OnceTok is the 'once'.
 185 ///
 186 void Preprocessor::HandlePragmaOnce(Token &OnceTok) {
 187   if (isInPrimaryFile()) {
 188     Diag(OnceTok, diag::pp_pragma_once_in_main_file);
 189     return;
 190   }
 191
 192   // Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
 193   // Mark the file as a once-only file now.
 194   HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry());
 195 }
 196
 197 void Preprocessor::HandlePragmaMark() {
 198   assert(CurPPLexer && "No current lexer?");
 199   if (CurLexer)
 200     CurLexer->ReadToEndOfLine();
 201   else
 202     CurPTHLexer->DiscardToEndOfLine();
 203 }
 204
 205
 206 /// HandlePragmaPoison - Handle #pragma GCC poison.  PoisonTok is the 'poison'.
 207 ///
 208 void Preprocessor::HandlePragmaPoison(Token &PoisonTok) {
 209   Token Tok;
 210
 211   while (1) {
 212     // Read the next token to poison.  While doing this, pretend that we are
 213     // skipping while reading the identifier to poison.
 214     // This avoids errors on code like:
 215     //   #pragma GCC poison X
 216     //   #pragma GCC poison X
 217     if (CurPPLexer) CurPPLexer->LexingRawMode = true;
 218     LexUnexpandedToken(Tok);
 219     if (CurPPLexer) CurPPLexer->LexingRawMode = false;
 220
 221     // If we reached the end of line, we're done.
 222     if (Tok.is(tok::eom)) return;
 223
 224     // Can only poison identifiers.
 225     if (Tok.isNot(tok::identifier)) {
 226       Diag(Tok, diag::err_pp_invalid_poison);
 227       return;
 228     }
 229
 230     // Look up the identifier info for the token.  We disabled identifier lookup
 231     // by saying we're skipping contents, so we need to do this manually.
 232     IdentifierInfo *II = LookUpIdentifierInfo(Tok);
 233
 234     // Already poisoned.
 235     if (II->isPoisoned()) continue;
 236
 237     // If this is a macro identifier, emit a warning.
 238     if (II->hasMacroDefinition())
 239       Diag(Tok, diag::pp_poisoning_existing_macro);
 240
 241     // Finally, poison it!
 242     II->setIsPoisoned();
 243   }
 244 }
 245
 246 /// HandlePragmaSystemHeader - Implement #pragma GCC system_header.  We know
 247 /// that the whole directive has been parsed.
 248 void Preprocessor::HandlePragmaSystemHeader(Token &SysHeaderTok) {
 249   if (isInPrimaryFile()) {
 250     Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file);
 251     return;
 252   }
 253
 254   // Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
 255   PreprocessorLexer *TheLexer = getCurrentFileLexer();
 256
 257   // Mark the file as a system header.
 258   HeaderInfo.MarkFileSystemHeader(TheLexer->getFileEntry());
 259
 260
 261   PresumedLoc PLoc = SourceMgr.getPresumedLoc(SysHeaderTok.getLocation());
 262   unsigned FilenameLen = strlen(PLoc.getFilename());
 263   unsigned FilenameID = SourceMgr.getLineTableFilenameID(PLoc.getFilename(),
 264                                                          FilenameLen);
 265
 266   // Emit a line marker.  This will change any source locations from this point
 267   // forward to realize they are in a system header.
 268   // Create a line note with this information.
 269   SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine(), FilenameID,
 270                         false, false, true, false);
 271
 272   // Notify the client, if desired, that we are in a new source file.
 273   if (Callbacks)
 274     Callbacks->FileChanged(SysHeaderTok.getLocation(),
 275                            PPCallbacks::SystemHeaderPragma, SrcMgr::C_System);
 276 }
 277
 278 /// HandlePragmaDependency - Handle #pragma GCC dependency "foo" blah.
 279 ///
 280 void Preprocessor::HandlePragmaDependency(Token &DependencyTok) {
 281   Token FilenameTok;
 282   CurPPLexer->LexIncludeFilename(FilenameTok);
 283
 284   // If the token kind is EOM, the error has already been diagnosed.
 285   if (FilenameTok.is(tok::eom))
 286     return;
 287
 288   // Reserve a buffer to get the spelling.
 289   llvm::SmallString<128> FilenameBuffer;
 290   bool Invalid = false;
 291   llvm::StringRef Filename = getSpelling(FilenameTok, FilenameBuffer, &Invalid);
 292   if (Invalid)
 293     return;
 294
 295   bool isAngled =
 296     GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
 297   // If GetIncludeFilenameSpelling set the start ptr to null, there was an
 298   // error.
 299   if (Filename.empty())
 300     return;
 301
 302   // Search include directories for this file.
 303   const DirectoryLookup *CurDir;
 304   const FileEntry *File = LookupFile(Filename, isAngled, 0, CurDir);
 305   if (File == 0) {
 306     Diag(FilenameTok, diag::err_pp_file_not_found) << Filename;
 307     return;
 308   }
 309
 310   const FileEntry *CurFile = getCurrentFileLexer()->getFileEntry();
 311
 312   // If this file is older than the file it depends on, emit a diagnostic.
 313   if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) {
 314     // Lex tokens at the end of the message and include them in the message.
 315     std::string Message;
 316     Lex(DependencyTok);
 317     while (DependencyTok.isNot(tok::eom)) {
 318       Message += getSpelling(DependencyTok) + " ";
 319       Lex(DependencyTok);
 320     }
 321
 322     Message.erase(Message.end()-1);
 323     Diag(FilenameTok, diag::pp_out_of_date_dependency) << Message;
 324   }
 325 }
 326
 327 /// HandlePragmaComment - Handle the microsoft #pragma comment extension.  The
 328 /// syntax is:
 329 ///   #pragma comment(linker, "foo")
 330 /// 'linker' is one of five identifiers: compiler, exestr, lib, linker, user.
 331 /// "foo" is a string, which is fully macro expanded, and permits string
 332 /// concatenation, embedded escape characters etc.  See MSDN for more details.
 333 void Preprocessor::HandlePragmaComment(Token &Tok) {
 334   SourceLocation CommentLoc = Tok.getLocation();
 335   Lex(Tok);
 336   if (Tok.isNot(tok::l_paren)) {
 337     Diag(CommentLoc, diag::err_pragma_comment_malformed);
 338     return;
 339   }
 340
 341   // Read the identifier.
 342   Lex(Tok);
 343   if (Tok.isNot(tok::identifier)) {
 344     Diag(CommentLoc, diag::err_pragma_comment_malformed);
 345     return;
 346   }
 347
 348   // Verify that this is one of the 5 whitelisted options.
 349   // FIXME: warn that 'exestr' is deprecated.
 350   const IdentifierInfo *II = Tok.getIdentifierInfo();
 351   if (!II->isStr("compiler") && !II->isStr("exestr") && !II->isStr("lib") &&
 352       !II->isStr("linker") && !II->isStr("user")) {
 353     Diag(Tok.getLocation(), diag::err_pragma_comment_unknown_kind);
 354     return;
 355   }
 356
 357   // Read the optional string if present.
 358   Lex(Tok);
 359   std::string ArgumentString;
 360   if (Tok.is(tok::comma)) {
 361     Lex(Tok); // eat the comma.
 362
 363     // We need at least one string.
 364     if (Tok.isNot(tok::string_literal)) {
 365       Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
 366       return;
 367     }
 368
 369     // String concatenation allows multiple strings, which can even come from
 370     // macro expansion.
 371     // "foo " "bar" "Baz"
 372     llvm::SmallVector<Token, 4> StrToks;
 373     while (Tok.is(tok::string_literal)) {
 374       StrToks.push_back(Tok);
 375       Lex(Tok);
 376     }
 377
 378     // Concatenate and parse the strings.
 379     StringLiteralParser Literal(&StrToks[0], StrToks.size(), *this);
 380     assert(!Literal.AnyWide && "Didn't allow wide strings in");
 381     if (Literal.hadError)
 382       return;
 383     if (Literal.Pascal) {
 384       Diag(StrToks[0].getLocation(), diag::err_pragma_comment_malformed);
 385       return;
 386     }
 387
 388     ArgumentString = std::string(Literal.GetString(),
 389                                  Literal.GetString()+Literal.GetStringLength());
 390   }
 391
 392   // FIXME: If the kind is "compiler" warn if the string is present (it is
 393   // ignored).
 394   // FIXME: 'lib' requires a comment string.
 395   // FIXME: 'linker' requires a comment string, and has a specific list of
 396   // things that are allowable.
 397
 398   if (Tok.isNot(tok::r_paren)) {
 399     Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
 400     return;
 401   }
 402   Lex(Tok);  // eat the r_paren.
 403
 404   if (Tok.isNot(tok::eom)) {
 405     Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
 406     return;
 407   }
 408
 409   // If the pragma is lexically sound, notify any interested PPCallbacks.
 410   if (Callbacks)
 411     Callbacks->PragmaComment(CommentLoc, II, ArgumentString);
 412 }
 413
 414
 415
 416
 417 /// AddPragmaHandler - Add the specified pragma handler to the preprocessor.
 418 /// If 'Namespace' is non-null, then it is a token required to exist on the
 419 /// pragma line before the pragma string starts, e.g. "STDC" or "GCC".
 420 void Preprocessor::AddPragmaHandler(const char *Namespace,
 421                                     PragmaHandler *Handler) {
 422   PragmaNamespace *InsertNS = PragmaHandlers;
 423
 424   // If this is specified to be in a namespace, step down into it.
 425   if (Namespace) {
 426     IdentifierInfo *NSID = getIdentifierInfo(Namespace);
 427
 428     // If there is already a pragma handler with the name of this namespace,
 429     // we either have an error (directive with the same name as a namespace) or
 430     // we already have the namespace to insert into.
 431     if (PragmaHandler *Existing = PragmaHandlers->FindHandler(NSID)) {
 432       InsertNS = Existing->getIfNamespace();
 433       assert(InsertNS != 0 && "Cannot have a pragma namespace and pragma"
 434              " handler with the same name!");
 435     } else {
 436       // Otherwise, this namespace doesn't exist yet, create and insert the
 437       // handler for it.
 438       InsertNS = new PragmaNamespace(NSID);
 439       PragmaHandlers->AddPragma(InsertNS);
 440     }
 441   }
 442
 443   // Check to make sure we don't already have a pragma for this identifier.
 444   assert(!InsertNS->FindHandler(Handler->getName()) &&
 445          "Pragma handler already exists for this identifier!");
 446   InsertNS->AddPragma(Handler);
 447 }
 448
 449 /// RemovePragmaHandler - Remove the specific pragma handler from the
 450 /// preprocessor. If \arg Namespace is non-null, then it should be the
 451 /// namespace that \arg Handler was added to. It is an error to remove
 452 /// a handler that has not been registered.
 453 void Preprocessor::RemovePragmaHandler(const char *Namespace,
 454                                        PragmaHandler *Handler) {
 455   PragmaNamespace *NS = PragmaHandlers;
 456
 457   // If this is specified to be in a namespace, step down into it.
 458   if (Namespace) {
 459     IdentifierInfo *NSID = getIdentifierInfo(Namespace);
 460     PragmaHandler *Existing = PragmaHandlers->FindHandler(NSID);
 461     assert(Existing && "Namespace containing handler does not exist!");
 462
 463     NS = Existing->getIfNamespace();
 464     assert(NS && "Invalid namespace, registered as a regular pragma handler!");
 465   }
 466
 467   NS->RemovePragmaHandler(Handler);
 468
 469   // If this is a non-default namespace and it is now empty, remove
 470   // it.
 471   if (NS != PragmaHandlers && NS->IsEmpty())
 472     PragmaHandlers->RemovePragmaHandler(NS);
 473 }
 474
 475 namespace {
 476 /// PragmaOnceHandler - "#pragma once" marks the file as atomically included.
 477 struct PragmaOnceHandler : public PragmaHandler {
 478   PragmaOnceHandler(const IdentifierInfo *OnceID) : PragmaHandler(OnceID) {}
 479   virtual void HandlePragma(Preprocessor &PP, Token &OnceTok) {
 480     PP.CheckEndOfDirective("pragma once");
 481     PP.HandlePragmaOnce(OnceTok);
 482   }
 483 };
 484
 485 /// PragmaMarkHandler - "#pragma mark ..." is ignored by the compiler, and the
 486 /// rest of the line is not lexed.
 487 struct PragmaMarkHandler : public PragmaHandler {
 488   PragmaMarkHandler(const IdentifierInfo *MarkID) : PragmaHandler(MarkID) {}
 489   virtual void HandlePragma(Preprocessor &PP, Token &MarkTok) {
 490     PP.HandlePragmaMark();
 491   }
 492 };
 493
 494 /// PragmaPoisonHandler - "#pragma poison x" marks x as not usable.
 495 struct PragmaPoisonHandler : public PragmaHandler {
 496   PragmaPoisonHandler(const IdentifierInfo *ID) : PragmaHandler(ID) {}
 497   virtual void HandlePragma(Preprocessor &PP, Token &PoisonTok) {
 498     PP.HandlePragmaPoison(PoisonTok);
 499   }
 500 };
 501
 502 /// PragmaSystemHeaderHandler - "#pragma system_header" marks the current file
 503 /// as a system header, which silences warnings in it.
 504 struct PragmaSystemHeaderHandler : public PragmaHandler {
 505   PragmaSystemHeaderHandler(const IdentifierInfo *ID) : PragmaHandler(ID) {}
 506   virtual void HandlePragma(Preprocessor &PP, Token &SHToken) {
 507     PP.HandlePragmaSystemHeader(SHToken);
 508     PP.CheckEndOfDirective("pragma");
 509   }
 510 };
 511 struct PragmaDependencyHandler : public PragmaHandler {
 512   PragmaDependencyHandler(const IdentifierInfo *ID) : PragmaHandler(ID) {}
 513   virtual void HandlePragma(Preprocessor &PP, Token &DepToken) {
 514     PP.HandlePragmaDependency(DepToken);
 515   }
 516 };
 517
 518 /// PragmaDiagnosticHandler - e.g. '#pragma GCC diagnostic ignored "-Wformat"'
 519 /// Since clang's diagnostic supports extended functionality beyond GCC's
 520 /// the constructor takes a clangMode flag to tell it whether or not to allow
 521 /// clang's extended functionality, or whether to reject it.
 522 struct PragmaDiagnosticHandler : public PragmaHandler {
 523 private:
 524   const bool ClangMode;
 525 public:
 526   PragmaDiagnosticHandler(const IdentifierInfo *ID,
 527                           const bool clangMode) : PragmaHandler(ID),
 528                                                   ClangMode(clangMode) {}
 529   virtual void HandlePragma(Preprocessor &PP, Token &DiagToken) {
 530     Token Tok;
 531     PP.LexUnexpandedToken(Tok);
 532     if (Tok.isNot(tok::identifier)) {
 533       unsigned Diag = ClangMode ? diag::warn_pragma_diagnostic_clang_invalid
 534                                  : diag::warn_pragma_diagnostic_gcc_invalid;
 535       PP.Diag(Tok, Diag);
 536       return;
 537     }
 538     IdentifierInfo *II = Tok.getIdentifierInfo();
 539
 540     diag::Mapping Map;
 541     if (II->isStr("warning"))
 542       Map = diag::MAP_WARNING;
 543     else if (II->isStr("error"))
 544       Map = diag::MAP_ERROR;
 545     else if (II->isStr("ignored"))
 546       Map = diag::MAP_IGNORE;
 547     else if (II->isStr("fatal"))
 548       Map = diag::MAP_FATAL;
 549     else if (ClangMode) {
 550       if (II->isStr("pop")) {
 551         if (!PP.getDiagnostics().popMappings())
 552           PP.Diag(Tok, diag::warn_pragma_diagnostic_clang_cannot_ppp);
 553         return;
 554       }
 555
 556       if (II->isStr("push")) {
 557         PP.getDiagnostics().pushMappings();
 558         return;
 559       }
 560
 561       PP.Diag(Tok, diag::warn_pragma_diagnostic_clang_invalid);
 562       return;
 563     } else {
 564       PP.Diag(Tok, diag::warn_pragma_diagnostic_gcc_invalid);
 565       return;
 566     }
 567
 568     PP.LexUnexpandedToken(Tok);
 569
 570     // We need at least one string.
 571     if (Tok.isNot(tok::string_literal)) {
 572       PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
 573       return;
 574     }
 575
 576     // String concatenation allows multiple strings, which can even come from
 577     // macro expansion.
 578     // "foo " "bar" "Baz"
 579     llvm::SmallVector<Token, 4> StrToks;
 580     while (Tok.is(tok::string_literal)) {
 581       StrToks.push_back(Tok);
 582       PP.LexUnexpandedToken(Tok);
 583     }
 584
 585     if (Tok.isNot(tok::eom)) {
 586       PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
 587       return;
 588     }
 589
 590     // Concatenate and parse the strings.
 591     StringLiteralParser Literal(&StrToks[0], StrToks.size(), PP);
 592     assert(!Literal.AnyWide && "Didn't allow wide strings in");
 593     if (Literal.hadError)
 594       return;
 595     if (Literal.Pascal) {
 596       unsigned Diag = ClangMode ? diag::warn_pragma_diagnostic_clang_invalid
 597                                  : diag::warn_pragma_diagnostic_gcc_invalid;
 598       PP.Diag(Tok, Diag);
 599       return;
 600     }
 601
 602     std::string WarningName(Literal.GetString(),
 603                             Literal.GetString()+Literal.GetStringLength());
 604
 605     if (WarningName.size() < 3 || WarningName[0] != '-' ||
 606         WarningName[1] != 'W') {
 607       PP.Diag(StrToks[0].getLocation(),
 608               diag::warn_pragma_diagnostic_invalid_option);
 609       return;
 610     }
 611
 612     if (PP.getDiagnostics().setDiagnosticGroupMapping(WarningName.c_str()+2,
 613                                                       Map))
 614       PP.Diag(StrToks[0].getLocation(),
 615               diag::warn_pragma_diagnostic_unknown_warning) << WarningName;
 616   }
 617 };
 618
 619 /// PragmaCommentHandler - "#pragma comment ...".
 620 struct PragmaCommentHandler : public PragmaHandler {
 621   PragmaCommentHandler(const IdentifierInfo *ID) : PragmaHandler(ID) {}
 622   virtual void HandlePragma(Preprocessor &PP, Token &CommentTok) {
 623     PP.HandlePragmaComment(CommentTok);
 624   }
 625 };
 626
 627 // Pragma STDC implementations.
 628
 629 enum STDCSetting {
 630   STDC_ON, STDC_OFF, STDC_DEFAULT, STDC_INVALID
 631 };
 632
 633 static STDCSetting LexOnOffSwitch(Preprocessor &PP) {
 634   Token Tok;
 635   PP.LexUnexpandedToken(Tok);
 636
 637   if (Tok.isNot(tok::identifier)) {
 638     PP.Diag(Tok, diag::ext_stdc_pragma_syntax);
 639     return STDC_INVALID;
 640   }
 641   IdentifierInfo *II = Tok.getIdentifierInfo();
 642   STDCSetting Result;
 643   if (II->isStr("ON"))
 644     Result = STDC_ON;
 645   else if (II->isStr("OFF"))
 646     Result = STDC_OFF;
 647   else if (II->isStr("DEFAULT"))
 648     Result = STDC_DEFAULT;
 649   else {
 650     PP.Diag(Tok, diag::ext_stdc_pragma_syntax);
 651     return STDC_INVALID;
 652   }
 653
 654   // Verify that this is followed by EOM.
 655   PP.LexUnexpandedToken(Tok);
 656   if (Tok.isNot(tok::eom))
 657     PP.Diag(Tok, diag::ext_stdc_pragma_syntax_eom);
 658   return Result;
 659 }
 660
 661 /// PragmaSTDC_FP_CONTRACTHandler - "#pragma STDC FP_CONTRACT ...".
 662 struct PragmaSTDC_FP_CONTRACTHandler : public PragmaHandler {
 663   PragmaSTDC_FP_CONTRACTHandler(const IdentifierInfo *ID) : PragmaHandler(ID) {}
 664   virtual void HandlePragma(Preprocessor &PP, Token &Tok) {
 665     // We just ignore the setting of FP_CONTRACT. Since we don't do contractions
 666     // at all, our default is OFF and setting it to ON is an optimization hint
 667     // we can safely ignore.  When we support -ffma or something, we would need
 668     // to diagnose that we are ignoring FMA.
 669     LexOnOffSwitch(PP);
 670   }
 671 };
 672
 673 /// PragmaSTDC_FENV_ACCESSHandler - "#pragma STDC FENV_ACCESS ...".
 674 struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler {
 675   PragmaSTDC_FENV_ACCESSHandler(const IdentifierInfo *ID) : PragmaHandler(ID) {}
 676   virtual void HandlePragma(Preprocessor &PP, Token &Tok) {
 677     if (LexOnOffSwitch(PP) == STDC_ON)
 678       PP.Diag(Tok, diag::warn_stdc_fenv_access_not_supported);
 679   }
 680 };
 681
 682 /// PragmaSTDC_CX_LIMITED_RANGEHandler - "#pragma STDC CX_LIMITED_RANGE ...".
 683 struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler {
 684   PragmaSTDC_CX_LIMITED_RANGEHandler(const IdentifierInfo *ID)
 685     : PragmaHandler(ID) {}
 686   virtual void HandlePragma(Preprocessor &PP, Token &Tok) {
 687     LexOnOffSwitch(PP);
 688   }
 689 };
 690
 691 /// PragmaSTDC_UnknownHandler - "#pragma STDC ...".
 692 struct PragmaSTDC_UnknownHandler : public PragmaHandler {
 693   PragmaSTDC_UnknownHandler() : PragmaHandler(0) {}
 694   virtual void HandlePragma(Preprocessor &PP, Token &UnknownTok) {
 695     // C99 6.10.6p2, unknown forms are not allowed.
 696     PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored);
 697   }
 698 };
 699
 700 }  // end anonymous namespace
 701
 702
 703 /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas:
 704 /// #pragma GCC poison/system_header/dependency and #pragma once.
 705 void Preprocessor::RegisterBuiltinPragmas() {
 706   AddPragmaHandler(0, new PragmaOnceHandler(getIdentifierInfo("once")));
 707   AddPragmaHandler(0, new PragmaMarkHandler(getIdentifierInfo("mark")));
 708
 709   // #pragma GCC ...
 710   AddPragmaHandler("GCC", new PragmaPoisonHandler(getIdentifierInfo("poison")));
 711   AddPragmaHandler("GCC", new PragmaSystemHeaderHandler(
 712                                           getIdentifierInfo("system_header")));
 713   AddPragmaHandler("GCC", new PragmaDependencyHandler(
 714                                           getIdentifierInfo("dependency")));
 715   AddPragmaHandler("GCC", new PragmaDiagnosticHandler(
 716                                               getIdentifierInfo("diagnostic"),
 717                                               false));
 718   // #pragma clang ...
 719   AddPragmaHandler("clang", new PragmaPoisonHandler(
 720                                           getIdentifierInfo("poison")));
 721   AddPragmaHandler("clang", new PragmaSystemHeaderHandler(
 722                                           getIdentifierInfo("system_header")));
 723   AddPragmaHandler("clang", new PragmaDependencyHandler(
 724                                           getIdentifierInfo("dependency")));
 725   AddPragmaHandler("clang", new PragmaDiagnosticHandler(
 726                                           getIdentifierInfo("diagnostic"),
 727                                           true));
 728
 729   AddPragmaHandler("STDC", new PragmaSTDC_FP_CONTRACTHandler(
 730                                              getIdentifierInfo("FP_CONTRACT")));
 731   AddPragmaHandler("STDC", new PragmaSTDC_FENV_ACCESSHandler(
 732                                              getIdentifierInfo("FENV_ACCESS")));
 733   AddPragmaHandler("STDC", new PragmaSTDC_CX_LIMITED_RANGEHandler(
 734                                         getIdentifierInfo("CX_LIMITED_RANGE")));
 735   AddPragmaHandler("STDC", new PragmaSTDC_UnknownHandler());
 736
 737   // MS extensions.
 738   if (Features.Microsoft)
 739     AddPragmaHandler(0, new PragmaCommentHandler(getIdentifierInfo("comment")));
 740 }