PPDirectives.cpp revision c56fff7fd231aebf4b152f60f8f11ef91835c48a
1//===--- PPDirectives.cpp - Directive Handling for Preprocessor -----------===// 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/// \file 11/// \brief Implements # directive processing for the Preprocessor. 12/// 13//===----------------------------------------------------------------------===// 14 15#include "clang/Lex/Preprocessor.h" 16#include "clang/Basic/FileManager.h" 17#include "clang/Basic/SourceManager.h" 18#include "clang/Lex/CodeCompletionHandler.h" 19#include "clang/Lex/HeaderSearch.h" 20#include "clang/Lex/LexDiagnostic.h" 21#include "clang/Lex/LiteralSupport.h" 22#include "clang/Lex/MacroInfo.h" 23#include "clang/Lex/ModuleLoader.h" 24#include "clang/Lex/Pragma.h" 25#include "llvm/ADT/APInt.h" 26#include "llvm/Support/ErrorHandling.h" 27#include "llvm/Support/SaveAndRestore.h" 28using namespace clang; 29 30//===----------------------------------------------------------------------===// 31// Utility Methods for Preprocessor Directive Handling. 32//===----------------------------------------------------------------------===// 33 34MacroInfo *Preprocessor::AllocateMacroInfo() { 35 MacroInfoChain *MIChain; 36 37 if (MICache) { 38 MIChain = MICache; 39 MICache = MICache->Next; 40 } 41 else { 42 MIChain = BP.Allocate<MacroInfoChain>(); 43 } 44 45 MIChain->Next = MIChainHead; 46 MIChain->Prev = 0; 47 if (MIChainHead) 48 MIChainHead->Prev = MIChain; 49 MIChainHead = MIChain; 50 51 return &(MIChain->MI); 52} 53 54MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) { 55 MacroInfo *MI = AllocateMacroInfo(); 56 new (MI) MacroInfo(L); 57 return MI; 58} 59 60MacroInfo *Preprocessor::AllocateDeserializedMacroInfo(SourceLocation L, 61 unsigned SubModuleID) { 62 LLVM_STATIC_ASSERT(llvm::AlignOf<MacroInfo>::Alignment >= sizeof(SubModuleID), 63 "alignment for MacroInfo is less than the ID"); 64 MacroInfo *MI = 65 (MacroInfo*)BP.Allocate(sizeof(MacroInfo) + sizeof(SubModuleID), 66 llvm::AlignOf<MacroInfo>::Alignment); 67 new (MI) MacroInfo(L); 68 MI->FromASTFile = true; 69 MI->setOwningModuleID(SubModuleID); 70 return MI; 71} 72 73DefMacroDirective * 74Preprocessor::AllocateDefMacroDirective(MacroInfo *MI, SourceLocation Loc, 75 bool isImported) { 76 DefMacroDirective *MD = BP.Allocate<DefMacroDirective>(); 77 new (MD) DefMacroDirective(MI, Loc, isImported); 78 return MD; 79} 80 81UndefMacroDirective * 82Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) { 83 UndefMacroDirective *MD = BP.Allocate<UndefMacroDirective>(); 84 new (MD) UndefMacroDirective(UndefLoc); 85 return MD; 86} 87 88VisibilityMacroDirective * 89Preprocessor::AllocateVisibilityMacroDirective(SourceLocation Loc, 90 bool isPublic) { 91 VisibilityMacroDirective *MD = BP.Allocate<VisibilityMacroDirective>(); 92 new (MD) VisibilityMacroDirective(Loc, isPublic); 93 return MD; 94} 95 96/// \brief Release the specified MacroInfo to be reused for allocating 97/// new MacroInfo objects. 98void Preprocessor::ReleaseMacroInfo(MacroInfo *MI) { 99 MacroInfoChain *MIChain = (MacroInfoChain*) MI; 100 if (MacroInfoChain *Prev = MIChain->Prev) { 101 MacroInfoChain *Next = MIChain->Next; 102 Prev->Next = Next; 103 if (Next) 104 Next->Prev = Prev; 105 } 106 else { 107 assert(MIChainHead == MIChain); 108 MIChainHead = MIChain->Next; 109 MIChainHead->Prev = 0; 110 } 111 MIChain->Next = MICache; 112 MICache = MIChain; 113 114 MI->Destroy(); 115} 116 117/// \brief Read and discard all tokens remaining on the current line until 118/// the tok::eod token is found. 119void Preprocessor::DiscardUntilEndOfDirective() { 120 Token Tmp; 121 do { 122 LexUnexpandedToken(Tmp); 123 assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens"); 124 } while (Tmp.isNot(tok::eod)); 125} 126 127/// \brief Lex and validate a macro name, which occurs after a 128/// \#define or \#undef. 129/// 130/// This sets the token kind to eod and discards the rest 131/// of the macro line if the macro name is invalid. \p isDefineUndef is 1 if 132/// this is due to a a \#define, 2 if \#undef directive, 0 if it is something 133/// else (e.g. \#ifdef). 134void Preprocessor::ReadMacroName(Token &MacroNameTok, char isDefineUndef) { 135 // Read the token, don't allow macro expansion on it. 136 LexUnexpandedToken(MacroNameTok); 137 138 if (MacroNameTok.is(tok::code_completion)) { 139 if (CodeComplete) 140 CodeComplete->CodeCompleteMacroName(isDefineUndef == 1); 141 setCodeCompletionReached(); 142 LexUnexpandedToken(MacroNameTok); 143 } 144 145 // Missing macro name? 146 if (MacroNameTok.is(tok::eod)) { 147 Diag(MacroNameTok, diag::err_pp_missing_macro_name); 148 return; 149 } 150 151 IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); 152 if (II == 0) { 153 bool Invalid = false; 154 std::string Spelling = getSpelling(MacroNameTok, &Invalid); 155 if (Invalid) 156 return; 157 158 const IdentifierInfo &Info = Identifiers.get(Spelling); 159 160 // Allow #defining |and| and friends in microsoft mode. 161 if (Info.isCPlusPlusOperatorKeyword() && getLangOpts().MicrosoftMode) { 162 MacroNameTok.setIdentifierInfo(getIdentifierInfo(Spelling)); 163 return; 164 } 165 166 if (Info.isCPlusPlusOperatorKeyword()) 167 // C++ 2.5p2: Alternative tokens behave the same as its primary token 168 // except for their spellings. 169 Diag(MacroNameTok, diag::err_pp_operator_used_as_macro_name) << Spelling; 170 else 171 Diag(MacroNameTok, diag::err_pp_macro_not_identifier); 172 // Fall through on error. 173 } else if (isDefineUndef && II->getPPKeywordID() == tok::pp_defined) { 174 // Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4. 175 Diag(MacroNameTok, diag::err_defined_macro_name); 176 } else if (isDefineUndef == 2 && II->hasMacroDefinition() && 177 getMacroInfo(II)->isBuiltinMacro()) { 178 // Warn if undefining "__LINE__" and other builtins, per C99 6.10.8/4 179 // and C++ [cpp.predefined]p4], but allow it as an extension. 180 Diag(MacroNameTok, diag::ext_pp_undef_builtin_macro); 181 return; 182 } else { 183 // Okay, we got a good identifier node. Return it. 184 return; 185 } 186 187 // Invalid macro name, read and discard the rest of the line. Then set the 188 // token kind to tok::eod. 189 MacroNameTok.setKind(tok::eod); 190 return DiscardUntilEndOfDirective(); 191} 192 193/// \brief Ensure that the next token is a tok::eod token. 194/// 195/// If not, emit a diagnostic and consume up until the eod. If EnableMacros is 196/// true, then we consider macros that expand to zero tokens as being ok. 197void Preprocessor::CheckEndOfDirective(const char *DirType, bool EnableMacros) { 198 Token Tmp; 199 // Lex unexpanded tokens for most directives: macros might expand to zero 200 // tokens, causing us to miss diagnosing invalid lines. Some directives (like 201 // #line) allow empty macros. 202 if (EnableMacros) 203 Lex(Tmp); 204 else 205 LexUnexpandedToken(Tmp); 206 207 // There should be no tokens after the directive, but we allow them as an 208 // extension. 209 while (Tmp.is(tok::comment)) // Skip comments in -C mode. 210 LexUnexpandedToken(Tmp); 211 212 if (Tmp.isNot(tok::eod)) { 213 // Add a fixit in GNU/C99/C++ mode. Don't offer a fixit for strict-C89, 214 // or if this is a macro-style preprocessing directive, because it is more 215 // trouble than it is worth to insert /**/ and check that there is no /**/ 216 // in the range also. 217 FixItHint Hint; 218 if ((LangOpts.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) && 219 !CurTokenLexer) 220 Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//"); 221 Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint; 222 DiscardUntilEndOfDirective(); 223 } 224} 225 226 227 228/// SkipExcludedConditionalBlock - We just read a \#if or related directive and 229/// decided that the subsequent tokens are in the \#if'd out portion of the 230/// file. Lex the rest of the file, until we see an \#endif. If 231/// FoundNonSkipPortion is true, then we have already emitted code for part of 232/// this \#if directive, so \#else/\#elif blocks should never be entered. 233/// If ElseOk is true, then \#else directives are ok, if not, then we have 234/// already seen one so a \#else directive is a duplicate. When this returns, 235/// the caller can lex the first valid token. 236void Preprocessor::SkipExcludedConditionalBlock(SourceLocation IfTokenLoc, 237 bool FoundNonSkipPortion, 238 bool FoundElse, 239 SourceLocation ElseLoc) { 240 ++NumSkipped; 241 assert(CurTokenLexer == 0 && CurPPLexer && "Lexing a macro, not a file?"); 242 243 CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/false, 244 FoundNonSkipPortion, FoundElse); 245 246 if (CurPTHLexer) { 247 PTHSkipExcludedConditionalBlock(); 248 return; 249 } 250 251 // Enter raw mode to disable identifier lookup (and thus macro expansion), 252 // disabling warnings, etc. 253 CurPPLexer->LexingRawMode = true; 254 Token Tok; 255 while (1) { 256 CurLexer->Lex(Tok); 257 258 if (Tok.is(tok::code_completion)) { 259 if (CodeComplete) 260 CodeComplete->CodeCompleteInConditionalExclusion(); 261 setCodeCompletionReached(); 262 continue; 263 } 264 265 // If this is the end of the buffer, we have an error. 266 if (Tok.is(tok::eof)) { 267 // Emit errors for each unterminated conditional on the stack, including 268 // the current one. 269 while (!CurPPLexer->ConditionalStack.empty()) { 270 if (CurLexer->getFileLoc() != CodeCompletionFileLoc) 271 Diag(CurPPLexer->ConditionalStack.back().IfLoc, 272 diag::err_pp_unterminated_conditional); 273 CurPPLexer->ConditionalStack.pop_back(); 274 } 275 276 // Just return and let the caller lex after this #include. 277 break; 278 } 279 280 // If this token is not a preprocessor directive, just skip it. 281 if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine()) 282 continue; 283 284 // We just parsed a # character at the start of a line, so we're in 285 // directive mode. Tell the lexer this so any newlines we see will be 286 // converted into an EOD token (this terminates the macro). 287 CurPPLexer->ParsingPreprocessorDirective = true; 288 if (CurLexer) CurLexer->SetKeepWhitespaceMode(false); 289 290 291 // Read the next token, the directive flavor. 292 LexUnexpandedToken(Tok); 293 294 // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or 295 // something bogus), skip it. 296 if (Tok.isNot(tok::raw_identifier)) { 297 CurPPLexer->ParsingPreprocessorDirective = false; 298 // Restore comment saving mode. 299 if (CurLexer) CurLexer->resetExtendedTokenMode(); 300 continue; 301 } 302 303 // If the first letter isn't i or e, it isn't intesting to us. We know that 304 // this is safe in the face of spelling differences, because there is no way 305 // to spell an i/e in a strange way that is another letter. Skipping this 306 // allows us to avoid looking up the identifier info for #define/#undef and 307 // other common directives. 308 const char *RawCharData = Tok.getRawIdentifierData(); 309 310 char FirstChar = RawCharData[0]; 311 if (FirstChar >= 'a' && FirstChar <= 'z' && 312 FirstChar != 'i' && FirstChar != 'e') { 313 CurPPLexer->ParsingPreprocessorDirective = false; 314 // Restore comment saving mode. 315 if (CurLexer) CurLexer->resetExtendedTokenMode(); 316 continue; 317 } 318 319 // Get the identifier name without trigraphs or embedded newlines. Note 320 // that we can't use Tok.getIdentifierInfo() because its lookup is disabled 321 // when skipping. 322 char DirectiveBuf[20]; 323 StringRef Directive; 324 if (!Tok.needsCleaning() && Tok.getLength() < 20) { 325 Directive = StringRef(RawCharData, Tok.getLength()); 326 } else { 327 std::string DirectiveStr = getSpelling(Tok); 328 unsigned IdLen = DirectiveStr.size(); 329 if (IdLen >= 20) { 330 CurPPLexer->ParsingPreprocessorDirective = false; 331 // Restore comment saving mode. 332 if (CurLexer) CurLexer->resetExtendedTokenMode(); 333 continue; 334 } 335 memcpy(DirectiveBuf, &DirectiveStr[0], IdLen); 336 Directive = StringRef(DirectiveBuf, IdLen); 337 } 338 339 if (Directive.startswith("if")) { 340 StringRef Sub = Directive.substr(2); 341 if (Sub.empty() || // "if" 342 Sub == "def" || // "ifdef" 343 Sub == "ndef") { // "ifndef" 344 // We know the entire #if/#ifdef/#ifndef block will be skipped, don't 345 // bother parsing the condition. 346 DiscardUntilEndOfDirective(); 347 CurPPLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true, 348 /*foundnonskip*/false, 349 /*foundelse*/false); 350 } 351 } else if (Directive[0] == 'e') { 352 StringRef Sub = Directive.substr(1); 353 if (Sub == "ndif") { // "endif" 354 PPConditionalInfo CondInfo; 355 CondInfo.WasSkipping = true; // Silence bogus warning. 356 bool InCond = CurPPLexer->popConditionalLevel(CondInfo); 357 (void)InCond; // Silence warning in no-asserts mode. 358 assert(!InCond && "Can't be skipping if not in a conditional!"); 359 360 // If we popped the outermost skipping block, we're done skipping! 361 if (!CondInfo.WasSkipping) { 362 // Restore the value of LexingRawMode so that trailing comments 363 // are handled correctly, if we've reached the outermost block. 364 CurPPLexer->LexingRawMode = false; 365 CheckEndOfDirective("endif"); 366 CurPPLexer->LexingRawMode = true; 367 if (Callbacks) 368 Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc); 369 break; 370 } else { 371 DiscardUntilEndOfDirective(); 372 } 373 } else if (Sub == "lse") { // "else". 374 // #else directive in a skipping conditional. If not in some other 375 // skipping conditional, and if #else hasn't already been seen, enter it 376 // as a non-skipping conditional. 377 PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel(); 378 379 // If this is a #else with a #else before it, report the error. 380 if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_else_after_else); 381 382 // Note that we've seen a #else in this conditional. 383 CondInfo.FoundElse = true; 384 385 // If the conditional is at the top level, and the #if block wasn't 386 // entered, enter the #else block now. 387 if (!CondInfo.WasSkipping && !CondInfo.FoundNonSkip) { 388 CondInfo.FoundNonSkip = true; 389 // Restore the value of LexingRawMode so that trailing comments 390 // are handled correctly. 391 CurPPLexer->LexingRawMode = false; 392 CheckEndOfDirective("else"); 393 CurPPLexer->LexingRawMode = true; 394 if (Callbacks) 395 Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc); 396 break; 397 } else { 398 DiscardUntilEndOfDirective(); // C99 6.10p4. 399 } 400 } else if (Sub == "lif") { // "elif". 401 PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel(); 402 403 bool ShouldEnter; 404 const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation(); 405 // If this is in a skipping block or if we're already handled this #if 406 // block, don't bother parsing the condition. 407 if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) { 408 DiscardUntilEndOfDirective(); 409 ShouldEnter = false; 410 } else { 411 // Restore the value of LexingRawMode so that identifiers are 412 // looked up, etc, inside the #elif expression. 413 assert(CurPPLexer->LexingRawMode && "We have to be skipping here!"); 414 CurPPLexer->LexingRawMode = false; 415 IdentifierInfo *IfNDefMacro = 0; 416 ShouldEnter = EvaluateDirectiveExpression(IfNDefMacro); 417 CurPPLexer->LexingRawMode = true; 418 } 419 const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation(); 420 421 // If this is a #elif with a #else before it, report the error. 422 if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_elif_after_else); 423 424 // If this condition is true, enter it! 425 if (ShouldEnter) { 426 CondInfo.FoundNonSkip = true; 427 if (Callbacks) 428 Callbacks->Elif(Tok.getLocation(), 429 SourceRange(ConditionalBegin, ConditionalEnd), 430 CondInfo.IfLoc); 431 break; 432 } 433 } 434 } 435 436 CurPPLexer->ParsingPreprocessorDirective = false; 437 // Restore comment saving mode. 438 if (CurLexer) CurLexer->resetExtendedTokenMode(); 439 } 440 441 // Finally, if we are out of the conditional (saw an #endif or ran off the end 442 // of the file, just stop skipping and return to lexing whatever came after 443 // the #if block. 444 CurPPLexer->LexingRawMode = false; 445 446 if (Callbacks) { 447 SourceLocation BeginLoc = ElseLoc.isValid() ? ElseLoc : IfTokenLoc; 448 Callbacks->SourceRangeSkipped(SourceRange(BeginLoc, Tok.getLocation())); 449 } 450} 451 452void Preprocessor::PTHSkipExcludedConditionalBlock() { 453 454 while (1) { 455 assert(CurPTHLexer); 456 assert(CurPTHLexer->LexingRawMode == false); 457 458 // Skip to the next '#else', '#elif', or #endif. 459 if (CurPTHLexer->SkipBlock()) { 460 // We have reached an #endif. Both the '#' and 'endif' tokens 461 // have been consumed by the PTHLexer. Just pop off the condition level. 462 PPConditionalInfo CondInfo; 463 bool InCond = CurPTHLexer->popConditionalLevel(CondInfo); 464 (void)InCond; // Silence warning in no-asserts mode. 465 assert(!InCond && "Can't be skipping if not in a conditional!"); 466 break; 467 } 468 469 // We have reached a '#else' or '#elif'. Lex the next token to get 470 // the directive flavor. 471 Token Tok; 472 LexUnexpandedToken(Tok); 473 474 // We can actually look up the IdentifierInfo here since we aren't in 475 // raw mode. 476 tok::PPKeywordKind K = Tok.getIdentifierInfo()->getPPKeywordID(); 477 478 if (K == tok::pp_else) { 479 // #else: Enter the else condition. We aren't in a nested condition 480 // since we skip those. We're always in the one matching the last 481 // blocked we skipped. 482 PPConditionalInfo &CondInfo = CurPTHLexer->peekConditionalLevel(); 483 // Note that we've seen a #else in this conditional. 484 CondInfo.FoundElse = true; 485 486 // If the #if block wasn't entered then enter the #else block now. 487 if (!CondInfo.FoundNonSkip) { 488 CondInfo.FoundNonSkip = true; 489 490 // Scan until the eod token. 491 CurPTHLexer->ParsingPreprocessorDirective = true; 492 DiscardUntilEndOfDirective(); 493 CurPTHLexer->ParsingPreprocessorDirective = false; 494 495 break; 496 } 497 498 // Otherwise skip this block. 499 continue; 500 } 501 502 assert(K == tok::pp_elif); 503 PPConditionalInfo &CondInfo = CurPTHLexer->peekConditionalLevel(); 504 505 // If this is a #elif with a #else before it, report the error. 506 if (CondInfo.FoundElse) 507 Diag(Tok, diag::pp_err_elif_after_else); 508 509 // If this is in a skipping block or if we're already handled this #if 510 // block, don't bother parsing the condition. We just skip this block. 511 if (CondInfo.FoundNonSkip) 512 continue; 513 514 // Evaluate the condition of the #elif. 515 IdentifierInfo *IfNDefMacro = 0; 516 CurPTHLexer->ParsingPreprocessorDirective = true; 517 bool ShouldEnter = EvaluateDirectiveExpression(IfNDefMacro); 518 CurPTHLexer->ParsingPreprocessorDirective = false; 519 520 // If this condition is true, enter it! 521 if (ShouldEnter) { 522 CondInfo.FoundNonSkip = true; 523 break; 524 } 525 526 // Otherwise, skip this block and go to the next one. 527 continue; 528 } 529} 530 531const FileEntry *Preprocessor::LookupFile( 532 StringRef Filename, 533 bool isAngled, 534 const DirectoryLookup *FromDir, 535 const DirectoryLookup *&CurDir, 536 SmallVectorImpl<char> *SearchPath, 537 SmallVectorImpl<char> *RelativePath, 538 Module **SuggestedModule, 539 bool SkipCache) { 540 // If the header lookup mechanism may be relative to the current file, pass in 541 // info about where the current file is. 542 const FileEntry *CurFileEnt = 0; 543 if (!FromDir) { 544 FileID FID = getCurrentFileLexer()->getFileID(); 545 CurFileEnt = SourceMgr.getFileEntryForID(FID); 546 547 // If there is no file entry associated with this file, it must be the 548 // predefines buffer. Any other file is not lexed with a normal lexer, so 549 // it won't be scanned for preprocessor directives. If we have the 550 // predefines buffer, resolve #include references (which come from the 551 // -include command line argument) as if they came from the main file, this 552 // affects file lookup etc. 553 if (CurFileEnt == 0) { 554 FID = SourceMgr.getMainFileID(); 555 CurFileEnt = SourceMgr.getFileEntryForID(FID); 556 } 557 } 558 559 // Do a standard file entry lookup. 560 CurDir = CurDirLookup; 561 const FileEntry *FE = HeaderInfo.LookupFile( 562 Filename, isAngled, FromDir, CurDir, CurFileEnt, 563 SearchPath, RelativePath, SuggestedModule, SkipCache); 564 if (FE) return FE; 565 566 // Otherwise, see if this is a subframework header. If so, this is relative 567 // to one of the headers on the #include stack. Walk the list of the current 568 // headers on the #include stack and pass them to HeaderInfo. 569 if (IsFileLexer()) { 570 if ((CurFileEnt = SourceMgr.getFileEntryForID(CurPPLexer->getFileID()))) 571 if ((FE = HeaderInfo.LookupSubframeworkHeader(Filename, CurFileEnt, 572 SearchPath, RelativePath, 573 SuggestedModule))) 574 return FE; 575 } 576 577 for (unsigned i = 0, e = IncludeMacroStack.size(); i != e; ++i) { 578 IncludeStackInfo &ISEntry = IncludeMacroStack[e-i-1]; 579 if (IsFileLexer(ISEntry)) { 580 if ((CurFileEnt = 581 SourceMgr.getFileEntryForID(ISEntry.ThePPLexer->getFileID()))) 582 if ((FE = HeaderInfo.LookupSubframeworkHeader( 583 Filename, CurFileEnt, SearchPath, RelativePath, 584 SuggestedModule))) 585 return FE; 586 } 587 } 588 589 // Otherwise, we really couldn't find the file. 590 return 0; 591} 592 593 594//===----------------------------------------------------------------------===// 595// Preprocessor Directive Handling. 596//===----------------------------------------------------------------------===// 597 598class Preprocessor::ResetMacroExpansionHelper { 599public: 600 ResetMacroExpansionHelper(Preprocessor *pp) 601 : PP(pp), save(pp->DisableMacroExpansion) { 602 if (pp->MacroExpansionInDirectivesOverride) 603 pp->DisableMacroExpansion = false; 604 } 605 ~ResetMacroExpansionHelper() { 606 PP->DisableMacroExpansion = save; 607 } 608private: 609 Preprocessor *PP; 610 bool save; 611}; 612 613/// HandleDirective - This callback is invoked when the lexer sees a # token 614/// at the start of a line. This consumes the directive, modifies the 615/// lexer/preprocessor state, and advances the lexer(s) so that the next token 616/// read is the correct one. 617void Preprocessor::HandleDirective(Token &Result) { 618 // FIXME: Traditional: # with whitespace before it not recognized by K&R? 619 620 // We just parsed a # character at the start of a line, so we're in directive 621 // mode. Tell the lexer this so any newlines we see will be converted into an 622 // EOD token (which terminates the directive). 623 CurPPLexer->ParsingPreprocessorDirective = true; 624 if (CurLexer) CurLexer->SetKeepWhitespaceMode(false); 625 626 ++NumDirectives; 627 628 // We are about to read a token. For the multiple-include optimization FA to 629 // work, we have to remember if we had read any tokens *before* this 630 // pp-directive. 631 bool ReadAnyTokensBeforeDirective =CurPPLexer->MIOpt.getHasReadAnyTokensVal(); 632 633 // Save the '#' token in case we need to return it later. 634 Token SavedHash = Result; 635 636 // Read the next token, the directive flavor. This isn't expanded due to 637 // C99 6.10.3p8. 638 LexUnexpandedToken(Result); 639 640 // C99 6.10.3p11: Is this preprocessor directive in macro invocation? e.g.: 641 // #define A(x) #x 642 // A(abc 643 // #warning blah 644 // def) 645 // If so, the user is relying on undefined behavior, emit a diagnostic. Do 646 // not support this for #include-like directives, since that can result in 647 // terrible diagnostics, and does not work in GCC. 648 if (InMacroArgs) { 649 if (IdentifierInfo *II = Result.getIdentifierInfo()) { 650 switch (II->getPPKeywordID()) { 651 case tok::pp_include: 652 case tok::pp_import: 653 case tok::pp_include_next: 654 case tok::pp___include_macros: 655 Diag(Result, diag::err_embedded_include) << II->getName(); 656 DiscardUntilEndOfDirective(); 657 return; 658 default: 659 break; 660 } 661 } 662 Diag(Result, diag::ext_embedded_directive); 663 } 664 665 // Temporarily enable macro expansion if set so 666 // and reset to previous state when returning from this function. 667 ResetMacroExpansionHelper helper(this); 668 669 switch (Result.getKind()) { 670 case tok::eod: 671 return; // null directive. 672 case tok::code_completion: 673 if (CodeComplete) 674 CodeComplete->CodeCompleteDirective( 675 CurPPLexer->getConditionalStackDepth() > 0); 676 setCodeCompletionReached(); 677 return; 678 case tok::numeric_constant: // # 7 GNU line marker directive. 679 if (getLangOpts().AsmPreprocessor) 680 break; // # 4 is not a preprocessor directive in .S files. 681 return HandleDigitDirective(Result); 682 default: 683 IdentifierInfo *II = Result.getIdentifierInfo(); 684 if (II == 0) break; // Not an identifier. 685 686 // Ask what the preprocessor keyword ID is. 687 switch (II->getPPKeywordID()) { 688 default: break; 689 // C99 6.10.1 - Conditional Inclusion. 690 case tok::pp_if: 691 return HandleIfDirective(Result, ReadAnyTokensBeforeDirective); 692 case tok::pp_ifdef: 693 return HandleIfdefDirective(Result, false, true/*not valid for miopt*/); 694 case tok::pp_ifndef: 695 return HandleIfdefDirective(Result, true, ReadAnyTokensBeforeDirective); 696 case tok::pp_elif: 697 return HandleElifDirective(Result); 698 case tok::pp_else: 699 return HandleElseDirective(Result); 700 case tok::pp_endif: 701 return HandleEndifDirective(Result); 702 703 // C99 6.10.2 - Source File Inclusion. 704 case tok::pp_include: 705 // Handle #include. 706 return HandleIncludeDirective(SavedHash.getLocation(), Result); 707 case tok::pp___include_macros: 708 // Handle -imacros. 709 return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result); 710 711 // C99 6.10.3 - Macro Replacement. 712 case tok::pp_define: 713 return HandleDefineDirective(Result); 714 case tok::pp_undef: 715 return HandleUndefDirective(Result); 716 717 // C99 6.10.4 - Line Control. 718 case tok::pp_line: 719 return HandleLineDirective(Result); 720 721 // C99 6.10.5 - Error Directive. 722 case tok::pp_error: 723 return HandleUserDiagnosticDirective(Result, false); 724 725 // C99 6.10.6 - Pragma Directive. 726 case tok::pp_pragma: 727 return HandlePragmaDirective(PIK_HashPragma); 728 729 // GNU Extensions. 730 case tok::pp_import: 731 return HandleImportDirective(SavedHash.getLocation(), Result); 732 case tok::pp_include_next: 733 return HandleIncludeNextDirective(SavedHash.getLocation(), Result); 734 735 case tok::pp_warning: 736 Diag(Result, diag::ext_pp_warning_directive); 737 return HandleUserDiagnosticDirective(Result, true); 738 case tok::pp_ident: 739 return HandleIdentSCCSDirective(Result); 740 case tok::pp_sccs: 741 return HandleIdentSCCSDirective(Result); 742 case tok::pp_assert: 743 //isExtension = true; // FIXME: implement #assert 744 break; 745 case tok::pp_unassert: 746 //isExtension = true; // FIXME: implement #unassert 747 break; 748 749 case tok::pp___public_macro: 750 if (getLangOpts().Modules) 751 return HandleMacroPublicDirective(Result); 752 break; 753 754 case tok::pp___private_macro: 755 if (getLangOpts().Modules) 756 return HandleMacroPrivateDirective(Result); 757 break; 758 } 759 break; 760 } 761 762 // If this is a .S file, treat unknown # directives as non-preprocessor 763 // directives. This is important because # may be a comment or introduce 764 // various pseudo-ops. Just return the # token and push back the following 765 // token to be lexed next time. 766 if (getLangOpts().AsmPreprocessor) { 767 Token *Toks = new Token[2]; 768 // Return the # and the token after it. 769 Toks[0] = SavedHash; 770 Toks[1] = Result; 771 772 // If the second token is a hashhash token, then we need to translate it to 773 // unknown so the token lexer doesn't try to perform token pasting. 774 if (Result.is(tok::hashhash)) 775 Toks[1].setKind(tok::unknown); 776 777 // Enter this token stream so that we re-lex the tokens. Make sure to 778 // enable macro expansion, in case the token after the # is an identifier 779 // that is expanded. 780 EnterTokenStream(Toks, 2, false, true); 781 return; 782 } 783 784 // If we reached here, the preprocessing token is not valid! 785 Diag(Result, diag::err_pp_invalid_directive); 786 787 // Read the rest of the PP line. 788 DiscardUntilEndOfDirective(); 789 790 // Okay, we're done parsing the directive. 791} 792 793/// GetLineValue - Convert a numeric token into an unsigned value, emitting 794/// Diagnostic DiagID if it is invalid, and returning the value in Val. 795static bool GetLineValue(Token &DigitTok, unsigned &Val, 796 unsigned DiagID, Preprocessor &PP) { 797 if (DigitTok.isNot(tok::numeric_constant)) { 798 PP.Diag(DigitTok, DiagID); 799 800 if (DigitTok.isNot(tok::eod)) 801 PP.DiscardUntilEndOfDirective(); 802 return true; 803 } 804 805 SmallString<64> IntegerBuffer; 806 IntegerBuffer.resize(DigitTok.getLength()); 807 const char *DigitTokBegin = &IntegerBuffer[0]; 808 bool Invalid = false; 809 unsigned ActualLength = PP.getSpelling(DigitTok, DigitTokBegin, &Invalid); 810 if (Invalid) 811 return true; 812 813 // Verify that we have a simple digit-sequence, and compute the value. This 814 // is always a simple digit string computed in decimal, so we do this manually 815 // here. 816 Val = 0; 817 for (unsigned i = 0; i != ActualLength; ++i) { 818 if (!isDigit(DigitTokBegin[i])) { 819 PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i), 820 diag::err_pp_line_digit_sequence); 821 PP.DiscardUntilEndOfDirective(); 822 return true; 823 } 824 825 unsigned NextVal = Val*10+(DigitTokBegin[i]-'0'); 826 if (NextVal < Val) { // overflow. 827 PP.Diag(DigitTok, DiagID); 828 PP.DiscardUntilEndOfDirective(); 829 return true; 830 } 831 Val = NextVal; 832 } 833 834 if (DigitTokBegin[0] == '0' && Val) 835 PP.Diag(DigitTok.getLocation(), diag::warn_pp_line_decimal); 836 837 return false; 838} 839 840/// \brief Handle a \#line directive: C99 6.10.4. 841/// 842/// The two acceptable forms are: 843/// \verbatim 844/// # line digit-sequence 845/// # line digit-sequence "s-char-sequence" 846/// \endverbatim 847void Preprocessor::HandleLineDirective(Token &Tok) { 848 // Read the line # and string argument. Per C99 6.10.4p5, these tokens are 849 // expanded. 850 Token DigitTok; 851 Lex(DigitTok); 852 853 // Validate the number and convert it to an unsigned. 854 unsigned LineNo; 855 if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer,*this)) 856 return; 857 858 if (LineNo == 0) 859 Diag(DigitTok, diag::ext_pp_line_zero); 860 861 // Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a 862 // number greater than 2147483647". C90 requires that the line # be <= 32767. 863 unsigned LineLimit = 32768U; 864 if (LangOpts.C99 || LangOpts.CPlusPlus11) 865 LineLimit = 2147483648U; 866 if (LineNo >= LineLimit) 867 Diag(DigitTok, diag::ext_pp_line_too_big) << LineLimit; 868 else if (LangOpts.CPlusPlus11 && LineNo >= 32768U) 869 Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big); 870 871 int FilenameID = -1; 872 Token StrTok; 873 Lex(StrTok); 874 875 // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a 876 // string followed by eod. 877 if (StrTok.is(tok::eod)) 878 ; // ok 879 else if (StrTok.isNot(tok::string_literal)) { 880 Diag(StrTok, diag::err_pp_line_invalid_filename); 881 return DiscardUntilEndOfDirective(); 882 } else if (StrTok.hasUDSuffix()) { 883 Diag(StrTok, diag::err_invalid_string_udl); 884 return DiscardUntilEndOfDirective(); 885 } else { 886 // Parse and validate the string, converting it into a unique ID. 887 StringLiteralParser Literal(&StrTok, 1, *this); 888 assert(Literal.isAscii() && "Didn't allow wide strings in"); 889 if (Literal.hadError) 890 return DiscardUntilEndOfDirective(); 891 if (Literal.Pascal) { 892 Diag(StrTok, diag::err_pp_linemarker_invalid_filename); 893 return DiscardUntilEndOfDirective(); 894 } 895 FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString()); 896 897 // Verify that there is nothing after the string, other than EOD. Because 898 // of C99 6.10.4p5, macros that expand to empty tokens are ok. 899 CheckEndOfDirective("line", true); 900 } 901 902 SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID); 903 904 if (Callbacks) 905 Callbacks->FileChanged(CurPPLexer->getSourceLocation(), 906 PPCallbacks::RenameFile, 907 SrcMgr::C_User); 908} 909 910/// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line 911/// marker directive. 912static bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit, 913 bool &IsSystemHeader, bool &IsExternCHeader, 914 Preprocessor &PP) { 915 unsigned FlagVal; 916 Token FlagTok; 917 PP.Lex(FlagTok); 918 if (FlagTok.is(tok::eod)) return false; 919 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP)) 920 return true; 921 922 if (FlagVal == 1) { 923 IsFileEntry = true; 924 925 PP.Lex(FlagTok); 926 if (FlagTok.is(tok::eod)) return false; 927 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP)) 928 return true; 929 } else if (FlagVal == 2) { 930 IsFileExit = true; 931 932 SourceManager &SM = PP.getSourceManager(); 933 // If we are leaving the current presumed file, check to make sure the 934 // presumed include stack isn't empty! 935 FileID CurFileID = 936 SM.getDecomposedExpansionLoc(FlagTok.getLocation()).first; 937 PresumedLoc PLoc = SM.getPresumedLoc(FlagTok.getLocation()); 938 if (PLoc.isInvalid()) 939 return true; 940 941 // If there is no include loc (main file) or if the include loc is in a 942 // different physical file, then we aren't in a "1" line marker flag region. 943 SourceLocation IncLoc = PLoc.getIncludeLoc(); 944 if (IncLoc.isInvalid() || 945 SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) { 946 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop); 947 PP.DiscardUntilEndOfDirective(); 948 return true; 949 } 950 951 PP.Lex(FlagTok); 952 if (FlagTok.is(tok::eod)) return false; 953 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP)) 954 return true; 955 } 956 957 // We must have 3 if there are still flags. 958 if (FlagVal != 3) { 959 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag); 960 PP.DiscardUntilEndOfDirective(); 961 return true; 962 } 963 964 IsSystemHeader = true; 965 966 PP.Lex(FlagTok); 967 if (FlagTok.is(tok::eod)) return false; 968 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP)) 969 return true; 970 971 // We must have 4 if there is yet another flag. 972 if (FlagVal != 4) { 973 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag); 974 PP.DiscardUntilEndOfDirective(); 975 return true; 976 } 977 978 IsExternCHeader = true; 979 980 PP.Lex(FlagTok); 981 if (FlagTok.is(tok::eod)) return false; 982 983 // There are no more valid flags here. 984 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag); 985 PP.DiscardUntilEndOfDirective(); 986 return true; 987} 988 989/// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is 990/// one of the following forms: 991/// 992/// # 42 993/// # 42 "file" ('1' | '2')? 994/// # 42 "file" ('1' | '2')? '3' '4'? 995/// 996void Preprocessor::HandleDigitDirective(Token &DigitTok) { 997 // Validate the number and convert it to an unsigned. GNU does not have a 998 // line # limit other than it fit in 32-bits. 999 unsigned LineNo; 1000 if (GetLineValue(DigitTok, LineNo, diag::err_pp_linemarker_requires_integer, 1001 *this)) 1002 return; 1003 1004 Token StrTok; 1005 Lex(StrTok); 1006 1007 bool IsFileEntry = false, IsFileExit = false; 1008 bool IsSystemHeader = false, IsExternCHeader = false; 1009 int FilenameID = -1; 1010 1011 // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a 1012 // string followed by eod. 1013 if (StrTok.is(tok::eod)) 1014 ; // ok 1015 else if (StrTok.isNot(tok::string_literal)) { 1016 Diag(StrTok, diag::err_pp_linemarker_invalid_filename); 1017 return DiscardUntilEndOfDirective(); 1018 } else if (StrTok.hasUDSuffix()) { 1019 Diag(StrTok, diag::err_invalid_string_udl); 1020 return DiscardUntilEndOfDirective(); 1021 } else { 1022 // Parse and validate the string, converting it into a unique ID. 1023 StringLiteralParser Literal(&StrTok, 1, *this); 1024 assert(Literal.isAscii() && "Didn't allow wide strings in"); 1025 if (Literal.hadError) 1026 return DiscardUntilEndOfDirective(); 1027 if (Literal.Pascal) { 1028 Diag(StrTok, diag::err_pp_linemarker_invalid_filename); 1029 return DiscardUntilEndOfDirective(); 1030 } 1031 FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString()); 1032 1033 // If a filename was present, read any flags that are present. 1034 if (ReadLineMarkerFlags(IsFileEntry, IsFileExit, 1035 IsSystemHeader, IsExternCHeader, *this)) 1036 return; 1037 } 1038 1039 // Create a line note with this information. 1040 SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, 1041 IsFileEntry, IsFileExit, 1042 IsSystemHeader, IsExternCHeader); 1043 1044 // If the preprocessor has callbacks installed, notify them of the #line 1045 // change. This is used so that the line marker comes out in -E mode for 1046 // example. 1047 if (Callbacks) { 1048 PPCallbacks::FileChangeReason Reason = PPCallbacks::RenameFile; 1049 if (IsFileEntry) 1050 Reason = PPCallbacks::EnterFile; 1051 else if (IsFileExit) 1052 Reason = PPCallbacks::ExitFile; 1053 SrcMgr::CharacteristicKind FileKind = SrcMgr::C_User; 1054 if (IsExternCHeader) 1055 FileKind = SrcMgr::C_ExternCSystem; 1056 else if (IsSystemHeader) 1057 FileKind = SrcMgr::C_System; 1058 1059 Callbacks->FileChanged(CurPPLexer->getSourceLocation(), Reason, FileKind); 1060 } 1061} 1062 1063 1064/// HandleUserDiagnosticDirective - Handle a #warning or #error directive. 1065/// 1066void Preprocessor::HandleUserDiagnosticDirective(Token &Tok, 1067 bool isWarning) { 1068 // PTH doesn't emit #warning or #error directives. 1069 if (CurPTHLexer) 1070 return CurPTHLexer->DiscardToEndOfLine(); 1071 1072 // Read the rest of the line raw. We do this because we don't want macros 1073 // to be expanded and we don't require that the tokens be valid preprocessing 1074 // tokens. For example, this is allowed: "#warning ` 'foo". GCC does 1075 // collapse multiple consequtive white space between tokens, but this isn't 1076 // specified by the standard. 1077 SmallString<128> Message; 1078 CurLexer->ReadToEndOfLine(&Message); 1079 1080 // Find the first non-whitespace character, so that we can make the 1081 // diagnostic more succinct. 1082 StringRef Msg = Message.str().ltrim(" "); 1083 1084 if (isWarning) 1085 Diag(Tok, diag::pp_hash_warning) << Msg; 1086 else 1087 Diag(Tok, diag::err_pp_hash_error) << Msg; 1088} 1089 1090/// HandleIdentSCCSDirective - Handle a #ident/#sccs directive. 1091/// 1092void Preprocessor::HandleIdentSCCSDirective(Token &Tok) { 1093 // Yes, this directive is an extension. 1094 Diag(Tok, diag::ext_pp_ident_directive); 1095 1096 // Read the string argument. 1097 Token StrTok; 1098 Lex(StrTok); 1099 1100 // If the token kind isn't a string, it's a malformed directive. 1101 if (StrTok.isNot(tok::string_literal) && 1102 StrTok.isNot(tok::wide_string_literal)) { 1103 Diag(StrTok, diag::err_pp_malformed_ident); 1104 if (StrTok.isNot(tok::eod)) 1105 DiscardUntilEndOfDirective(); 1106 return; 1107 } 1108 1109 if (StrTok.hasUDSuffix()) { 1110 Diag(StrTok, diag::err_invalid_string_udl); 1111 return DiscardUntilEndOfDirective(); 1112 } 1113 1114 // Verify that there is nothing after the string, other than EOD. 1115 CheckEndOfDirective("ident"); 1116 1117 if (Callbacks) { 1118 bool Invalid = false; 1119 std::string Str = getSpelling(StrTok, &Invalid); 1120 if (!Invalid) 1121 Callbacks->Ident(Tok.getLocation(), Str); 1122 } 1123} 1124 1125/// \brief Handle a #public directive. 1126void Preprocessor::HandleMacroPublicDirective(Token &Tok) { 1127 Token MacroNameTok; 1128 ReadMacroName(MacroNameTok, 2); 1129 1130 // Error reading macro name? If so, diagnostic already issued. 1131 if (MacroNameTok.is(tok::eod)) 1132 return; 1133 1134 // Check to see if this is the last token on the #__public_macro line. 1135 CheckEndOfDirective("__public_macro"); 1136 1137 IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); 1138 // Okay, we finally have a valid identifier to undef. 1139 MacroDirective *MD = getMacroDirective(II); 1140 1141 // If the macro is not defined, this is an error. 1142 if (MD == 0) { 1143 Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II; 1144 return; 1145 } 1146 1147 // Note that this macro has now been exported. 1148 appendMacroDirective(II, AllocateVisibilityMacroDirective( 1149 MacroNameTok.getLocation(), /*IsPublic=*/true)); 1150} 1151 1152/// \brief Handle a #private directive. 1153void Preprocessor::HandleMacroPrivateDirective(Token &Tok) { 1154 Token MacroNameTok; 1155 ReadMacroName(MacroNameTok, 2); 1156 1157 // Error reading macro name? If so, diagnostic already issued. 1158 if (MacroNameTok.is(tok::eod)) 1159 return; 1160 1161 // Check to see if this is the last token on the #__private_macro line. 1162 CheckEndOfDirective("__private_macro"); 1163 1164 IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); 1165 // Okay, we finally have a valid identifier to undef. 1166 MacroDirective *MD = getMacroDirective(II); 1167 1168 // If the macro is not defined, this is an error. 1169 if (MD == 0) { 1170 Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II; 1171 return; 1172 } 1173 1174 // Note that this macro has now been marked private. 1175 appendMacroDirective(II, AllocateVisibilityMacroDirective( 1176 MacroNameTok.getLocation(), /*IsPublic=*/false)); 1177} 1178 1179//===----------------------------------------------------------------------===// 1180// Preprocessor Include Directive Handling. 1181//===----------------------------------------------------------------------===// 1182 1183/// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully 1184/// checked and spelled filename, e.g. as an operand of \#include. This returns 1185/// true if the input filename was in <>'s or false if it were in ""'s. The 1186/// caller is expected to provide a buffer that is large enough to hold the 1187/// spelling of the filename, but is also expected to handle the case when 1188/// this method decides to use a different buffer. 1189bool Preprocessor::GetIncludeFilenameSpelling(SourceLocation Loc, 1190 StringRef &Buffer) { 1191 // Get the text form of the filename. 1192 assert(!Buffer.empty() && "Can't have tokens with empty spellings!"); 1193 1194 // Make sure the filename is <x> or "x". 1195 bool isAngled; 1196 if (Buffer[0] == '<') { 1197 if (Buffer.back() != '>') { 1198 Diag(Loc, diag::err_pp_expects_filename); 1199 Buffer = StringRef(); 1200 return true; 1201 } 1202 isAngled = true; 1203 } else if (Buffer[0] == '"') { 1204 if (Buffer.back() != '"') { 1205 Diag(Loc, diag::err_pp_expects_filename); 1206 Buffer = StringRef(); 1207 return true; 1208 } 1209 isAngled = false; 1210 } else { 1211 Diag(Loc, diag::err_pp_expects_filename); 1212 Buffer = StringRef(); 1213 return true; 1214 } 1215 1216 // Diagnose #include "" as invalid. 1217 if (Buffer.size() <= 2) { 1218 Diag(Loc, diag::err_pp_empty_filename); 1219 Buffer = StringRef(); 1220 return true; 1221 } 1222 1223 // Skip the brackets. 1224 Buffer = Buffer.substr(1, Buffer.size()-2); 1225 return isAngled; 1226} 1227 1228/// \brief Handle cases where the \#include name is expanded from a macro 1229/// as multiple tokens, which need to be glued together. 1230/// 1231/// This occurs for code like: 1232/// \code 1233/// \#define FOO <a/b.h> 1234/// \#include FOO 1235/// \endcode 1236/// because in this case, "<a/b.h>" is returned as 7 tokens, not one. 1237/// 1238/// This code concatenates and consumes tokens up to the '>' token. It returns 1239/// false if the > was found, otherwise it returns true if it finds and consumes 1240/// the EOD marker. 1241bool Preprocessor::ConcatenateIncludeName( 1242 SmallString<128> &FilenameBuffer, 1243 SourceLocation &End) { 1244 Token CurTok; 1245 1246 Lex(CurTok); 1247 while (CurTok.isNot(tok::eod)) { 1248 End = CurTok.getLocation(); 1249 1250 // FIXME: Provide code completion for #includes. 1251 if (CurTok.is(tok::code_completion)) { 1252 setCodeCompletionReached(); 1253 Lex(CurTok); 1254 continue; 1255 } 1256 1257 // Append the spelling of this token to the buffer. If there was a space 1258 // before it, add it now. 1259 if (CurTok.hasLeadingSpace()) 1260 FilenameBuffer.push_back(' '); 1261 1262 // Get the spelling of the token, directly into FilenameBuffer if possible. 1263 unsigned PreAppendSize = FilenameBuffer.size(); 1264 FilenameBuffer.resize(PreAppendSize+CurTok.getLength()); 1265 1266 const char *BufPtr = &FilenameBuffer[PreAppendSize]; 1267 unsigned ActualLen = getSpelling(CurTok, BufPtr); 1268 1269 // If the token was spelled somewhere else, copy it into FilenameBuffer. 1270 if (BufPtr != &FilenameBuffer[PreAppendSize]) 1271 memcpy(&FilenameBuffer[PreAppendSize], BufPtr, ActualLen); 1272 1273 // Resize FilenameBuffer to the correct size. 1274 if (CurTok.getLength() != ActualLen) 1275 FilenameBuffer.resize(PreAppendSize+ActualLen); 1276 1277 // If we found the '>' marker, return success. 1278 if (CurTok.is(tok::greater)) 1279 return false; 1280 1281 Lex(CurTok); 1282 } 1283 1284 // If we hit the eod marker, emit an error and return true so that the caller 1285 // knows the EOD has been read. 1286 Diag(CurTok.getLocation(), diag::err_pp_expects_filename); 1287 return true; 1288} 1289 1290/// HandleIncludeDirective - The "\#include" tokens have just been read, read 1291/// the file to be included from the lexer, then include it! This is a common 1292/// routine with functionality shared between \#include, \#include_next and 1293/// \#import. LookupFrom is set when this is a \#include_next directive, it 1294/// specifies the file to start searching from. 1295void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc, 1296 Token &IncludeTok, 1297 const DirectoryLookup *LookupFrom, 1298 bool isImport) { 1299 1300 Token FilenameTok; 1301 CurPPLexer->LexIncludeFilename(FilenameTok); 1302 1303 // Reserve a buffer to get the spelling. 1304 SmallString<128> FilenameBuffer; 1305 StringRef Filename; 1306 SourceLocation End; 1307 SourceLocation CharEnd; // the end of this directive, in characters 1308 1309 switch (FilenameTok.getKind()) { 1310 case tok::eod: 1311 // If the token kind is EOD, the error has already been diagnosed. 1312 return; 1313 1314 case tok::angle_string_literal: 1315 case tok::string_literal: 1316 Filename = getSpelling(FilenameTok, FilenameBuffer); 1317 End = FilenameTok.getLocation(); 1318 CharEnd = End.getLocWithOffset(FilenameTok.getLength()); 1319 break; 1320 1321 case tok::less: 1322 // This could be a <foo/bar.h> file coming from a macro expansion. In this 1323 // case, glue the tokens together into FilenameBuffer and interpret those. 1324 FilenameBuffer.push_back('<'); 1325 if (ConcatenateIncludeName(FilenameBuffer, End)) 1326 return; // Found <eod> but no ">"? Diagnostic already emitted. 1327 Filename = FilenameBuffer.str(); 1328 CharEnd = End.getLocWithOffset(1); 1329 break; 1330 default: 1331 Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename); 1332 DiscardUntilEndOfDirective(); 1333 return; 1334 } 1335 1336 CharSourceRange FilenameRange 1337 = CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd); 1338 StringRef OriginalFilename = Filename; 1339 bool isAngled = 1340 GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename); 1341 // If GetIncludeFilenameSpelling set the start ptr to null, there was an 1342 // error. 1343 if (Filename.empty()) { 1344 DiscardUntilEndOfDirective(); 1345 return; 1346 } 1347 1348 // Verify that there is nothing after the filename, other than EOD. Note that 1349 // we allow macros that expand to nothing after the filename, because this 1350 // falls into the category of "#include pp-tokens new-line" specified in 1351 // C99 6.10.2p4. 1352 CheckEndOfDirective(IncludeTok.getIdentifierInfo()->getNameStart(), true); 1353 1354 // Check that we don't have infinite #include recursion. 1355 if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) { 1356 Diag(FilenameTok, diag::err_pp_include_too_deep); 1357 return; 1358 } 1359 1360 // Complain about attempts to #include files in an audit pragma. 1361 if (PragmaARCCFCodeAuditedLoc.isValid()) { 1362 Diag(HashLoc, diag::err_pp_include_in_arc_cf_code_audited); 1363 Diag(PragmaARCCFCodeAuditedLoc, diag::note_pragma_entered_here); 1364 1365 // Immediately leave the pragma. 1366 PragmaARCCFCodeAuditedLoc = SourceLocation(); 1367 } 1368 1369 if (HeaderInfo.HasIncludeAliasMap()) { 1370 // Map the filename with the brackets still attached. If the name doesn't 1371 // map to anything, fall back on the filename we've already gotten the 1372 // spelling for. 1373 StringRef NewName = HeaderInfo.MapHeaderToIncludeAlias(OriginalFilename); 1374 if (!NewName.empty()) 1375 Filename = NewName; 1376 } 1377 1378 // Search include directories. 1379 const DirectoryLookup *CurDir; 1380 SmallString<1024> SearchPath; 1381 SmallString<1024> RelativePath; 1382 // We get the raw path only if we have 'Callbacks' to which we later pass 1383 // the path. 1384 Module *SuggestedModule = 0; 1385 const FileEntry *File = LookupFile( 1386 Filename, isAngled, LookupFrom, CurDir, 1387 Callbacks ? &SearchPath : NULL, Callbacks ? &RelativePath : NULL, 1388 getLangOpts().Modules? &SuggestedModule : 0); 1389 1390 if (Callbacks) { 1391 if (!File) { 1392 // Give the clients a chance to recover. 1393 SmallString<128> RecoveryPath; 1394 if (Callbacks->FileNotFound(Filename, RecoveryPath)) { 1395 if (const DirectoryEntry *DE = FileMgr.getDirectory(RecoveryPath)) { 1396 // Add the recovery path to the list of search paths. 1397 DirectoryLookup DL(DE, SrcMgr::C_User, false); 1398 HeaderInfo.AddSearchPath(DL, isAngled); 1399 1400 // Try the lookup again, skipping the cache. 1401 File = LookupFile(Filename, isAngled, LookupFrom, CurDir, 0, 0, 1402 getLangOpts().Modules? &SuggestedModule : 0, 1403 /*SkipCache*/true); 1404 } 1405 } 1406 } 1407 1408 if (!SuggestedModule) { 1409 // Notify the callback object that we've seen an inclusion directive. 1410 Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled, 1411 FilenameRange, File, 1412 SearchPath, RelativePath, 1413 /*ImportedModule=*/0); 1414 } 1415 } 1416 1417 if (File == 0) { 1418 if (!SuppressIncludeNotFoundError) { 1419 // If the file could not be located and it was included via angle 1420 // brackets, we can attempt a lookup as though it were a quoted path to 1421 // provide the user with a possible fixit. 1422 if (isAngled) { 1423 File = LookupFile(Filename, false, LookupFrom, CurDir, 1424 Callbacks ? &SearchPath : 0, 1425 Callbacks ? &RelativePath : 0, 1426 getLangOpts().Modules ? &SuggestedModule : 0); 1427 if (File) { 1428 SourceRange Range(FilenameTok.getLocation(), CharEnd); 1429 Diag(FilenameTok, diag::err_pp_file_not_found_not_fatal) << 1430 Filename << 1431 FixItHint::CreateReplacement(Range, "\"" + Filename.str() + "\""); 1432 } 1433 } 1434 // If the file is still not found, just go with the vanilla diagnostic 1435 if (!File) 1436 Diag(FilenameTok, diag::err_pp_file_not_found) << Filename; 1437 } 1438 if (!File) 1439 return; 1440 } 1441 1442 // If we are supposed to import a module rather than including the header, 1443 // do so now. 1444 if (SuggestedModule) { 1445 // Compute the module access path corresponding to this module. 1446 // FIXME: Should we have a second loadModule() overload to avoid this 1447 // extra lookup step? 1448 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path; 1449 for (Module *Mod = SuggestedModule; Mod; Mod = Mod->Parent) 1450 Path.push_back(std::make_pair(getIdentifierInfo(Mod->Name), 1451 FilenameTok.getLocation())); 1452 std::reverse(Path.begin(), Path.end()); 1453 1454 // Warn that we're replacing the include/import with a module import. 1455 SmallString<128> PathString; 1456 for (unsigned I = 0, N = Path.size(); I != N; ++I) { 1457 if (I) 1458 PathString += '.'; 1459 PathString += Path[I].first->getName(); 1460 } 1461 int IncludeKind = 0; 1462 1463 switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) { 1464 case tok::pp_include: 1465 IncludeKind = 0; 1466 break; 1467 1468 case tok::pp_import: 1469 IncludeKind = 1; 1470 break; 1471 1472 case tok::pp_include_next: 1473 IncludeKind = 2; 1474 break; 1475 1476 case tok::pp___include_macros: 1477 IncludeKind = 3; 1478 break; 1479 1480 default: 1481 llvm_unreachable("unknown include directive kind"); 1482 } 1483 1484 // Determine whether we are actually building the module that this 1485 // include directive maps to. 1486 bool BuildingImportedModule 1487 = Path[0].first->getName() == getLangOpts().CurrentModule; 1488 1489 if (!BuildingImportedModule && getLangOpts().ObjC2) { 1490 // If we're not building the imported module, warn that we're going 1491 // to automatically turn this inclusion directive into a module import. 1492 // We only do this in Objective-C, where we have a module-import syntax. 1493 CharSourceRange ReplaceRange(SourceRange(HashLoc, CharEnd), 1494 /*IsTokenRange=*/false); 1495 Diag(HashLoc, diag::warn_auto_module_import) 1496 << IncludeKind << PathString 1497 << FixItHint::CreateReplacement(ReplaceRange, 1498 "@import " + PathString.str().str() + ";"); 1499 } 1500 1501 // Load the module. 1502 // If this was an #__include_macros directive, only make macros visible. 1503 Module::NameVisibilityKind Visibility 1504 = (IncludeKind == 3)? Module::MacrosVisible : Module::AllVisible; 1505 ModuleLoadResult Imported 1506 = TheModuleLoader.loadModule(IncludeTok.getLocation(), Path, Visibility, 1507 /*IsIncludeDirective=*/true); 1508 assert((Imported == 0 || Imported == SuggestedModule) && 1509 "the imported module is different than the suggested one"); 1510 1511 // If this header isn't part of the module we're building, we're done. 1512 if (!BuildingImportedModule && Imported) { 1513 if (Callbacks) { 1514 Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled, 1515 FilenameRange, File, 1516 SearchPath, RelativePath, Imported); 1517 } 1518 return; 1519 } 1520 1521 // If we failed to find a submodule that we expected to find, we can 1522 // continue. Otherwise, there's an error in the included file, so we 1523 // don't want to include it. 1524 if (!BuildingImportedModule && !Imported.isMissingExpected()) { 1525 return; 1526 } 1527 } 1528 1529 if (Callbacks && SuggestedModule) { 1530 // We didn't notify the callback object that we've seen an inclusion 1531 // directive before. Now that we are parsing the include normally and not 1532 // turning it to a module import, notify the callback object. 1533 Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled, 1534 FilenameRange, File, 1535 SearchPath, RelativePath, 1536 /*ImportedModule=*/0); 1537 } 1538 1539 // The #included file will be considered to be a system header if either it is 1540 // in a system include directory, or if the #includer is a system include 1541 // header. 1542 SrcMgr::CharacteristicKind FileCharacter = 1543 std::max(HeaderInfo.getFileDirFlavor(File), 1544 SourceMgr.getFileCharacteristic(FilenameTok.getLocation())); 1545 1546 // Ask HeaderInfo if we should enter this #include file. If not, #including 1547 // this file will have no effect. 1548 if (!HeaderInfo.ShouldEnterIncludeFile(File, isImport)) { 1549 if (Callbacks) 1550 Callbacks->FileSkipped(*File, FilenameTok, FileCharacter); 1551 return; 1552 } 1553 1554 // Look up the file, create a File ID for it. 1555 SourceLocation IncludePos = End; 1556 // If the filename string was the result of macro expansions, set the include 1557 // position on the file where it will be included and after the expansions. 1558 if (IncludePos.isMacroID()) 1559 IncludePos = SourceMgr.getExpansionRange(IncludePos).second; 1560 FileID FID = SourceMgr.createFileID(File, IncludePos, FileCharacter); 1561 assert(!FID.isInvalid() && "Expected valid file ID"); 1562 1563 // Finally, if all is good, enter the new file! 1564 EnterSourceFile(FID, CurDir, FilenameTok.getLocation()); 1565} 1566 1567/// HandleIncludeNextDirective - Implements \#include_next. 1568/// 1569void Preprocessor::HandleIncludeNextDirective(SourceLocation HashLoc, 1570 Token &IncludeNextTok) { 1571 Diag(IncludeNextTok, diag::ext_pp_include_next_directive); 1572 1573 // #include_next is like #include, except that we start searching after 1574 // the current found directory. If we can't do this, issue a 1575 // diagnostic. 1576 const DirectoryLookup *Lookup = CurDirLookup; 1577 if (isInPrimaryFile()) { 1578 Lookup = 0; 1579 Diag(IncludeNextTok, diag::pp_include_next_in_primary); 1580 } else if (Lookup == 0) { 1581 Diag(IncludeNextTok, diag::pp_include_next_absolute_path); 1582 } else { 1583 // Start looking up in the next directory. 1584 ++Lookup; 1585 } 1586 1587 return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup); 1588} 1589 1590/// HandleMicrosoftImportDirective - Implements \#import for Microsoft Mode 1591void Preprocessor::HandleMicrosoftImportDirective(Token &Tok) { 1592 // The Microsoft #import directive takes a type library and generates header 1593 // files from it, and includes those. This is beyond the scope of what clang 1594 // does, so we ignore it and error out. However, #import can optionally have 1595 // trailing attributes that span multiple lines. We're going to eat those 1596 // so we can continue processing from there. 1597 Diag(Tok, diag::err_pp_import_directive_ms ); 1598 1599 // Read tokens until we get to the end of the directive. Note that the 1600 // directive can be split over multiple lines using the backslash character. 1601 DiscardUntilEndOfDirective(); 1602} 1603 1604/// HandleImportDirective - Implements \#import. 1605/// 1606void Preprocessor::HandleImportDirective(SourceLocation HashLoc, 1607 Token &ImportTok) { 1608 if (!LangOpts.ObjC1) { // #import is standard for ObjC. 1609 if (LangOpts.MicrosoftMode) 1610 return HandleMicrosoftImportDirective(ImportTok); 1611 Diag(ImportTok, diag::ext_pp_import_directive); 1612 } 1613 return HandleIncludeDirective(HashLoc, ImportTok, 0, true); 1614} 1615 1616/// HandleIncludeMacrosDirective - The -imacros command line option turns into a 1617/// pseudo directive in the predefines buffer. This handles it by sucking all 1618/// tokens through the preprocessor and discarding them (only keeping the side 1619/// effects on the preprocessor). 1620void Preprocessor::HandleIncludeMacrosDirective(SourceLocation HashLoc, 1621 Token &IncludeMacrosTok) { 1622 // This directive should only occur in the predefines buffer. If not, emit an 1623 // error and reject it. 1624 SourceLocation Loc = IncludeMacrosTok.getLocation(); 1625 if (strcmp(SourceMgr.getBufferName(Loc), "<built-in>") != 0) { 1626 Diag(IncludeMacrosTok.getLocation(), 1627 diag::pp_include_macros_out_of_predefines); 1628 DiscardUntilEndOfDirective(); 1629 return; 1630 } 1631 1632 // Treat this as a normal #include for checking purposes. If this is 1633 // successful, it will push a new lexer onto the include stack. 1634 HandleIncludeDirective(HashLoc, IncludeMacrosTok, 0, false); 1635 1636 Token TmpTok; 1637 do { 1638 Lex(TmpTok); 1639 assert(TmpTok.isNot(tok::eof) && "Didn't find end of -imacros!"); 1640 } while (TmpTok.isNot(tok::hashhash)); 1641} 1642 1643//===----------------------------------------------------------------------===// 1644// Preprocessor Macro Directive Handling. 1645//===----------------------------------------------------------------------===// 1646 1647/// ReadMacroDefinitionArgList - The ( starting an argument list of a macro 1648/// definition has just been read. Lex the rest of the arguments and the 1649/// closing ), updating MI with what we learn. Return true if an error occurs 1650/// parsing the arg list. 1651bool Preprocessor::ReadMacroDefinitionArgList(MacroInfo *MI, Token &Tok) { 1652 SmallVector<IdentifierInfo*, 32> Arguments; 1653 1654 while (1) { 1655 LexUnexpandedToken(Tok); 1656 switch (Tok.getKind()) { 1657 case tok::r_paren: 1658 // Found the end of the argument list. 1659 if (Arguments.empty()) // #define FOO() 1660 return false; 1661 // Otherwise we have #define FOO(A,) 1662 Diag(Tok, diag::err_pp_expected_ident_in_arg_list); 1663 return true; 1664 case tok::ellipsis: // #define X(... -> C99 varargs 1665 if (!LangOpts.C99) 1666 Diag(Tok, LangOpts.CPlusPlus11 ? 1667 diag::warn_cxx98_compat_variadic_macro : 1668 diag::ext_variadic_macro); 1669 1670 // OpenCL v1.2 s6.9.e: variadic macros are not supported. 1671 if (LangOpts.OpenCL) { 1672 Diag(Tok, diag::err_pp_opencl_variadic_macros); 1673 return true; 1674 } 1675 1676 // Lex the token after the identifier. 1677 LexUnexpandedToken(Tok); 1678 if (Tok.isNot(tok::r_paren)) { 1679 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def); 1680 return true; 1681 } 1682 // Add the __VA_ARGS__ identifier as an argument. 1683 Arguments.push_back(Ident__VA_ARGS__); 1684 MI->setIsC99Varargs(); 1685 MI->setArgumentList(&Arguments[0], Arguments.size(), BP); 1686 return false; 1687 case tok::eod: // #define X( 1688 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def); 1689 return true; 1690 default: 1691 // Handle keywords and identifiers here to accept things like 1692 // #define Foo(for) for. 1693 IdentifierInfo *II = Tok.getIdentifierInfo(); 1694 if (II == 0) { 1695 // #define X(1 1696 Diag(Tok, diag::err_pp_invalid_tok_in_arg_list); 1697 return true; 1698 } 1699 1700 // If this is already used as an argument, it is used multiple times (e.g. 1701 // #define X(A,A. 1702 if (std::find(Arguments.begin(), Arguments.end(), II) != 1703 Arguments.end()) { // C99 6.10.3p6 1704 Diag(Tok, diag::err_pp_duplicate_name_in_arg_list) << II; 1705 return true; 1706 } 1707 1708 // Add the argument to the macro info. 1709 Arguments.push_back(II); 1710 1711 // Lex the token after the identifier. 1712 LexUnexpandedToken(Tok); 1713 1714 switch (Tok.getKind()) { 1715 default: // #define X(A B 1716 Diag(Tok, diag::err_pp_expected_comma_in_arg_list); 1717 return true; 1718 case tok::r_paren: // #define X(A) 1719 MI->setArgumentList(&Arguments[0], Arguments.size(), BP); 1720 return false; 1721 case tok::comma: // #define X(A, 1722 break; 1723 case tok::ellipsis: // #define X(A... -> GCC extension 1724 // Diagnose extension. 1725 Diag(Tok, diag::ext_named_variadic_macro); 1726 1727 // Lex the token after the identifier. 1728 LexUnexpandedToken(Tok); 1729 if (Tok.isNot(tok::r_paren)) { 1730 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def); 1731 return true; 1732 } 1733 1734 MI->setIsGNUVarargs(); 1735 MI->setArgumentList(&Arguments[0], Arguments.size(), BP); 1736 return false; 1737 } 1738 } 1739 } 1740} 1741 1742/// HandleDefineDirective - Implements \#define. This consumes the entire macro 1743/// line then lets the caller lex the next real token. 1744void Preprocessor::HandleDefineDirective(Token &DefineTok) { 1745 ++NumDefined; 1746 1747 Token MacroNameTok; 1748 ReadMacroName(MacroNameTok, 1); 1749 1750 // Error reading macro name? If so, diagnostic already issued. 1751 if (MacroNameTok.is(tok::eod)) 1752 return; 1753 1754 Token LastTok = MacroNameTok; 1755 1756 // If we are supposed to keep comments in #defines, reenable comment saving 1757 // mode. 1758 if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments); 1759 1760 // Create the new macro. 1761 MacroInfo *MI = AllocateMacroInfo(MacroNameTok.getLocation()); 1762 1763 Token Tok; 1764 LexUnexpandedToken(Tok); 1765 1766 // If this is a function-like macro definition, parse the argument list, 1767 // marking each of the identifiers as being used as macro arguments. Also, 1768 // check other constraints on the first token of the macro body. 1769 if (Tok.is(tok::eod)) { 1770 // If there is no body to this macro, we have no special handling here. 1771 } else if (Tok.hasLeadingSpace()) { 1772 // This is a normal token with leading space. Clear the leading space 1773 // marker on the first token to get proper expansion. 1774 Tok.clearFlag(Token::LeadingSpace); 1775 } else if (Tok.is(tok::l_paren)) { 1776 // This is a function-like macro definition. Read the argument list. 1777 MI->setIsFunctionLike(); 1778 if (ReadMacroDefinitionArgList(MI, LastTok)) { 1779 // Forget about MI. 1780 ReleaseMacroInfo(MI); 1781 // Throw away the rest of the line. 1782 if (CurPPLexer->ParsingPreprocessorDirective) 1783 DiscardUntilEndOfDirective(); 1784 return; 1785 } 1786 1787 // If this is a definition of a variadic C99 function-like macro, not using 1788 // the GNU named varargs extension, enabled __VA_ARGS__. 1789 1790 // "Poison" __VA_ARGS__, which can only appear in the expansion of a macro. 1791 // This gets unpoisoned where it is allowed. 1792 assert(Ident__VA_ARGS__->isPoisoned() && "__VA_ARGS__ should be poisoned!"); 1793 if (MI->isC99Varargs()) 1794 Ident__VA_ARGS__->setIsPoisoned(false); 1795 1796 // Read the first token after the arg list for down below. 1797 LexUnexpandedToken(Tok); 1798 } else if (LangOpts.C99 || LangOpts.CPlusPlus11) { 1799 // C99 requires whitespace between the macro definition and the body. Emit 1800 // a diagnostic for something like "#define X+". 1801 Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name); 1802 } else { 1803 // C90 6.8 TC1 says: "In the definition of an object-like macro, if the 1804 // first character of a replacement list is not a character required by 1805 // subclause 5.2.1, then there shall be white-space separation between the 1806 // identifier and the replacement list.". 5.2.1 lists this set: 1807 // "A-Za-z0-9!"#%&'()*+,_./:;<=>?[\]^_{|}~" as well as whitespace, which 1808 // is irrelevant here. 1809 bool isInvalid = false; 1810 if (Tok.is(tok::at)) // @ is not in the list above. 1811 isInvalid = true; 1812 else if (Tok.is(tok::unknown)) { 1813 // If we have an unknown token, it is something strange like "`". Since 1814 // all of valid characters would have lexed into a single character 1815 // token of some sort, we know this is not a valid case. 1816 isInvalid = true; 1817 } 1818 if (isInvalid) 1819 Diag(Tok, diag::ext_missing_whitespace_after_macro_name); 1820 else 1821 Diag(Tok, diag::warn_missing_whitespace_after_macro_name); 1822 } 1823 1824 if (!Tok.is(tok::eod)) 1825 LastTok = Tok; 1826 1827 // Read the rest of the macro body. 1828 if (MI->isObjectLike()) { 1829 // Object-like macros are very simple, just read their body. 1830 while (Tok.isNot(tok::eod)) { 1831 LastTok = Tok; 1832 MI->AddTokenToBody(Tok); 1833 // Get the next token of the macro. 1834 LexUnexpandedToken(Tok); 1835 } 1836 1837 } else { 1838 // Otherwise, read the body of a function-like macro. While we are at it, 1839 // check C99 6.10.3.2p1: ensure that # operators are followed by macro 1840 // parameters in function-like macro expansions. 1841 while (Tok.isNot(tok::eod)) { 1842 LastTok = Tok; 1843 1844 if (Tok.isNot(tok::hash) && Tok.isNot(tok::hashhash)) { 1845 MI->AddTokenToBody(Tok); 1846 1847 // Get the next token of the macro. 1848 LexUnexpandedToken(Tok); 1849 continue; 1850 } 1851 1852 if (Tok.is(tok::hashhash)) { 1853 1854 // If we see token pasting, check if it looks like the gcc comma 1855 // pasting extension. We'll use this information to suppress 1856 // diagnostics later on. 1857 1858 // Get the next token of the macro. 1859 LexUnexpandedToken(Tok); 1860 1861 if (Tok.is(tok::eod)) { 1862 MI->AddTokenToBody(LastTok); 1863 break; 1864 } 1865 1866 unsigned NumTokens = MI->getNumTokens(); 1867 if (NumTokens && Tok.getIdentifierInfo() == Ident__VA_ARGS__ && 1868 MI->getReplacementToken(NumTokens-1).is(tok::comma)) 1869 MI->setHasCommaPasting(); 1870 1871 // Things look ok, add the '##' and param name tokens to the macro. 1872 MI->AddTokenToBody(LastTok); 1873 MI->AddTokenToBody(Tok); 1874 LastTok = Tok; 1875 1876 // Get the next token of the macro. 1877 LexUnexpandedToken(Tok); 1878 continue; 1879 } 1880 1881 // Get the next token of the macro. 1882 LexUnexpandedToken(Tok); 1883 1884 // Check for a valid macro arg identifier. 1885 if (Tok.getIdentifierInfo() == 0 || 1886 MI->getArgumentNum(Tok.getIdentifierInfo()) == -1) { 1887 1888 // If this is assembler-with-cpp mode, we accept random gibberish after 1889 // the '#' because '#' is often a comment character. However, change 1890 // the kind of the token to tok::unknown so that the preprocessor isn't 1891 // confused. 1892 if (getLangOpts().AsmPreprocessor && Tok.isNot(tok::eod)) { 1893 LastTok.setKind(tok::unknown); 1894 } else { 1895 Diag(Tok, diag::err_pp_stringize_not_parameter); 1896 ReleaseMacroInfo(MI); 1897 1898 // Disable __VA_ARGS__ again. 1899 Ident__VA_ARGS__->setIsPoisoned(true); 1900 return; 1901 } 1902 } 1903 1904 // Things look ok, add the '#' and param name tokens to the macro. 1905 MI->AddTokenToBody(LastTok); 1906 MI->AddTokenToBody(Tok); 1907 LastTok = Tok; 1908 1909 // Get the next token of the macro. 1910 LexUnexpandedToken(Tok); 1911 } 1912 } 1913 1914 1915 // Disable __VA_ARGS__ again. 1916 Ident__VA_ARGS__->setIsPoisoned(true); 1917 1918 // Check that there is no paste (##) operator at the beginning or end of the 1919 // replacement list. 1920 unsigned NumTokens = MI->getNumTokens(); 1921 if (NumTokens != 0) { 1922 if (MI->getReplacementToken(0).is(tok::hashhash)) { 1923 Diag(MI->getReplacementToken(0), diag::err_paste_at_start); 1924 ReleaseMacroInfo(MI); 1925 return; 1926 } 1927 if (MI->getReplacementToken(NumTokens-1).is(tok::hashhash)) { 1928 Diag(MI->getReplacementToken(NumTokens-1), diag::err_paste_at_end); 1929 ReleaseMacroInfo(MI); 1930 return; 1931 } 1932 } 1933 1934 MI->setDefinitionEndLoc(LastTok.getLocation()); 1935 1936 // Finally, if this identifier already had a macro defined for it, verify that 1937 // the macro bodies are identical, and issue diagnostics if they are not. 1938 if (const MacroInfo *OtherMI=getMacroInfo(MacroNameTok.getIdentifierInfo())) { 1939 // It is very common for system headers to have tons of macro redefinitions 1940 // and for warnings to be disabled in system headers. If this is the case, 1941 // then don't bother calling MacroInfo::isIdenticalTo. 1942 if (!getDiagnostics().getSuppressSystemWarnings() || 1943 !SourceMgr.isInSystemHeader(DefineTok.getLocation())) { 1944 if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused()) 1945 Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used); 1946 1947 // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and 1948 // C++ [cpp.predefined]p4, but allow it as an extension. 1949 if (OtherMI->isBuiltinMacro()) 1950 Diag(MacroNameTok, diag::ext_pp_redef_builtin_macro); 1951 // Macros must be identical. This means all tokens and whitespace 1952 // separation must be the same. C99 6.10.3.2. 1953 else if (!OtherMI->isAllowRedefinitionsWithoutWarning() && 1954 !MI->isIdenticalTo(*OtherMI, *this)) { 1955 Diag(MI->getDefinitionLoc(), diag::ext_pp_macro_redef) 1956 << MacroNameTok.getIdentifierInfo(); 1957 Diag(OtherMI->getDefinitionLoc(), diag::note_previous_definition); 1958 } 1959 } 1960 if (OtherMI->isWarnIfUnused()) 1961 WarnUnusedMacroLocs.erase(OtherMI->getDefinitionLoc()); 1962 } 1963 1964 DefMacroDirective *MD = 1965 appendDefMacroDirective(MacroNameTok.getIdentifierInfo(), MI); 1966 1967 assert(!MI->isUsed()); 1968 // If we need warning for not using the macro, add its location in the 1969 // warn-because-unused-macro set. If it gets used it will be removed from set. 1970 if (isInPrimaryFile() && // don't warn for include'd macros. 1971 Diags->getDiagnosticLevel(diag::pp_macro_not_used, 1972 MI->getDefinitionLoc()) != DiagnosticsEngine::Ignored) { 1973 MI->setIsWarnIfUnused(true); 1974 WarnUnusedMacroLocs.insert(MI->getDefinitionLoc()); 1975 } 1976 1977 // If the callbacks want to know, tell them about the macro definition. 1978 if (Callbacks) 1979 Callbacks->MacroDefined(MacroNameTok, MD); 1980} 1981 1982/// HandleUndefDirective - Implements \#undef. 1983/// 1984void Preprocessor::HandleUndefDirective(Token &UndefTok) { 1985 ++NumUndefined; 1986 1987 Token MacroNameTok; 1988 ReadMacroName(MacroNameTok, 2); 1989 1990 // Error reading macro name? If so, diagnostic already issued. 1991 if (MacroNameTok.is(tok::eod)) 1992 return; 1993 1994 // Check to see if this is the last token on the #undef line. 1995 CheckEndOfDirective("undef"); 1996 1997 // Okay, we finally have a valid identifier to undef. 1998 MacroDirective *MD = getMacroDirective(MacroNameTok.getIdentifierInfo()); 1999 const MacroInfo *MI = MD ? MD->getMacroInfo() : 0; 2000 2001 // If the callbacks want to know, tell them about the macro #undef. 2002 // Note: no matter if the macro was defined or not. 2003 if (Callbacks) 2004 Callbacks->MacroUndefined(MacroNameTok, MD); 2005 2006 // If the macro is not defined, this is a noop undef, just return. 2007 if (MI == 0) return; 2008 2009 if (!MI->isUsed() && MI->isWarnIfUnused()) 2010 Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used); 2011 2012 if (MI->isWarnIfUnused()) 2013 WarnUnusedMacroLocs.erase(MI->getDefinitionLoc()); 2014 2015 appendMacroDirective(MacroNameTok.getIdentifierInfo(), 2016 AllocateUndefMacroDirective(MacroNameTok.getLocation())); 2017} 2018 2019 2020//===----------------------------------------------------------------------===// 2021// Preprocessor Conditional Directive Handling. 2022//===----------------------------------------------------------------------===// 2023 2024/// HandleIfdefDirective - Implements the \#ifdef/\#ifndef directive. isIfndef 2025/// is true when this is a \#ifndef directive. ReadAnyTokensBeforeDirective is 2026/// true if any tokens have been returned or pp-directives activated before this 2027/// \#ifndef has been lexed. 2028/// 2029void Preprocessor::HandleIfdefDirective(Token &Result, bool isIfndef, 2030 bool ReadAnyTokensBeforeDirective) { 2031 ++NumIf; 2032 Token DirectiveTok = Result; 2033 2034 Token MacroNameTok; 2035 ReadMacroName(MacroNameTok); 2036 2037 // Error reading macro name? If so, diagnostic already issued. 2038 if (MacroNameTok.is(tok::eod)) { 2039 // Skip code until we get to #endif. This helps with recovery by not 2040 // emitting an error when the #endif is reached. 2041 SkipExcludedConditionalBlock(DirectiveTok.getLocation(), 2042 /*Foundnonskip*/false, /*FoundElse*/false); 2043 return; 2044 } 2045 2046 // Check to see if this is the last token on the #if[n]def line. 2047 CheckEndOfDirective(isIfndef ? "ifndef" : "ifdef"); 2048 2049 IdentifierInfo *MII = MacroNameTok.getIdentifierInfo(); 2050 MacroDirective *MD = getMacroDirective(MII); 2051 MacroInfo *MI = MD ? MD->getMacroInfo() : 0; 2052 2053 if (CurPPLexer->getConditionalStackDepth() == 0) { 2054 // If the start of a top-level #ifdef and if the macro is not defined, 2055 // inform MIOpt that this might be the start of a proper include guard. 2056 // Otherwise it is some other form of unknown conditional which we can't 2057 // handle. 2058 if (!ReadAnyTokensBeforeDirective && MI == 0) { 2059 assert(isIfndef && "#ifdef shouldn't reach here"); 2060 CurPPLexer->MIOpt.EnterTopLevelIFNDEF(MII); 2061 } else 2062 CurPPLexer->MIOpt.EnterTopLevelConditional(); 2063 } 2064 2065 // If there is a macro, process it. 2066 if (MI) // Mark it used. 2067 markMacroAsUsed(MI); 2068 2069 if (Callbacks) { 2070 if (isIfndef) 2071 Callbacks->Ifndef(DirectiveTok.getLocation(), MacroNameTok, MD); 2072 else 2073 Callbacks->Ifdef(DirectiveTok.getLocation(), MacroNameTok, MD); 2074 } 2075 2076 // Should we include the stuff contained by this directive? 2077 if (!MI == isIfndef) { 2078 // Yes, remember that we are inside a conditional, then lex the next token. 2079 CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(), 2080 /*wasskip*/false, /*foundnonskip*/true, 2081 /*foundelse*/false); 2082 } else { 2083 // No, skip the contents of this block. 2084 SkipExcludedConditionalBlock(DirectiveTok.getLocation(), 2085 /*Foundnonskip*/false, 2086 /*FoundElse*/false); 2087 } 2088} 2089 2090/// HandleIfDirective - Implements the \#if directive. 2091/// 2092void Preprocessor::HandleIfDirective(Token &IfToken, 2093 bool ReadAnyTokensBeforeDirective) { 2094 ++NumIf; 2095 2096 // Parse and evaluate the conditional expression. 2097 IdentifierInfo *IfNDefMacro = 0; 2098 const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation(); 2099 const bool ConditionalTrue = EvaluateDirectiveExpression(IfNDefMacro); 2100 const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation(); 2101 2102 // If this condition is equivalent to #ifndef X, and if this is the first 2103 // directive seen, handle it for the multiple-include optimization. 2104 if (CurPPLexer->getConditionalStackDepth() == 0) { 2105 if (!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue) 2106 CurPPLexer->MIOpt.EnterTopLevelIFNDEF(IfNDefMacro); 2107 else 2108 CurPPLexer->MIOpt.EnterTopLevelConditional(); 2109 } 2110 2111 if (Callbacks) 2112 Callbacks->If(IfToken.getLocation(), 2113 SourceRange(ConditionalBegin, ConditionalEnd)); 2114 2115 // Should we include the stuff contained by this directive? 2116 if (ConditionalTrue) { 2117 // Yes, remember that we are inside a conditional, then lex the next token. 2118 CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false, 2119 /*foundnonskip*/true, /*foundelse*/false); 2120 } else { 2121 // No, skip the contents of this block. 2122 SkipExcludedConditionalBlock(IfToken.getLocation(), /*Foundnonskip*/false, 2123 /*FoundElse*/false); 2124 } 2125} 2126 2127/// HandleEndifDirective - Implements the \#endif directive. 2128/// 2129void Preprocessor::HandleEndifDirective(Token &EndifToken) { 2130 ++NumEndif; 2131 2132 // Check that this is the whole directive. 2133 CheckEndOfDirective("endif"); 2134 2135 PPConditionalInfo CondInfo; 2136 if (CurPPLexer->popConditionalLevel(CondInfo)) { 2137 // No conditionals on the stack: this is an #endif without an #if. 2138 Diag(EndifToken, diag::err_pp_endif_without_if); 2139 return; 2140 } 2141 2142 // If this the end of a top-level #endif, inform MIOpt. 2143 if (CurPPLexer->getConditionalStackDepth() == 0) 2144 CurPPLexer->MIOpt.ExitTopLevelConditional(); 2145 2146 assert(!CondInfo.WasSkipping && !CurPPLexer->LexingRawMode && 2147 "This code should only be reachable in the non-skipping case!"); 2148 2149 if (Callbacks) 2150 Callbacks->Endif(EndifToken.getLocation(), CondInfo.IfLoc); 2151} 2152 2153/// HandleElseDirective - Implements the \#else directive. 2154/// 2155void Preprocessor::HandleElseDirective(Token &Result) { 2156 ++NumElse; 2157 2158 // #else directive in a non-skipping conditional... start skipping. 2159 CheckEndOfDirective("else"); 2160 2161 PPConditionalInfo CI; 2162 if (CurPPLexer->popConditionalLevel(CI)) { 2163 Diag(Result, diag::pp_err_else_without_if); 2164 return; 2165 } 2166 2167 // If this is a top-level #else, inform the MIOpt. 2168 if (CurPPLexer->getConditionalStackDepth() == 0) 2169 CurPPLexer->MIOpt.EnterTopLevelConditional(); 2170 2171 // If this is a #else with a #else before it, report the error. 2172 if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else); 2173 2174 if (Callbacks) 2175 Callbacks->Else(Result.getLocation(), CI.IfLoc); 2176 2177 // Finally, skip the rest of the contents of this block. 2178 SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true, 2179 /*FoundElse*/true, Result.getLocation()); 2180} 2181 2182/// HandleElifDirective - Implements the \#elif directive. 2183/// 2184void Preprocessor::HandleElifDirective(Token &ElifToken) { 2185 ++NumElse; 2186 2187 // #elif directive in a non-skipping conditional... start skipping. 2188 // We don't care what the condition is, because we will always skip it (since 2189 // the block immediately before it was included). 2190 const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation(); 2191 DiscardUntilEndOfDirective(); 2192 const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation(); 2193 2194 PPConditionalInfo CI; 2195 if (CurPPLexer->popConditionalLevel(CI)) { 2196 Diag(ElifToken, diag::pp_err_elif_without_if); 2197 return; 2198 } 2199 2200 // If this is a top-level #elif, inform the MIOpt. 2201 if (CurPPLexer->getConditionalStackDepth() == 0) 2202 CurPPLexer->MIOpt.EnterTopLevelConditional(); 2203 2204 // If this is a #elif with a #else before it, report the error. 2205 if (CI.FoundElse) Diag(ElifToken, diag::pp_err_elif_after_else); 2206 2207 if (Callbacks) 2208 Callbacks->Elif(ElifToken.getLocation(), 2209 SourceRange(ConditionalBegin, ConditionalEnd), CI.IfLoc); 2210 2211 // Finally, skip the rest of the contents of this block. 2212 SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true, 2213 /*FoundElse*/CI.FoundElse, 2214 ElifToken.getLocation()); 2215} 2216