1 //===--- PPDirectives.cpp - Directive Handling for Preprocessor -----------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// 9 /// \file 10 /// Implements # directive processing for the Preprocessor. 11 /// 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Basic/CharInfo.h" 15 #include "clang/Basic/FileManager.h" 16 #include "clang/Basic/IdentifierTable.h" 17 #include "clang/Basic/LangOptions.h" 18 #include "clang/Basic/Module.h" 19 #include "clang/Basic/SourceLocation.h" 20 #include "clang/Basic/SourceManager.h" 21 #include "clang/Basic/TokenKinds.h" 22 #include "clang/Lex/CodeCompletionHandler.h" 23 #include "clang/Lex/HeaderSearch.h" 24 #include "clang/Lex/LexDiagnostic.h" 25 #include "clang/Lex/LiteralSupport.h" 26 #include "clang/Lex/MacroInfo.h" 27 #include "clang/Lex/ModuleLoader.h" 28 #include "clang/Lex/ModuleMap.h" 29 #include "clang/Lex/PPCallbacks.h" 30 #include "clang/Lex/Pragma.h" 31 #include "clang/Lex/Preprocessor.h" 32 #include "clang/Lex/PreprocessorOptions.h" 33 #include "clang/Lex/Token.h" 34 #include "clang/Lex/VariadicMacroSupport.h" 35 #include "llvm/ADT/ArrayRef.h" 36 #include "llvm/ADT/STLExtras.h" 37 #include "llvm/ADT/ScopeExit.h" 38 #include "llvm/ADT/SmallString.h" 39 #include "llvm/ADT/SmallVector.h" 40 #include "llvm/ADT/StringRef.h" 41 #include "llvm/ADT/StringSwitch.h" 42 #include "llvm/Support/AlignOf.h" 43 #include "llvm/Support/ErrorHandling.h" 44 #include "llvm/Support/Path.h" 45 #include "llvm/Support/SaveAndRestore.h" 46 #include <algorithm> 47 #include <cassert> 48 #include <cstring> 49 #include <new> 50 #include <string> 51 #include <utility> 52 53 using namespace clang; 54 55 //===----------------------------------------------------------------------===// 56 // Utility Methods for Preprocessor Directive Handling. 57 //===----------------------------------------------------------------------===// 58 59 MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) { 60 auto *MIChain = new (BP) MacroInfoChain{L, MIChainHead}; 61 MIChainHead = MIChain; 62 return &MIChain->MI; 63 } 64 65 DefMacroDirective *Preprocessor::AllocateDefMacroDirective(MacroInfo *MI, 66 SourceLocation Loc) { 67 return new (BP) DefMacroDirective(MI, Loc); 68 } 69 70 UndefMacroDirective * 71 Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) { 72 return new (BP) UndefMacroDirective(UndefLoc); 73 } 74 75 VisibilityMacroDirective * 76 Preprocessor::AllocateVisibilityMacroDirective(SourceLocation Loc, 77 bool isPublic) { 78 return new (BP) VisibilityMacroDirective(Loc, isPublic); 79 } 80 81 /// Read and discard all tokens remaining on the current line until 82 /// the tok::eod token is found. 83 SourceRange Preprocessor::DiscardUntilEndOfDirective() { 84 Token Tmp; 85 SourceRange Res; 86 87 LexUnexpandedToken(Tmp); 88 Res.setBegin(Tmp.getLocation()); 89 while (Tmp.isNot(tok::eod)) { 90 assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens"); 91 LexUnexpandedToken(Tmp); 92 } 93 Res.setEnd(Tmp.getLocation()); 94 return Res; 95 } 96 97 /// Enumerates possible cases of #define/#undef a reserved identifier. 98 enum MacroDiag { 99 MD_NoWarn, //> Not a reserved identifier 100 MD_KeywordDef, //> Macro hides keyword, enabled by default 101 MD_ReservedMacro //> #define of #undef reserved id, disabled by default 102 }; 103 104 /// Enumerates possible %select values for the pp_err_elif_after_else and 105 /// pp_err_elif_without_if diagnostics. 106 enum PPElifDiag { 107 PED_Elif, 108 PED_Elifdef, 109 PED_Elifndef 110 }; 111 112 // The -fmodule-name option tells the compiler to textually include headers in 113 // the specified module, meaning clang won't build the specified module. This is 114 // useful in a number of situations, for instance, when building a library that 115 // vends a module map, one might want to avoid hitting intermediate build 116 // products containimg the module map or avoid finding the system installed 117 // modulemap for that library. 118 static bool isForModuleBuilding(Module *M, StringRef CurrentModule, 119 StringRef ModuleName) { 120 StringRef TopLevelName = M->getTopLevelModuleName(); 121 122 // When building framework Foo, we wanna make sure that Foo *and* Foo_Private 123 // are textually included and no modules are built for both. 124 if (M->getTopLevelModule()->IsFramework && CurrentModule == ModuleName && 125 !CurrentModule.endswith("_Private") && TopLevelName.endswith("_Private")) 126 TopLevelName = TopLevelName.drop_back(8); 127 128 return TopLevelName == CurrentModule; 129 } 130 131 static MacroDiag shouldWarnOnMacroDef(Preprocessor &PP, IdentifierInfo *II) { 132 const LangOptions &Lang = PP.getLangOpts(); 133 if (isReservedInAllContexts(II->isReserved(Lang))) { 134 // list from: 135 // - https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_macros.html 136 // - https://docs.microsoft.com/en-us/cpp/c-runtime-library/security-features-in-the-crt?view=msvc-160 137 // - man 7 feature_test_macros 138 // The list must be sorted for correct binary search. 139 static constexpr StringRef ReservedMacro[] = { 140 "_ATFILE_SOURCE", 141 "_BSD_SOURCE", 142 "_CRT_NONSTDC_NO_WARNINGS", 143 "_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES", 144 "_CRT_SECURE_NO_WARNINGS", 145 "_FILE_OFFSET_BITS", 146 "_FORTIFY_SOURCE", 147 "_GLIBCXX_ASSERTIONS", 148 "_GLIBCXX_CONCEPT_CHECKS", 149 "_GLIBCXX_DEBUG", 150 "_GLIBCXX_DEBUG_PEDANTIC", 151 "_GLIBCXX_PARALLEL", 152 "_GLIBCXX_PARALLEL_ASSERTIONS", 153 "_GLIBCXX_SANITIZE_VECTOR", 154 "_GLIBCXX_USE_CXX11_ABI", 155 "_GLIBCXX_USE_DEPRECATED", 156 "_GNU_SOURCE", 157 "_ISOC11_SOURCE", 158 "_ISOC95_SOURCE", 159 "_ISOC99_SOURCE", 160 "_LARGEFILE64_SOURCE", 161 "_POSIX_C_SOURCE", 162 "_REENTRANT", 163 "_SVID_SOURCE", 164 "_THREAD_SAFE", 165 "_XOPEN_SOURCE", 166 "_XOPEN_SOURCE_EXTENDED", 167 "__STDCPP_WANT_MATH_SPEC_FUNCS__", 168 "__STDC_FORMAT_MACROS", 169 }; 170 if (std::binary_search(std::begin(ReservedMacro), std::end(ReservedMacro), 171 II->getName())) 172 return MD_NoWarn; 173 174 return MD_ReservedMacro; 175 } 176 StringRef Text = II->getName(); 177 if (II->isKeyword(Lang)) 178 return MD_KeywordDef; 179 if (Lang.CPlusPlus11 && (Text.equals("override") || Text.equals("final"))) 180 return MD_KeywordDef; 181 return MD_NoWarn; 182 } 183 184 static MacroDiag shouldWarnOnMacroUndef(Preprocessor &PP, IdentifierInfo *II) { 185 const LangOptions &Lang = PP.getLangOpts(); 186 // Do not warn on keyword undef. It is generally harmless and widely used. 187 if (isReservedInAllContexts(II->isReserved(Lang))) 188 return MD_ReservedMacro; 189 return MD_NoWarn; 190 } 191 192 // Return true if we want to issue a diagnostic by default if we 193 // encounter this name in a #include with the wrong case. For now, 194 // this includes the standard C and C++ headers, Posix headers, 195 // and Boost headers. Improper case for these #includes is a 196 // potential portability issue. 197 static bool warnByDefaultOnWrongCase(StringRef Include) { 198 // If the first component of the path is "boost", treat this like a standard header 199 // for the purposes of diagnostics. 200 if (::llvm::sys::path::begin(Include)->equals_insensitive("boost")) 201 return true; 202 203 // "condition_variable" is the longest standard header name at 18 characters. 204 // If the include file name is longer than that, it can't be a standard header. 205 static const size_t MaxStdHeaderNameLen = 18u; 206 if (Include.size() > MaxStdHeaderNameLen) 207 return false; 208 209 // Lowercase and normalize the search string. 210 SmallString<32> LowerInclude{Include}; 211 for (char &Ch : LowerInclude) { 212 // In the ASCII range? 213 if (static_cast<unsigned char>(Ch) > 0x7f) 214 return false; // Can't be a standard header 215 // ASCII lowercase: 216 if (Ch >= 'A' && Ch <= 'Z') 217 Ch += 'a' - 'A'; 218 // Normalize path separators for comparison purposes. 219 else if (::llvm::sys::path::is_separator(Ch)) 220 Ch = '/'; 221 } 222 223 // The standard C/C++ and Posix headers 224 return llvm::StringSwitch<bool>(LowerInclude) 225 // C library headers 226 .Cases("assert.h", "complex.h", "ctype.h", "errno.h", "fenv.h", true) 227 .Cases("float.h", "inttypes.h", "iso646.h", "limits.h", "locale.h", true) 228 .Cases("math.h", "setjmp.h", "signal.h", "stdalign.h", "stdarg.h", true) 229 .Cases("stdatomic.h", "stdbool.h", "stddef.h", "stdint.h", "stdio.h", true) 230 .Cases("stdlib.h", "stdnoreturn.h", "string.h", "tgmath.h", "threads.h", true) 231 .Cases("time.h", "uchar.h", "wchar.h", "wctype.h", true) 232 233 // C++ headers for C library facilities 234 .Cases("cassert", "ccomplex", "cctype", "cerrno", "cfenv", true) 235 .Cases("cfloat", "cinttypes", "ciso646", "climits", "clocale", true) 236 .Cases("cmath", "csetjmp", "csignal", "cstdalign", "cstdarg", true) 237 .Cases("cstdbool", "cstddef", "cstdint", "cstdio", "cstdlib", true) 238 .Cases("cstring", "ctgmath", "ctime", "cuchar", "cwchar", true) 239 .Case("cwctype", true) 240 241 // C++ library headers 242 .Cases("algorithm", "fstream", "list", "regex", "thread", true) 243 .Cases("array", "functional", "locale", "scoped_allocator", "tuple", true) 244 .Cases("atomic", "future", "map", "set", "type_traits", true) 245 .Cases("bitset", "initializer_list", "memory", "shared_mutex", "typeindex", true) 246 .Cases("chrono", "iomanip", "mutex", "sstream", "typeinfo", true) 247 .Cases("codecvt", "ios", "new", "stack", "unordered_map", true) 248 .Cases("complex", "iosfwd", "numeric", "stdexcept", "unordered_set", true) 249 .Cases("condition_variable", "iostream", "ostream", "streambuf", "utility", true) 250 .Cases("deque", "istream", "queue", "string", "valarray", true) 251 .Cases("exception", "iterator", "random", "strstream", "vector", true) 252 .Cases("forward_list", "limits", "ratio", "system_error", true) 253 254 // POSIX headers (which aren't also C headers) 255 .Cases("aio.h", "arpa/inet.h", "cpio.h", "dirent.h", "dlfcn.h", true) 256 .Cases("fcntl.h", "fmtmsg.h", "fnmatch.h", "ftw.h", "glob.h", true) 257 .Cases("grp.h", "iconv.h", "langinfo.h", "libgen.h", "monetary.h", true) 258 .Cases("mqueue.h", "ndbm.h", "net/if.h", "netdb.h", "netinet/in.h", true) 259 .Cases("netinet/tcp.h", "nl_types.h", "poll.h", "pthread.h", "pwd.h", true) 260 .Cases("regex.h", "sched.h", "search.h", "semaphore.h", "spawn.h", true) 261 .Cases("strings.h", "stropts.h", "sys/ipc.h", "sys/mman.h", "sys/msg.h", true) 262 .Cases("sys/resource.h", "sys/select.h", "sys/sem.h", "sys/shm.h", "sys/socket.h", true) 263 .Cases("sys/stat.h", "sys/statvfs.h", "sys/time.h", "sys/times.h", "sys/types.h", true) 264 .Cases("sys/uio.h", "sys/un.h", "sys/utsname.h", "sys/wait.h", "syslog.h", true) 265 .Cases("tar.h", "termios.h", "trace.h", "ulimit.h", true) 266 .Cases("unistd.h", "utime.h", "utmpx.h", "wordexp.h", true) 267 .Default(false); 268 } 269 270 /// Find a similar string in `Candidates`. 271 /// 272 /// \param LHS a string for a similar string in `Candidates` 273 /// 274 /// \param Candidates the candidates to find a similar string. 275 /// 276 /// \returns a similar string if exists. If no similar string exists, 277 /// returns None. 278 static Optional<StringRef> findSimilarStr( 279 StringRef LHS, const std::vector<StringRef> &Candidates) { 280 // We need to check if `Candidates` has the exact case-insensitive string 281 // because the Levenshtein distance match does not care about it. 282 for (StringRef C : Candidates) { 283 if (LHS.equals_insensitive(C)) { 284 return C; 285 } 286 } 287 288 // Keep going with the Levenshtein distance match. 289 // If the LHS size is less than 3, use the LHS size minus 1 and if not, 290 // use the LHS size divided by 3. 291 size_t Length = LHS.size(); 292 size_t MaxDist = Length < 3 ? Length - 1 : Length / 3; 293 294 Optional<std::pair<StringRef, size_t>> SimilarStr = None; 295 for (StringRef C : Candidates) { 296 size_t CurDist = LHS.edit_distance(C, true); 297 if (CurDist <= MaxDist) { 298 if (!SimilarStr) { 299 // The first similar string found. 300 SimilarStr = {C, CurDist}; 301 } else if (CurDist < SimilarStr->second) { 302 // More similar string found. 303 SimilarStr = {C, CurDist}; 304 } 305 } 306 } 307 308 if (SimilarStr) { 309 return SimilarStr->first; 310 } else { 311 return None; 312 } 313 } 314 315 bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef, 316 bool *ShadowFlag) { 317 // Missing macro name? 318 if (MacroNameTok.is(tok::eod)) 319 return Diag(MacroNameTok, diag::err_pp_missing_macro_name); 320 321 IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); 322 if (!II) 323 return Diag(MacroNameTok, diag::err_pp_macro_not_identifier); 324 325 if (II->isCPlusPlusOperatorKeyword()) { 326 // C++ 2.5p2: Alternative tokens behave the same as its primary token 327 // except for their spellings. 328 Diag(MacroNameTok, getLangOpts().MicrosoftExt 329 ? diag::ext_pp_operator_used_as_macro_name 330 : diag::err_pp_operator_used_as_macro_name) 331 << II << MacroNameTok.getKind(); 332 // Allow #defining |and| and friends for Microsoft compatibility or 333 // recovery when legacy C headers are included in C++. 334 } 335 336 if ((isDefineUndef != MU_Other) && II->getPPKeywordID() == tok::pp_defined) { 337 // Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4. 338 return Diag(MacroNameTok, diag::err_defined_macro_name); 339 } 340 341 if (isDefineUndef == MU_Undef) { 342 auto *MI = getMacroInfo(II); 343 if (MI && MI->isBuiltinMacro()) { 344 // Warn if undefining "__LINE__" and other builtins, per C99 6.10.8/4 345 // and C++ [cpp.predefined]p4], but allow it as an extension. 346 Diag(MacroNameTok, diag::ext_pp_undef_builtin_macro); 347 } 348 } 349 350 // If defining/undefining reserved identifier or a keyword, we need to issue 351 // a warning. 352 SourceLocation MacroNameLoc = MacroNameTok.getLocation(); 353 if (ShadowFlag) 354 *ShadowFlag = false; 355 if (!SourceMgr.isInSystemHeader(MacroNameLoc) && 356 (SourceMgr.getBufferName(MacroNameLoc) != "<built-in>")) { 357 MacroDiag D = MD_NoWarn; 358 if (isDefineUndef == MU_Define) { 359 D = shouldWarnOnMacroDef(*this, II); 360 } 361 else if (isDefineUndef == MU_Undef) 362 D = shouldWarnOnMacroUndef(*this, II); 363 if (D == MD_KeywordDef) { 364 // We do not want to warn on some patterns widely used in configuration 365 // scripts. This requires analyzing next tokens, so do not issue warnings 366 // now, only inform caller. 367 if (ShadowFlag) 368 *ShadowFlag = true; 369 } 370 if (D == MD_ReservedMacro) 371 Diag(MacroNameTok, diag::warn_pp_macro_is_reserved_id); 372 } 373 374 // Okay, we got a good identifier. 375 return false; 376 } 377 378 /// Lex and validate a macro name, which occurs after a 379 /// \#define or \#undef. 380 /// 381 /// This sets the token kind to eod and discards the rest of the macro line if 382 /// the macro name is invalid. 383 /// 384 /// \param MacroNameTok Token that is expected to be a macro name. 385 /// \param isDefineUndef Context in which macro is used. 386 /// \param ShadowFlag Points to a flag that is set if macro shadows a keyword. 387 void Preprocessor::ReadMacroName(Token &MacroNameTok, MacroUse isDefineUndef, 388 bool *ShadowFlag) { 389 // Read the token, don't allow macro expansion on it. 390 LexUnexpandedToken(MacroNameTok); 391 392 if (MacroNameTok.is(tok::code_completion)) { 393 if (CodeComplete) 394 CodeComplete->CodeCompleteMacroName(isDefineUndef == MU_Define); 395 setCodeCompletionReached(); 396 LexUnexpandedToken(MacroNameTok); 397 } 398 399 if (!CheckMacroName(MacroNameTok, isDefineUndef, ShadowFlag)) 400 return; 401 402 // Invalid macro name, read and discard the rest of the line and set the 403 // token kind to tok::eod if necessary. 404 if (MacroNameTok.isNot(tok::eod)) { 405 MacroNameTok.setKind(tok::eod); 406 DiscardUntilEndOfDirective(); 407 } 408 } 409 410 /// Ensure that the next token is a tok::eod token. 411 /// 412 /// If not, emit a diagnostic and consume up until the eod. If EnableMacros is 413 /// true, then we consider macros that expand to zero tokens as being ok. 414 /// 415 /// Returns the location of the end of the directive. 416 SourceLocation Preprocessor::CheckEndOfDirective(const char *DirType, 417 bool EnableMacros) { 418 Token Tmp; 419 // Lex unexpanded tokens for most directives: macros might expand to zero 420 // tokens, causing us to miss diagnosing invalid lines. Some directives (like 421 // #line) allow empty macros. 422 if (EnableMacros) 423 Lex(Tmp); 424 else 425 LexUnexpandedToken(Tmp); 426 427 // There should be no tokens after the directive, but we allow them as an 428 // extension. 429 while (Tmp.is(tok::comment)) // Skip comments in -C mode. 430 LexUnexpandedToken(Tmp); 431 432 if (Tmp.is(tok::eod)) 433 return Tmp.getLocation(); 434 435 // Add a fixit in GNU/C99/C++ mode. Don't offer a fixit for strict-C89, 436 // or if this is a macro-style preprocessing directive, because it is more 437 // trouble than it is worth to insert /**/ and check that there is no /**/ 438 // in the range also. 439 FixItHint Hint; 440 if ((LangOpts.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) && 441 !CurTokenLexer) 442 Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//"); 443 Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint; 444 return DiscardUntilEndOfDirective().getEnd(); 445 } 446 447 void Preprocessor::SuggestTypoedDirective(const Token &Tok, 448 StringRef Directive) const { 449 // If this is a `.S` file, treat unknown # directives as non-preprocessor 450 // directives. 451 if (getLangOpts().AsmPreprocessor) return; 452 453 std::vector<StringRef> Candidates = { 454 "if", "ifdef", "ifndef", "elif", "else", "endif" 455 }; 456 if (LangOpts.C2x || LangOpts.CPlusPlus2b) 457 Candidates.insert(Candidates.end(), {"elifdef", "elifndef"}); 458 459 if (Optional<StringRef> Sugg = findSimilarStr(Directive, Candidates)) { 460 // Directive cannot be coming from macro. 461 assert(Tok.getLocation().isFileID()); 462 CharSourceRange DirectiveRange = CharSourceRange::getCharRange( 463 Tok.getLocation(), 464 Tok.getLocation().getLocWithOffset(Directive.size())); 465 StringRef SuggValue = *Sugg; 466 467 auto Hint = FixItHint::CreateReplacement(DirectiveRange, SuggValue); 468 Diag(Tok, diag::warn_pp_invalid_directive) << 1 << SuggValue << Hint; 469 } 470 } 471 472 /// SkipExcludedConditionalBlock - We just read a \#if or related directive and 473 /// decided that the subsequent tokens are in the \#if'd out portion of the 474 /// file. Lex the rest of the file, until we see an \#endif. If 475 /// FoundNonSkipPortion is true, then we have already emitted code for part of 476 /// this \#if directive, so \#else/\#elif blocks should never be entered. 477 /// If ElseOk is true, then \#else directives are ok, if not, then we have 478 /// already seen one so a \#else directive is a duplicate. When this returns, 479 /// the caller can lex the first valid token. 480 void Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc, 481 SourceLocation IfTokenLoc, 482 bool FoundNonSkipPortion, 483 bool FoundElse, 484 SourceLocation ElseLoc) { 485 // In SkippingRangeStateTy we are depending on SkipExcludedConditionalBlock() 486 // not getting called recursively by storing the RecordedSkippedRanges 487 // DenseMap lookup pointer (field SkipRangePtr). SkippingRangeStateTy expects 488 // that RecordedSkippedRanges won't get modified and SkipRangePtr won't be 489 // invalidated. If this changes and there is a need to call 490 // SkipExcludedConditionalBlock() recursively, SkippingRangeStateTy should 491 // change to do a second lookup in endLexPass function instead of reusing the 492 // lookup pointer. 493 assert(!SkippingExcludedConditionalBlock && 494 "calling SkipExcludedConditionalBlock recursively"); 495 llvm::SaveAndRestore<bool> SARSkipping(SkippingExcludedConditionalBlock, 496 true); 497 498 ++NumSkipped; 499 assert(!CurTokenLexer && CurPPLexer && "Lexing a macro, not a file?"); 500 501 if (PreambleConditionalStack.reachedEOFWhileSkipping()) 502 PreambleConditionalStack.clearSkipInfo(); 503 else 504 CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/ false, 505 FoundNonSkipPortion, FoundElse); 506 507 // Enter raw mode to disable identifier lookup (and thus macro expansion), 508 // disabling warnings, etc. 509 CurPPLexer->LexingRawMode = true; 510 Token Tok; 511 SourceLocation endLoc; 512 513 /// Keeps track and caches skipped ranges and also retrieves a prior skipped 514 /// range if the same block is re-visited. 515 struct SkippingRangeStateTy { 516 Preprocessor &PP; 517 518 const char *BeginPtr = nullptr; 519 unsigned *SkipRangePtr = nullptr; 520 521 SkippingRangeStateTy(Preprocessor &PP) : PP(PP) {} 522 523 void beginLexPass() { 524 if (BeginPtr) 525 return; // continue skipping a block. 526 527 // Initiate a skipping block and adjust the lexer if we already skipped it 528 // before. 529 BeginPtr = PP.CurLexer->getBufferLocation(); 530 SkipRangePtr = &PP.RecordedSkippedRanges[BeginPtr]; 531 if (*SkipRangePtr) { 532 PP.CurLexer->seek(PP.CurLexer->getCurrentBufferOffset() + *SkipRangePtr, 533 /*IsAtStartOfLine*/ true); 534 } 535 } 536 537 void endLexPass(const char *Hashptr) { 538 if (!BeginPtr) { 539 // Not doing normal lexing. 540 assert(PP.CurLexer->isDependencyDirectivesLexer()); 541 return; 542 } 543 544 // Finished skipping a block, record the range if it's first time visited. 545 if (!*SkipRangePtr) { 546 *SkipRangePtr = Hashptr - BeginPtr; 547 } 548 assert(*SkipRangePtr == Hashptr - BeginPtr); 549 BeginPtr = nullptr; 550 SkipRangePtr = nullptr; 551 } 552 } SkippingRangeState(*this); 553 554 while (true) { 555 if (CurLexer->isDependencyDirectivesLexer()) { 556 CurLexer->LexDependencyDirectiveTokenWhileSkipping(Tok); 557 } else { 558 SkippingRangeState.beginLexPass(); 559 while (true) { 560 CurLexer->Lex(Tok); 561 562 if (Tok.is(tok::code_completion)) { 563 setCodeCompletionReached(); 564 if (CodeComplete) 565 CodeComplete->CodeCompleteInConditionalExclusion(); 566 continue; 567 } 568 569 // If this is the end of the buffer, we have an error. 570 if (Tok.is(tok::eof)) { 571 // We don't emit errors for unterminated conditionals here, 572 // Lexer::LexEndOfFile can do that properly. 573 // Just return and let the caller lex after this #include. 574 if (PreambleConditionalStack.isRecording()) 575 PreambleConditionalStack.SkipInfo.emplace(HashTokenLoc, IfTokenLoc, 576 FoundNonSkipPortion, 577 FoundElse, ElseLoc); 578 break; 579 } 580 581 // If this token is not a preprocessor directive, just skip it. 582 if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine()) 583 continue; 584 585 break; 586 } 587 } 588 if (Tok.is(tok::eof)) 589 break; 590 591 // We just parsed a # character at the start of a line, so we're in 592 // directive mode. Tell the lexer this so any newlines we see will be 593 // converted into an EOD token (this terminates the macro). 594 CurPPLexer->ParsingPreprocessorDirective = true; 595 if (CurLexer) CurLexer->SetKeepWhitespaceMode(false); 596 597 assert(Tok.is(tok::hash)); 598 const char *Hashptr = CurLexer->getBufferLocation() - Tok.getLength(); 599 assert(CurLexer->getSourceLocation(Hashptr) == Tok.getLocation()); 600 601 // Read the next token, the directive flavor. 602 LexUnexpandedToken(Tok); 603 604 // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or 605 // something bogus), skip it. 606 if (Tok.isNot(tok::raw_identifier)) { 607 CurPPLexer->ParsingPreprocessorDirective = false; 608 // Restore comment saving mode. 609 if (CurLexer) CurLexer->resetExtendedTokenMode(); 610 continue; 611 } 612 613 // If the first letter isn't i or e, it isn't intesting to us. We know that 614 // this is safe in the face of spelling differences, because there is no way 615 // to spell an i/e in a strange way that is another letter. Skipping this 616 // allows us to avoid looking up the identifier info for #define/#undef and 617 // other common directives. 618 StringRef RI = Tok.getRawIdentifier(); 619 620 char FirstChar = RI[0]; 621 if (FirstChar >= 'a' && FirstChar <= 'z' && 622 FirstChar != 'i' && FirstChar != 'e') { 623 CurPPLexer->ParsingPreprocessorDirective = false; 624 // Restore comment saving mode. 625 if (CurLexer) CurLexer->resetExtendedTokenMode(); 626 continue; 627 } 628 629 // Get the identifier name without trigraphs or embedded newlines. Note 630 // that we can't use Tok.getIdentifierInfo() because its lookup is disabled 631 // when skipping. 632 char DirectiveBuf[20]; 633 StringRef Directive; 634 if (!Tok.needsCleaning() && RI.size() < 20) { 635 Directive = RI; 636 } else { 637 std::string DirectiveStr = getSpelling(Tok); 638 size_t IdLen = DirectiveStr.size(); 639 if (IdLen >= 20) { 640 CurPPLexer->ParsingPreprocessorDirective = false; 641 // Restore comment saving mode. 642 if (CurLexer) CurLexer->resetExtendedTokenMode(); 643 continue; 644 } 645 memcpy(DirectiveBuf, &DirectiveStr[0], IdLen); 646 Directive = StringRef(DirectiveBuf, IdLen); 647 } 648 649 if (Directive.startswith("if")) { 650 StringRef Sub = Directive.substr(2); 651 if (Sub.empty() || // "if" 652 Sub == "def" || // "ifdef" 653 Sub == "ndef") { // "ifndef" 654 // We know the entire #if/#ifdef/#ifndef block will be skipped, don't 655 // bother parsing the condition. 656 DiscardUntilEndOfDirective(); 657 CurPPLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true, 658 /*foundnonskip*/false, 659 /*foundelse*/false); 660 } else { 661 SuggestTypoedDirective(Tok, Directive); 662 } 663 } else if (Directive[0] == 'e') { 664 StringRef Sub = Directive.substr(1); 665 if (Sub == "ndif") { // "endif" 666 PPConditionalInfo CondInfo; 667 CondInfo.WasSkipping = true; // Silence bogus warning. 668 bool InCond = CurPPLexer->popConditionalLevel(CondInfo); 669 (void)InCond; // Silence warning in no-asserts mode. 670 assert(!InCond && "Can't be skipping if not in a conditional!"); 671 672 // If we popped the outermost skipping block, we're done skipping! 673 if (!CondInfo.WasSkipping) { 674 SkippingRangeState.endLexPass(Hashptr); 675 // Restore the value of LexingRawMode so that trailing comments 676 // are handled correctly, if we've reached the outermost block. 677 CurPPLexer->LexingRawMode = false; 678 endLoc = CheckEndOfDirective("endif"); 679 CurPPLexer->LexingRawMode = true; 680 if (Callbacks) 681 Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc); 682 break; 683 } else { 684 DiscardUntilEndOfDirective(); 685 } 686 } else if (Sub == "lse") { // "else". 687 // #else directive in a skipping conditional. If not in some other 688 // skipping conditional, and if #else hasn't already been seen, enter it 689 // as a non-skipping conditional. 690 PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel(); 691 692 if (!CondInfo.WasSkipping) 693 SkippingRangeState.endLexPass(Hashptr); 694 695 // If this is a #else with a #else before it, report the error. 696 if (CondInfo.FoundElse) 697 Diag(Tok, diag::pp_err_else_after_else); 698 699 // Note that we've seen a #else in this conditional. 700 CondInfo.FoundElse = true; 701 702 // If the conditional is at the top level, and the #if block wasn't 703 // entered, enter the #else block now. 704 if (!CondInfo.WasSkipping && !CondInfo.FoundNonSkip) { 705 CondInfo.FoundNonSkip = true; 706 // Restore the value of LexingRawMode so that trailing comments 707 // are handled correctly. 708 CurPPLexer->LexingRawMode = false; 709 endLoc = CheckEndOfDirective("else"); 710 CurPPLexer->LexingRawMode = true; 711 if (Callbacks) 712 Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc); 713 break; 714 } else { 715 DiscardUntilEndOfDirective(); // C99 6.10p4. 716 } 717 } else if (Sub == "lif") { // "elif". 718 PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel(); 719 720 if (!CondInfo.WasSkipping) 721 SkippingRangeState.endLexPass(Hashptr); 722 723 // If this is a #elif with a #else before it, report the error. 724 if (CondInfo.FoundElse) 725 Diag(Tok, diag::pp_err_elif_after_else) << PED_Elif; 726 727 // If this is in a skipping block or if we're already handled this #if 728 // block, don't bother parsing the condition. 729 if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) { 730 // FIXME: We should probably do at least some minimal parsing of the 731 // condition to verify that it is well-formed. The current state 732 // allows #elif* directives with completely malformed (or missing) 733 // conditions. 734 DiscardUntilEndOfDirective(); 735 } else { 736 // Restore the value of LexingRawMode so that identifiers are 737 // looked up, etc, inside the #elif expression. 738 assert(CurPPLexer->LexingRawMode && "We have to be skipping here!"); 739 CurPPLexer->LexingRawMode = false; 740 IdentifierInfo *IfNDefMacro = nullptr; 741 DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro); 742 // Stop if Lexer became invalid after hitting code completion token. 743 if (!CurPPLexer) 744 return; 745 const bool CondValue = DER.Conditional; 746 CurPPLexer->LexingRawMode = true; 747 if (Callbacks) { 748 Callbacks->Elif( 749 Tok.getLocation(), DER.ExprRange, 750 (CondValue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False), 751 CondInfo.IfLoc); 752 } 753 // If this condition is true, enter it! 754 if (CondValue) { 755 CondInfo.FoundNonSkip = true; 756 break; 757 } 758 } 759 } else if (Sub == "lifdef" || // "elifdef" 760 Sub == "lifndef") { // "elifndef" 761 bool IsElifDef = Sub == "lifdef"; 762 PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel(); 763 Token DirectiveToken = Tok; 764 765 if (!CondInfo.WasSkipping) 766 SkippingRangeState.endLexPass(Hashptr); 767 768 // Warn if using `#elifdef` & `#elifndef` in not C2x & C++2b mode even 769 // if this branch is in a skipping block. 770 unsigned DiagID; 771 if (LangOpts.CPlusPlus) 772 DiagID = LangOpts.CPlusPlus2b ? diag::warn_cxx2b_compat_pp_directive 773 : diag::ext_cxx2b_pp_directive; 774 else 775 DiagID = LangOpts.C2x ? diag::warn_c2x_compat_pp_directive 776 : diag::ext_c2x_pp_directive; 777 Diag(Tok, DiagID) << (IsElifDef ? PED_Elifdef : PED_Elifndef); 778 779 // If this is a #elif with a #else before it, report the error. 780 if (CondInfo.FoundElse) 781 Diag(Tok, diag::pp_err_elif_after_else) 782 << (IsElifDef ? PED_Elifdef : PED_Elifndef); 783 784 // If this is in a skipping block or if we're already handled this #if 785 // block, don't bother parsing the condition. 786 if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) { 787 // FIXME: We should probably do at least some minimal parsing of the 788 // condition to verify that it is well-formed. The current state 789 // allows #elif* directives with completely malformed (or missing) 790 // conditions. 791 DiscardUntilEndOfDirective(); 792 } else { 793 // Restore the value of LexingRawMode so that identifiers are 794 // looked up, etc, inside the #elif[n]def expression. 795 assert(CurPPLexer->LexingRawMode && "We have to be skipping here!"); 796 CurPPLexer->LexingRawMode = false; 797 Token MacroNameTok; 798 ReadMacroName(MacroNameTok); 799 CurPPLexer->LexingRawMode = true; 800 801 // If the macro name token is tok::eod, there was an error that was 802 // already reported. 803 if (MacroNameTok.is(tok::eod)) { 804 // Skip code until we get to #endif. This helps with recovery by 805 // not emitting an error when the #endif is reached. 806 continue; 807 } 808 809 emitMacroExpansionWarnings(MacroNameTok); 810 811 CheckEndOfDirective(IsElifDef ? "elifdef" : "elifndef"); 812 813 IdentifierInfo *MII = MacroNameTok.getIdentifierInfo(); 814 auto MD = getMacroDefinition(MII); 815 MacroInfo *MI = MD.getMacroInfo(); 816 817 if (Callbacks) { 818 if (IsElifDef) { 819 Callbacks->Elifdef(DirectiveToken.getLocation(), MacroNameTok, 820 MD); 821 } else { 822 Callbacks->Elifndef(DirectiveToken.getLocation(), MacroNameTok, 823 MD); 824 } 825 } 826 // If this condition is true, enter it! 827 if (static_cast<bool>(MI) == IsElifDef) { 828 CondInfo.FoundNonSkip = true; 829 break; 830 } 831 } 832 } else { 833 SuggestTypoedDirective(Tok, Directive); 834 } 835 } else { 836 SuggestTypoedDirective(Tok, Directive); 837 } 838 839 CurPPLexer->ParsingPreprocessorDirective = false; 840 // Restore comment saving mode. 841 if (CurLexer) CurLexer->resetExtendedTokenMode(); 842 } 843 844 // Finally, if we are out of the conditional (saw an #endif or ran off the end 845 // of the file, just stop skipping and return to lexing whatever came after 846 // the #if block. 847 CurPPLexer->LexingRawMode = false; 848 849 // The last skipped range isn't actually skipped yet if it's truncated 850 // by the end of the preamble; we'll resume parsing after the preamble. 851 if (Callbacks && (Tok.isNot(tok::eof) || !isRecordingPreamble())) 852 Callbacks->SourceRangeSkipped( 853 SourceRange(HashTokenLoc, endLoc.isValid() 854 ? endLoc 855 : CurPPLexer->getSourceLocation()), 856 Tok.getLocation()); 857 } 858 859 Module *Preprocessor::getModuleForLocation(SourceLocation Loc) { 860 if (!SourceMgr.isInMainFile(Loc)) { 861 // Try to determine the module of the include directive. 862 // FIXME: Look into directly passing the FileEntry from LookupFile instead. 863 FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getExpansionLoc(Loc)); 864 if (const FileEntry *EntryOfIncl = SourceMgr.getFileEntryForID(IDOfIncl)) { 865 // The include comes from an included file. 866 return HeaderInfo.getModuleMap() 867 .findModuleForHeader(EntryOfIncl) 868 .getModule(); 869 } 870 } 871 872 // This is either in the main file or not in a file at all. It belongs 873 // to the current module, if there is one. 874 return getLangOpts().CurrentModule.empty() 875 ? nullptr 876 : HeaderInfo.lookupModule(getLangOpts().CurrentModule, Loc); 877 } 878 879 const FileEntry * 880 Preprocessor::getHeaderToIncludeForDiagnostics(SourceLocation IncLoc, 881 SourceLocation Loc) { 882 Module *IncM = getModuleForLocation(IncLoc); 883 884 // Walk up through the include stack, looking through textual headers of M 885 // until we hit a non-textual header that we can #include. (We assume textual 886 // headers of a module with non-textual headers aren't meant to be used to 887 // import entities from the module.) 888 auto &SM = getSourceManager(); 889 while (!Loc.isInvalid() && !SM.isInMainFile(Loc)) { 890 auto ID = SM.getFileID(SM.getExpansionLoc(Loc)); 891 auto *FE = SM.getFileEntryForID(ID); 892 if (!FE) 893 break; 894 895 // We want to find all possible modules that might contain this header, so 896 // search all enclosing directories for module maps and load them. 897 HeaderInfo.hasModuleMap(FE->getName(), /*Root*/ nullptr, 898 SourceMgr.isInSystemHeader(Loc)); 899 900 bool InPrivateHeader = false; 901 for (auto Header : HeaderInfo.findAllModulesForHeader(FE)) { 902 if (!Header.isAccessibleFrom(IncM)) { 903 // It's in a private header; we can't #include it. 904 // FIXME: If there's a public header in some module that re-exports it, 905 // then we could suggest including that, but it's not clear that's the 906 // expected way to make this entity visible. 907 InPrivateHeader = true; 908 continue; 909 } 910 911 // We'll suggest including textual headers below if they're 912 // include-guarded. 913 if (Header.getRole() & ModuleMap::TextualHeader) 914 continue; 915 916 // If we have a module import syntax, we shouldn't include a header to 917 // make a particular module visible. Let the caller know they should 918 // suggest an import instead. 919 if (getLangOpts().ObjC || getLangOpts().CPlusPlusModules || 920 getLangOpts().ModulesTS) 921 return nullptr; 922 923 // If this is an accessible, non-textual header of M's top-level module 924 // that transitively includes the given location and makes the 925 // corresponding module visible, this is the thing to #include. 926 return FE; 927 } 928 929 // FIXME: If we're bailing out due to a private header, we shouldn't suggest 930 // an import either. 931 if (InPrivateHeader) 932 return nullptr; 933 934 // If the header is includable and has an include guard, assume the 935 // intended way to expose its contents is by #include, not by importing a 936 // module that transitively includes it. 937 if (getHeaderSearchInfo().isFileMultipleIncludeGuarded(FE)) 938 return FE; 939 940 Loc = SM.getIncludeLoc(ID); 941 } 942 943 return nullptr; 944 } 945 946 Optional<FileEntryRef> Preprocessor::LookupFile( 947 SourceLocation FilenameLoc, StringRef Filename, bool isAngled, 948 ConstSearchDirIterator FromDir, const FileEntry *FromFile, 949 ConstSearchDirIterator *CurDirArg, SmallVectorImpl<char> *SearchPath, 950 SmallVectorImpl<char> *RelativePath, 951 ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped, 952 bool *IsFrameworkFound, bool SkipCache) { 953 ConstSearchDirIterator CurDirLocal = nullptr; 954 ConstSearchDirIterator &CurDir = CurDirArg ? *CurDirArg : CurDirLocal; 955 956 Module *RequestingModule = getModuleForLocation(FilenameLoc); 957 bool RequestingModuleIsModuleInterface = !SourceMgr.isInMainFile(FilenameLoc); 958 959 // If the header lookup mechanism may be relative to the current inclusion 960 // stack, record the parent #includes. 961 SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 16> 962 Includers; 963 bool BuildSystemModule = false; 964 if (!FromDir && !FromFile) { 965 FileID FID = getCurrentFileLexer()->getFileID(); 966 const FileEntry *FileEnt = SourceMgr.getFileEntryForID(FID); 967 968 // If there is no file entry associated with this file, it must be the 969 // predefines buffer or the module includes buffer. Any other file is not 970 // lexed with a normal lexer, so it won't be scanned for preprocessor 971 // directives. 972 // 973 // If we have the predefines buffer, resolve #include references (which come 974 // from the -include command line argument) from the current working 975 // directory instead of relative to the main file. 976 // 977 // If we have the module includes buffer, resolve #include references (which 978 // come from header declarations in the module map) relative to the module 979 // map file. 980 if (!FileEnt) { 981 if (FID == SourceMgr.getMainFileID() && MainFileDir) { 982 Includers.push_back(std::make_pair(nullptr, MainFileDir)); 983 BuildSystemModule = getCurrentModule()->IsSystem; 984 } else if ((FileEnt = 985 SourceMgr.getFileEntryForID(SourceMgr.getMainFileID()))) 986 Includers.push_back(std::make_pair(FileEnt, *FileMgr.getDirectory("."))); 987 } else { 988 Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir())); 989 } 990 991 // MSVC searches the current include stack from top to bottom for 992 // headers included by quoted include directives. 993 // See: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx 994 if (LangOpts.MSVCCompat && !isAngled) { 995 for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) { 996 if (IsFileLexer(ISEntry)) 997 if ((FileEnt = ISEntry.ThePPLexer->getFileEntry())) 998 Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir())); 999 } 1000 } 1001 } 1002 1003 CurDir = CurDirLookup; 1004 1005 if (FromFile) { 1006 // We're supposed to start looking from after a particular file. Search 1007 // the include path until we find that file or run out of files. 1008 ConstSearchDirIterator TmpCurDir = CurDir; 1009 ConstSearchDirIterator TmpFromDir = nullptr; 1010 while (Optional<FileEntryRef> FE = HeaderInfo.LookupFile( 1011 Filename, FilenameLoc, isAngled, TmpFromDir, &TmpCurDir, 1012 Includers, SearchPath, RelativePath, RequestingModule, 1013 SuggestedModule, /*IsMapped=*/nullptr, 1014 /*IsFrameworkFound=*/nullptr, SkipCache)) { 1015 // Keep looking as if this file did a #include_next. 1016 TmpFromDir = TmpCurDir; 1017 ++TmpFromDir; 1018 if (&FE->getFileEntry() == FromFile) { 1019 // Found it. 1020 FromDir = TmpFromDir; 1021 CurDir = TmpCurDir; 1022 break; 1023 } 1024 } 1025 } 1026 1027 // Do a standard file entry lookup. 1028 Optional<FileEntryRef> FE = HeaderInfo.LookupFile( 1029 Filename, FilenameLoc, isAngled, FromDir, &CurDir, Includers, SearchPath, 1030 RelativePath, RequestingModule, SuggestedModule, IsMapped, 1031 IsFrameworkFound, SkipCache, BuildSystemModule); 1032 if (FE) { 1033 if (SuggestedModule && !LangOpts.AsmPreprocessor) 1034 HeaderInfo.getModuleMap().diagnoseHeaderInclusion( 1035 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc, 1036 Filename, *FE); 1037 return FE; 1038 } 1039 1040 const FileEntry *CurFileEnt; 1041 // Otherwise, see if this is a subframework header. If so, this is relative 1042 // to one of the headers on the #include stack. Walk the list of the current 1043 // headers on the #include stack and pass them to HeaderInfo. 1044 if (IsFileLexer()) { 1045 if ((CurFileEnt = CurPPLexer->getFileEntry())) { 1046 if (Optional<FileEntryRef> FE = HeaderInfo.LookupSubframeworkHeader( 1047 Filename, CurFileEnt, SearchPath, RelativePath, RequestingModule, 1048 SuggestedModule)) { 1049 if (SuggestedModule && !LangOpts.AsmPreprocessor) 1050 HeaderInfo.getModuleMap().diagnoseHeaderInclusion( 1051 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc, 1052 Filename, *FE); 1053 return FE; 1054 } 1055 } 1056 } 1057 1058 for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) { 1059 if (IsFileLexer(ISEntry)) { 1060 if ((CurFileEnt = ISEntry.ThePPLexer->getFileEntry())) { 1061 if (Optional<FileEntryRef> FE = HeaderInfo.LookupSubframeworkHeader( 1062 Filename, CurFileEnt, SearchPath, RelativePath, 1063 RequestingModule, SuggestedModule)) { 1064 if (SuggestedModule && !LangOpts.AsmPreprocessor) 1065 HeaderInfo.getModuleMap().diagnoseHeaderInclusion( 1066 RequestingModule, RequestingModuleIsModuleInterface, 1067 FilenameLoc, Filename, *FE); 1068 return FE; 1069 } 1070 } 1071 } 1072 } 1073 1074 // Otherwise, we really couldn't find the file. 1075 return None; 1076 } 1077 1078 //===----------------------------------------------------------------------===// 1079 // Preprocessor Directive Handling. 1080 //===----------------------------------------------------------------------===// 1081 1082 class Preprocessor::ResetMacroExpansionHelper { 1083 public: 1084 ResetMacroExpansionHelper(Preprocessor *pp) 1085 : PP(pp), save(pp->DisableMacroExpansion) { 1086 if (pp->MacroExpansionInDirectivesOverride) 1087 pp->DisableMacroExpansion = false; 1088 } 1089 1090 ~ResetMacroExpansionHelper() { 1091 PP->DisableMacroExpansion = save; 1092 } 1093 1094 private: 1095 Preprocessor *PP; 1096 bool save; 1097 }; 1098 1099 /// Process a directive while looking for the through header or a #pragma 1100 /// hdrstop. The following directives are handled: 1101 /// #include (to check if it is the through header) 1102 /// #define (to warn about macros that don't match the PCH) 1103 /// #pragma (to check for pragma hdrstop). 1104 /// All other directives are completely discarded. 1105 void Preprocessor::HandleSkippedDirectiveWhileUsingPCH(Token &Result, 1106 SourceLocation HashLoc) { 1107 if (const IdentifierInfo *II = Result.getIdentifierInfo()) { 1108 if (II->getPPKeywordID() == tok::pp_define) { 1109 return HandleDefineDirective(Result, 1110 /*ImmediatelyAfterHeaderGuard=*/false); 1111 } 1112 if (SkippingUntilPCHThroughHeader && 1113 II->getPPKeywordID() == tok::pp_include) { 1114 return HandleIncludeDirective(HashLoc, Result); 1115 } 1116 if (SkippingUntilPragmaHdrStop && II->getPPKeywordID() == tok::pp_pragma) { 1117 Lex(Result); 1118 auto *II = Result.getIdentifierInfo(); 1119 if (II && II->getName() == "hdrstop") 1120 return HandlePragmaHdrstop(Result); 1121 } 1122 } 1123 DiscardUntilEndOfDirective(); 1124 } 1125 1126 /// HandleDirective - This callback is invoked when the lexer sees a # token 1127 /// at the start of a line. This consumes the directive, modifies the 1128 /// lexer/preprocessor state, and advances the lexer(s) so that the next token 1129 /// read is the correct one. 1130 void Preprocessor::HandleDirective(Token &Result) { 1131 // FIXME: Traditional: # with whitespace before it not recognized by K&R? 1132 1133 // We just parsed a # character at the start of a line, so we're in directive 1134 // mode. Tell the lexer this so any newlines we see will be converted into an 1135 // EOD token (which terminates the directive). 1136 CurPPLexer->ParsingPreprocessorDirective = true; 1137 if (CurLexer) CurLexer->SetKeepWhitespaceMode(false); 1138 1139 bool ImmediatelyAfterTopLevelIfndef = 1140 CurPPLexer->MIOpt.getImmediatelyAfterTopLevelIfndef(); 1141 CurPPLexer->MIOpt.resetImmediatelyAfterTopLevelIfndef(); 1142 1143 ++NumDirectives; 1144 1145 // We are about to read a token. For the multiple-include optimization FA to 1146 // work, we have to remember if we had read any tokens *before* this 1147 // pp-directive. 1148 bool ReadAnyTokensBeforeDirective =CurPPLexer->MIOpt.getHasReadAnyTokensVal(); 1149 1150 // Save the '#' token in case we need to return it later. 1151 Token SavedHash = Result; 1152 1153 // Read the next token, the directive flavor. This isn't expanded due to 1154 // C99 6.10.3p8. 1155 LexUnexpandedToken(Result); 1156 1157 // C99 6.10.3p11: Is this preprocessor directive in macro invocation? e.g.: 1158 // #define A(x) #x 1159 // A(abc 1160 // #warning blah 1161 // def) 1162 // If so, the user is relying on undefined behavior, emit a diagnostic. Do 1163 // not support this for #include-like directives, since that can result in 1164 // terrible diagnostics, and does not work in GCC. 1165 if (InMacroArgs) { 1166 if (IdentifierInfo *II = Result.getIdentifierInfo()) { 1167 switch (II->getPPKeywordID()) { 1168 case tok::pp_include: 1169 case tok::pp_import: 1170 case tok::pp_include_next: 1171 case tok::pp___include_macros: 1172 case tok::pp_pragma: 1173 Diag(Result, diag::err_embedded_directive) << II->getName(); 1174 Diag(*ArgMacro, diag::note_macro_expansion_here) 1175 << ArgMacro->getIdentifierInfo(); 1176 DiscardUntilEndOfDirective(); 1177 return; 1178 default: 1179 break; 1180 } 1181 } 1182 Diag(Result, diag::ext_embedded_directive); 1183 } 1184 1185 // Temporarily enable macro expansion if set so 1186 // and reset to previous state when returning from this function. 1187 ResetMacroExpansionHelper helper(this); 1188 1189 if (SkippingUntilPCHThroughHeader || SkippingUntilPragmaHdrStop) 1190 return HandleSkippedDirectiveWhileUsingPCH(Result, SavedHash.getLocation()); 1191 1192 switch (Result.getKind()) { 1193 case tok::eod: 1194 return; // null directive. 1195 case tok::code_completion: 1196 setCodeCompletionReached(); 1197 if (CodeComplete) 1198 CodeComplete->CodeCompleteDirective( 1199 CurPPLexer->getConditionalStackDepth() > 0); 1200 return; 1201 case tok::numeric_constant: // # 7 GNU line marker directive. 1202 if (getLangOpts().AsmPreprocessor) 1203 break; // # 4 is not a preprocessor directive in .S files. 1204 return HandleDigitDirective(Result); 1205 default: 1206 IdentifierInfo *II = Result.getIdentifierInfo(); 1207 if (!II) break; // Not an identifier. 1208 1209 // Ask what the preprocessor keyword ID is. 1210 switch (II->getPPKeywordID()) { 1211 default: break; 1212 // C99 6.10.1 - Conditional Inclusion. 1213 case tok::pp_if: 1214 return HandleIfDirective(Result, SavedHash, ReadAnyTokensBeforeDirective); 1215 case tok::pp_ifdef: 1216 return HandleIfdefDirective(Result, SavedHash, false, 1217 true /*not valid for miopt*/); 1218 case tok::pp_ifndef: 1219 return HandleIfdefDirective(Result, SavedHash, true, 1220 ReadAnyTokensBeforeDirective); 1221 case tok::pp_elif: 1222 case tok::pp_elifdef: 1223 case tok::pp_elifndef: 1224 return HandleElifFamilyDirective(Result, SavedHash, II->getPPKeywordID()); 1225 1226 case tok::pp_else: 1227 return HandleElseDirective(Result, SavedHash); 1228 case tok::pp_endif: 1229 return HandleEndifDirective(Result); 1230 1231 // C99 6.10.2 - Source File Inclusion. 1232 case tok::pp_include: 1233 // Handle #include. 1234 return HandleIncludeDirective(SavedHash.getLocation(), Result); 1235 case tok::pp___include_macros: 1236 // Handle -imacros. 1237 return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result); 1238 1239 // C99 6.10.3 - Macro Replacement. 1240 case tok::pp_define: 1241 return HandleDefineDirective(Result, ImmediatelyAfterTopLevelIfndef); 1242 case tok::pp_undef: 1243 return HandleUndefDirective(); 1244 1245 // C99 6.10.4 - Line Control. 1246 case tok::pp_line: 1247 return HandleLineDirective(); 1248 1249 // C99 6.10.5 - Error Directive. 1250 case tok::pp_error: 1251 return HandleUserDiagnosticDirective(Result, false); 1252 1253 // C99 6.10.6 - Pragma Directive. 1254 case tok::pp_pragma: 1255 return HandlePragmaDirective({PIK_HashPragma, SavedHash.getLocation()}); 1256 1257 // GNU Extensions. 1258 case tok::pp_import: 1259 return HandleImportDirective(SavedHash.getLocation(), Result); 1260 case tok::pp_include_next: 1261 return HandleIncludeNextDirective(SavedHash.getLocation(), Result); 1262 1263 case tok::pp_warning: 1264 Diag(Result, diag::ext_pp_warning_directive); 1265 return HandleUserDiagnosticDirective(Result, true); 1266 case tok::pp_ident: 1267 return HandleIdentSCCSDirective(Result); 1268 case tok::pp_sccs: 1269 return HandleIdentSCCSDirective(Result); 1270 case tok::pp_assert: 1271 //isExtension = true; // FIXME: implement #assert 1272 break; 1273 case tok::pp_unassert: 1274 //isExtension = true; // FIXME: implement #unassert 1275 break; 1276 1277 case tok::pp___public_macro: 1278 if (getLangOpts().Modules || getLangOpts().ModulesLocalVisibility) 1279 return HandleMacroPublicDirective(Result); 1280 break; 1281 1282 case tok::pp___private_macro: 1283 if (getLangOpts().Modules || getLangOpts().ModulesLocalVisibility) 1284 return HandleMacroPrivateDirective(); 1285 break; 1286 } 1287 break; 1288 } 1289 1290 // If this is a .S file, treat unknown # directives as non-preprocessor 1291 // directives. This is important because # may be a comment or introduce 1292 // various pseudo-ops. Just return the # token and push back the following 1293 // token to be lexed next time. 1294 if (getLangOpts().AsmPreprocessor) { 1295 auto Toks = std::make_unique<Token[]>(2); 1296 // Return the # and the token after it. 1297 Toks[0] = SavedHash; 1298 Toks[1] = Result; 1299 1300 // If the second token is a hashhash token, then we need to translate it to 1301 // unknown so the token lexer doesn't try to perform token pasting. 1302 if (Result.is(tok::hashhash)) 1303 Toks[1].setKind(tok::unknown); 1304 1305 // Enter this token stream so that we re-lex the tokens. Make sure to 1306 // enable macro expansion, in case the token after the # is an identifier 1307 // that is expanded. 1308 EnterTokenStream(std::move(Toks), 2, false, /*IsReinject*/false); 1309 return; 1310 } 1311 1312 // If we reached here, the preprocessing token is not valid! 1313 // Start suggesting if a similar directive found. 1314 Diag(Result, diag::err_pp_invalid_directive) << 0; 1315 1316 // Read the rest of the PP line. 1317 DiscardUntilEndOfDirective(); 1318 1319 // Okay, we're done parsing the directive. 1320 } 1321 1322 /// GetLineValue - Convert a numeric token into an unsigned value, emitting 1323 /// Diagnostic DiagID if it is invalid, and returning the value in Val. 1324 static bool GetLineValue(Token &DigitTok, unsigned &Val, 1325 unsigned DiagID, Preprocessor &PP, 1326 bool IsGNULineDirective=false) { 1327 if (DigitTok.isNot(tok::numeric_constant)) { 1328 PP.Diag(DigitTok, DiagID); 1329 1330 if (DigitTok.isNot(tok::eod)) 1331 PP.DiscardUntilEndOfDirective(); 1332 return true; 1333 } 1334 1335 SmallString<64> IntegerBuffer; 1336 IntegerBuffer.resize(DigitTok.getLength()); 1337 const char *DigitTokBegin = &IntegerBuffer[0]; 1338 bool Invalid = false; 1339 unsigned ActualLength = PP.getSpelling(DigitTok, DigitTokBegin, &Invalid); 1340 if (Invalid) 1341 return true; 1342 1343 // Verify that we have a simple digit-sequence, and compute the value. This 1344 // is always a simple digit string computed in decimal, so we do this manually 1345 // here. 1346 Val = 0; 1347 for (unsigned i = 0; i != ActualLength; ++i) { 1348 // C++1y [lex.fcon]p1: 1349 // Optional separating single quotes in a digit-sequence are ignored 1350 if (DigitTokBegin[i] == '\'') 1351 continue; 1352 1353 if (!isDigit(DigitTokBegin[i])) { 1354 PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i), 1355 diag::err_pp_line_digit_sequence) << IsGNULineDirective; 1356 PP.DiscardUntilEndOfDirective(); 1357 return true; 1358 } 1359 1360 unsigned NextVal = Val*10+(DigitTokBegin[i]-'0'); 1361 if (NextVal < Val) { // overflow. 1362 PP.Diag(DigitTok, DiagID); 1363 PP.DiscardUntilEndOfDirective(); 1364 return true; 1365 } 1366 Val = NextVal; 1367 } 1368 1369 if (DigitTokBegin[0] == '0' && Val) 1370 PP.Diag(DigitTok.getLocation(), diag::warn_pp_line_decimal) 1371 << IsGNULineDirective; 1372 1373 return false; 1374 } 1375 1376 /// Handle a \#line directive: C99 6.10.4. 1377 /// 1378 /// The two acceptable forms are: 1379 /// \verbatim 1380 /// # line digit-sequence 1381 /// # line digit-sequence "s-char-sequence" 1382 /// \endverbatim 1383 void Preprocessor::HandleLineDirective() { 1384 // Read the line # and string argument. Per C99 6.10.4p5, these tokens are 1385 // expanded. 1386 Token DigitTok; 1387 Lex(DigitTok); 1388 1389 // Validate the number and convert it to an unsigned. 1390 unsigned LineNo; 1391 if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer,*this)) 1392 return; 1393 1394 if (LineNo == 0) 1395 Diag(DigitTok, diag::ext_pp_line_zero); 1396 1397 // Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a 1398 // number greater than 2147483647". C90 requires that the line # be <= 32767. 1399 unsigned LineLimit = 32768U; 1400 if (LangOpts.C99 || LangOpts.CPlusPlus11) 1401 LineLimit = 2147483648U; 1402 if (LineNo >= LineLimit) 1403 Diag(DigitTok, diag::ext_pp_line_too_big) << LineLimit; 1404 else if (LangOpts.CPlusPlus11 && LineNo >= 32768U) 1405 Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big); 1406 1407 int FilenameID = -1; 1408 Token StrTok; 1409 Lex(StrTok); 1410 1411 // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a 1412 // string followed by eod. 1413 if (StrTok.is(tok::eod)) 1414 ; // ok 1415 else if (StrTok.isNot(tok::string_literal)) { 1416 Diag(StrTok, diag::err_pp_line_invalid_filename); 1417 DiscardUntilEndOfDirective(); 1418 return; 1419 } else if (StrTok.hasUDSuffix()) { 1420 Diag(StrTok, diag::err_invalid_string_udl); 1421 DiscardUntilEndOfDirective(); 1422 return; 1423 } else { 1424 // Parse and validate the string, converting it into a unique ID. 1425 StringLiteralParser Literal(StrTok, *this); 1426 assert(Literal.isOrdinary() && "Didn't allow wide strings in"); 1427 if (Literal.hadError) { 1428 DiscardUntilEndOfDirective(); 1429 return; 1430 } 1431 if (Literal.Pascal) { 1432 Diag(StrTok, diag::err_pp_linemarker_invalid_filename); 1433 DiscardUntilEndOfDirective(); 1434 return; 1435 } 1436 FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString()); 1437 1438 // Verify that there is nothing after the string, other than EOD. Because 1439 // of C99 6.10.4p5, macros that expand to empty tokens are ok. 1440 CheckEndOfDirective("line", true); 1441 } 1442 1443 // Take the file kind of the file containing the #line directive. #line 1444 // directives are often used for generated sources from the same codebase, so 1445 // the new file should generally be classified the same way as the current 1446 // file. This is visible in GCC's pre-processed output, which rewrites #line 1447 // to GNU line markers. 1448 SrcMgr::CharacteristicKind FileKind = 1449 SourceMgr.getFileCharacteristic(DigitTok.getLocation()); 1450 1451 SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, false, 1452 false, FileKind); 1453 1454 if (Callbacks) 1455 Callbacks->FileChanged(CurPPLexer->getSourceLocation(), 1456 PPCallbacks::RenameFile, FileKind); 1457 } 1458 1459 /// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line 1460 /// marker directive. 1461 static bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit, 1462 SrcMgr::CharacteristicKind &FileKind, 1463 Preprocessor &PP) { 1464 unsigned FlagVal; 1465 Token FlagTok; 1466 PP.Lex(FlagTok); 1467 if (FlagTok.is(tok::eod)) return false; 1468 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP)) 1469 return true; 1470 1471 if (FlagVal == 1) { 1472 IsFileEntry = true; 1473 1474 PP.Lex(FlagTok); 1475 if (FlagTok.is(tok::eod)) return false; 1476 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP)) 1477 return true; 1478 } else if (FlagVal == 2) { 1479 IsFileExit = true; 1480 1481 SourceManager &SM = PP.getSourceManager(); 1482 // If we are leaving the current presumed file, check to make sure the 1483 // presumed include stack isn't empty! 1484 FileID CurFileID = 1485 SM.getDecomposedExpansionLoc(FlagTok.getLocation()).first; 1486 PresumedLoc PLoc = SM.getPresumedLoc(FlagTok.getLocation()); 1487 if (PLoc.isInvalid()) 1488 return true; 1489 1490 // If there is no include loc (main file) or if the include loc is in a 1491 // different physical file, then we aren't in a "1" line marker flag region. 1492 SourceLocation IncLoc = PLoc.getIncludeLoc(); 1493 if (IncLoc.isInvalid() || 1494 SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) { 1495 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop); 1496 PP.DiscardUntilEndOfDirective(); 1497 return true; 1498 } 1499 1500 PP.Lex(FlagTok); 1501 if (FlagTok.is(tok::eod)) return false; 1502 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP)) 1503 return true; 1504 } 1505 1506 // We must have 3 if there are still flags. 1507 if (FlagVal != 3) { 1508 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag); 1509 PP.DiscardUntilEndOfDirective(); 1510 return true; 1511 } 1512 1513 FileKind = SrcMgr::C_System; 1514 1515 PP.Lex(FlagTok); 1516 if (FlagTok.is(tok::eod)) return false; 1517 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP)) 1518 return true; 1519 1520 // We must have 4 if there is yet another flag. 1521 if (FlagVal != 4) { 1522 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag); 1523 PP.DiscardUntilEndOfDirective(); 1524 return true; 1525 } 1526 1527 FileKind = SrcMgr::C_ExternCSystem; 1528 1529 PP.Lex(FlagTok); 1530 if (FlagTok.is(tok::eod)) return false; 1531 1532 // There are no more valid flags here. 1533 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag); 1534 PP.DiscardUntilEndOfDirective(); 1535 return true; 1536 } 1537 1538 /// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is 1539 /// one of the following forms: 1540 /// 1541 /// # 42 1542 /// # 42 "file" ('1' | '2')? 1543 /// # 42 "file" ('1' | '2')? '3' '4'? 1544 /// 1545 void Preprocessor::HandleDigitDirective(Token &DigitTok) { 1546 // Validate the number and convert it to an unsigned. GNU does not have a 1547 // line # limit other than it fit in 32-bits. 1548 unsigned LineNo; 1549 if (GetLineValue(DigitTok, LineNo, diag::err_pp_linemarker_requires_integer, 1550 *this, true)) 1551 return; 1552 1553 Token StrTok; 1554 Lex(StrTok); 1555 1556 bool IsFileEntry = false, IsFileExit = false; 1557 int FilenameID = -1; 1558 SrcMgr::CharacteristicKind FileKind = SrcMgr::C_User; 1559 1560 // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a 1561 // string followed by eod. 1562 if (StrTok.is(tok::eod)) { 1563 Diag(StrTok, diag::ext_pp_gnu_line_directive); 1564 // Treat this like "#line NN", which doesn't change file characteristics. 1565 FileKind = SourceMgr.getFileCharacteristic(DigitTok.getLocation()); 1566 } else if (StrTok.isNot(tok::string_literal)) { 1567 Diag(StrTok, diag::err_pp_linemarker_invalid_filename); 1568 DiscardUntilEndOfDirective(); 1569 return; 1570 } else if (StrTok.hasUDSuffix()) { 1571 Diag(StrTok, diag::err_invalid_string_udl); 1572 DiscardUntilEndOfDirective(); 1573 return; 1574 } else { 1575 // Parse and validate the string, converting it into a unique ID. 1576 StringLiteralParser Literal(StrTok, *this); 1577 assert(Literal.isOrdinary() && "Didn't allow wide strings in"); 1578 if (Literal.hadError) { 1579 DiscardUntilEndOfDirective(); 1580 return; 1581 } 1582 if (Literal.Pascal) { 1583 Diag(StrTok, diag::err_pp_linemarker_invalid_filename); 1584 DiscardUntilEndOfDirective(); 1585 return; 1586 } 1587 1588 // If a filename was present, read any flags that are present. 1589 if (ReadLineMarkerFlags(IsFileEntry, IsFileExit, FileKind, *this)) 1590 return; 1591 if (!SourceMgr.isWrittenInBuiltinFile(DigitTok.getLocation()) && 1592 !SourceMgr.isWrittenInCommandLineFile(DigitTok.getLocation())) 1593 Diag(StrTok, diag::ext_pp_gnu_line_directive); 1594 1595 // Exiting to an empty string means pop to the including file, so leave 1596 // FilenameID as -1 in that case. 1597 if (!(IsFileExit && Literal.GetString().empty())) 1598 FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString()); 1599 } 1600 1601 // Create a line note with this information. 1602 SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, IsFileEntry, 1603 IsFileExit, FileKind); 1604 1605 // If the preprocessor has callbacks installed, notify them of the #line 1606 // change. This is used so that the line marker comes out in -E mode for 1607 // example. 1608 if (Callbacks) { 1609 PPCallbacks::FileChangeReason Reason = PPCallbacks::RenameFile; 1610 if (IsFileEntry) 1611 Reason = PPCallbacks::EnterFile; 1612 else if (IsFileExit) 1613 Reason = PPCallbacks::ExitFile; 1614 1615 Callbacks->FileChanged(CurPPLexer->getSourceLocation(), Reason, FileKind); 1616 } 1617 } 1618 1619 /// HandleUserDiagnosticDirective - Handle a #warning or #error directive. 1620 /// 1621 void Preprocessor::HandleUserDiagnosticDirective(Token &Tok, 1622 bool isWarning) { 1623 // Read the rest of the line raw. We do this because we don't want macros 1624 // to be expanded and we don't require that the tokens be valid preprocessing 1625 // tokens. For example, this is allowed: "#warning ` 'foo". GCC does 1626 // collapse multiple consecutive white space between tokens, but this isn't 1627 // specified by the standard. 1628 SmallString<128> Message; 1629 CurLexer->ReadToEndOfLine(&Message); 1630 1631 // Find the first non-whitespace character, so that we can make the 1632 // diagnostic more succinct. 1633 StringRef Msg = Message.str().ltrim(' '); 1634 1635 if (isWarning) 1636 Diag(Tok, diag::pp_hash_warning) << Msg; 1637 else 1638 Diag(Tok, diag::err_pp_hash_error) << Msg; 1639 } 1640 1641 /// HandleIdentSCCSDirective - Handle a #ident/#sccs directive. 1642 /// 1643 void Preprocessor::HandleIdentSCCSDirective(Token &Tok) { 1644 // Yes, this directive is an extension. 1645 Diag(Tok, diag::ext_pp_ident_directive); 1646 1647 // Read the string argument. 1648 Token StrTok; 1649 Lex(StrTok); 1650 1651 // If the token kind isn't a string, it's a malformed directive. 1652 if (StrTok.isNot(tok::string_literal) && 1653 StrTok.isNot(tok::wide_string_literal)) { 1654 Diag(StrTok, diag::err_pp_malformed_ident); 1655 if (StrTok.isNot(tok::eod)) 1656 DiscardUntilEndOfDirective(); 1657 return; 1658 } 1659 1660 if (StrTok.hasUDSuffix()) { 1661 Diag(StrTok, diag::err_invalid_string_udl); 1662 DiscardUntilEndOfDirective(); 1663 return; 1664 } 1665 1666 // Verify that there is nothing after the string, other than EOD. 1667 CheckEndOfDirective("ident"); 1668 1669 if (Callbacks) { 1670 bool Invalid = false; 1671 std::string Str = getSpelling(StrTok, &Invalid); 1672 if (!Invalid) 1673 Callbacks->Ident(Tok.getLocation(), Str); 1674 } 1675 } 1676 1677 /// Handle a #public directive. 1678 void Preprocessor::HandleMacroPublicDirective(Token &Tok) { 1679 Token MacroNameTok; 1680 ReadMacroName(MacroNameTok, MU_Undef); 1681 1682 // Error reading macro name? If so, diagnostic already issued. 1683 if (MacroNameTok.is(tok::eod)) 1684 return; 1685 1686 // Check to see if this is the last token on the #__public_macro line. 1687 CheckEndOfDirective("__public_macro"); 1688 1689 IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); 1690 // Okay, we finally have a valid identifier to undef. 1691 MacroDirective *MD = getLocalMacroDirective(II); 1692 1693 // If the macro is not defined, this is an error. 1694 if (!MD) { 1695 Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II; 1696 return; 1697 } 1698 1699 // Note that this macro has now been exported. 1700 appendMacroDirective(II, AllocateVisibilityMacroDirective( 1701 MacroNameTok.getLocation(), /*isPublic=*/true)); 1702 } 1703 1704 /// Handle a #private directive. 1705 void Preprocessor::HandleMacroPrivateDirective() { 1706 Token MacroNameTok; 1707 ReadMacroName(MacroNameTok, MU_Undef); 1708 1709 // Error reading macro name? If so, diagnostic already issued. 1710 if (MacroNameTok.is(tok::eod)) 1711 return; 1712 1713 // Check to see if this is the last token on the #__private_macro line. 1714 CheckEndOfDirective("__private_macro"); 1715 1716 IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); 1717 // Okay, we finally have a valid identifier to undef. 1718 MacroDirective *MD = getLocalMacroDirective(II); 1719 1720 // If the macro is not defined, this is an error. 1721 if (!MD) { 1722 Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II; 1723 return; 1724 } 1725 1726 // Note that this macro has now been marked private. 1727 appendMacroDirective(II, AllocateVisibilityMacroDirective( 1728 MacroNameTok.getLocation(), /*isPublic=*/false)); 1729 } 1730 1731 //===----------------------------------------------------------------------===// 1732 // Preprocessor Include Directive Handling. 1733 //===----------------------------------------------------------------------===// 1734 1735 /// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully 1736 /// checked and spelled filename, e.g. as an operand of \#include. This returns 1737 /// true if the input filename was in <>'s or false if it were in ""'s. The 1738 /// caller is expected to provide a buffer that is large enough to hold the 1739 /// spelling of the filename, but is also expected to handle the case when 1740 /// this method decides to use a different buffer. 1741 bool Preprocessor::GetIncludeFilenameSpelling(SourceLocation Loc, 1742 StringRef &Buffer) { 1743 // Get the text form of the filename. 1744 assert(!Buffer.empty() && "Can't have tokens with empty spellings!"); 1745 1746 // FIXME: Consider warning on some of the cases described in C11 6.4.7/3 and 1747 // C++20 [lex.header]/2: 1748 // 1749 // If `"`, `'`, `\`, `/*`, or `//` appears in a header-name, then 1750 // in C: behavior is undefined 1751 // in C++: program is conditionally-supported with implementation-defined 1752 // semantics 1753 1754 // Make sure the filename is <x> or "x". 1755 bool isAngled; 1756 if (Buffer[0] == '<') { 1757 if (Buffer.back() != '>') { 1758 Diag(Loc, diag::err_pp_expects_filename); 1759 Buffer = StringRef(); 1760 return true; 1761 } 1762 isAngled = true; 1763 } else if (Buffer[0] == '"') { 1764 if (Buffer.back() != '"') { 1765 Diag(Loc, diag::err_pp_expects_filename); 1766 Buffer = StringRef(); 1767 return true; 1768 } 1769 isAngled = false; 1770 } else { 1771 Diag(Loc, diag::err_pp_expects_filename); 1772 Buffer = StringRef(); 1773 return true; 1774 } 1775 1776 // Diagnose #include "" as invalid. 1777 if (Buffer.size() <= 2) { 1778 Diag(Loc, diag::err_pp_empty_filename); 1779 Buffer = StringRef(); 1780 return true; 1781 } 1782 1783 // Skip the brackets. 1784 Buffer = Buffer.substr(1, Buffer.size()-2); 1785 return isAngled; 1786 } 1787 1788 /// Push a token onto the token stream containing an annotation. 1789 void Preprocessor::EnterAnnotationToken(SourceRange Range, 1790 tok::TokenKind Kind, 1791 void *AnnotationVal) { 1792 // FIXME: Produce this as the current token directly, rather than 1793 // allocating a new token for it. 1794 auto Tok = std::make_unique<Token[]>(1); 1795 Tok[0].startToken(); 1796 Tok[0].setKind(Kind); 1797 Tok[0].setLocation(Range.getBegin()); 1798 Tok[0].setAnnotationEndLoc(Range.getEnd()); 1799 Tok[0].setAnnotationValue(AnnotationVal); 1800 EnterTokenStream(std::move(Tok), 1, true, /*IsReinject*/ false); 1801 } 1802 1803 /// Produce a diagnostic informing the user that a #include or similar 1804 /// was implicitly treated as a module import. 1805 static void diagnoseAutoModuleImport( 1806 Preprocessor &PP, SourceLocation HashLoc, Token &IncludeTok, 1807 ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> Path, 1808 SourceLocation PathEnd) { 1809 StringRef ImportKeyword; 1810 if (PP.getLangOpts().ObjC) 1811 ImportKeyword = "@import"; 1812 else if (PP.getLangOpts().ModulesTS || PP.getLangOpts().CPlusPlusModules) 1813 ImportKeyword = "import"; 1814 else 1815 return; // no import syntax available 1816 1817 SmallString<128> PathString; 1818 for (size_t I = 0, N = Path.size(); I != N; ++I) { 1819 if (I) 1820 PathString += '.'; 1821 PathString += Path[I].first->getName(); 1822 } 1823 int IncludeKind = 0; 1824 1825 switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) { 1826 case tok::pp_include: 1827 IncludeKind = 0; 1828 break; 1829 1830 case tok::pp_import: 1831 IncludeKind = 1; 1832 break; 1833 1834 case tok::pp_include_next: 1835 IncludeKind = 2; 1836 break; 1837 1838 case tok::pp___include_macros: 1839 IncludeKind = 3; 1840 break; 1841 1842 default: 1843 llvm_unreachable("unknown include directive kind"); 1844 } 1845 1846 CharSourceRange ReplaceRange(SourceRange(HashLoc, PathEnd), 1847 /*IsTokenRange=*/false); 1848 PP.Diag(HashLoc, diag::warn_auto_module_import) 1849 << IncludeKind << PathString 1850 << FixItHint::CreateReplacement( 1851 ReplaceRange, (ImportKeyword + " " + PathString + ";").str()); 1852 } 1853 1854 // Given a vector of path components and a string containing the real 1855 // path to the file, build a properly-cased replacement in the vector, 1856 // and return true if the replacement should be suggested. 1857 static bool trySimplifyPath(SmallVectorImpl<StringRef> &Components, 1858 StringRef RealPathName) { 1859 auto RealPathComponentIter = llvm::sys::path::rbegin(RealPathName); 1860 auto RealPathComponentEnd = llvm::sys::path::rend(RealPathName); 1861 int Cnt = 0; 1862 bool SuggestReplacement = false; 1863 // Below is a best-effort to handle ".." in paths. It is admittedly 1864 // not 100% correct in the presence of symlinks. 1865 for (auto &Component : llvm::reverse(Components)) { 1866 if ("." == Component) { 1867 } else if (".." == Component) { 1868 ++Cnt; 1869 } else if (Cnt) { 1870 --Cnt; 1871 } else if (RealPathComponentIter != RealPathComponentEnd) { 1872 if (Component != *RealPathComponentIter) { 1873 // If these path components differ by more than just case, then we 1874 // may be looking at symlinked paths. Bail on this diagnostic to avoid 1875 // noisy false positives. 1876 SuggestReplacement = 1877 RealPathComponentIter->equals_insensitive(Component); 1878 if (!SuggestReplacement) 1879 break; 1880 Component = *RealPathComponentIter; 1881 } 1882 ++RealPathComponentIter; 1883 } 1884 } 1885 return SuggestReplacement; 1886 } 1887 1888 bool Preprocessor::checkModuleIsAvailable(const LangOptions &LangOpts, 1889 const TargetInfo &TargetInfo, 1890 DiagnosticsEngine &Diags, Module *M) { 1891 Module::Requirement Requirement; 1892 Module::UnresolvedHeaderDirective MissingHeader; 1893 Module *ShadowingModule = nullptr; 1894 if (M->isAvailable(LangOpts, TargetInfo, Requirement, MissingHeader, 1895 ShadowingModule)) 1896 return false; 1897 1898 if (MissingHeader.FileNameLoc.isValid()) { 1899 Diags.Report(MissingHeader.FileNameLoc, diag::err_module_header_missing) 1900 << MissingHeader.IsUmbrella << MissingHeader.FileName; 1901 } else if (ShadowingModule) { 1902 Diags.Report(M->DefinitionLoc, diag::err_module_shadowed) << M->Name; 1903 Diags.Report(ShadowingModule->DefinitionLoc, 1904 diag::note_previous_definition); 1905 } else { 1906 // FIXME: Track the location at which the requirement was specified, and 1907 // use it here. 1908 Diags.Report(M->DefinitionLoc, diag::err_module_unavailable) 1909 << M->getFullModuleName() << Requirement.second << Requirement.first; 1910 } 1911 return true; 1912 } 1913 1914 std::pair<ConstSearchDirIterator, const FileEntry *> 1915 Preprocessor::getIncludeNextStart(const Token &IncludeNextTok) const { 1916 // #include_next is like #include, except that we start searching after 1917 // the current found directory. If we can't do this, issue a 1918 // diagnostic. 1919 ConstSearchDirIterator Lookup = CurDirLookup; 1920 const FileEntry *LookupFromFile = nullptr; 1921 1922 if (isInPrimaryFile() && LangOpts.IsHeaderFile) { 1923 // If the main file is a header, then it's either for PCH/AST generation, 1924 // or libclang opened it. Either way, handle it as a normal include below 1925 // and do not complain about include_next. 1926 } else if (isInPrimaryFile()) { 1927 Lookup = nullptr; 1928 Diag(IncludeNextTok, diag::pp_include_next_in_primary); 1929 } else if (CurLexerSubmodule) { 1930 // Start looking up in the directory *after* the one in which the current 1931 // file would be found, if any. 1932 assert(CurPPLexer && "#include_next directive in macro?"); 1933 LookupFromFile = CurPPLexer->getFileEntry(); 1934 Lookup = nullptr; 1935 } else if (!Lookup) { 1936 // The current file was not found by walking the include path. Either it 1937 // is the primary file (handled above), or it was found by absolute path, 1938 // or it was found relative to such a file. 1939 // FIXME: Track enough information so we know which case we're in. 1940 Diag(IncludeNextTok, diag::pp_include_next_absolute_path); 1941 } else { 1942 // Start looking up in the next directory. 1943 ++Lookup; 1944 } 1945 1946 return {Lookup, LookupFromFile}; 1947 } 1948 1949 /// HandleIncludeDirective - The "\#include" tokens have just been read, read 1950 /// the file to be included from the lexer, then include it! This is a common 1951 /// routine with functionality shared between \#include, \#include_next and 1952 /// \#import. LookupFrom is set when this is a \#include_next directive, it 1953 /// specifies the file to start searching from. 1954 void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc, 1955 Token &IncludeTok, 1956 ConstSearchDirIterator LookupFrom, 1957 const FileEntry *LookupFromFile) { 1958 Token FilenameTok; 1959 if (LexHeaderName(FilenameTok)) 1960 return; 1961 1962 if (FilenameTok.isNot(tok::header_name)) { 1963 Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename); 1964 if (FilenameTok.isNot(tok::eod)) 1965 DiscardUntilEndOfDirective(); 1966 return; 1967 } 1968 1969 // Verify that there is nothing after the filename, other than EOD. Note 1970 // that we allow macros that expand to nothing after the filename, because 1971 // this falls into the category of "#include pp-tokens new-line" specified 1972 // in C99 6.10.2p4. 1973 SourceLocation EndLoc = 1974 CheckEndOfDirective(IncludeTok.getIdentifierInfo()->getNameStart(), true); 1975 1976 auto Action = HandleHeaderIncludeOrImport(HashLoc, IncludeTok, FilenameTok, 1977 EndLoc, LookupFrom, LookupFromFile); 1978 switch (Action.Kind) { 1979 case ImportAction::None: 1980 case ImportAction::SkippedModuleImport: 1981 break; 1982 case ImportAction::ModuleBegin: 1983 EnterAnnotationToken(SourceRange(HashLoc, EndLoc), 1984 tok::annot_module_begin, Action.ModuleForHeader); 1985 break; 1986 case ImportAction::HeaderUnitImport: 1987 EnterAnnotationToken(SourceRange(HashLoc, EndLoc), tok::annot_header_unit, 1988 Action.ModuleForHeader); 1989 break; 1990 case ImportAction::ModuleImport: 1991 EnterAnnotationToken(SourceRange(HashLoc, EndLoc), 1992 tok::annot_module_include, Action.ModuleForHeader); 1993 break; 1994 case ImportAction::Failure: 1995 assert(TheModuleLoader.HadFatalFailure && 1996 "This should be an early exit only to a fatal error"); 1997 TheModuleLoader.HadFatalFailure = true; 1998 IncludeTok.setKind(tok::eof); 1999 CurLexer->cutOffLexing(); 2000 return; 2001 } 2002 } 2003 2004 Optional<FileEntryRef> Preprocessor::LookupHeaderIncludeOrImport( 2005 ConstSearchDirIterator *CurDir, StringRef &Filename, 2006 SourceLocation FilenameLoc, CharSourceRange FilenameRange, 2007 const Token &FilenameTok, bool &IsFrameworkFound, bool IsImportDecl, 2008 bool &IsMapped, ConstSearchDirIterator LookupFrom, 2009 const FileEntry *LookupFromFile, StringRef &LookupFilename, 2010 SmallVectorImpl<char> &RelativePath, SmallVectorImpl<char> &SearchPath, 2011 ModuleMap::KnownHeader &SuggestedModule, bool isAngled) { 2012 Optional<FileEntryRef> File = LookupFile( 2013 FilenameLoc, LookupFilename, 2014 isAngled, LookupFrom, LookupFromFile, CurDir, 2015 Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr, 2016 &SuggestedModule, &IsMapped, &IsFrameworkFound); 2017 if (File) 2018 return File; 2019 2020 if (SuppressIncludeNotFoundError) 2021 return None; 2022 2023 // If the file could not be located and it was included via angle 2024 // brackets, we can attempt a lookup as though it were a quoted path to 2025 // provide the user with a possible fixit. 2026 if (isAngled) { 2027 Optional<FileEntryRef> File = LookupFile( 2028 FilenameLoc, LookupFilename, 2029 false, LookupFrom, LookupFromFile, CurDir, 2030 Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr, 2031 &SuggestedModule, &IsMapped, 2032 /*IsFrameworkFound=*/nullptr); 2033 if (File) { 2034 Diag(FilenameTok, diag::err_pp_file_not_found_angled_include_not_fatal) 2035 << Filename << IsImportDecl 2036 << FixItHint::CreateReplacement(FilenameRange, 2037 "\"" + Filename.str() + "\""); 2038 return File; 2039 } 2040 } 2041 2042 // Check for likely typos due to leading or trailing non-isAlphanumeric 2043 // characters 2044 StringRef OriginalFilename = Filename; 2045 if (LangOpts.SpellChecking) { 2046 // A heuristic to correct a typo file name by removing leading and 2047 // trailing non-isAlphanumeric characters. 2048 auto CorrectTypoFilename = [](llvm::StringRef Filename) { 2049 Filename = Filename.drop_until(isAlphanumeric); 2050 while (!Filename.empty() && !isAlphanumeric(Filename.back())) { 2051 Filename = Filename.drop_back(); 2052 } 2053 return Filename; 2054 }; 2055 StringRef TypoCorrectionName = CorrectTypoFilename(Filename); 2056 StringRef TypoCorrectionLookupName = CorrectTypoFilename(LookupFilename); 2057 2058 Optional<FileEntryRef> File = LookupFile( 2059 FilenameLoc, TypoCorrectionLookupName, isAngled, LookupFrom, LookupFromFile, 2060 CurDir, Callbacks ? &SearchPath : nullptr, 2061 Callbacks ? &RelativePath : nullptr, &SuggestedModule, &IsMapped, 2062 /*IsFrameworkFound=*/nullptr); 2063 if (File) { 2064 auto Hint = 2065 isAngled ? FixItHint::CreateReplacement( 2066 FilenameRange, "<" + TypoCorrectionName.str() + ">") 2067 : FixItHint::CreateReplacement( 2068 FilenameRange, "\"" + TypoCorrectionName.str() + "\""); 2069 Diag(FilenameTok, diag::err_pp_file_not_found_typo_not_fatal) 2070 << OriginalFilename << TypoCorrectionName << Hint; 2071 // We found the file, so set the Filename to the name after typo 2072 // correction. 2073 Filename = TypoCorrectionName; 2074 LookupFilename = TypoCorrectionLookupName; 2075 return File; 2076 } 2077 } 2078 2079 // If the file is still not found, just go with the vanilla diagnostic 2080 assert(!File && "expected missing file"); 2081 Diag(FilenameTok, diag::err_pp_file_not_found) 2082 << OriginalFilename << FilenameRange; 2083 if (IsFrameworkFound) { 2084 size_t SlashPos = OriginalFilename.find('/'); 2085 assert(SlashPos != StringRef::npos && 2086 "Include with framework name should have '/' in the filename"); 2087 StringRef FrameworkName = OriginalFilename.substr(0, SlashPos); 2088 FrameworkCacheEntry &CacheEntry = 2089 HeaderInfo.LookupFrameworkCache(FrameworkName); 2090 assert(CacheEntry.Directory && "Found framework should be in cache"); 2091 Diag(FilenameTok, diag::note_pp_framework_without_header) 2092 << OriginalFilename.substr(SlashPos + 1) << FrameworkName 2093 << CacheEntry.Directory->getName(); 2094 } 2095 2096 return None; 2097 } 2098 2099 /// Handle either a #include-like directive or an import declaration that names 2100 /// a header file. 2101 /// 2102 /// \param HashLoc The location of the '#' token for an include, or 2103 /// SourceLocation() for an import declaration. 2104 /// \param IncludeTok The include / include_next / import token. 2105 /// \param FilenameTok The header-name token. 2106 /// \param EndLoc The location at which any imported macros become visible. 2107 /// \param LookupFrom For #include_next, the starting directory for the 2108 /// directory lookup. 2109 /// \param LookupFromFile For #include_next, the starting file for the directory 2110 /// lookup. 2111 Preprocessor::ImportAction Preprocessor::HandleHeaderIncludeOrImport( 2112 SourceLocation HashLoc, Token &IncludeTok, Token &FilenameTok, 2113 SourceLocation EndLoc, ConstSearchDirIterator LookupFrom, 2114 const FileEntry *LookupFromFile) { 2115 SmallString<128> FilenameBuffer; 2116 StringRef Filename = getSpelling(FilenameTok, FilenameBuffer); 2117 SourceLocation CharEnd = FilenameTok.getEndLoc(); 2118 2119 CharSourceRange FilenameRange 2120 = CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd); 2121 StringRef OriginalFilename = Filename; 2122 bool isAngled = 2123 GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename); 2124 2125 // If GetIncludeFilenameSpelling set the start ptr to null, there was an 2126 // error. 2127 if (Filename.empty()) 2128 return {ImportAction::None}; 2129 2130 bool IsImportDecl = HashLoc.isInvalid(); 2131 SourceLocation StartLoc = IsImportDecl ? IncludeTok.getLocation() : HashLoc; 2132 2133 // Complain about attempts to #include files in an audit pragma. 2134 if (PragmaARCCFCodeAuditedInfo.second.isValid()) { 2135 Diag(StartLoc, diag::err_pp_include_in_arc_cf_code_audited) << IsImportDecl; 2136 Diag(PragmaARCCFCodeAuditedInfo.second, diag::note_pragma_entered_here); 2137 2138 // Immediately leave the pragma. 2139 PragmaARCCFCodeAuditedInfo = {nullptr, SourceLocation()}; 2140 } 2141 2142 // Complain about attempts to #include files in an assume-nonnull pragma. 2143 if (PragmaAssumeNonNullLoc.isValid()) { 2144 Diag(StartLoc, diag::err_pp_include_in_assume_nonnull) << IsImportDecl; 2145 Diag(PragmaAssumeNonNullLoc, diag::note_pragma_entered_here); 2146 2147 // Immediately leave the pragma. 2148 PragmaAssumeNonNullLoc = SourceLocation(); 2149 } 2150 2151 if (HeaderInfo.HasIncludeAliasMap()) { 2152 // Map the filename with the brackets still attached. If the name doesn't 2153 // map to anything, fall back on the filename we've already gotten the 2154 // spelling for. 2155 StringRef NewName = HeaderInfo.MapHeaderToIncludeAlias(OriginalFilename); 2156 if (!NewName.empty()) 2157 Filename = NewName; 2158 } 2159 2160 // Search include directories. 2161 bool IsMapped = false; 2162 bool IsFrameworkFound = false; 2163 ConstSearchDirIterator CurDir = nullptr; 2164 SmallString<1024> SearchPath; 2165 SmallString<1024> RelativePath; 2166 // We get the raw path only if we have 'Callbacks' to which we later pass 2167 // the path. 2168 ModuleMap::KnownHeader SuggestedModule; 2169 SourceLocation FilenameLoc = FilenameTok.getLocation(); 2170 StringRef LookupFilename = Filename; 2171 2172 // Normalize slashes when compiling with -fms-extensions on non-Windows. This 2173 // is unnecessary on Windows since the filesystem there handles backslashes. 2174 SmallString<128> NormalizedPath; 2175 llvm::sys::path::Style BackslashStyle = llvm::sys::path::Style::native; 2176 if (is_style_posix(BackslashStyle) && LangOpts.MicrosoftExt) { 2177 NormalizedPath = Filename.str(); 2178 llvm::sys::path::native(NormalizedPath); 2179 LookupFilename = NormalizedPath; 2180 BackslashStyle = llvm::sys::path::Style::windows; 2181 } 2182 2183 Optional<FileEntryRef> File = LookupHeaderIncludeOrImport( 2184 &CurDir, Filename, FilenameLoc, FilenameRange, FilenameTok, 2185 IsFrameworkFound, IsImportDecl, IsMapped, LookupFrom, LookupFromFile, 2186 LookupFilename, RelativePath, SearchPath, SuggestedModule, isAngled); 2187 2188 if (usingPCHWithThroughHeader() && SkippingUntilPCHThroughHeader) { 2189 if (File && isPCHThroughHeader(&File->getFileEntry())) 2190 SkippingUntilPCHThroughHeader = false; 2191 return {ImportAction::None}; 2192 } 2193 2194 // Should we enter the source file? Set to Skip if either the source file is 2195 // known to have no effect beyond its effect on module visibility -- that is, 2196 // if it's got an include guard that is already defined, set to Import if it 2197 // is a modular header we've already built and should import. 2198 2199 // For C++20 Modules 2200 // [cpp.include]/7 If the header identified by the header-name denotes an 2201 // importable header, it is implementation-defined whether the #include 2202 // preprocessing directive is instead replaced by an import directive. 2203 // For this implementation, the translation is permitted when we are parsing 2204 // the Global Module Fragment, and not otherwise (the cases where it would be 2205 // valid to replace an include with an import are highly constrained once in 2206 // named module purview; this choice avoids considerable complexity in 2207 // determining valid cases). 2208 2209 enum { Enter, Import, Skip, IncludeLimitReached } Action = Enter; 2210 2211 if (PPOpts->SingleFileParseMode) 2212 Action = IncludeLimitReached; 2213 2214 // If we've reached the max allowed include depth, it is usually due to an 2215 // include cycle. Don't enter already processed files again as it can lead to 2216 // reaching the max allowed include depth again. 2217 if (Action == Enter && HasReachedMaxIncludeDepth && File && 2218 alreadyIncluded(*File)) 2219 Action = IncludeLimitReached; 2220 2221 bool MaybeTranslateInclude = Action == Enter && File && SuggestedModule && 2222 !isForModuleBuilding(SuggestedModule.getModule(), 2223 getLangOpts().CurrentModule, 2224 getLangOpts().ModuleName); 2225 2226 // FIXME: We do not have a good way to disambiguate C++ clang modules from 2227 // C++ standard modules (other than use/non-use of Header Units). 2228 Module *SM = SuggestedModule.getModule(); 2229 // Maybe a usable Header Unit 2230 bool UsableHeaderUnit = false; 2231 if (getLangOpts().CPlusPlusModules && SM && SM->isHeaderUnit()) { 2232 if (TrackGMFState.inGMF() || IsImportDecl) 2233 UsableHeaderUnit = true; 2234 else if (!IsImportDecl) { 2235 // This is a Header Unit that we do not include-translate 2236 SuggestedModule = ModuleMap::KnownHeader(); 2237 SM = nullptr; 2238 } 2239 } 2240 // Maybe a usable clang header module. 2241 bool UsableHeaderModule = 2242 (getLangOpts().CPlusPlusModules || getLangOpts().Modules) && SM && 2243 !SM->isHeaderUnit(); 2244 2245 // Determine whether we should try to import the module for this #include, if 2246 // there is one. Don't do so if precompiled module support is disabled or we 2247 // are processing this module textually (because we're building the module). 2248 if (MaybeTranslateInclude && (UsableHeaderUnit || UsableHeaderModule)) { 2249 // If this include corresponds to a module but that module is 2250 // unavailable, diagnose the situation and bail out. 2251 // FIXME: Remove this; loadModule does the same check (but produces 2252 // slightly worse diagnostics). 2253 if (checkModuleIsAvailable(getLangOpts(), getTargetInfo(), getDiagnostics(), 2254 SuggestedModule.getModule())) { 2255 Diag(FilenameTok.getLocation(), 2256 diag::note_implicit_top_level_module_import_here) 2257 << SuggestedModule.getModule()->getTopLevelModuleName(); 2258 return {ImportAction::None}; 2259 } 2260 2261 // Compute the module access path corresponding to this module. 2262 // FIXME: Should we have a second loadModule() overload to avoid this 2263 // extra lookup step? 2264 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path; 2265 for (Module *Mod = SM; Mod; Mod = Mod->Parent) 2266 Path.push_back(std::make_pair(getIdentifierInfo(Mod->Name), 2267 FilenameTok.getLocation())); 2268 std::reverse(Path.begin(), Path.end()); 2269 2270 // Warn that we're replacing the include/import with a module import. 2271 if (!IsImportDecl) 2272 diagnoseAutoModuleImport(*this, StartLoc, IncludeTok, Path, CharEnd); 2273 2274 // Load the module to import its macros. We'll make the declarations 2275 // visible when the parser gets here. 2276 // FIXME: Pass SuggestedModule in here rather than converting it to a path 2277 // and making the module loader convert it back again. 2278 ModuleLoadResult Imported = TheModuleLoader.loadModule( 2279 IncludeTok.getLocation(), Path, Module::Hidden, 2280 /*IsInclusionDirective=*/true); 2281 assert((Imported == nullptr || Imported == SuggestedModule.getModule()) && 2282 "the imported module is different than the suggested one"); 2283 2284 if (Imported) { 2285 Action = Import; 2286 } else if (Imported.isMissingExpected()) { 2287 // We failed to find a submodule that we assumed would exist (because it 2288 // was in the directory of an umbrella header, for instance), but no 2289 // actual module containing it exists (because the umbrella header is 2290 // incomplete). Treat this as a textual inclusion. 2291 SuggestedModule = ModuleMap::KnownHeader(); 2292 } else if (Imported.isConfigMismatch()) { 2293 // On a configuration mismatch, enter the header textually. We still know 2294 // that it's part of the corresponding module. 2295 } else { 2296 // We hit an error processing the import. Bail out. 2297 if (hadModuleLoaderFatalFailure()) { 2298 // With a fatal failure in the module loader, we abort parsing. 2299 Token &Result = IncludeTok; 2300 assert(CurLexer && "#include but no current lexer set!"); 2301 Result.startToken(); 2302 CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof); 2303 CurLexer->cutOffLexing(); 2304 } 2305 return {ImportAction::None}; 2306 } 2307 } 2308 2309 // The #included file will be considered to be a system header if either it is 2310 // in a system include directory, or if the #includer is a system include 2311 // header. 2312 SrcMgr::CharacteristicKind FileCharacter = 2313 SourceMgr.getFileCharacteristic(FilenameTok.getLocation()); 2314 if (File) 2315 FileCharacter = std::max(HeaderInfo.getFileDirFlavor(&File->getFileEntry()), 2316 FileCharacter); 2317 2318 // If this is a '#import' or an import-declaration, don't re-enter the file. 2319 // 2320 // FIXME: If we have a suggested module for a '#include', and we've already 2321 // visited this file, don't bother entering it again. We know it has no 2322 // further effect. 2323 bool EnterOnce = 2324 IsImportDecl || 2325 IncludeTok.getIdentifierInfo()->getPPKeywordID() == tok::pp_import; 2326 2327 bool IsFirstIncludeOfFile = false; 2328 2329 // Ask HeaderInfo if we should enter this #include file. If not, #including 2330 // this file will have no effect. 2331 if (Action == Enter && File && 2332 !HeaderInfo.ShouldEnterIncludeFile(*this, &File->getFileEntry(), 2333 EnterOnce, getLangOpts().Modules, SM, 2334 IsFirstIncludeOfFile)) { 2335 // C++ standard modules: 2336 // If we are not in the GMF, then we textually include only 2337 // clang modules: 2338 // Even if we've already preprocessed this header once and know that we 2339 // don't need to see its contents again, we still need to import it if it's 2340 // modular because we might not have imported it from this submodule before. 2341 // 2342 // FIXME: We don't do this when compiling a PCH because the AST 2343 // serialization layer can't cope with it. This means we get local 2344 // submodule visibility semantics wrong in that case. 2345 if (UsableHeaderUnit && !getLangOpts().CompilingPCH) 2346 Action = TrackGMFState.inGMF() ? Import : Skip; 2347 else 2348 Action = (SuggestedModule && !getLangOpts().CompilingPCH) ? Import : Skip; 2349 } 2350 2351 // Check for circular inclusion of the main file. 2352 // We can't generate a consistent preamble with regard to the conditional 2353 // stack if the main file is included again as due to the preamble bounds 2354 // some directives (e.g. #endif of a header guard) will never be seen. 2355 // Since this will lead to confusing errors, avoid the inclusion. 2356 if (Action == Enter && File && PreambleConditionalStack.isRecording() && 2357 SourceMgr.isMainFile(File->getFileEntry())) { 2358 Diag(FilenameTok.getLocation(), 2359 diag::err_pp_including_mainfile_in_preamble); 2360 return {ImportAction::None}; 2361 } 2362 2363 if (Callbacks && !IsImportDecl) { 2364 // Notify the callback object that we've seen an inclusion directive. 2365 // FIXME: Use a different callback for a pp-import? 2366 Callbacks->InclusionDirective(HashLoc, IncludeTok, LookupFilename, isAngled, 2367 FilenameRange, File, SearchPath, RelativePath, 2368 Action == Import ? SuggestedModule.getModule() 2369 : nullptr, 2370 FileCharacter); 2371 if (Action == Skip && File) 2372 Callbacks->FileSkipped(*File, FilenameTok, FileCharacter); 2373 } 2374 2375 if (!File) 2376 return {ImportAction::None}; 2377 2378 // If this is a C++20 pp-import declaration, diagnose if we didn't find any 2379 // module corresponding to the named header. 2380 if (IsImportDecl && !SuggestedModule) { 2381 Diag(FilenameTok, diag::err_header_import_not_header_unit) 2382 << OriginalFilename << File->getName(); 2383 return {ImportAction::None}; 2384 } 2385 2386 // Issue a diagnostic if the name of the file on disk has a different case 2387 // than the one we're about to open. 2388 const bool CheckIncludePathPortability = 2389 !IsMapped && !File->getFileEntry().tryGetRealPathName().empty(); 2390 2391 if (CheckIncludePathPortability) { 2392 StringRef Name = LookupFilename; 2393 StringRef NameWithoriginalSlashes = Filename; 2394 #if defined(_WIN32) 2395 // Skip UNC prefix if present. (tryGetRealPathName() always 2396 // returns a path with the prefix skipped.) 2397 bool NameWasUNC = Name.consume_front("\\\\?\\"); 2398 NameWithoriginalSlashes.consume_front("\\\\?\\"); 2399 #endif 2400 StringRef RealPathName = File->getFileEntry().tryGetRealPathName(); 2401 SmallVector<StringRef, 16> Components(llvm::sys::path::begin(Name), 2402 llvm::sys::path::end(Name)); 2403 #if defined(_WIN32) 2404 // -Wnonportable-include-path is designed to diagnose includes using 2405 // case even on systems with a case-insensitive file system. 2406 // On Windows, RealPathName always starts with an upper-case drive 2407 // letter for absolute paths, but Name might start with either 2408 // case depending on if `cd c:\foo` or `cd C:\foo` was used in the shell. 2409 // ("foo" will always have on-disk case, no matter which case was 2410 // used in the cd command). To not emit this warning solely for 2411 // the drive letter, whose case is dependent on if `cd` is used 2412 // with upper- or lower-case drive letters, always consider the 2413 // given drive letter case as correct for the purpose of this warning. 2414 SmallString<128> FixedDriveRealPath; 2415 if (llvm::sys::path::is_absolute(Name) && 2416 llvm::sys::path::is_absolute(RealPathName) && 2417 toLowercase(Name[0]) == toLowercase(RealPathName[0]) && 2418 isLowercase(Name[0]) != isLowercase(RealPathName[0])) { 2419 assert(Components.size() >= 3 && "should have drive, backslash, name"); 2420 assert(Components[0].size() == 2 && "should start with drive"); 2421 assert(Components[0][1] == ':' && "should have colon"); 2422 FixedDriveRealPath = (Name.substr(0, 1) + RealPathName.substr(1)).str(); 2423 RealPathName = FixedDriveRealPath; 2424 } 2425 #endif 2426 2427 if (trySimplifyPath(Components, RealPathName)) { 2428 SmallString<128> Path; 2429 Path.reserve(Name.size()+2); 2430 Path.push_back(isAngled ? '<' : '"'); 2431 2432 const auto IsSep = [BackslashStyle](char c) { 2433 return llvm::sys::path::is_separator(c, BackslashStyle); 2434 }; 2435 2436 for (auto Component : Components) { 2437 // On POSIX, Components will contain a single '/' as first element 2438 // exactly if Name is an absolute path. 2439 // On Windows, it will contain "C:" followed by '\' for absolute paths. 2440 // The drive letter is optional for absolute paths on Windows, but 2441 // clang currently cannot process absolute paths in #include lines that 2442 // don't have a drive. 2443 // If the first entry in Components is a directory separator, 2444 // then the code at the bottom of this loop that keeps the original 2445 // directory separator style copies it. If the second entry is 2446 // a directory separator (the C:\ case), then that separator already 2447 // got copied when the C: was processed and we want to skip that entry. 2448 if (!(Component.size() == 1 && IsSep(Component[0]))) 2449 Path.append(Component); 2450 else if (!Path.empty()) 2451 continue; 2452 2453 // Append the separator(s) the user used, or the close quote 2454 if (Path.size() > NameWithoriginalSlashes.size()) { 2455 Path.push_back(isAngled ? '>' : '"'); 2456 continue; 2457 } 2458 assert(IsSep(NameWithoriginalSlashes[Path.size()-1])); 2459 do 2460 Path.push_back(NameWithoriginalSlashes[Path.size()-1]); 2461 while (Path.size() <= NameWithoriginalSlashes.size() && 2462 IsSep(NameWithoriginalSlashes[Path.size()-1])); 2463 } 2464 2465 #if defined(_WIN32) 2466 // Restore UNC prefix if it was there. 2467 if (NameWasUNC) 2468 Path = (Path.substr(0, 1) + "\\\\?\\" + Path.substr(1)).str(); 2469 #endif 2470 2471 // For user files and known standard headers, issue a diagnostic. 2472 // For other system headers, don't. They can be controlled separately. 2473 auto DiagId = 2474 (FileCharacter == SrcMgr::C_User || warnByDefaultOnWrongCase(Name)) 2475 ? diag::pp_nonportable_path 2476 : diag::pp_nonportable_system_path; 2477 Diag(FilenameTok, DiagId) << Path << 2478 FixItHint::CreateReplacement(FilenameRange, Path); 2479 } 2480 } 2481 2482 switch (Action) { 2483 case Skip: 2484 // If we don't need to enter the file, stop now. 2485 if (SM) 2486 return {ImportAction::SkippedModuleImport, SM}; 2487 return {ImportAction::None}; 2488 2489 case IncludeLimitReached: 2490 // If we reached our include limit and don't want to enter any more files, 2491 // don't go any further. 2492 return {ImportAction::None}; 2493 2494 case Import: { 2495 // If this is a module import, make it visible if needed. 2496 assert(SM && "no module to import"); 2497 2498 makeModuleVisible(SM, EndLoc); 2499 2500 if (IncludeTok.getIdentifierInfo()->getPPKeywordID() == 2501 tok::pp___include_macros) 2502 return {ImportAction::None}; 2503 2504 return {ImportAction::ModuleImport, SM}; 2505 } 2506 2507 case Enter: 2508 break; 2509 } 2510 2511 // Check that we don't have infinite #include recursion. 2512 if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) { 2513 Diag(FilenameTok, diag::err_pp_include_too_deep); 2514 HasReachedMaxIncludeDepth = true; 2515 return {ImportAction::None}; 2516 } 2517 2518 // Look up the file, create a File ID for it. 2519 SourceLocation IncludePos = FilenameTok.getLocation(); 2520 // If the filename string was the result of macro expansions, set the include 2521 // position on the file where it will be included and after the expansions. 2522 if (IncludePos.isMacroID()) 2523 IncludePos = SourceMgr.getExpansionRange(IncludePos).getEnd(); 2524 FileID FID = SourceMgr.createFileID(*File, IncludePos, FileCharacter); 2525 if (!FID.isValid()) { 2526 TheModuleLoader.HadFatalFailure = true; 2527 return ImportAction::Failure; 2528 } 2529 2530 // If all is good, enter the new file! 2531 if (EnterSourceFile(FID, CurDir, FilenameTok.getLocation(), 2532 IsFirstIncludeOfFile)) 2533 return {ImportAction::None}; 2534 2535 // Determine if we're switching to building a new submodule, and which one. 2536 // This does not apply for C++20 modules header units. 2537 if (SM && !SM->isHeaderUnit()) { 2538 if (SM->getTopLevelModule()->ShadowingModule) { 2539 // We are building a submodule that belongs to a shadowed module. This 2540 // means we find header files in the shadowed module. 2541 Diag(SM->DefinitionLoc, diag::err_module_build_shadowed_submodule) 2542 << SM->getFullModuleName(); 2543 Diag(SM->getTopLevelModule()->ShadowingModule->DefinitionLoc, 2544 diag::note_previous_definition); 2545 return {ImportAction::None}; 2546 } 2547 // When building a pch, -fmodule-name tells the compiler to textually 2548 // include headers in the specified module. We are not building the 2549 // specified module. 2550 // 2551 // FIXME: This is the wrong way to handle this. We should produce a PCH 2552 // that behaves the same as the header would behave in a compilation using 2553 // that PCH, which means we should enter the submodule. We need to teach 2554 // the AST serialization layer to deal with the resulting AST. 2555 if (getLangOpts().CompilingPCH && 2556 isForModuleBuilding(SM, getLangOpts().CurrentModule, 2557 getLangOpts().ModuleName)) 2558 return {ImportAction::None}; 2559 2560 assert(!CurLexerSubmodule && "should not have marked this as a module yet"); 2561 CurLexerSubmodule = SM; 2562 2563 // Let the macro handling code know that any future macros are within 2564 // the new submodule. 2565 EnterSubmodule(SM, EndLoc, /*ForPragma*/ false); 2566 2567 // Let the parser know that any future declarations are within the new 2568 // submodule. 2569 // FIXME: There's no point doing this if we're handling a #__include_macros 2570 // directive. 2571 return {ImportAction::ModuleBegin, SM}; 2572 } 2573 2574 assert(!IsImportDecl && "failed to diagnose missing module for import decl"); 2575 return {ImportAction::None}; 2576 } 2577 2578 /// HandleIncludeNextDirective - Implements \#include_next. 2579 /// 2580 void Preprocessor::HandleIncludeNextDirective(SourceLocation HashLoc, 2581 Token &IncludeNextTok) { 2582 Diag(IncludeNextTok, diag::ext_pp_include_next_directive); 2583 2584 ConstSearchDirIterator Lookup = nullptr; 2585 const FileEntry *LookupFromFile; 2586 std::tie(Lookup, LookupFromFile) = getIncludeNextStart(IncludeNextTok); 2587 2588 return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup, 2589 LookupFromFile); 2590 } 2591 2592 /// HandleMicrosoftImportDirective - Implements \#import for Microsoft Mode 2593 void Preprocessor::HandleMicrosoftImportDirective(Token &Tok) { 2594 // The Microsoft #import directive takes a type library and generates header 2595 // files from it, and includes those. This is beyond the scope of what clang 2596 // does, so we ignore it and error out. However, #import can optionally have 2597 // trailing attributes that span multiple lines. We're going to eat those 2598 // so we can continue processing from there. 2599 Diag(Tok, diag::err_pp_import_directive_ms ); 2600 2601 // Read tokens until we get to the end of the directive. Note that the 2602 // directive can be split over multiple lines using the backslash character. 2603 DiscardUntilEndOfDirective(); 2604 } 2605 2606 /// HandleImportDirective - Implements \#import. 2607 /// 2608 void Preprocessor::HandleImportDirective(SourceLocation HashLoc, 2609 Token &ImportTok) { 2610 if (!LangOpts.ObjC) { // #import is standard for ObjC. 2611 if (LangOpts.MSVCCompat) 2612 return HandleMicrosoftImportDirective(ImportTok); 2613 Diag(ImportTok, diag::ext_pp_import_directive); 2614 } 2615 return HandleIncludeDirective(HashLoc, ImportTok); 2616 } 2617 2618 /// HandleIncludeMacrosDirective - The -imacros command line option turns into a 2619 /// pseudo directive in the predefines buffer. This handles it by sucking all 2620 /// tokens through the preprocessor and discarding them (only keeping the side 2621 /// effects on the preprocessor). 2622 void Preprocessor::HandleIncludeMacrosDirective(SourceLocation HashLoc, 2623 Token &IncludeMacrosTok) { 2624 // This directive should only occur in the predefines buffer. If not, emit an 2625 // error and reject it. 2626 SourceLocation Loc = IncludeMacrosTok.getLocation(); 2627 if (SourceMgr.getBufferName(Loc) != "<built-in>") { 2628 Diag(IncludeMacrosTok.getLocation(), 2629 diag::pp_include_macros_out_of_predefines); 2630 DiscardUntilEndOfDirective(); 2631 return; 2632 } 2633 2634 // Treat this as a normal #include for checking purposes. If this is 2635 // successful, it will push a new lexer onto the include stack. 2636 HandleIncludeDirective(HashLoc, IncludeMacrosTok); 2637 2638 Token TmpTok; 2639 do { 2640 Lex(TmpTok); 2641 assert(TmpTok.isNot(tok::eof) && "Didn't find end of -imacros!"); 2642 } while (TmpTok.isNot(tok::hashhash)); 2643 } 2644 2645 //===----------------------------------------------------------------------===// 2646 // Preprocessor Macro Directive Handling. 2647 //===----------------------------------------------------------------------===// 2648 2649 /// ReadMacroParameterList - The ( starting a parameter list of a macro 2650 /// definition has just been read. Lex the rest of the parameters and the 2651 /// closing ), updating MI with what we learn. Return true if an error occurs 2652 /// parsing the param list. 2653 bool Preprocessor::ReadMacroParameterList(MacroInfo *MI, Token &Tok) { 2654 SmallVector<IdentifierInfo*, 32> Parameters; 2655 2656 while (true) { 2657 LexUnexpandedToken(Tok); 2658 switch (Tok.getKind()) { 2659 case tok::r_paren: 2660 // Found the end of the parameter list. 2661 if (Parameters.empty()) // #define FOO() 2662 return false; 2663 // Otherwise we have #define FOO(A,) 2664 Diag(Tok, diag::err_pp_expected_ident_in_arg_list); 2665 return true; 2666 case tok::ellipsis: // #define X(... -> C99 varargs 2667 if (!LangOpts.C99) 2668 Diag(Tok, LangOpts.CPlusPlus11 ? 2669 diag::warn_cxx98_compat_variadic_macro : 2670 diag::ext_variadic_macro); 2671 2672 // OpenCL v1.2 s6.9.e: variadic macros are not supported. 2673 if (LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus) { 2674 Diag(Tok, diag::ext_pp_opencl_variadic_macros); 2675 } 2676 2677 // Lex the token after the identifier. 2678 LexUnexpandedToken(Tok); 2679 if (Tok.isNot(tok::r_paren)) { 2680 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def); 2681 return true; 2682 } 2683 // Add the __VA_ARGS__ identifier as a parameter. 2684 Parameters.push_back(Ident__VA_ARGS__); 2685 MI->setIsC99Varargs(); 2686 MI->setParameterList(Parameters, BP); 2687 return false; 2688 case tok::eod: // #define X( 2689 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def); 2690 return true; 2691 default: 2692 // Handle keywords and identifiers here to accept things like 2693 // #define Foo(for) for. 2694 IdentifierInfo *II = Tok.getIdentifierInfo(); 2695 if (!II) { 2696 // #define X(1 2697 Diag(Tok, diag::err_pp_invalid_tok_in_arg_list); 2698 return true; 2699 } 2700 2701 // If this is already used as a parameter, it is used multiple times (e.g. 2702 // #define X(A,A. 2703 if (llvm::is_contained(Parameters, II)) { // C99 6.10.3p6 2704 Diag(Tok, diag::err_pp_duplicate_name_in_arg_list) << II; 2705 return true; 2706 } 2707 2708 // Add the parameter to the macro info. 2709 Parameters.push_back(II); 2710 2711 // Lex the token after the identifier. 2712 LexUnexpandedToken(Tok); 2713 2714 switch (Tok.getKind()) { 2715 default: // #define X(A B 2716 Diag(Tok, diag::err_pp_expected_comma_in_arg_list); 2717 return true; 2718 case tok::r_paren: // #define X(A) 2719 MI->setParameterList(Parameters, BP); 2720 return false; 2721 case tok::comma: // #define X(A, 2722 break; 2723 case tok::ellipsis: // #define X(A... -> GCC extension 2724 // Diagnose extension. 2725 Diag(Tok, diag::ext_named_variadic_macro); 2726 2727 // Lex the token after the identifier. 2728 LexUnexpandedToken(Tok); 2729 if (Tok.isNot(tok::r_paren)) { 2730 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def); 2731 return true; 2732 } 2733 2734 MI->setIsGNUVarargs(); 2735 MI->setParameterList(Parameters, BP); 2736 return false; 2737 } 2738 } 2739 } 2740 } 2741 2742 static bool isConfigurationPattern(Token &MacroName, MacroInfo *MI, 2743 const LangOptions &LOptions) { 2744 if (MI->getNumTokens() == 1) { 2745 const Token &Value = MI->getReplacementToken(0); 2746 2747 // Macro that is identity, like '#define inline inline' is a valid pattern. 2748 if (MacroName.getKind() == Value.getKind()) 2749 return true; 2750 2751 // Macro that maps a keyword to the same keyword decorated with leading/ 2752 // trailing underscores is a valid pattern: 2753 // #define inline __inline 2754 // #define inline __inline__ 2755 // #define inline _inline (in MS compatibility mode) 2756 StringRef MacroText = MacroName.getIdentifierInfo()->getName(); 2757 if (IdentifierInfo *II = Value.getIdentifierInfo()) { 2758 if (!II->isKeyword(LOptions)) 2759 return false; 2760 StringRef ValueText = II->getName(); 2761 StringRef TrimmedValue = ValueText; 2762 if (!ValueText.startswith("__")) { 2763 if (ValueText.startswith("_")) 2764 TrimmedValue = TrimmedValue.drop_front(1); 2765 else 2766 return false; 2767 } else { 2768 TrimmedValue = TrimmedValue.drop_front(2); 2769 if (TrimmedValue.endswith("__")) 2770 TrimmedValue = TrimmedValue.drop_back(2); 2771 } 2772 return TrimmedValue.equals(MacroText); 2773 } else { 2774 return false; 2775 } 2776 } 2777 2778 // #define inline 2779 return MacroName.isOneOf(tok::kw_extern, tok::kw_inline, tok::kw_static, 2780 tok::kw_const) && 2781 MI->getNumTokens() == 0; 2782 } 2783 2784 // ReadOptionalMacroParameterListAndBody - This consumes all (i.e. the 2785 // entire line) of the macro's tokens and adds them to MacroInfo, and while 2786 // doing so performs certain validity checks including (but not limited to): 2787 // - # (stringization) is followed by a macro parameter 2788 // 2789 // Returns a nullptr if an invalid sequence of tokens is encountered or returns 2790 // a pointer to a MacroInfo object. 2791 2792 MacroInfo *Preprocessor::ReadOptionalMacroParameterListAndBody( 2793 const Token &MacroNameTok, const bool ImmediatelyAfterHeaderGuard) { 2794 2795 Token LastTok = MacroNameTok; 2796 // Create the new macro. 2797 MacroInfo *const MI = AllocateMacroInfo(MacroNameTok.getLocation()); 2798 2799 Token Tok; 2800 LexUnexpandedToken(Tok); 2801 2802 // Ensure we consume the rest of the macro body if errors occur. 2803 auto _ = llvm::make_scope_exit([&]() { 2804 // The flag indicates if we are still waiting for 'eod'. 2805 if (CurLexer->ParsingPreprocessorDirective) 2806 DiscardUntilEndOfDirective(); 2807 }); 2808 2809 // Used to un-poison and then re-poison identifiers of the __VA_ARGS__ ilk 2810 // within their appropriate context. 2811 VariadicMacroScopeGuard VariadicMacroScopeGuard(*this); 2812 2813 // If this is a function-like macro definition, parse the argument list, 2814 // marking each of the identifiers as being used as macro arguments. Also, 2815 // check other constraints on the first token of the macro body. 2816 if (Tok.is(tok::eod)) { 2817 if (ImmediatelyAfterHeaderGuard) { 2818 // Save this macro information since it may part of a header guard. 2819 CurPPLexer->MIOpt.SetDefinedMacro(MacroNameTok.getIdentifierInfo(), 2820 MacroNameTok.getLocation()); 2821 } 2822 // If there is no body to this macro, we have no special handling here. 2823 } else if (Tok.hasLeadingSpace()) { 2824 // This is a normal token with leading space. Clear the leading space 2825 // marker on the first token to get proper expansion. 2826 Tok.clearFlag(Token::LeadingSpace); 2827 } else if (Tok.is(tok::l_paren)) { 2828 // This is a function-like macro definition. Read the argument list. 2829 MI->setIsFunctionLike(); 2830 if (ReadMacroParameterList(MI, LastTok)) 2831 return nullptr; 2832 2833 // If this is a definition of an ISO C/C++ variadic function-like macro (not 2834 // using the GNU named varargs extension) inform our variadic scope guard 2835 // which un-poisons and re-poisons certain identifiers (e.g. __VA_ARGS__) 2836 // allowed only within the definition of a variadic macro. 2837 2838 if (MI->isC99Varargs()) { 2839 VariadicMacroScopeGuard.enterScope(); 2840 } 2841 2842 // Read the first token after the arg list for down below. 2843 LexUnexpandedToken(Tok); 2844 } else if (LangOpts.C99 || LangOpts.CPlusPlus11) { 2845 // C99 requires whitespace between the macro definition and the body. Emit 2846 // a diagnostic for something like "#define X+". 2847 Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name); 2848 } else { 2849 // C90 6.8 TC1 says: "In the definition of an object-like macro, if the 2850 // first character of a replacement list is not a character required by 2851 // subclause 5.2.1, then there shall be white-space separation between the 2852 // identifier and the replacement list.". 5.2.1 lists this set: 2853 // "A-Za-z0-9!"#%&'()*+,_./:;<=>?[\]^_{|}~" as well as whitespace, which 2854 // is irrelevant here. 2855 bool isInvalid = false; 2856 if (Tok.is(tok::at)) // @ is not in the list above. 2857 isInvalid = true; 2858 else if (Tok.is(tok::unknown)) { 2859 // If we have an unknown token, it is something strange like "`". Since 2860 // all of valid characters would have lexed into a single character 2861 // token of some sort, we know this is not a valid case. 2862 isInvalid = true; 2863 } 2864 if (isInvalid) 2865 Diag(Tok, diag::ext_missing_whitespace_after_macro_name); 2866 else 2867 Diag(Tok, diag::warn_missing_whitespace_after_macro_name); 2868 } 2869 2870 if (!Tok.is(tok::eod)) 2871 LastTok = Tok; 2872 2873 SmallVector<Token, 16> Tokens; 2874 2875 // Read the rest of the macro body. 2876 if (MI->isObjectLike()) { 2877 // Object-like macros are very simple, just read their body. 2878 while (Tok.isNot(tok::eod)) { 2879 LastTok = Tok; 2880 Tokens.push_back(Tok); 2881 // Get the next token of the macro. 2882 LexUnexpandedToken(Tok); 2883 } 2884 } else { 2885 // Otherwise, read the body of a function-like macro. While we are at it, 2886 // check C99 6.10.3.2p1: ensure that # operators are followed by macro 2887 // parameters in function-like macro expansions. 2888 2889 VAOptDefinitionContext VAOCtx(*this); 2890 2891 while (Tok.isNot(tok::eod)) { 2892 LastTok = Tok; 2893 2894 if (!Tok.isOneOf(tok::hash, tok::hashat, tok::hashhash)) { 2895 Tokens.push_back(Tok); 2896 2897 if (VAOCtx.isVAOptToken(Tok)) { 2898 // If we're already within a VAOPT, emit an error. 2899 if (VAOCtx.isInVAOpt()) { 2900 Diag(Tok, diag::err_pp_vaopt_nested_use); 2901 return nullptr; 2902 } 2903 // Ensure VAOPT is followed by a '(' . 2904 LexUnexpandedToken(Tok); 2905 if (Tok.isNot(tok::l_paren)) { 2906 Diag(Tok, diag::err_pp_missing_lparen_in_vaopt_use); 2907 return nullptr; 2908 } 2909 Tokens.push_back(Tok); 2910 VAOCtx.sawVAOptFollowedByOpeningParens(Tok.getLocation()); 2911 LexUnexpandedToken(Tok); 2912 if (Tok.is(tok::hashhash)) { 2913 Diag(Tok, diag::err_vaopt_paste_at_start); 2914 return nullptr; 2915 } 2916 continue; 2917 } else if (VAOCtx.isInVAOpt()) { 2918 if (Tok.is(tok::r_paren)) { 2919 if (VAOCtx.sawClosingParen()) { 2920 assert(Tokens.size() >= 3 && 2921 "Must have seen at least __VA_OPT__( " 2922 "and a subsequent tok::r_paren"); 2923 if (Tokens[Tokens.size() - 2].is(tok::hashhash)) { 2924 Diag(Tok, diag::err_vaopt_paste_at_end); 2925 return nullptr; 2926 } 2927 } 2928 } else if (Tok.is(tok::l_paren)) { 2929 VAOCtx.sawOpeningParen(Tok.getLocation()); 2930 } 2931 } 2932 // Get the next token of the macro. 2933 LexUnexpandedToken(Tok); 2934 continue; 2935 } 2936 2937 // If we're in -traditional mode, then we should ignore stringification 2938 // and token pasting. Mark the tokens as unknown so as not to confuse 2939 // things. 2940 if (getLangOpts().TraditionalCPP) { 2941 Tok.setKind(tok::unknown); 2942 Tokens.push_back(Tok); 2943 2944 // Get the next token of the macro. 2945 LexUnexpandedToken(Tok); 2946 continue; 2947 } 2948 2949 if (Tok.is(tok::hashhash)) { 2950 // If we see token pasting, check if it looks like the gcc comma 2951 // pasting extension. We'll use this information to suppress 2952 // diagnostics later on. 2953 2954 // Get the next token of the macro. 2955 LexUnexpandedToken(Tok); 2956 2957 if (Tok.is(tok::eod)) { 2958 Tokens.push_back(LastTok); 2959 break; 2960 } 2961 2962 if (!Tokens.empty() && Tok.getIdentifierInfo() == Ident__VA_ARGS__ && 2963 Tokens[Tokens.size() - 1].is(tok::comma)) 2964 MI->setHasCommaPasting(); 2965 2966 // Things look ok, add the '##' token to the macro. 2967 Tokens.push_back(LastTok); 2968 continue; 2969 } 2970 2971 // Our Token is a stringization operator. 2972 // Get the next token of the macro. 2973 LexUnexpandedToken(Tok); 2974 2975 // Check for a valid macro arg identifier or __VA_OPT__. 2976 if (!VAOCtx.isVAOptToken(Tok) && 2977 (Tok.getIdentifierInfo() == nullptr || 2978 MI->getParameterNum(Tok.getIdentifierInfo()) == -1)) { 2979 2980 // If this is assembler-with-cpp mode, we accept random gibberish after 2981 // the '#' because '#' is often a comment character. However, change 2982 // the kind of the token to tok::unknown so that the preprocessor isn't 2983 // confused. 2984 if (getLangOpts().AsmPreprocessor && Tok.isNot(tok::eod)) { 2985 LastTok.setKind(tok::unknown); 2986 Tokens.push_back(LastTok); 2987 continue; 2988 } else { 2989 Diag(Tok, diag::err_pp_stringize_not_parameter) 2990 << LastTok.is(tok::hashat); 2991 return nullptr; 2992 } 2993 } 2994 2995 // Things look ok, add the '#' and param name tokens to the macro. 2996 Tokens.push_back(LastTok); 2997 2998 // If the token following '#' is VAOPT, let the next iteration handle it 2999 // and check it for correctness, otherwise add the token and prime the 3000 // loop with the next one. 3001 if (!VAOCtx.isVAOptToken(Tok)) { 3002 Tokens.push_back(Tok); 3003 LastTok = Tok; 3004 3005 // Get the next token of the macro. 3006 LexUnexpandedToken(Tok); 3007 } 3008 } 3009 if (VAOCtx.isInVAOpt()) { 3010 assert(Tok.is(tok::eod) && "Must be at End Of preprocessing Directive"); 3011 Diag(Tok, diag::err_pp_expected_after) 3012 << LastTok.getKind() << tok::r_paren; 3013 Diag(VAOCtx.getUnmatchedOpeningParenLoc(), diag::note_matching) << tok::l_paren; 3014 return nullptr; 3015 } 3016 } 3017 MI->setDefinitionEndLoc(LastTok.getLocation()); 3018 3019 MI->setTokens(Tokens, BP); 3020 return MI; 3021 } 3022 /// HandleDefineDirective - Implements \#define. This consumes the entire macro 3023 /// line then lets the caller lex the next real token. 3024 void Preprocessor::HandleDefineDirective( 3025 Token &DefineTok, const bool ImmediatelyAfterHeaderGuard) { 3026 ++NumDefined; 3027 3028 Token MacroNameTok; 3029 bool MacroShadowsKeyword; 3030 ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword); 3031 3032 // Error reading macro name? If so, diagnostic already issued. 3033 if (MacroNameTok.is(tok::eod)) 3034 return; 3035 3036 IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); 3037 // Issue a final pragma warning if we're defining a macro that was has been 3038 // undefined and is being redefined. 3039 if (!II->hasMacroDefinition() && II->hadMacroDefinition() && II->isFinal()) 3040 emitFinalMacroWarning(MacroNameTok, /*IsUndef=*/false); 3041 3042 // If we are supposed to keep comments in #defines, reenable comment saving 3043 // mode. 3044 if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments); 3045 3046 MacroInfo *const MI = ReadOptionalMacroParameterListAndBody( 3047 MacroNameTok, ImmediatelyAfterHeaderGuard); 3048 3049 if (!MI) return; 3050 3051 if (MacroShadowsKeyword && 3052 !isConfigurationPattern(MacroNameTok, MI, getLangOpts())) { 3053 Diag(MacroNameTok, diag::warn_pp_macro_hides_keyword); 3054 } 3055 // Check that there is no paste (##) operator at the beginning or end of the 3056 // replacement list. 3057 unsigned NumTokens = MI->getNumTokens(); 3058 if (NumTokens != 0) { 3059 if (MI->getReplacementToken(0).is(tok::hashhash)) { 3060 Diag(MI->getReplacementToken(0), diag::err_paste_at_start); 3061 return; 3062 } 3063 if (MI->getReplacementToken(NumTokens-1).is(tok::hashhash)) { 3064 Diag(MI->getReplacementToken(NumTokens-1), diag::err_paste_at_end); 3065 return; 3066 } 3067 } 3068 3069 // When skipping just warn about macros that do not match. 3070 if (SkippingUntilPCHThroughHeader) { 3071 const MacroInfo *OtherMI = getMacroInfo(MacroNameTok.getIdentifierInfo()); 3072 if (!OtherMI || !MI->isIdenticalTo(*OtherMI, *this, 3073 /*Syntactic=*/LangOpts.MicrosoftExt)) 3074 Diag(MI->getDefinitionLoc(), diag::warn_pp_macro_def_mismatch_with_pch) 3075 << MacroNameTok.getIdentifierInfo(); 3076 // Issue the diagnostic but allow the change if msvc extensions are enabled 3077 if (!LangOpts.MicrosoftExt) 3078 return; 3079 } 3080 3081 // Finally, if this identifier already had a macro defined for it, verify that 3082 // the macro bodies are identical, and issue diagnostics if they are not. 3083 if (const MacroInfo *OtherMI=getMacroInfo(MacroNameTok.getIdentifierInfo())) { 3084 // Final macros are hard-mode: they always warn. Even if the bodies are 3085 // identical. Even if they are in system headers. Even if they are things we 3086 // would silently allow in the past. 3087 if (MacroNameTok.getIdentifierInfo()->isFinal()) 3088 emitFinalMacroWarning(MacroNameTok, /*IsUndef=*/false); 3089 3090 // In Objective-C, ignore attempts to directly redefine the builtin 3091 // definitions of the ownership qualifiers. It's still possible to 3092 // #undef them. 3093 auto isObjCProtectedMacro = [](const IdentifierInfo *II) -> bool { 3094 return II->isStr("__strong") || 3095 II->isStr("__weak") || 3096 II->isStr("__unsafe_unretained") || 3097 II->isStr("__autoreleasing"); 3098 }; 3099 if (getLangOpts().ObjC && 3100 SourceMgr.getFileID(OtherMI->getDefinitionLoc()) 3101 == getPredefinesFileID() && 3102 isObjCProtectedMacro(MacroNameTok.getIdentifierInfo())) { 3103 // Warn if it changes the tokens. 3104 if ((!getDiagnostics().getSuppressSystemWarnings() || 3105 !SourceMgr.isInSystemHeader(DefineTok.getLocation())) && 3106 !MI->isIdenticalTo(*OtherMI, *this, 3107 /*Syntactic=*/LangOpts.MicrosoftExt)) { 3108 Diag(MI->getDefinitionLoc(), diag::warn_pp_objc_macro_redef_ignored); 3109 } 3110 assert(!OtherMI->isWarnIfUnused()); 3111 return; 3112 } 3113 3114 // It is very common for system headers to have tons of macro redefinitions 3115 // and for warnings to be disabled in system headers. If this is the case, 3116 // then don't bother calling MacroInfo::isIdenticalTo. 3117 if (!getDiagnostics().getSuppressSystemWarnings() || 3118 !SourceMgr.isInSystemHeader(DefineTok.getLocation())) { 3119 3120 if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused()) 3121 Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used); 3122 3123 // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and 3124 // C++ [cpp.predefined]p4, but allow it as an extension. 3125 if (OtherMI->isBuiltinMacro()) 3126 Diag(MacroNameTok, diag::ext_pp_redef_builtin_macro); 3127 // Macros must be identical. This means all tokens and whitespace 3128 // separation must be the same. C99 6.10.3p2. 3129 else if (!OtherMI->isAllowRedefinitionsWithoutWarning() && 3130 !MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) { 3131 Diag(MI->getDefinitionLoc(), diag::ext_pp_macro_redef) 3132 << MacroNameTok.getIdentifierInfo(); 3133 Diag(OtherMI->getDefinitionLoc(), diag::note_previous_definition); 3134 } 3135 } 3136 if (OtherMI->isWarnIfUnused()) 3137 WarnUnusedMacroLocs.erase(OtherMI->getDefinitionLoc()); 3138 } 3139 3140 DefMacroDirective *MD = 3141 appendDefMacroDirective(MacroNameTok.getIdentifierInfo(), MI); 3142 3143 assert(!MI->isUsed()); 3144 // If we need warning for not using the macro, add its location in the 3145 // warn-because-unused-macro set. If it gets used it will be removed from set. 3146 if (getSourceManager().isInMainFile(MI->getDefinitionLoc()) && 3147 !Diags->isIgnored(diag::pp_macro_not_used, MI->getDefinitionLoc()) && 3148 !MacroExpansionInDirectivesOverride && 3149 getSourceManager().getFileID(MI->getDefinitionLoc()) != 3150 getPredefinesFileID()) { 3151 MI->setIsWarnIfUnused(true); 3152 WarnUnusedMacroLocs.insert(MI->getDefinitionLoc()); 3153 } 3154 3155 // If the callbacks want to know, tell them about the macro definition. 3156 if (Callbacks) 3157 Callbacks->MacroDefined(MacroNameTok, MD); 3158 3159 // If we're in MS compatibility mode and the macro being defined is the 3160 // assert macro, implicitly add a macro definition for static_assert to work 3161 // around their broken assert.h header file in C. Only do so if there isn't 3162 // already a static_assert macro defined. 3163 if (!getLangOpts().CPlusPlus && getLangOpts().MSVCCompat && 3164 MacroNameTok.getIdentifierInfo()->isStr("assert") && 3165 !isMacroDefined("static_assert")) { 3166 MacroInfo *MI = AllocateMacroInfo(SourceLocation()); 3167 3168 Token Tok; 3169 Tok.startToken(); 3170 Tok.setKind(tok::kw__Static_assert); 3171 Tok.setIdentifierInfo(getIdentifierInfo("_Static_assert")); 3172 MI->setTokens({Tok}, BP); 3173 (void)appendDefMacroDirective(getIdentifierInfo("static_assert"), MI); 3174 } 3175 } 3176 3177 /// HandleUndefDirective - Implements \#undef. 3178 /// 3179 void Preprocessor::HandleUndefDirective() { 3180 ++NumUndefined; 3181 3182 Token MacroNameTok; 3183 ReadMacroName(MacroNameTok, MU_Undef); 3184 3185 // Error reading macro name? If so, diagnostic already issued. 3186 if (MacroNameTok.is(tok::eod)) 3187 return; 3188 3189 // Check to see if this is the last token on the #undef line. 3190 CheckEndOfDirective("undef"); 3191 3192 // Okay, we have a valid identifier to undef. 3193 auto *II = MacroNameTok.getIdentifierInfo(); 3194 auto MD = getMacroDefinition(II); 3195 UndefMacroDirective *Undef = nullptr; 3196 3197 if (II->isFinal()) 3198 emitFinalMacroWarning(MacroNameTok, /*IsUndef=*/true); 3199 3200 // If the macro is not defined, this is a noop undef. 3201 if (const MacroInfo *MI = MD.getMacroInfo()) { 3202 if (!MI->isUsed() && MI->isWarnIfUnused()) 3203 Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used); 3204 3205 if (MI->isWarnIfUnused()) 3206 WarnUnusedMacroLocs.erase(MI->getDefinitionLoc()); 3207 3208 Undef = AllocateUndefMacroDirective(MacroNameTok.getLocation()); 3209 } 3210 3211 // If the callbacks want to know, tell them about the macro #undef. 3212 // Note: no matter if the macro was defined or not. 3213 if (Callbacks) 3214 Callbacks->MacroUndefined(MacroNameTok, MD, Undef); 3215 3216 if (Undef) 3217 appendMacroDirective(II, Undef); 3218 } 3219 3220 //===----------------------------------------------------------------------===// 3221 // Preprocessor Conditional Directive Handling. 3222 //===----------------------------------------------------------------------===// 3223 3224 /// HandleIfdefDirective - Implements the \#ifdef/\#ifndef directive. isIfndef 3225 /// is true when this is a \#ifndef directive. ReadAnyTokensBeforeDirective is 3226 /// true if any tokens have been returned or pp-directives activated before this 3227 /// \#ifndef has been lexed. 3228 /// 3229 void Preprocessor::HandleIfdefDirective(Token &Result, 3230 const Token &HashToken, 3231 bool isIfndef, 3232 bool ReadAnyTokensBeforeDirective) { 3233 ++NumIf; 3234 Token DirectiveTok = Result; 3235 3236 Token MacroNameTok; 3237 ReadMacroName(MacroNameTok); 3238 3239 // Error reading macro name? If so, diagnostic already issued. 3240 if (MacroNameTok.is(tok::eod)) { 3241 // Skip code until we get to #endif. This helps with recovery by not 3242 // emitting an error when the #endif is reached. 3243 SkipExcludedConditionalBlock(HashToken.getLocation(), 3244 DirectiveTok.getLocation(), 3245 /*Foundnonskip*/ false, /*FoundElse*/ false); 3246 return; 3247 } 3248 3249 emitMacroExpansionWarnings(MacroNameTok); 3250 3251 // Check to see if this is the last token on the #if[n]def line. 3252 CheckEndOfDirective(isIfndef ? "ifndef" : "ifdef"); 3253 3254 IdentifierInfo *MII = MacroNameTok.getIdentifierInfo(); 3255 auto MD = getMacroDefinition(MII); 3256 MacroInfo *MI = MD.getMacroInfo(); 3257 3258 if (CurPPLexer->getConditionalStackDepth() == 0) { 3259 // If the start of a top-level #ifdef and if the macro is not defined, 3260 // inform MIOpt that this might be the start of a proper include guard. 3261 // Otherwise it is some other form of unknown conditional which we can't 3262 // handle. 3263 if (!ReadAnyTokensBeforeDirective && !MI) { 3264 assert(isIfndef && "#ifdef shouldn't reach here"); 3265 CurPPLexer->MIOpt.EnterTopLevelIfndef(MII, MacroNameTok.getLocation()); 3266 } else 3267 CurPPLexer->MIOpt.EnterTopLevelConditional(); 3268 } 3269 3270 // If there is a macro, process it. 3271 if (MI) // Mark it used. 3272 markMacroAsUsed(MI); 3273 3274 if (Callbacks) { 3275 if (isIfndef) 3276 Callbacks->Ifndef(DirectiveTok.getLocation(), MacroNameTok, MD); 3277 else 3278 Callbacks->Ifdef(DirectiveTok.getLocation(), MacroNameTok, MD); 3279 } 3280 3281 bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks && 3282 getSourceManager().isInMainFile(DirectiveTok.getLocation()); 3283 3284 // Should we include the stuff contained by this directive? 3285 if (PPOpts->SingleFileParseMode && !MI) { 3286 // In 'single-file-parse mode' undefined identifiers trigger parsing of all 3287 // the directive blocks. 3288 CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(), 3289 /*wasskip*/false, /*foundnonskip*/false, 3290 /*foundelse*/false); 3291 } else if (!MI == isIfndef || RetainExcludedCB) { 3292 // Yes, remember that we are inside a conditional, then lex the next token. 3293 CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(), 3294 /*wasskip*/false, /*foundnonskip*/true, 3295 /*foundelse*/false); 3296 } else { 3297 // No, skip the contents of this block. 3298 SkipExcludedConditionalBlock(HashToken.getLocation(), 3299 DirectiveTok.getLocation(), 3300 /*Foundnonskip*/ false, 3301 /*FoundElse*/ false); 3302 } 3303 } 3304 3305 /// HandleIfDirective - Implements the \#if directive. 3306 /// 3307 void Preprocessor::HandleIfDirective(Token &IfToken, 3308 const Token &HashToken, 3309 bool ReadAnyTokensBeforeDirective) { 3310 ++NumIf; 3311 3312 // Parse and evaluate the conditional expression. 3313 IdentifierInfo *IfNDefMacro = nullptr; 3314 const DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro); 3315 const bool ConditionalTrue = DER.Conditional; 3316 // Lexer might become invalid if we hit code completion point while evaluating 3317 // expression. 3318 if (!CurPPLexer) 3319 return; 3320 3321 // If this condition is equivalent to #ifndef X, and if this is the first 3322 // directive seen, handle it for the multiple-include optimization. 3323 if (CurPPLexer->getConditionalStackDepth() == 0) { 3324 if (!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue) 3325 // FIXME: Pass in the location of the macro name, not the 'if' token. 3326 CurPPLexer->MIOpt.EnterTopLevelIfndef(IfNDefMacro, IfToken.getLocation()); 3327 else 3328 CurPPLexer->MIOpt.EnterTopLevelConditional(); 3329 } 3330 3331 if (Callbacks) 3332 Callbacks->If( 3333 IfToken.getLocation(), DER.ExprRange, 3334 (ConditionalTrue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False)); 3335 3336 bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks && 3337 getSourceManager().isInMainFile(IfToken.getLocation()); 3338 3339 // Should we include the stuff contained by this directive? 3340 if (PPOpts->SingleFileParseMode && DER.IncludedUndefinedIds) { 3341 // In 'single-file-parse mode' undefined identifiers trigger parsing of all 3342 // the directive blocks. 3343 CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false, 3344 /*foundnonskip*/false, /*foundelse*/false); 3345 } else if (ConditionalTrue || RetainExcludedCB) { 3346 // Yes, remember that we are inside a conditional, then lex the next token. 3347 CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false, 3348 /*foundnonskip*/true, /*foundelse*/false); 3349 } else { 3350 // No, skip the contents of this block. 3351 SkipExcludedConditionalBlock(HashToken.getLocation(), IfToken.getLocation(), 3352 /*Foundnonskip*/ false, 3353 /*FoundElse*/ false); 3354 } 3355 } 3356 3357 /// HandleEndifDirective - Implements the \#endif directive. 3358 /// 3359 void Preprocessor::HandleEndifDirective(Token &EndifToken) { 3360 ++NumEndif; 3361 3362 // Check that this is the whole directive. 3363 CheckEndOfDirective("endif"); 3364 3365 PPConditionalInfo CondInfo; 3366 if (CurPPLexer->popConditionalLevel(CondInfo)) { 3367 // No conditionals on the stack: this is an #endif without an #if. 3368 Diag(EndifToken, diag::err_pp_endif_without_if); 3369 return; 3370 } 3371 3372 // If this the end of a top-level #endif, inform MIOpt. 3373 if (CurPPLexer->getConditionalStackDepth() == 0) 3374 CurPPLexer->MIOpt.ExitTopLevelConditional(); 3375 3376 assert(!CondInfo.WasSkipping && !CurPPLexer->LexingRawMode && 3377 "This code should only be reachable in the non-skipping case!"); 3378 3379 if (Callbacks) 3380 Callbacks->Endif(EndifToken.getLocation(), CondInfo.IfLoc); 3381 } 3382 3383 /// HandleElseDirective - Implements the \#else directive. 3384 /// 3385 void Preprocessor::HandleElseDirective(Token &Result, const Token &HashToken) { 3386 ++NumElse; 3387 3388 // #else directive in a non-skipping conditional... start skipping. 3389 CheckEndOfDirective("else"); 3390 3391 PPConditionalInfo CI; 3392 if (CurPPLexer->popConditionalLevel(CI)) { 3393 Diag(Result, diag::pp_err_else_without_if); 3394 return; 3395 } 3396 3397 // If this is a top-level #else, inform the MIOpt. 3398 if (CurPPLexer->getConditionalStackDepth() == 0) 3399 CurPPLexer->MIOpt.EnterTopLevelConditional(); 3400 3401 // If this is a #else with a #else before it, report the error. 3402 if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else); 3403 3404 if (Callbacks) 3405 Callbacks->Else(Result.getLocation(), CI.IfLoc); 3406 3407 bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks && 3408 getSourceManager().isInMainFile(Result.getLocation()); 3409 3410 if ((PPOpts->SingleFileParseMode && !CI.FoundNonSkip) || RetainExcludedCB) { 3411 // In 'single-file-parse mode' undefined identifiers trigger parsing of all 3412 // the directive blocks. 3413 CurPPLexer->pushConditionalLevel(CI.IfLoc, /*wasskip*/false, 3414 /*foundnonskip*/false, /*foundelse*/true); 3415 return; 3416 } 3417 3418 // Finally, skip the rest of the contents of this block. 3419 SkipExcludedConditionalBlock(HashToken.getLocation(), CI.IfLoc, 3420 /*Foundnonskip*/ true, 3421 /*FoundElse*/ true, Result.getLocation()); 3422 } 3423 3424 /// Implements the \#elif, \#elifdef, and \#elifndef directives. 3425 void Preprocessor::HandleElifFamilyDirective(Token &ElifToken, 3426 const Token &HashToken, 3427 tok::PPKeywordKind Kind) { 3428 PPElifDiag DirKind = Kind == tok::pp_elif ? PED_Elif 3429 : Kind == tok::pp_elifdef ? PED_Elifdef 3430 : PED_Elifndef; 3431 ++NumElse; 3432 3433 // Warn if using `#elifdef` & `#elifndef` in not C2x & C++2b mode. 3434 switch (DirKind) { 3435 case PED_Elifdef: 3436 case PED_Elifndef: 3437 unsigned DiagID; 3438 if (LangOpts.CPlusPlus) 3439 DiagID = LangOpts.CPlusPlus2b ? diag::warn_cxx2b_compat_pp_directive 3440 : diag::ext_cxx2b_pp_directive; 3441 else 3442 DiagID = LangOpts.C2x ? diag::warn_c2x_compat_pp_directive 3443 : diag::ext_c2x_pp_directive; 3444 Diag(ElifToken, DiagID) << DirKind; 3445 break; 3446 default: 3447 break; 3448 } 3449 3450 // #elif directive in a non-skipping conditional... start skipping. 3451 // We don't care what the condition is, because we will always skip it (since 3452 // the block immediately before it was included). 3453 SourceRange ConditionRange = DiscardUntilEndOfDirective(); 3454 3455 PPConditionalInfo CI; 3456 if (CurPPLexer->popConditionalLevel(CI)) { 3457 Diag(ElifToken, diag::pp_err_elif_without_if) << DirKind; 3458 return; 3459 } 3460 3461 // If this is a top-level #elif, inform the MIOpt. 3462 if (CurPPLexer->getConditionalStackDepth() == 0) 3463 CurPPLexer->MIOpt.EnterTopLevelConditional(); 3464 3465 // If this is a #elif with a #else before it, report the error. 3466 if (CI.FoundElse) 3467 Diag(ElifToken, diag::pp_err_elif_after_else) << DirKind; 3468 3469 if (Callbacks) { 3470 switch (Kind) { 3471 case tok::pp_elif: 3472 Callbacks->Elif(ElifToken.getLocation(), ConditionRange, 3473 PPCallbacks::CVK_NotEvaluated, CI.IfLoc); 3474 break; 3475 case tok::pp_elifdef: 3476 Callbacks->Elifdef(ElifToken.getLocation(), ConditionRange, CI.IfLoc); 3477 break; 3478 case tok::pp_elifndef: 3479 Callbacks->Elifndef(ElifToken.getLocation(), ConditionRange, CI.IfLoc); 3480 break; 3481 default: 3482 assert(false && "unexpected directive kind"); 3483 break; 3484 } 3485 } 3486 3487 bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks && 3488 getSourceManager().isInMainFile(ElifToken.getLocation()); 3489 3490 if ((PPOpts->SingleFileParseMode && !CI.FoundNonSkip) || RetainExcludedCB) { 3491 // In 'single-file-parse mode' undefined identifiers trigger parsing of all 3492 // the directive blocks. 3493 CurPPLexer->pushConditionalLevel(ElifToken.getLocation(), /*wasskip*/false, 3494 /*foundnonskip*/false, /*foundelse*/false); 3495 return; 3496 } 3497 3498 // Finally, skip the rest of the contents of this block. 3499 SkipExcludedConditionalBlock( 3500 HashToken.getLocation(), CI.IfLoc, /*Foundnonskip*/ true, 3501 /*FoundElse*/ CI.FoundElse, ElifToken.getLocation()); 3502 } 3503