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