1 //===--- PPDirectives.cpp - Directive Handling for Preprocessor -----------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// \brief Implements # directive processing for the Preprocessor.
13 //===----------------------------------------------------------------------===//
15 #include "clang/Basic/CharInfo.h"
16 #include "clang/Basic/FileManager.h"
17 #include "clang/Basic/IdentifierTable.h"
18 #include "clang/Basic/LangOptions.h"
19 #include "clang/Basic/Module.h"
20 #include "clang/Basic/SourceLocation.h"
21 #include "clang/Basic/SourceManager.h"
22 #include "clang/Basic/TokenKinds.h"
23 #include "clang/Lex/CodeCompletionHandler.h"
24 #include "clang/Lex/HeaderSearch.h"
25 #include "clang/Lex/LexDiagnostic.h"
26 #include "clang/Lex/LiteralSupport.h"
27 #include "clang/Lex/MacroInfo.h"
28 #include "clang/Lex/ModuleLoader.h"
29 #include "clang/Lex/ModuleMap.h"
30 #include "clang/Lex/PPCallbacks.h"
31 #include "clang/Lex/Pragma.h"
32 #include "clang/Lex/Preprocessor.h"
33 #include "clang/Lex/PTHLexer.h"
34 #include "clang/Lex/Token.h"
35 #include "llvm/ADT/ArrayRef.h"
36 #include "llvm/ADT/SmallString.h"
37 #include "llvm/ADT/SmallVector.h"
38 #include "llvm/ADT/STLExtras.h"
39 #include "llvm/ADT/StringSwitch.h"
40 #include "llvm/ADT/StringRef.h"
41 #include "llvm/Support/AlignOf.h"
42 #include "llvm/Support/ErrorHandling.h"
43 #include "llvm/Support/Path.h"
51 using namespace clang;
53 //===----------------------------------------------------------------------===//
54 // Utility Methods for Preprocessor Directive Handling.
55 //===----------------------------------------------------------------------===//
57 MacroInfo *Preprocessor::AllocateMacroInfo() {
58 MacroInfoChain *MIChain = BP.Allocate<MacroInfoChain>();
59 MIChain->Next = MIChainHead;
60 MIChainHead = MIChain;
64 MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) {
65 MacroInfo *MI = AllocateMacroInfo();
66 new (MI) MacroInfo(L);
70 MacroInfo *Preprocessor::AllocateDeserializedMacroInfo(SourceLocation L,
71 unsigned SubModuleID) {
72 static_assert(alignof(MacroInfo) >= sizeof(SubModuleID),
73 "alignment for MacroInfo is less than the ID");
74 DeserializedMacroInfoChain *MIChain =
75 BP.Allocate<DeserializedMacroInfoChain>();
76 MIChain->Next = DeserialMIChainHead;
77 DeserialMIChainHead = MIChain;
79 MacroInfo *MI = &MIChain->MI;
80 new (MI) MacroInfo(L);
81 MI->FromASTFile = true;
82 MI->setOwningModuleID(SubModuleID);
86 DefMacroDirective *Preprocessor::AllocateDefMacroDirective(MacroInfo *MI,
88 return new (BP) DefMacroDirective(MI, Loc);
92 Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) {
93 return new (BP) UndefMacroDirective(UndefLoc);
96 VisibilityMacroDirective *
97 Preprocessor::AllocateVisibilityMacroDirective(SourceLocation Loc,
99 return new (BP) VisibilityMacroDirective(Loc, isPublic);
102 /// \brief Read and discard all tokens remaining on the current line until
103 /// the tok::eod token is found.
104 void Preprocessor::DiscardUntilEndOfDirective() {
107 LexUnexpandedToken(Tmp);
108 assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens");
109 } while (Tmp.isNot(tok::eod));
112 /// \brief Enumerates possible cases of #define/#undef a reserved identifier.
114 MD_NoWarn, //> Not a reserved identifier
115 MD_KeywordDef, //> Macro hides keyword, enabled by default
116 MD_ReservedMacro //> #define of #undef reserved id, disabled by default
119 /// \brief Checks if the specified identifier is reserved in the specified
121 /// This function does not check if the identifier is a keyword.
122 static bool isReservedId(StringRef Text, const LangOptions &Lang) {
123 // C++ [macro.names], C11 7.1.3:
124 // All identifiers that begin with an underscore and either an uppercase
125 // letter or another underscore are always reserved for any use.
126 if (Text.size() >= 2 && Text[0] == '_' &&
127 (isUppercase(Text[1]) || Text[1] == '_'))
129 // C++ [global.names]
130 // Each name that contains a double underscore ... is reserved to the
131 // implementation for any use.
132 if (Lang.CPlusPlus) {
133 if (Text.find("__") != StringRef::npos)
139 static MacroDiag shouldWarnOnMacroDef(Preprocessor &PP, IdentifierInfo *II) {
140 const LangOptions &Lang = PP.getLangOpts();
141 StringRef Text = II->getName();
142 if (isReservedId(Text, Lang))
143 return MD_ReservedMacro;
144 if (II->isKeyword(Lang))
145 return MD_KeywordDef;
146 if (Lang.CPlusPlus11 && (Text.equals("override") || Text.equals("final")))
147 return MD_KeywordDef;
151 static MacroDiag shouldWarnOnMacroUndef(Preprocessor &PP, IdentifierInfo *II) {
152 const LangOptions &Lang = PP.getLangOpts();
153 StringRef Text = II->getName();
154 // Do not warn on keyword undef. It is generally harmless and widely used.
155 if (isReservedId(Text, Lang))
156 return MD_ReservedMacro;
160 // Return true if we want to issue a diagnostic by default if we
161 // encounter this name in a #include with the wrong case. For now,
162 // this includes the standard C and C++ headers, Posix headers,
163 // and Boost headers. Improper case for these #includes is a
164 // potential portability issue.
165 static bool warnByDefaultOnWrongCase(StringRef Include) {
166 // If the first component of the path is "boost", treat this like a standard header
167 // for the purposes of diagnostics.
168 if (::llvm::sys::path::begin(Include)->equals_lower("boost"))
171 // "condition_variable" is the longest standard header name at 18 characters.
172 // If the include file name is longer than that, it can't be a standard header.
173 static const size_t MaxStdHeaderNameLen = 18u;
174 if (Include.size() > MaxStdHeaderNameLen)
177 // Lowercase and normalize the search string.
178 SmallString<32> LowerInclude{Include};
179 for (char &Ch : LowerInclude) {
180 // In the ASCII range?
181 if (static_cast<unsigned char>(Ch) > 0x7f)
182 return false; // Can't be a standard header
184 if (Ch >= 'A' && Ch <= 'Z')
186 // Normalize path separators for comparison purposes.
187 else if (::llvm::sys::path::is_separator(Ch))
191 // The standard C/C++ and Posix headers
192 return llvm::StringSwitch<bool>(LowerInclude)
194 .Cases("assert.h", "complex.h", "ctype.h", "errno.h", "fenv.h", true)
195 .Cases("float.h", "inttypes.h", "iso646.h", "limits.h", "locale.h", true)
196 .Cases("math.h", "setjmp.h", "signal.h", "stdalign.h", "stdarg.h", true)
197 .Cases("stdatomic.h", "stdbool.h", "stddef.h", "stdint.h", "stdio.h", true)
198 .Cases("stdlib.h", "stdnoreturn.h", "string.h", "tgmath.h", "threads.h", true)
199 .Cases("time.h", "uchar.h", "wchar.h", "wctype.h", true)
201 // C++ headers for C library facilities
202 .Cases("cassert", "ccomplex", "cctype", "cerrno", "cfenv", true)
203 .Cases("cfloat", "cinttypes", "ciso646", "climits", "clocale", true)
204 .Cases("cmath", "csetjmp", "csignal", "cstdalign", "cstdarg", true)
205 .Cases("cstdbool", "cstddef", "cstdint", "cstdio", "cstdlib", true)
206 .Cases("cstring", "ctgmath", "ctime", "cuchar", "cwchar", true)
207 .Case("cwctype", true)
209 // C++ library headers
210 .Cases("algorithm", "fstream", "list", "regex", "thread", true)
211 .Cases("array", "functional", "locale", "scoped_allocator", "tuple", true)
212 .Cases("atomic", "future", "map", "set", "type_traits", true)
213 .Cases("bitset", "initializer_list", "memory", "shared_mutex", "typeindex", true)
214 .Cases("chrono", "iomanip", "mutex", "sstream", "typeinfo", true)
215 .Cases("codecvt", "ios", "new", "stack", "unordered_map", true)
216 .Cases("complex", "iosfwd", "numeric", "stdexcept", "unordered_set", true)
217 .Cases("condition_variable", "iostream", "ostream", "streambuf", "utility", true)
218 .Cases("deque", "istream", "queue", "string", "valarray", true)
219 .Cases("exception", "iterator", "random", "strstream", "vector", true)
220 .Cases("forward_list", "limits", "ratio", "system_error", true)
222 // POSIX headers (which aren't also C headers)
223 .Cases("aio.h", "arpa/inet.h", "cpio.h", "dirent.h", "dlfcn.h", true)
224 .Cases("fcntl.h", "fmtmsg.h", "fnmatch.h", "ftw.h", "glob.h", true)
225 .Cases("grp.h", "iconv.h", "langinfo.h", "libgen.h", "monetary.h", true)
226 .Cases("mqueue.h", "ndbm.h", "net/if.h", "netdb.h", "netinet/in.h", true)
227 .Cases("netinet/tcp.h", "nl_types.h", "poll.h", "pthread.h", "pwd.h", true)
228 .Cases("regex.h", "sched.h", "search.h", "semaphore.h", "spawn.h", true)
229 .Cases("strings.h", "stropts.h", "sys/ipc.h", "sys/mman.h", "sys/msg.h", true)
230 .Cases("sys/resource.h", "sys/select.h", "sys/sem.h", "sys/shm.h", "sys/socket.h", true)
231 .Cases("sys/stat.h", "sys/statvfs.h", "sys/time.h", "sys/times.h", "sys/types.h", true)
232 .Cases("sys/uio.h", "sys/un.h", "sys/utsname.h", "sys/wait.h", "syslog.h", true)
233 .Cases("tar.h", "termios.h", "trace.h", "ulimit.h", true)
234 .Cases("unistd.h", "utime.h", "utmpx.h", "wordexp.h", true)
238 bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
240 // Missing macro name?
241 if (MacroNameTok.is(tok::eod))
242 return Diag(MacroNameTok, diag::err_pp_missing_macro_name);
244 IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
246 bool Invalid = false;
247 std::string Spelling = getSpelling(MacroNameTok, &Invalid);
249 return Diag(MacroNameTok, diag::err_pp_macro_not_identifier);
250 II = getIdentifierInfo(Spelling);
252 if (!II->isCPlusPlusOperatorKeyword())
253 return Diag(MacroNameTok, diag::err_pp_macro_not_identifier);
255 // C++ 2.5p2: Alternative tokens behave the same as its primary token
256 // except for their spellings.
257 Diag(MacroNameTok, getLangOpts().MicrosoftExt
258 ? diag::ext_pp_operator_used_as_macro_name
259 : diag::err_pp_operator_used_as_macro_name)
260 << II << MacroNameTok.getKind();
262 // Allow #defining |and| and friends for Microsoft compatibility or
263 // recovery when legacy C headers are included in C++.
264 MacroNameTok.setIdentifierInfo(II);
267 if ((isDefineUndef != MU_Other) && II->getPPKeywordID() == tok::pp_defined) {
268 // Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4.
269 return Diag(MacroNameTok, diag::err_defined_macro_name);
272 if (isDefineUndef == MU_Undef) {
273 auto *MI = getMacroInfo(II);
274 if (MI && MI->isBuiltinMacro()) {
275 // Warn if undefining "__LINE__" and other builtins, per C99 6.10.8/4
276 // and C++ [cpp.predefined]p4], but allow it as an extension.
277 Diag(MacroNameTok, diag::ext_pp_undef_builtin_macro);
281 // If defining/undefining reserved identifier or a keyword, we need to issue
283 SourceLocation MacroNameLoc = MacroNameTok.getLocation();
286 if (!SourceMgr.isInSystemHeader(MacroNameLoc) &&
287 (SourceMgr.getBufferName(MacroNameLoc) != "<built-in>")) {
288 MacroDiag D = MD_NoWarn;
289 if (isDefineUndef == MU_Define) {
290 D = shouldWarnOnMacroDef(*this, II);
292 else if (isDefineUndef == MU_Undef)
293 D = shouldWarnOnMacroUndef(*this, II);
294 if (D == MD_KeywordDef) {
295 // We do not want to warn on some patterns widely used in configuration
296 // scripts. This requires analyzing next tokens, so do not issue warnings
297 // now, only inform caller.
301 if (D == MD_ReservedMacro)
302 Diag(MacroNameTok, diag::warn_pp_macro_is_reserved_id);
305 // Okay, we got a good identifier.
309 /// \brief Lex and validate a macro name, which occurs after a
310 /// \#define or \#undef.
312 /// This sets the token kind to eod and discards the rest of the macro line if
313 /// the macro name is invalid.
315 /// \param MacroNameTok Token that is expected to be a macro name.
316 /// \param isDefineUndef Context in which macro is used.
317 /// \param ShadowFlag Points to a flag that is set if macro shadows a keyword.
318 void Preprocessor::ReadMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
320 // Read the token, don't allow macro expansion on it.
321 LexUnexpandedToken(MacroNameTok);
323 if (MacroNameTok.is(tok::code_completion)) {
325 CodeComplete->CodeCompleteMacroName(isDefineUndef == MU_Define);
326 setCodeCompletionReached();
327 LexUnexpandedToken(MacroNameTok);
330 if (!CheckMacroName(MacroNameTok, isDefineUndef, ShadowFlag))
333 // Invalid macro name, read and discard the rest of the line and set the
334 // token kind to tok::eod if necessary.
335 if (MacroNameTok.isNot(tok::eod)) {
336 MacroNameTok.setKind(tok::eod);
337 DiscardUntilEndOfDirective();
341 /// \brief Ensure that the next token is a tok::eod token.
343 /// If not, emit a diagnostic and consume up until the eod. If EnableMacros is
344 /// true, then we consider macros that expand to zero tokens as being ok.
345 void Preprocessor::CheckEndOfDirective(const char *DirType, bool EnableMacros) {
347 // Lex unexpanded tokens for most directives: macros might expand to zero
348 // tokens, causing us to miss diagnosing invalid lines. Some directives (like
349 // #line) allow empty macros.
353 LexUnexpandedToken(Tmp);
355 // There should be no tokens after the directive, but we allow them as an
357 while (Tmp.is(tok::comment)) // Skip comments in -C mode.
358 LexUnexpandedToken(Tmp);
360 if (Tmp.isNot(tok::eod)) {
361 // Add a fixit in GNU/C99/C++ mode. Don't offer a fixit for strict-C89,
362 // or if this is a macro-style preprocessing directive, because it is more
363 // trouble than it is worth to insert /**/ and check that there is no /**/
364 // in the range also.
366 if ((LangOpts.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) &&
368 Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//");
369 Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint;
370 DiscardUntilEndOfDirective();
374 /// SkipExcludedConditionalBlock - We just read a \#if or related directive and
375 /// decided that the subsequent tokens are in the \#if'd out portion of the
376 /// file. Lex the rest of the file, until we see an \#endif. If
377 /// FoundNonSkipPortion is true, then we have already emitted code for part of
378 /// this \#if directive, so \#else/\#elif blocks should never be entered.
379 /// If ElseOk is true, then \#else directives are ok, if not, then we have
380 /// already seen one so a \#else directive is a duplicate. When this returns,
381 /// the caller can lex the first valid token.
382 void Preprocessor::SkipExcludedConditionalBlock(SourceLocation IfTokenLoc,
383 bool FoundNonSkipPortion,
385 SourceLocation ElseLoc) {
387 assert(!CurTokenLexer && CurPPLexer && "Lexing a macro, not a file?");
389 CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/false,
390 FoundNonSkipPortion, FoundElse);
393 PTHSkipExcludedConditionalBlock();
397 // Enter raw mode to disable identifier lookup (and thus macro expansion),
398 // disabling warnings, etc.
399 CurPPLexer->LexingRawMode = true;
404 if (Tok.is(tok::code_completion)) {
406 CodeComplete->CodeCompleteInConditionalExclusion();
407 setCodeCompletionReached();
411 // If this is the end of the buffer, we have an error.
412 if (Tok.is(tok::eof)) {
413 // Emit errors for each unterminated conditional on the stack, including
415 while (!CurPPLexer->ConditionalStack.empty()) {
416 if (CurLexer->getFileLoc() != CodeCompletionFileLoc)
417 Diag(CurPPLexer->ConditionalStack.back().IfLoc,
418 diag::err_pp_unterminated_conditional);
419 CurPPLexer->ConditionalStack.pop_back();
422 // Just return and let the caller lex after this #include.
426 // If this token is not a preprocessor directive, just skip it.
427 if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine())
430 // We just parsed a # character at the start of a line, so we're in
431 // directive mode. Tell the lexer this so any newlines we see will be
432 // converted into an EOD token (this terminates the macro).
433 CurPPLexer->ParsingPreprocessorDirective = true;
434 if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);
437 // Read the next token, the directive flavor.
438 LexUnexpandedToken(Tok);
440 // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or
441 // something bogus), skip it.
442 if (Tok.isNot(tok::raw_identifier)) {
443 CurPPLexer->ParsingPreprocessorDirective = false;
444 // Restore comment saving mode.
445 if (CurLexer) CurLexer->resetExtendedTokenMode();
449 // If the first letter isn't i or e, it isn't intesting to us. We know that
450 // this is safe in the face of spelling differences, because there is no way
451 // to spell an i/e in a strange way that is another letter. Skipping this
452 // allows us to avoid looking up the identifier info for #define/#undef and
453 // other common directives.
454 StringRef RI = Tok.getRawIdentifier();
456 char FirstChar = RI[0];
457 if (FirstChar >= 'a' && FirstChar <= 'z' &&
458 FirstChar != 'i' && FirstChar != 'e') {
459 CurPPLexer->ParsingPreprocessorDirective = false;
460 // Restore comment saving mode.
461 if (CurLexer) CurLexer->resetExtendedTokenMode();
465 // Get the identifier name without trigraphs or embedded newlines. Note
466 // that we can't use Tok.getIdentifierInfo() because its lookup is disabled
468 char DirectiveBuf[20];
470 if (!Tok.needsCleaning() && RI.size() < 20) {
473 std::string DirectiveStr = getSpelling(Tok);
474 size_t IdLen = DirectiveStr.size();
476 CurPPLexer->ParsingPreprocessorDirective = false;
477 // Restore comment saving mode.
478 if (CurLexer) CurLexer->resetExtendedTokenMode();
481 memcpy(DirectiveBuf, &DirectiveStr[0], IdLen);
482 Directive = StringRef(DirectiveBuf, IdLen);
485 if (Directive.startswith("if")) {
486 StringRef Sub = Directive.substr(2);
487 if (Sub.empty() || // "if"
488 Sub == "def" || // "ifdef"
489 Sub == "ndef") { // "ifndef"
490 // We know the entire #if/#ifdef/#ifndef block will be skipped, don't
491 // bother parsing the condition.
492 DiscardUntilEndOfDirective();
493 CurPPLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true,
494 /*foundnonskip*/false,
497 } else if (Directive[0] == 'e') {
498 StringRef Sub = Directive.substr(1);
499 if (Sub == "ndif") { // "endif"
500 PPConditionalInfo CondInfo;
501 CondInfo.WasSkipping = true; // Silence bogus warning.
502 bool InCond = CurPPLexer->popConditionalLevel(CondInfo);
503 (void)InCond; // Silence warning in no-asserts mode.
504 assert(!InCond && "Can't be skipping if not in a conditional!");
506 // If we popped the outermost skipping block, we're done skipping!
507 if (!CondInfo.WasSkipping) {
508 // Restore the value of LexingRawMode so that trailing comments
509 // are handled correctly, if we've reached the outermost block.
510 CurPPLexer->LexingRawMode = false;
511 CheckEndOfDirective("endif");
512 CurPPLexer->LexingRawMode = true;
514 Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc);
517 DiscardUntilEndOfDirective();
519 } else if (Sub == "lse") { // "else".
520 // #else directive in a skipping conditional. If not in some other
521 // skipping conditional, and if #else hasn't already been seen, enter it
522 // as a non-skipping conditional.
523 PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
525 // If this is a #else with a #else before it, report the error.
526 if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_else_after_else);
528 // Note that we've seen a #else in this conditional.
529 CondInfo.FoundElse = true;
531 // If the conditional is at the top level, and the #if block wasn't
532 // entered, enter the #else block now.
533 if (!CondInfo.WasSkipping && !CondInfo.FoundNonSkip) {
534 CondInfo.FoundNonSkip = true;
535 // Restore the value of LexingRawMode so that trailing comments
536 // are handled correctly.
537 CurPPLexer->LexingRawMode = false;
538 CheckEndOfDirective("else");
539 CurPPLexer->LexingRawMode = true;
541 Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc);
544 DiscardUntilEndOfDirective(); // C99 6.10p4.
546 } else if (Sub == "lif") { // "elif".
547 PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
549 // If this is a #elif with a #else before it, report the error.
550 if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_elif_after_else);
552 // If this is in a skipping block or if we're already handled this #if
553 // block, don't bother parsing the condition.
554 if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
555 DiscardUntilEndOfDirective();
557 const SourceLocation CondBegin = CurPPLexer->getSourceLocation();
558 // Restore the value of LexingRawMode so that identifiers are
559 // looked up, etc, inside the #elif expression.
560 assert(CurPPLexer->LexingRawMode && "We have to be skipping here!");
561 CurPPLexer->LexingRawMode = false;
562 IdentifierInfo *IfNDefMacro = nullptr;
563 const bool CondValue = EvaluateDirectiveExpression(IfNDefMacro);
564 CurPPLexer->LexingRawMode = true;
566 const SourceLocation CondEnd = CurPPLexer->getSourceLocation();
567 Callbacks->Elif(Tok.getLocation(),
568 SourceRange(CondBegin, CondEnd),
569 (CondValue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False), CondInfo.IfLoc);
571 // If this condition is true, enter it!
573 CondInfo.FoundNonSkip = true;
580 CurPPLexer->ParsingPreprocessorDirective = false;
581 // Restore comment saving mode.
582 if (CurLexer) CurLexer->resetExtendedTokenMode();
585 // Finally, if we are out of the conditional (saw an #endif or ran off the end
586 // of the file, just stop skipping and return to lexing whatever came after
588 CurPPLexer->LexingRawMode = false;
591 SourceLocation BeginLoc = ElseLoc.isValid() ? ElseLoc : IfTokenLoc;
592 Callbacks->SourceRangeSkipped(SourceRange(BeginLoc, Tok.getLocation()));
596 void Preprocessor::PTHSkipExcludedConditionalBlock() {
599 assert(CurPTHLexer->LexingRawMode == false);
601 // Skip to the next '#else', '#elif', or #endif.
602 if (CurPTHLexer->SkipBlock()) {
603 // We have reached an #endif. Both the '#' and 'endif' tokens
604 // have been consumed by the PTHLexer. Just pop off the condition level.
605 PPConditionalInfo CondInfo;
606 bool InCond = CurPTHLexer->popConditionalLevel(CondInfo);
607 (void)InCond; // Silence warning in no-asserts mode.
608 assert(!InCond && "Can't be skipping if not in a conditional!");
612 // We have reached a '#else' or '#elif'. Lex the next token to get
613 // the directive flavor.
615 LexUnexpandedToken(Tok);
617 // We can actually look up the IdentifierInfo here since we aren't in
619 tok::PPKeywordKind K = Tok.getIdentifierInfo()->getPPKeywordID();
621 if (K == tok::pp_else) {
622 // #else: Enter the else condition. We aren't in a nested condition
623 // since we skip those. We're always in the one matching the last
624 // blocked we skipped.
625 PPConditionalInfo &CondInfo = CurPTHLexer->peekConditionalLevel();
626 // Note that we've seen a #else in this conditional.
627 CondInfo.FoundElse = true;
629 // If the #if block wasn't entered then enter the #else block now.
630 if (!CondInfo.FoundNonSkip) {
631 CondInfo.FoundNonSkip = true;
633 // Scan until the eod token.
634 CurPTHLexer->ParsingPreprocessorDirective = true;
635 DiscardUntilEndOfDirective();
636 CurPTHLexer->ParsingPreprocessorDirective = false;
641 // Otherwise skip this block.
645 assert(K == tok::pp_elif);
646 PPConditionalInfo &CondInfo = CurPTHLexer->peekConditionalLevel();
648 // If this is a #elif with a #else before it, report the error.
649 if (CondInfo.FoundElse)
650 Diag(Tok, diag::pp_err_elif_after_else);
652 // If this is in a skipping block or if we're already handled this #if
653 // block, don't bother parsing the condition. We just skip this block.
654 if (CondInfo.FoundNonSkip)
657 // Evaluate the condition of the #elif.
658 IdentifierInfo *IfNDefMacro = nullptr;
659 CurPTHLexer->ParsingPreprocessorDirective = true;
660 bool ShouldEnter = EvaluateDirectiveExpression(IfNDefMacro);
661 CurPTHLexer->ParsingPreprocessorDirective = false;
663 // If this condition is true, enter it!
665 CondInfo.FoundNonSkip = true;
669 // Otherwise, skip this block and go to the next one.
673 Module *Preprocessor::getModuleForLocation(SourceLocation Loc) {
674 if (!SourceMgr.isInMainFile(Loc)) {
675 // Try to determine the module of the include directive.
676 // FIXME: Look into directly passing the FileEntry from LookupFile instead.
677 FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getExpansionLoc(Loc));
678 if (const FileEntry *EntryOfIncl = SourceMgr.getFileEntryForID(IDOfIncl)) {
679 // The include comes from an included file.
680 return HeaderInfo.getModuleMap()
681 .findModuleForHeader(EntryOfIncl)
686 // This is either in the main file or not in a file at all. It belongs
687 // to the current module, if there is one.
688 return getLangOpts().CurrentModule.empty()
690 : HeaderInfo.lookupModule(getLangOpts().CurrentModule);
693 Module *Preprocessor::getModuleContainingLocation(SourceLocation Loc) {
694 return HeaderInfo.getModuleMap().inferModuleFromLocation(
695 FullSourceLoc(Loc, SourceMgr));
699 Preprocessor::getModuleHeaderToIncludeForDiagnostics(SourceLocation IncLoc,
700 SourceLocation Loc) {
701 // If we have a module import syntax, we shouldn't include a header to
702 // make a particular module visible.
703 if (getLangOpts().ObjC2)
706 // Figure out which module we'd want to import.
707 Module *M = getModuleContainingLocation(Loc);
711 Module *TopM = M->getTopLevelModule();
712 Module *IncM = getModuleForLocation(IncLoc);
714 // Walk up through the include stack, looking through textual headers of M
715 // until we hit a non-textual header that we can #include. (We assume textual
716 // headers of a module with non-textual headers aren't meant to be used to
717 // import entities from the module.)
718 auto &SM = getSourceManager();
719 while (!Loc.isInvalid() && !SM.isInMainFile(Loc)) {
720 auto ID = SM.getFileID(SM.getExpansionLoc(Loc));
721 auto *FE = SM.getFileEntryForID(ID);
723 bool InTextualHeader = false;
724 for (auto Header : HeaderInfo.getModuleMap().findAllModulesForHeader(FE)) {
725 if (!Header.getModule()->isSubModuleOf(TopM))
728 if (!(Header.getRole() & ModuleMap::TextualHeader)) {
729 // If this is an accessible, non-textual header of M's top-level module
730 // that transitively includes the given location and makes the
731 // corresponding module visible, this is the thing to #include.
732 if (Header.isAccessibleFrom(IncM))
735 // It's in a private header; we can't #include it.
736 // FIXME: If there's a public header in some module that re-exports it,
737 // then we could suggest including that, but it's not clear that's the
738 // expected way to make this entity visible.
742 InTextualHeader = true;
745 if (!InTextualHeader)
748 Loc = SM.getIncludeLoc(ID);
754 const FileEntry *Preprocessor::LookupFile(
755 SourceLocation FilenameLoc,
758 const DirectoryLookup *FromDir,
759 const FileEntry *FromFile,
760 const DirectoryLookup *&CurDir,
761 SmallVectorImpl<char> *SearchPath,
762 SmallVectorImpl<char> *RelativePath,
763 ModuleMap::KnownHeader *SuggestedModule,
765 Module *RequestingModule = getModuleForLocation(FilenameLoc);
766 bool RequestingModuleIsModuleInterface = !SourceMgr.isInMainFile(FilenameLoc);
768 // If the header lookup mechanism may be relative to the current inclusion
769 // stack, record the parent #includes.
770 SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 16>
772 bool BuildSystemModule = false;
773 if (!FromDir && !FromFile) {
774 FileID FID = getCurrentFileLexer()->getFileID();
775 const FileEntry *FileEnt = SourceMgr.getFileEntryForID(FID);
777 // If there is no file entry associated with this file, it must be the
778 // predefines buffer or the module includes buffer. Any other file is not
779 // lexed with a normal lexer, so it won't be scanned for preprocessor
782 // If we have the predefines buffer, resolve #include references (which come
783 // from the -include command line argument) from the current working
784 // directory instead of relative to the main file.
786 // If we have the module includes buffer, resolve #include references (which
787 // come from header declarations in the module map) relative to the module
790 if (FID == SourceMgr.getMainFileID() && MainFileDir) {
791 Includers.push_back(std::make_pair(nullptr, MainFileDir));
792 BuildSystemModule = getCurrentModule()->IsSystem;
793 } else if ((FileEnt =
794 SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())))
795 Includers.push_back(std::make_pair(FileEnt, FileMgr.getDirectory(".")));
797 Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
800 // MSVC searches the current include stack from top to bottom for
801 // headers included by quoted include directives.
802 // See: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx
803 if (LangOpts.MSVCCompat && !isAngled) {
804 for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {
805 if (IsFileLexer(ISEntry))
806 if ((FileEnt = ISEntry.ThePPLexer->getFileEntry()))
807 Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
812 CurDir = CurDirLookup;
815 // We're supposed to start looking from after a particular file. Search
816 // the include path until we find that file or run out of files.
817 const DirectoryLookup *TmpCurDir = CurDir;
818 const DirectoryLookup *TmpFromDir = nullptr;
819 while (const FileEntry *FE = HeaderInfo.LookupFile(
820 Filename, FilenameLoc, isAngled, TmpFromDir, TmpCurDir,
821 Includers, SearchPath, RelativePath, RequestingModule,
822 SuggestedModule, SkipCache)) {
823 // Keep looking as if this file did a #include_next.
824 TmpFromDir = TmpCurDir;
826 if (FE == FromFile) {
828 FromDir = TmpFromDir;
835 // Do a standard file entry lookup.
836 const FileEntry *FE = HeaderInfo.LookupFile(
837 Filename, FilenameLoc, isAngled, FromDir, CurDir, Includers, SearchPath,
838 RelativePath, RequestingModule, SuggestedModule, SkipCache,
841 if (SuggestedModule && !LangOpts.AsmPreprocessor)
842 HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
843 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,
848 const FileEntry *CurFileEnt;
849 // Otherwise, see if this is a subframework header. If so, this is relative
850 // to one of the headers on the #include stack. Walk the list of the current
851 // headers on the #include stack and pass them to HeaderInfo.
853 if ((CurFileEnt = CurPPLexer->getFileEntry())) {
854 if ((FE = HeaderInfo.LookupSubframeworkHeader(Filename, CurFileEnt,
855 SearchPath, RelativePath,
858 if (SuggestedModule && !LangOpts.AsmPreprocessor)
859 HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
860 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,
867 for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {
868 if (IsFileLexer(ISEntry)) {
869 if ((CurFileEnt = ISEntry.ThePPLexer->getFileEntry())) {
870 if ((FE = HeaderInfo.LookupSubframeworkHeader(
871 Filename, CurFileEnt, SearchPath, RelativePath,
872 RequestingModule, SuggestedModule))) {
873 if (SuggestedModule && !LangOpts.AsmPreprocessor)
874 HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
875 RequestingModule, RequestingModuleIsModuleInterface,
876 FilenameLoc, Filename, FE);
883 // Otherwise, we really couldn't find the file.
887 //===----------------------------------------------------------------------===//
888 // Preprocessor Directive Handling.
889 //===----------------------------------------------------------------------===//
891 class Preprocessor::ResetMacroExpansionHelper {
893 ResetMacroExpansionHelper(Preprocessor *pp)
894 : PP(pp), save(pp->DisableMacroExpansion) {
895 if (pp->MacroExpansionInDirectivesOverride)
896 pp->DisableMacroExpansion = false;
899 ~ResetMacroExpansionHelper() {
900 PP->DisableMacroExpansion = save;
908 /// HandleDirective - This callback is invoked when the lexer sees a # token
909 /// at the start of a line. This consumes the directive, modifies the
910 /// lexer/preprocessor state, and advances the lexer(s) so that the next token
911 /// read is the correct one.
912 void Preprocessor::HandleDirective(Token &Result) {
913 // FIXME: Traditional: # with whitespace before it not recognized by K&R?
915 // We just parsed a # character at the start of a line, so we're in directive
916 // mode. Tell the lexer this so any newlines we see will be converted into an
917 // EOD token (which terminates the directive).
918 CurPPLexer->ParsingPreprocessorDirective = true;
919 if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);
921 bool ImmediatelyAfterTopLevelIfndef =
922 CurPPLexer->MIOpt.getImmediatelyAfterTopLevelIfndef();
923 CurPPLexer->MIOpt.resetImmediatelyAfterTopLevelIfndef();
927 // We are about to read a token. For the multiple-include optimization FA to
928 // work, we have to remember if we had read any tokens *before* this
930 bool ReadAnyTokensBeforeDirective =CurPPLexer->MIOpt.getHasReadAnyTokensVal();
932 // Save the '#' token in case we need to return it later.
933 Token SavedHash = Result;
935 // Read the next token, the directive flavor. This isn't expanded due to
937 LexUnexpandedToken(Result);
939 // C99 6.10.3p11: Is this preprocessor directive in macro invocation? e.g.:
944 // If so, the user is relying on undefined behavior, emit a diagnostic. Do
945 // not support this for #include-like directives, since that can result in
946 // terrible diagnostics, and does not work in GCC.
948 if (IdentifierInfo *II = Result.getIdentifierInfo()) {
949 switch (II->getPPKeywordID()) {
950 case tok::pp_include:
952 case tok::pp_include_next:
953 case tok::pp___include_macros:
955 Diag(Result, diag::err_embedded_directive) << II->getName();
956 DiscardUntilEndOfDirective();
962 Diag(Result, diag::ext_embedded_directive);
965 // Temporarily enable macro expansion if set so
966 // and reset to previous state when returning from this function.
967 ResetMacroExpansionHelper helper(this);
969 switch (Result.getKind()) {
971 return; // null directive.
972 case tok::code_completion:
974 CodeComplete->CodeCompleteDirective(
975 CurPPLexer->getConditionalStackDepth() > 0);
976 setCodeCompletionReached();
978 case tok::numeric_constant: // # 7 GNU line marker directive.
979 if (getLangOpts().AsmPreprocessor)
980 break; // # 4 is not a preprocessor directive in .S files.
981 return HandleDigitDirective(Result);
983 IdentifierInfo *II = Result.getIdentifierInfo();
984 if (!II) break; // Not an identifier.
986 // Ask what the preprocessor keyword ID is.
987 switch (II->getPPKeywordID()) {
989 // C99 6.10.1 - Conditional Inclusion.
991 return HandleIfDirective(Result, ReadAnyTokensBeforeDirective);
993 return HandleIfdefDirective(Result, false, true/*not valid for miopt*/);
995 return HandleIfdefDirective(Result, true, ReadAnyTokensBeforeDirective);
997 return HandleElifDirective(Result);
999 return HandleElseDirective(Result);
1001 return HandleEndifDirective(Result);
1003 // C99 6.10.2 - Source File Inclusion.
1004 case tok::pp_include:
1006 return HandleIncludeDirective(SavedHash.getLocation(), Result);
1007 case tok::pp___include_macros:
1009 return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result);
1011 // C99 6.10.3 - Macro Replacement.
1012 case tok::pp_define:
1013 return HandleDefineDirective(Result, ImmediatelyAfterTopLevelIfndef);
1015 return HandleUndefDirective();
1017 // C99 6.10.4 - Line Control.
1019 return HandleLineDirective();
1021 // C99 6.10.5 - Error Directive.
1023 return HandleUserDiagnosticDirective(Result, false);
1025 // C99 6.10.6 - Pragma Directive.
1026 case tok::pp_pragma:
1027 return HandlePragmaDirective(SavedHash.getLocation(), PIK_HashPragma);
1030 case tok::pp_import:
1031 return HandleImportDirective(SavedHash.getLocation(), Result);
1032 case tok::pp_include_next:
1033 return HandleIncludeNextDirective(SavedHash.getLocation(), Result);
1035 case tok::pp_warning:
1036 Diag(Result, diag::ext_pp_warning_directive);
1037 return HandleUserDiagnosticDirective(Result, true);
1039 return HandleIdentSCCSDirective(Result);
1041 return HandleIdentSCCSDirective(Result);
1042 case tok::pp_assert:
1043 //isExtension = true; // FIXME: implement #assert
1045 case tok::pp_unassert:
1046 //isExtension = true; // FIXME: implement #unassert
1049 case tok::pp___public_macro:
1050 if (getLangOpts().Modules)
1051 return HandleMacroPublicDirective(Result);
1054 case tok::pp___private_macro:
1055 if (getLangOpts().Modules)
1056 return HandleMacroPrivateDirective();
1062 // If this is a .S file, treat unknown # directives as non-preprocessor
1063 // directives. This is important because # may be a comment or introduce
1064 // various pseudo-ops. Just return the # token and push back the following
1065 // token to be lexed next time.
1066 if (getLangOpts().AsmPreprocessor) {
1067 auto Toks = llvm::make_unique<Token[]>(2);
1068 // Return the # and the token after it.
1069 Toks[0] = SavedHash;
1072 // If the second token is a hashhash token, then we need to translate it to
1073 // unknown so the token lexer doesn't try to perform token pasting.
1074 if (Result.is(tok::hashhash))
1075 Toks[1].setKind(tok::unknown);
1077 // Enter this token stream so that we re-lex the tokens. Make sure to
1078 // enable macro expansion, in case the token after the # is an identifier
1079 // that is expanded.
1080 EnterTokenStream(std::move(Toks), 2, false);
1084 // If we reached here, the preprocessing token is not valid!
1085 Diag(Result, diag::err_pp_invalid_directive);
1087 // Read the rest of the PP line.
1088 DiscardUntilEndOfDirective();
1090 // Okay, we're done parsing the directive.
1093 /// GetLineValue - Convert a numeric token into an unsigned value, emitting
1094 /// Diagnostic DiagID if it is invalid, and returning the value in Val.
1095 static bool GetLineValue(Token &DigitTok, unsigned &Val,
1096 unsigned DiagID, Preprocessor &PP,
1097 bool IsGNULineDirective=false) {
1098 if (DigitTok.isNot(tok::numeric_constant)) {
1099 PP.Diag(DigitTok, DiagID);
1101 if (DigitTok.isNot(tok::eod))
1102 PP.DiscardUntilEndOfDirective();
1106 SmallString<64> IntegerBuffer;
1107 IntegerBuffer.resize(DigitTok.getLength());
1108 const char *DigitTokBegin = &IntegerBuffer[0];
1109 bool Invalid = false;
1110 unsigned ActualLength = PP.getSpelling(DigitTok, DigitTokBegin, &Invalid);
1114 // Verify that we have a simple digit-sequence, and compute the value. This
1115 // is always a simple digit string computed in decimal, so we do this manually
1118 for (unsigned i = 0; i != ActualLength; ++i) {
1119 // C++1y [lex.fcon]p1:
1120 // Optional separating single quotes in a digit-sequence are ignored
1121 if (DigitTokBegin[i] == '\'')
1124 if (!isDigit(DigitTokBegin[i])) {
1125 PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i),
1126 diag::err_pp_line_digit_sequence) << IsGNULineDirective;
1127 PP.DiscardUntilEndOfDirective();
1131 unsigned NextVal = Val*10+(DigitTokBegin[i]-'0');
1132 if (NextVal < Val) { // overflow.
1133 PP.Diag(DigitTok, DiagID);
1134 PP.DiscardUntilEndOfDirective();
1140 if (DigitTokBegin[0] == '0' && Val)
1141 PP.Diag(DigitTok.getLocation(), diag::warn_pp_line_decimal)
1142 << IsGNULineDirective;
1147 /// \brief Handle a \#line directive: C99 6.10.4.
1149 /// The two acceptable forms are:
1151 /// # line digit-sequence
1152 /// # line digit-sequence "s-char-sequence"
1154 void Preprocessor::HandleLineDirective() {
1155 // Read the line # and string argument. Per C99 6.10.4p5, these tokens are
1160 // Validate the number and convert it to an unsigned.
1162 if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer,*this))
1166 Diag(DigitTok, diag::ext_pp_line_zero);
1168 // Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a
1169 // number greater than 2147483647". C90 requires that the line # be <= 32767.
1170 unsigned LineLimit = 32768U;
1171 if (LangOpts.C99 || LangOpts.CPlusPlus11)
1172 LineLimit = 2147483648U;
1173 if (LineNo >= LineLimit)
1174 Diag(DigitTok, diag::ext_pp_line_too_big) << LineLimit;
1175 else if (LangOpts.CPlusPlus11 && LineNo >= 32768U)
1176 Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big);
1178 int FilenameID = -1;
1182 // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a
1183 // string followed by eod.
1184 if (StrTok.is(tok::eod))
1186 else if (StrTok.isNot(tok::string_literal)) {
1187 Diag(StrTok, diag::err_pp_line_invalid_filename);
1188 return DiscardUntilEndOfDirective();
1189 } else if (StrTok.hasUDSuffix()) {
1190 Diag(StrTok, diag::err_invalid_string_udl);
1191 return DiscardUntilEndOfDirective();
1193 // Parse and validate the string, converting it into a unique ID.
1194 StringLiteralParser Literal(StrTok, *this);
1195 assert(Literal.isAscii() && "Didn't allow wide strings in");
1196 if (Literal.hadError)
1197 return DiscardUntilEndOfDirective();
1198 if (Literal.Pascal) {
1199 Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
1200 return DiscardUntilEndOfDirective();
1202 FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());
1204 // Verify that there is nothing after the string, other than EOD. Because
1205 // of C99 6.10.4p5, macros that expand to empty tokens are ok.
1206 CheckEndOfDirective("line", true);
1209 SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID);
1212 Callbacks->FileChanged(CurPPLexer->getSourceLocation(),
1213 PPCallbacks::RenameFile,
1217 /// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line
1218 /// marker directive.
1219 static bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit,
1220 bool &IsSystemHeader, bool &IsExternCHeader,
1225 if (FlagTok.is(tok::eod)) return false;
1226 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))
1233 if (FlagTok.is(tok::eod)) return false;
1234 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))
1236 } else if (FlagVal == 2) {
1239 SourceManager &SM = PP.getSourceManager();
1240 // If we are leaving the current presumed file, check to make sure the
1241 // presumed include stack isn't empty!
1243 SM.getDecomposedExpansionLoc(FlagTok.getLocation()).first;
1244 PresumedLoc PLoc = SM.getPresumedLoc(FlagTok.getLocation());
1245 if (PLoc.isInvalid())
1248 // If there is no include loc (main file) or if the include loc is in a
1249 // different physical file, then we aren't in a "1" line marker flag region.
1250 SourceLocation IncLoc = PLoc.getIncludeLoc();
1251 if (IncLoc.isInvalid() ||
1252 SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) {
1253 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop);
1254 PP.DiscardUntilEndOfDirective();
1259 if (FlagTok.is(tok::eod)) return false;
1260 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))
1264 // We must have 3 if there are still flags.
1266 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
1267 PP.DiscardUntilEndOfDirective();
1271 IsSystemHeader = true;
1274 if (FlagTok.is(tok::eod)) return false;
1275 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))
1278 // We must have 4 if there is yet another flag.
1280 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
1281 PP.DiscardUntilEndOfDirective();
1285 IsExternCHeader = true;
1288 if (FlagTok.is(tok::eod)) return false;
1290 // There are no more valid flags here.
1291 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
1292 PP.DiscardUntilEndOfDirective();
1296 /// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is
1297 /// one of the following forms:
1300 /// # 42 "file" ('1' | '2')?
1301 /// # 42 "file" ('1' | '2')? '3' '4'?
1303 void Preprocessor::HandleDigitDirective(Token &DigitTok) {
1304 // Validate the number and convert it to an unsigned. GNU does not have a
1305 // line # limit other than it fit in 32-bits.
1307 if (GetLineValue(DigitTok, LineNo, diag::err_pp_linemarker_requires_integer,
1314 bool IsFileEntry = false, IsFileExit = false;
1315 bool IsSystemHeader = false, IsExternCHeader = false;
1316 int FilenameID = -1;
1318 // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a
1319 // string followed by eod.
1320 if (StrTok.is(tok::eod))
1322 else if (StrTok.isNot(tok::string_literal)) {
1323 Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
1324 return DiscardUntilEndOfDirective();
1325 } else if (StrTok.hasUDSuffix()) {
1326 Diag(StrTok, diag::err_invalid_string_udl);
1327 return DiscardUntilEndOfDirective();
1329 // Parse and validate the string, converting it into a unique ID.
1330 StringLiteralParser Literal(StrTok, *this);
1331 assert(Literal.isAscii() && "Didn't allow wide strings in");
1332 if (Literal.hadError)
1333 return DiscardUntilEndOfDirective();
1334 if (Literal.Pascal) {
1335 Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
1336 return DiscardUntilEndOfDirective();
1338 FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());
1340 // If a filename was present, read any flags that are present.
1341 if (ReadLineMarkerFlags(IsFileEntry, IsFileExit,
1342 IsSystemHeader, IsExternCHeader, *this))
1346 // Create a line note with this information.
1347 SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID,
1348 IsFileEntry, IsFileExit,
1349 IsSystemHeader, IsExternCHeader);
1351 // If the preprocessor has callbacks installed, notify them of the #line
1352 // change. This is used so that the line marker comes out in -E mode for
1355 PPCallbacks::FileChangeReason Reason = PPCallbacks::RenameFile;
1357 Reason = PPCallbacks::EnterFile;
1358 else if (IsFileExit)
1359 Reason = PPCallbacks::ExitFile;
1360 SrcMgr::CharacteristicKind FileKind = SrcMgr::C_User;
1361 if (IsExternCHeader)
1362 FileKind = SrcMgr::C_ExternCSystem;
1363 else if (IsSystemHeader)
1364 FileKind = SrcMgr::C_System;
1366 Callbacks->FileChanged(CurPPLexer->getSourceLocation(), Reason, FileKind);
1370 /// HandleUserDiagnosticDirective - Handle a #warning or #error directive.
1372 void Preprocessor::HandleUserDiagnosticDirective(Token &Tok,
1374 // PTH doesn't emit #warning or #error directives.
1376 return CurPTHLexer->DiscardToEndOfLine();
1378 // Read the rest of the line raw. We do this because we don't want macros
1379 // to be expanded and we don't require that the tokens be valid preprocessing
1380 // tokens. For example, this is allowed: "#warning ` 'foo". GCC does
1381 // collapse multiple consequtive white space between tokens, but this isn't
1382 // specified by the standard.
1383 SmallString<128> Message;
1384 CurLexer->ReadToEndOfLine(&Message);
1386 // Find the first non-whitespace character, so that we can make the
1387 // diagnostic more succinct.
1388 StringRef Msg = StringRef(Message).ltrim(' ');
1391 Diag(Tok, diag::pp_hash_warning) << Msg;
1393 Diag(Tok, diag::err_pp_hash_error) << Msg;
1396 /// HandleIdentSCCSDirective - Handle a #ident/#sccs directive.
1398 void Preprocessor::HandleIdentSCCSDirective(Token &Tok) {
1399 // Yes, this directive is an extension.
1400 Diag(Tok, diag::ext_pp_ident_directive);
1402 // Read the string argument.
1406 // If the token kind isn't a string, it's a malformed directive.
1407 if (StrTok.isNot(tok::string_literal) &&
1408 StrTok.isNot(tok::wide_string_literal)) {
1409 Diag(StrTok, diag::err_pp_malformed_ident);
1410 if (StrTok.isNot(tok::eod))
1411 DiscardUntilEndOfDirective();
1415 if (StrTok.hasUDSuffix()) {
1416 Diag(StrTok, diag::err_invalid_string_udl);
1417 return DiscardUntilEndOfDirective();
1420 // Verify that there is nothing after the string, other than EOD.
1421 CheckEndOfDirective("ident");
1424 bool Invalid = false;
1425 std::string Str = getSpelling(StrTok, &Invalid);
1427 Callbacks->Ident(Tok.getLocation(), Str);
1431 /// \brief Handle a #public directive.
1432 void Preprocessor::HandleMacroPublicDirective(Token &Tok) {
1434 ReadMacroName(MacroNameTok, MU_Undef);
1436 // Error reading macro name? If so, diagnostic already issued.
1437 if (MacroNameTok.is(tok::eod))
1440 // Check to see if this is the last token on the #__public_macro line.
1441 CheckEndOfDirective("__public_macro");
1443 IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
1444 // Okay, we finally have a valid identifier to undef.
1445 MacroDirective *MD = getLocalMacroDirective(II);
1447 // If the macro is not defined, this is an error.
1449 Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;
1453 // Note that this macro has now been exported.
1454 appendMacroDirective(II, AllocateVisibilityMacroDirective(
1455 MacroNameTok.getLocation(), /*IsPublic=*/true));
1458 /// \brief Handle a #private directive.
1459 void Preprocessor::HandleMacroPrivateDirective() {
1461 ReadMacroName(MacroNameTok, MU_Undef);
1463 // Error reading macro name? If so, diagnostic already issued.
1464 if (MacroNameTok.is(tok::eod))
1467 // Check to see if this is the last token on the #__private_macro line.
1468 CheckEndOfDirective("__private_macro");
1470 IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
1471 // Okay, we finally have a valid identifier to undef.
1472 MacroDirective *MD = getLocalMacroDirective(II);
1474 // If the macro is not defined, this is an error.
1476 Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;
1480 // Note that this macro has now been marked private.
1481 appendMacroDirective(II, AllocateVisibilityMacroDirective(
1482 MacroNameTok.getLocation(), /*IsPublic=*/false));
1485 //===----------------------------------------------------------------------===//
1486 // Preprocessor Include Directive Handling.
1487 //===----------------------------------------------------------------------===//
1489 /// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully
1490 /// checked and spelled filename, e.g. as an operand of \#include. This returns
1491 /// true if the input filename was in <>'s or false if it were in ""'s. The
1492 /// caller is expected to provide a buffer that is large enough to hold the
1493 /// spelling of the filename, but is also expected to handle the case when
1494 /// this method decides to use a different buffer.
1495 bool Preprocessor::GetIncludeFilenameSpelling(SourceLocation Loc,
1496 StringRef &Buffer) {
1497 // Get the text form of the filename.
1498 assert(!Buffer.empty() && "Can't have tokens with empty spellings!");
1500 // Make sure the filename is <x> or "x".
1502 if (Buffer[0] == '<') {
1503 if (Buffer.back() != '>') {
1504 Diag(Loc, diag::err_pp_expects_filename);
1505 Buffer = StringRef();
1509 } else if (Buffer[0] == '"') {
1510 if (Buffer.back() != '"') {
1511 Diag(Loc, diag::err_pp_expects_filename);
1512 Buffer = StringRef();
1517 Diag(Loc, diag::err_pp_expects_filename);
1518 Buffer = StringRef();
1522 // Diagnose #include "" as invalid.
1523 if (Buffer.size() <= 2) {
1524 Diag(Loc, diag::err_pp_empty_filename);
1525 Buffer = StringRef();
1529 // Skip the brackets.
1530 Buffer = Buffer.substr(1, Buffer.size()-2);
1534 // \brief Handle cases where the \#include name is expanded from a macro
1535 // as multiple tokens, which need to be glued together.
1537 // This occurs for code like:
1539 // \#define FOO <a/b.h>
1542 // because in this case, "<a/b.h>" is returned as 7 tokens, not one.
1544 // This code concatenates and consumes tokens up to the '>' token. It returns
1545 // false if the > was found, otherwise it returns true if it finds and consumes
1547 bool Preprocessor::ConcatenateIncludeName(SmallString<128> &FilenameBuffer,
1548 SourceLocation &End) {
1552 while (CurTok.isNot(tok::eod)) {
1553 End = CurTok.getLocation();
1555 // FIXME: Provide code completion for #includes.
1556 if (CurTok.is(tok::code_completion)) {
1557 setCodeCompletionReached();
1562 // Append the spelling of this token to the buffer. If there was a space
1563 // before it, add it now.
1564 if (CurTok.hasLeadingSpace())
1565 FilenameBuffer.push_back(' ');
1567 // Get the spelling of the token, directly into FilenameBuffer if possible.
1568 size_t PreAppendSize = FilenameBuffer.size();
1569 FilenameBuffer.resize(PreAppendSize+CurTok.getLength());
1571 const char *BufPtr = &FilenameBuffer[PreAppendSize];
1572 unsigned ActualLen = getSpelling(CurTok, BufPtr);
1574 // If the token was spelled somewhere else, copy it into FilenameBuffer.
1575 if (BufPtr != &FilenameBuffer[PreAppendSize])
1576 memcpy(&FilenameBuffer[PreAppendSize], BufPtr, ActualLen);
1578 // Resize FilenameBuffer to the correct size.
1579 if (CurTok.getLength() != ActualLen)
1580 FilenameBuffer.resize(PreAppendSize+ActualLen);
1582 // If we found the '>' marker, return success.
1583 if (CurTok.is(tok::greater))
1589 // If we hit the eod marker, emit an error and return true so that the caller
1590 // knows the EOD has been read.
1591 Diag(CurTok.getLocation(), diag::err_pp_expects_filename);
1595 /// \brief Push a token onto the token stream containing an annotation.
1596 static void EnterAnnotationToken(Preprocessor &PP,
1597 SourceLocation Begin, SourceLocation End,
1598 tok::TokenKind Kind, void *AnnotationVal) {
1599 // FIXME: Produce this as the current token directly, rather than
1600 // allocating a new token for it.
1601 auto Tok = llvm::make_unique<Token[]>(1);
1602 Tok[0].startToken();
1603 Tok[0].setKind(Kind);
1604 Tok[0].setLocation(Begin);
1605 Tok[0].setAnnotationEndLoc(End);
1606 Tok[0].setAnnotationValue(AnnotationVal);
1607 PP.EnterTokenStream(std::move(Tok), 1, true);
1610 /// \brief Produce a diagnostic informing the user that a #include or similar
1611 /// was implicitly treated as a module import.
1612 static void diagnoseAutoModuleImport(
1613 Preprocessor &PP, SourceLocation HashLoc, Token &IncludeTok,
1614 ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> Path,
1615 SourceLocation PathEnd) {
1616 assert(PP.getLangOpts().ObjC2 && "no import syntax available");
1618 SmallString<128> PathString;
1619 for (size_t I = 0, N = Path.size(); I != N; ++I) {
1622 PathString += Path[I].first->getName();
1624 int IncludeKind = 0;
1626 switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) {
1627 case tok::pp_include:
1631 case tok::pp_import:
1635 case tok::pp_include_next:
1639 case tok::pp___include_macros:
1644 llvm_unreachable("unknown include directive kind");
1647 CharSourceRange ReplaceRange(SourceRange(HashLoc, PathEnd),
1648 /*IsTokenRange=*/false);
1649 PP.Diag(HashLoc, diag::warn_auto_module_import)
1650 << IncludeKind << PathString
1651 << FixItHint::CreateReplacement(ReplaceRange,
1652 ("@import " + PathString + ";").str());
1655 // Given a vector of path components and a string containing the real
1656 // path to the file, build a properly-cased replacement in the vector,
1657 // and return true if the replacement should be suggested.
1658 static bool trySimplifyPath(SmallVectorImpl<StringRef> &Components,
1659 StringRef RealPathName) {
1660 auto RealPathComponentIter = llvm::sys::path::rbegin(RealPathName);
1661 auto RealPathComponentEnd = llvm::sys::path::rend(RealPathName);
1663 bool SuggestReplacement = false;
1664 // Below is a best-effort to handle ".." in paths. It is admittedly
1665 // not 100% correct in the presence of symlinks.
1666 for (auto &Component : llvm::reverse(Components)) {
1667 if ("." == Component) {
1668 } else if (".." == Component) {
1672 } else if (RealPathComponentIter != RealPathComponentEnd) {
1673 if (Component != *RealPathComponentIter) {
1674 // If these path components differ by more than just case, then we
1675 // may be looking at symlinked paths. Bail on this diagnostic to avoid
1676 // noisy false positives.
1677 SuggestReplacement = RealPathComponentIter->equals_lower(Component);
1678 if (!SuggestReplacement)
1680 Component = *RealPathComponentIter;
1682 ++RealPathComponentIter;
1685 return SuggestReplacement;
1688 /// HandleIncludeDirective - The "\#include" tokens have just been read, read
1689 /// the file to be included from the lexer, then include it! This is a common
1690 /// routine with functionality shared between \#include, \#include_next and
1691 /// \#import. LookupFrom is set when this is a \#include_next directive, it
1692 /// specifies the file to start searching from.
1693 void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc,
1695 const DirectoryLookup *LookupFrom,
1696 const FileEntry *LookupFromFile,
1699 CurPPLexer->LexIncludeFilename(FilenameTok);
1701 // Reserve a buffer to get the spelling.
1702 SmallString<128> FilenameBuffer;
1705 SourceLocation CharEnd; // the end of this directive, in characters
1707 switch (FilenameTok.getKind()) {
1709 // If the token kind is EOD, the error has already been diagnosed.
1712 case tok::angle_string_literal:
1713 case tok::string_literal:
1714 Filename = getSpelling(FilenameTok, FilenameBuffer);
1715 End = FilenameTok.getLocation();
1716 CharEnd = End.getLocWithOffset(FilenameTok.getLength());
1720 // This could be a <foo/bar.h> file coming from a macro expansion. In this
1721 // case, glue the tokens together into FilenameBuffer and interpret those.
1722 FilenameBuffer.push_back('<');
1723 if (ConcatenateIncludeName(FilenameBuffer, End))
1724 return; // Found <eod> but no ">"? Diagnostic already emitted.
1725 Filename = FilenameBuffer;
1726 CharEnd = End.getLocWithOffset(1);
1729 Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);
1730 DiscardUntilEndOfDirective();
1734 CharSourceRange FilenameRange
1735 = CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd);
1736 StringRef OriginalFilename = Filename;
1738 GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
1739 // If GetIncludeFilenameSpelling set the start ptr to null, there was an
1741 if (Filename.empty()) {
1742 DiscardUntilEndOfDirective();
1746 // Verify that there is nothing after the filename, other than EOD. Note that
1747 // we allow macros that expand to nothing after the filename, because this
1748 // falls into the category of "#include pp-tokens new-line" specified in
1750 CheckEndOfDirective(IncludeTok.getIdentifierInfo()->getNameStart(), true);
1752 // Check that we don't have infinite #include recursion.
1753 if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) {
1754 Diag(FilenameTok, diag::err_pp_include_too_deep);
1758 // Complain about attempts to #include files in an audit pragma.
1759 if (PragmaARCCFCodeAuditedLoc.isValid()) {
1760 Diag(HashLoc, diag::err_pp_include_in_arc_cf_code_audited);
1761 Diag(PragmaARCCFCodeAuditedLoc, diag::note_pragma_entered_here);
1763 // Immediately leave the pragma.
1764 PragmaARCCFCodeAuditedLoc = SourceLocation();
1767 // Complain about attempts to #include files in an assume-nonnull pragma.
1768 if (PragmaAssumeNonNullLoc.isValid()) {
1769 Diag(HashLoc, diag::err_pp_include_in_assume_nonnull);
1770 Diag(PragmaAssumeNonNullLoc, diag::note_pragma_entered_here);
1772 // Immediately leave the pragma.
1773 PragmaAssumeNonNullLoc = SourceLocation();
1776 if (HeaderInfo.HasIncludeAliasMap()) {
1777 // Map the filename with the brackets still attached. If the name doesn't
1778 // map to anything, fall back on the filename we've already gotten the
1780 StringRef NewName = HeaderInfo.MapHeaderToIncludeAlias(OriginalFilename);
1781 if (!NewName.empty())
1785 // Search include directories.
1786 const DirectoryLookup *CurDir;
1787 SmallString<1024> SearchPath;
1788 SmallString<1024> RelativePath;
1789 // We get the raw path only if we have 'Callbacks' to which we later pass
1791 ModuleMap::KnownHeader SuggestedModule;
1792 SourceLocation FilenameLoc = FilenameTok.getLocation();
1793 SmallString<128> NormalizedPath;
1794 if (LangOpts.MSVCCompat) {
1795 NormalizedPath = Filename.str();
1796 #ifndef LLVM_ON_WIN32
1797 llvm::sys::path::native(NormalizedPath);
1800 const FileEntry *File = LookupFile(
1801 FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename,
1802 isAngled, LookupFrom, LookupFromFile, CurDir,
1803 Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr,
1808 // Give the clients a chance to recover.
1809 SmallString<128> RecoveryPath;
1810 if (Callbacks->FileNotFound(Filename, RecoveryPath)) {
1811 if (const DirectoryEntry *DE = FileMgr.getDirectory(RecoveryPath)) {
1812 // Add the recovery path to the list of search paths.
1813 DirectoryLookup DL(DE, SrcMgr::C_User, false);
1814 HeaderInfo.AddSearchPath(DL, isAngled);
1816 // Try the lookup again, skipping the cache.
1819 LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled,
1820 LookupFrom, LookupFromFile, CurDir, nullptr, nullptr,
1821 &SuggestedModule, /*SkipCache*/ true);
1826 if (!SuppressIncludeNotFoundError) {
1827 // If the file could not be located and it was included via angle
1828 // brackets, we can attempt a lookup as though it were a quoted path to
1829 // provide the user with a possible fixit.
1833 LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, false,
1834 LookupFrom, LookupFromFile, CurDir,
1835 Callbacks ? &SearchPath : nullptr,
1836 Callbacks ? &RelativePath : nullptr,
1839 SourceRange Range(FilenameTok.getLocation(), CharEnd);
1840 Diag(FilenameTok, diag::err_pp_file_not_found_not_fatal) <<
1842 FixItHint::CreateReplacement(Range, "\"" + Filename.str() + "\"");
1846 // If the file is still not found, just go with the vanilla diagnostic
1848 Diag(FilenameTok, diag::err_pp_file_not_found) << Filename
1853 // Should we enter the source file? Set to false if either the source file is
1854 // known to have no effect beyond its effect on module visibility -- that is,
1855 // if it's got an include guard that is already defined or is a modular header
1856 // we've imported or already built.
1857 bool ShouldEnter = true;
1859 // Determine whether we should try to import the module for this #include, if
1860 // there is one. Don't do so if precompiled module support is disabled or we
1861 // are processing this module textually (because we're building the module).
1862 if (File && SuggestedModule && getLangOpts().Modules &&
1863 SuggestedModule.getModule()->getTopLevelModuleName() !=
1864 getLangOpts().CurrentModule) {
1865 // If this include corresponds to a module but that module is
1866 // unavailable, diagnose the situation and bail out.
1867 // FIXME: Remove this; loadModule does the same check (but produces
1868 // slightly worse diagnostics).
1869 if (!SuggestedModule.getModule()->isAvailable()) {
1870 Module::Requirement Requirement;
1871 Module::UnresolvedHeaderDirective MissingHeader;
1872 Module *M = SuggestedModule.getModule();
1873 // Identify the cause.
1874 (void)M->isAvailable(getLangOpts(), getTargetInfo(), Requirement,
1876 if (MissingHeader.FileNameLoc.isValid()) {
1877 Diag(MissingHeader.FileNameLoc, diag::err_module_header_missing)
1878 << MissingHeader.IsUmbrella << MissingHeader.FileName;
1880 Diag(M->DefinitionLoc, diag::err_module_unavailable)
1881 << M->getFullModuleName() << Requirement.second << Requirement.first;
1883 Diag(FilenameTok.getLocation(),
1884 diag::note_implicit_top_level_module_import_here)
1885 << M->getTopLevelModuleName();
1889 // Compute the module access path corresponding to this module.
1890 // FIXME: Should we have a second loadModule() overload to avoid this
1891 // extra lookup step?
1892 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
1893 for (Module *Mod = SuggestedModule.getModule(); Mod; Mod = Mod->Parent)
1894 Path.push_back(std::make_pair(getIdentifierInfo(Mod->Name),
1895 FilenameTok.getLocation()));
1896 std::reverse(Path.begin(), Path.end());
1898 // Warn that we're replacing the include/import with a module import.
1899 // We only do this in Objective-C, where we have a module-import syntax.
1900 if (getLangOpts().ObjC2)
1901 diagnoseAutoModuleImport(*this, HashLoc, IncludeTok, Path, CharEnd);
1903 // Load the module to import its macros. We'll make the declarations
1904 // visible when the parser gets here.
1905 // FIXME: Pass SuggestedModule in here rather than converting it to a path
1906 // and making the module loader convert it back again.
1907 ModuleLoadResult Imported = TheModuleLoader.loadModule(
1908 IncludeTok.getLocation(), Path, Module::Hidden,
1909 /*IsIncludeDirective=*/true);
1910 assert((Imported == nullptr || Imported == SuggestedModule.getModule()) &&
1911 "the imported module is different than the suggested one");
1914 ShouldEnter = false;
1915 else if (Imported.isMissingExpected()) {
1916 // We failed to find a submodule that we assumed would exist (because it
1917 // was in the directory of an umbrella header, for instance), but no
1918 // actual module containing it exists (because the umbrella header is
1919 // incomplete). Treat this as a textual inclusion.
1920 SuggestedModule = ModuleMap::KnownHeader();
1921 } else if (Imported.isConfigMismatch()) {
1922 // On a configuration mismatch, enter the header textually. We still know
1923 // that it's part of the corresponding module.
1925 // We hit an error processing the import. Bail out.
1926 if (hadModuleLoaderFatalFailure()) {
1927 // With a fatal failure in the module loader, we abort parsing.
1928 Token &Result = IncludeTok;
1930 Result.startToken();
1931 CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
1932 CurLexer->cutOffLexing();
1934 assert(CurPTHLexer && "#include but no current lexer set!");
1935 CurPTHLexer->getEOF(Result);
1943 // Notify the callback object that we've seen an inclusion directive.
1944 Callbacks->InclusionDirective(
1945 HashLoc, IncludeTok,
1946 LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled,
1947 FilenameRange, File, SearchPath, RelativePath,
1948 ShouldEnter ? nullptr : SuggestedModule.getModule());
1954 // The #included file will be considered to be a system header if either it is
1955 // in a system include directory, or if the #includer is a system include
1957 SrcMgr::CharacteristicKind FileCharacter =
1958 std::max(HeaderInfo.getFileDirFlavor(File),
1959 SourceMgr.getFileCharacteristic(FilenameTok.getLocation()));
1961 // FIXME: If we have a suggested module, and we've already visited this file,
1962 // don't bother entering it again. We know it has no further effect.
1964 // Issue a diagnostic if the name of the file on disk has a different case
1965 // than the one we're about to open.
1966 const bool CheckIncludePathPortability =
1967 File && !File->tryGetRealPathName().empty();
1969 if (CheckIncludePathPortability) {
1970 StringRef Name = LangOpts.MSVCCompat ? NormalizedPath.str() : Filename;
1971 StringRef RealPathName = File->tryGetRealPathName();
1972 SmallVector<StringRef, 16> Components(llvm::sys::path::begin(Name),
1973 llvm::sys::path::end(Name));
1975 if (trySimplifyPath(Components, RealPathName)) {
1976 SmallString<128> Path;
1977 Path.reserve(Name.size()+2);
1978 Path.push_back(isAngled ? '<' : '"');
1979 for (auto Component : Components) {
1980 Path.append(Component);
1981 // Append the separator the user used, or the close quote
1983 Path.size() <= Filename.size() ? Filename[Path.size()-1] :
1984 (isAngled ? '>' : '"'));
1986 auto Replacement = Path.str().str();
1987 // For user files and known standard headers, by default we issue a diagnostic.
1988 // For other system headers, we don't. They can be controlled separately.
1989 auto DiagId = (FileCharacter == SrcMgr::C_User || warnByDefaultOnWrongCase(Name)) ?
1990 diag::pp_nonportable_path : diag::pp_nonportable_system_path;
1991 SourceRange Range(FilenameTok.getLocation(), CharEnd);
1992 Diag(FilenameTok, DiagId) << Replacement <<
1993 FixItHint::CreateReplacement(Range, Replacement);
1997 // Ask HeaderInfo if we should enter this #include file. If not, #including
1998 // this file will have no effect.
2000 !HeaderInfo.ShouldEnterIncludeFile(*this, File, isImport,
2001 SuggestedModule.getModule())) {
2002 ShouldEnter = false;
2004 Callbacks->FileSkipped(*File, FilenameTok, FileCharacter);
2007 // If we don't need to enter the file, stop now.
2009 // If this is a module import, make it visible if needed.
2010 if (auto *M = SuggestedModule.getModule()) {
2011 makeModuleVisible(M, HashLoc);
2013 if (IncludeTok.getIdentifierInfo()->getPPKeywordID() !=
2014 tok::pp___include_macros)
2015 EnterAnnotationToken(*this, HashLoc, End, tok::annot_module_include, M);
2020 // Look up the file, create a File ID for it.
2021 SourceLocation IncludePos = End;
2022 // If the filename string was the result of macro expansions, set the include
2023 // position on the file where it will be included and after the expansions.
2024 if (IncludePos.isMacroID())
2025 IncludePos = SourceMgr.getExpansionRange(IncludePos).second;
2026 FileID FID = SourceMgr.createFileID(File, IncludePos, FileCharacter);
2027 assert(FID.isValid() && "Expected valid file ID");
2029 // If all is good, enter the new file!
2030 if (EnterSourceFile(FID, CurDir, FilenameTok.getLocation()))
2033 // Determine if we're switching to building a new submodule, and which one.
2034 if (auto *M = SuggestedModule.getModule()) {
2035 assert(!CurSubmodule && "should not have marked this as a module yet");
2038 // Let the macro handling code know that any future macros are within
2039 // the new submodule.
2040 EnterSubmodule(M, HashLoc);
2042 // Let the parser know that any future declarations are within the new
2044 // FIXME: There's no point doing this if we're handling a #__include_macros
2046 EnterAnnotationToken(*this, HashLoc, End, tok::annot_module_begin, M);
2050 /// HandleIncludeNextDirective - Implements \#include_next.
2052 void Preprocessor::HandleIncludeNextDirective(SourceLocation HashLoc,
2053 Token &IncludeNextTok) {
2054 Diag(IncludeNextTok, diag::ext_pp_include_next_directive);
2056 // #include_next is like #include, except that we start searching after
2057 // the current found directory. If we can't do this, issue a
2059 const DirectoryLookup *Lookup = CurDirLookup;
2060 const FileEntry *LookupFromFile = nullptr;
2061 if (isInPrimaryFile() && LangOpts.IsHeaderFile) {
2062 // If the main file is a header, then it's either for PCH/AST generation,
2063 // or libclang opened it. Either way, handle it as a normal include below
2064 // and do not complain about include_next.
2065 } else if (isInPrimaryFile()) {
2067 Diag(IncludeNextTok, diag::pp_include_next_in_primary);
2068 } else if (CurSubmodule) {
2069 // Start looking up in the directory *after* the one in which the current
2070 // file would be found, if any.
2071 assert(CurPPLexer && "#include_next directive in macro?");
2072 LookupFromFile = CurPPLexer->getFileEntry();
2074 } else if (!Lookup) {
2075 Diag(IncludeNextTok, diag::pp_include_next_absolute_path);
2077 // Start looking up in the next directory.
2081 return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup,
2085 /// HandleMicrosoftImportDirective - Implements \#import for Microsoft Mode
2086 void Preprocessor::HandleMicrosoftImportDirective(Token &Tok) {
2087 // The Microsoft #import directive takes a type library and generates header
2088 // files from it, and includes those. This is beyond the scope of what clang
2089 // does, so we ignore it and error out. However, #import can optionally have
2090 // trailing attributes that span multiple lines. We're going to eat those
2091 // so we can continue processing from there.
2092 Diag(Tok, diag::err_pp_import_directive_ms );
2094 // Read tokens until we get to the end of the directive. Note that the
2095 // directive can be split over multiple lines using the backslash character.
2096 DiscardUntilEndOfDirective();
2099 /// HandleImportDirective - Implements \#import.
2101 void Preprocessor::HandleImportDirective(SourceLocation HashLoc,
2103 if (!LangOpts.ObjC1) { // #import is standard for ObjC.
2104 if (LangOpts.MSVCCompat)
2105 return HandleMicrosoftImportDirective(ImportTok);
2106 Diag(ImportTok, diag::ext_pp_import_directive);
2108 return HandleIncludeDirective(HashLoc, ImportTok, nullptr, nullptr, true);
2111 /// HandleIncludeMacrosDirective - The -imacros command line option turns into a
2112 /// pseudo directive in the predefines buffer. This handles it by sucking all
2113 /// tokens through the preprocessor and discarding them (only keeping the side
2114 /// effects on the preprocessor).
2115 void Preprocessor::HandleIncludeMacrosDirective(SourceLocation HashLoc,
2116 Token &IncludeMacrosTok) {
2117 // This directive should only occur in the predefines buffer. If not, emit an
2118 // error and reject it.
2119 SourceLocation Loc = IncludeMacrosTok.getLocation();
2120 if (SourceMgr.getBufferName(Loc) != "<built-in>") {
2121 Diag(IncludeMacrosTok.getLocation(),
2122 diag::pp_include_macros_out_of_predefines);
2123 DiscardUntilEndOfDirective();
2127 // Treat this as a normal #include for checking purposes. If this is
2128 // successful, it will push a new lexer onto the include stack.
2129 HandleIncludeDirective(HashLoc, IncludeMacrosTok);
2134 assert(TmpTok.isNot(tok::eof) && "Didn't find end of -imacros!");
2135 } while (TmpTok.isNot(tok::hashhash));
2138 //===----------------------------------------------------------------------===//
2139 // Preprocessor Macro Directive Handling.
2140 //===----------------------------------------------------------------------===//
2142 /// ReadMacroDefinitionArgList - The ( starting an argument list of a macro
2143 /// definition has just been read. Lex the rest of the arguments and the
2144 /// closing ), updating MI with what we learn. Return true if an error occurs
2145 /// parsing the arg list.
2146 bool Preprocessor::ReadMacroDefinitionArgList(MacroInfo *MI, Token &Tok) {
2147 SmallVector<IdentifierInfo*, 32> Arguments;
2150 LexUnexpandedToken(Tok);
2151 switch (Tok.getKind()) {
2153 // Found the end of the argument list.
2154 if (Arguments.empty()) // #define FOO()
2156 // Otherwise we have #define FOO(A,)
2157 Diag(Tok, diag::err_pp_expected_ident_in_arg_list);
2159 case tok::ellipsis: // #define X(... -> C99 varargs
2161 Diag(Tok, LangOpts.CPlusPlus11 ?
2162 diag::warn_cxx98_compat_variadic_macro :
2163 diag::ext_variadic_macro);
2165 // OpenCL v1.2 s6.9.e: variadic macros are not supported.
2166 if (LangOpts.OpenCL) {
2167 Diag(Tok, diag::err_pp_opencl_variadic_macros);
2171 // Lex the token after the identifier.
2172 LexUnexpandedToken(Tok);
2173 if (Tok.isNot(tok::r_paren)) {
2174 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
2177 // Add the __VA_ARGS__ identifier as an argument.
2178 Arguments.push_back(Ident__VA_ARGS__);
2179 MI->setIsC99Varargs();
2180 MI->setArgumentList(Arguments, BP);
2182 case tok::eod: // #define X(
2183 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
2186 // Handle keywords and identifiers here to accept things like
2187 // #define Foo(for) for.
2188 IdentifierInfo *II = Tok.getIdentifierInfo();
2191 Diag(Tok, diag::err_pp_invalid_tok_in_arg_list);
2195 // If this is already used as an argument, it is used multiple times (e.g.
2197 if (std::find(Arguments.begin(), Arguments.end(), II) !=
2198 Arguments.end()) { // C99 6.10.3p6
2199 Diag(Tok, diag::err_pp_duplicate_name_in_arg_list) << II;
2203 // Add the argument to the macro info.
2204 Arguments.push_back(II);
2206 // Lex the token after the identifier.
2207 LexUnexpandedToken(Tok);
2209 switch (Tok.getKind()) {
2210 default: // #define X(A B
2211 Diag(Tok, diag::err_pp_expected_comma_in_arg_list);
2213 case tok::r_paren: // #define X(A)
2214 MI->setArgumentList(Arguments, BP);
2216 case tok::comma: // #define X(A,
2218 case tok::ellipsis: // #define X(A... -> GCC extension
2219 // Diagnose extension.
2220 Diag(Tok, diag::ext_named_variadic_macro);
2222 // Lex the token after the identifier.
2223 LexUnexpandedToken(Tok);
2224 if (Tok.isNot(tok::r_paren)) {
2225 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
2229 MI->setIsGNUVarargs();
2230 MI->setArgumentList(Arguments, BP);
2237 static bool isConfigurationPattern(Token &MacroName, MacroInfo *MI,
2238 const LangOptions &LOptions) {
2239 if (MI->getNumTokens() == 1) {
2240 const Token &Value = MI->getReplacementToken(0);
2242 // Macro that is identity, like '#define inline inline' is a valid pattern.
2243 if (MacroName.getKind() == Value.getKind())
2246 // Macro that maps a keyword to the same keyword decorated with leading/
2247 // trailing underscores is a valid pattern:
2248 // #define inline __inline
2249 // #define inline __inline__
2250 // #define inline _inline (in MS compatibility mode)
2251 StringRef MacroText = MacroName.getIdentifierInfo()->getName();
2252 if (IdentifierInfo *II = Value.getIdentifierInfo()) {
2253 if (!II->isKeyword(LOptions))
2255 StringRef ValueText = II->getName();
2256 StringRef TrimmedValue = ValueText;
2257 if (!ValueText.startswith("__")) {
2258 if (ValueText.startswith("_"))
2259 TrimmedValue = TrimmedValue.drop_front(1);
2263 TrimmedValue = TrimmedValue.drop_front(2);
2264 if (TrimmedValue.endswith("__"))
2265 TrimmedValue = TrimmedValue.drop_back(2);
2267 return TrimmedValue.equals(MacroText);
2274 return MacroName.isOneOf(tok::kw_extern, tok::kw_inline, tok::kw_static,
2276 MI->getNumTokens() == 0;
2279 /// HandleDefineDirective - Implements \#define. This consumes the entire macro
2280 /// line then lets the caller lex the next real token.
2281 void Preprocessor::HandleDefineDirective(Token &DefineTok,
2282 bool ImmediatelyAfterHeaderGuard) {
2286 bool MacroShadowsKeyword;
2287 ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword);
2289 // Error reading macro name? If so, diagnostic already issued.
2290 if (MacroNameTok.is(tok::eod))
2293 Token LastTok = MacroNameTok;
2295 // If we are supposed to keep comments in #defines, reenable comment saving
2297 if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments);
2299 // Create the new macro.
2300 MacroInfo *MI = AllocateMacroInfo(MacroNameTok.getLocation());
2303 LexUnexpandedToken(Tok);
2305 // If this is a function-like macro definition, parse the argument list,
2306 // marking each of the identifiers as being used as macro arguments. Also,
2307 // check other constraints on the first token of the macro body.
2308 if (Tok.is(tok::eod)) {
2309 if (ImmediatelyAfterHeaderGuard) {
2310 // Save this macro information since it may part of a header guard.
2311 CurPPLexer->MIOpt.SetDefinedMacro(MacroNameTok.getIdentifierInfo(),
2312 MacroNameTok.getLocation());
2314 // If there is no body to this macro, we have no special handling here.
2315 } else if (Tok.hasLeadingSpace()) {
2316 // This is a normal token with leading space. Clear the leading space
2317 // marker on the first token to get proper expansion.
2318 Tok.clearFlag(Token::LeadingSpace);
2319 } else if (Tok.is(tok::l_paren)) {
2320 // This is a function-like macro definition. Read the argument list.
2321 MI->setIsFunctionLike();
2322 if (ReadMacroDefinitionArgList(MI, LastTok)) {
2323 // Throw away the rest of the line.
2324 if (CurPPLexer->ParsingPreprocessorDirective)
2325 DiscardUntilEndOfDirective();
2329 // If this is a definition of a variadic C99 function-like macro, not using
2330 // the GNU named varargs extension, enabled __VA_ARGS__.
2332 // "Poison" __VA_ARGS__, which can only appear in the expansion of a macro.
2333 // This gets unpoisoned where it is allowed.
2334 assert(Ident__VA_ARGS__->isPoisoned() && "__VA_ARGS__ should be poisoned!");
2335 if (MI->isC99Varargs())
2336 Ident__VA_ARGS__->setIsPoisoned(false);
2338 // Read the first token after the arg list for down below.
2339 LexUnexpandedToken(Tok);
2340 } else if (LangOpts.C99 || LangOpts.CPlusPlus11) {
2341 // C99 requires whitespace between the macro definition and the body. Emit
2342 // a diagnostic for something like "#define X+".
2343 Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name);
2345 // C90 6.8 TC1 says: "In the definition of an object-like macro, if the
2346 // first character of a replacement list is not a character required by
2347 // subclause 5.2.1, then there shall be white-space separation between the
2348 // identifier and the replacement list.". 5.2.1 lists this set:
2349 // "A-Za-z0-9!"#%&'()*+,_./:;<=>?[\]^_{|}~" as well as whitespace, which
2350 // is irrelevant here.
2351 bool isInvalid = false;
2352 if (Tok.is(tok::at)) // @ is not in the list above.
2354 else if (Tok.is(tok::unknown)) {
2355 // If we have an unknown token, it is something strange like "`". Since
2356 // all of valid characters would have lexed into a single character
2357 // token of some sort, we know this is not a valid case.
2361 Diag(Tok, diag::ext_missing_whitespace_after_macro_name);
2363 Diag(Tok, diag::warn_missing_whitespace_after_macro_name);
2366 if (!Tok.is(tok::eod))
2369 // Read the rest of the macro body.
2370 if (MI->isObjectLike()) {
2371 // Object-like macros are very simple, just read their body.
2372 while (Tok.isNot(tok::eod)) {
2374 MI->AddTokenToBody(Tok);
2375 // Get the next token of the macro.
2376 LexUnexpandedToken(Tok);
2379 // Otherwise, read the body of a function-like macro. While we are at it,
2380 // check C99 6.10.3.2p1: ensure that # operators are followed by macro
2381 // parameters in function-like macro expansions.
2382 while (Tok.isNot(tok::eod)) {
2385 if (!Tok.isOneOf(tok::hash, tok::hashat, tok::hashhash)) {
2386 MI->AddTokenToBody(Tok);
2388 // Get the next token of the macro.
2389 LexUnexpandedToken(Tok);
2393 // If we're in -traditional mode, then we should ignore stringification
2394 // and token pasting. Mark the tokens as unknown so as not to confuse
2396 if (getLangOpts().TraditionalCPP) {
2397 Tok.setKind(tok::unknown);
2398 MI->AddTokenToBody(Tok);
2400 // Get the next token of the macro.
2401 LexUnexpandedToken(Tok);
2405 if (Tok.is(tok::hashhash)) {
2406 // If we see token pasting, check if it looks like the gcc comma
2407 // pasting extension. We'll use this information to suppress
2408 // diagnostics later on.
2410 // Get the next token of the macro.
2411 LexUnexpandedToken(Tok);
2413 if (Tok.is(tok::eod)) {
2414 MI->AddTokenToBody(LastTok);
2418 unsigned NumTokens = MI->getNumTokens();
2419 if (NumTokens && Tok.getIdentifierInfo() == Ident__VA_ARGS__ &&
2420 MI->getReplacementToken(NumTokens-1).is(tok::comma))
2421 MI->setHasCommaPasting();
2423 // Things look ok, add the '##' token to the macro.
2424 MI->AddTokenToBody(LastTok);
2428 // Get the next token of the macro.
2429 LexUnexpandedToken(Tok);
2431 // Check for a valid macro arg identifier.
2432 if (Tok.getIdentifierInfo() == nullptr ||
2433 MI->getArgumentNum(Tok.getIdentifierInfo()) == -1) {
2435 // If this is assembler-with-cpp mode, we accept random gibberish after
2436 // the '#' because '#' is often a comment character. However, change
2437 // the kind of the token to tok::unknown so that the preprocessor isn't
2439 if (getLangOpts().AsmPreprocessor && Tok.isNot(tok::eod)) {
2440 LastTok.setKind(tok::unknown);
2441 MI->AddTokenToBody(LastTok);
2444 Diag(Tok, diag::err_pp_stringize_not_parameter)
2445 << LastTok.is(tok::hashat);
2447 // Disable __VA_ARGS__ again.
2448 Ident__VA_ARGS__->setIsPoisoned(true);
2453 // Things look ok, add the '#' and param name tokens to the macro.
2454 MI->AddTokenToBody(LastTok);
2455 MI->AddTokenToBody(Tok);
2458 // Get the next token of the macro.
2459 LexUnexpandedToken(Tok);
2463 if (MacroShadowsKeyword &&
2464 !isConfigurationPattern(MacroNameTok, MI, getLangOpts())) {
2465 Diag(MacroNameTok, diag::warn_pp_macro_hides_keyword);
2468 // Disable __VA_ARGS__ again.
2469 Ident__VA_ARGS__->setIsPoisoned(true);
2471 // Check that there is no paste (##) operator at the beginning or end of the
2472 // replacement list.
2473 unsigned NumTokens = MI->getNumTokens();
2474 if (NumTokens != 0) {
2475 if (MI->getReplacementToken(0).is(tok::hashhash)) {
2476 Diag(MI->getReplacementToken(0), diag::err_paste_at_start);
2479 if (MI->getReplacementToken(NumTokens-1).is(tok::hashhash)) {
2480 Diag(MI->getReplacementToken(NumTokens-1), diag::err_paste_at_end);
2485 MI->setDefinitionEndLoc(LastTok.getLocation());
2487 // Finally, if this identifier already had a macro defined for it, verify that
2488 // the macro bodies are identical, and issue diagnostics if they are not.
2489 if (const MacroInfo *OtherMI=getMacroInfo(MacroNameTok.getIdentifierInfo())) {
2490 // In Objective-C, ignore attempts to directly redefine the builtin
2491 // definitions of the ownership qualifiers. It's still possible to
2493 auto isObjCProtectedMacro = [](const IdentifierInfo *II) -> bool {
2494 return II->isStr("__strong") ||
2495 II->isStr("__weak") ||
2496 II->isStr("__unsafe_unretained") ||
2497 II->isStr("__autoreleasing");
2499 if (getLangOpts().ObjC1 &&
2500 SourceMgr.getFileID(OtherMI->getDefinitionLoc())
2501 == getPredefinesFileID() &&
2502 isObjCProtectedMacro(MacroNameTok.getIdentifierInfo())) {
2503 // Warn if it changes the tokens.
2504 if ((!getDiagnostics().getSuppressSystemWarnings() ||
2505 !SourceMgr.isInSystemHeader(DefineTok.getLocation())) &&
2506 !MI->isIdenticalTo(*OtherMI, *this,
2507 /*Syntactic=*/LangOpts.MicrosoftExt)) {
2508 Diag(MI->getDefinitionLoc(), diag::warn_pp_objc_macro_redef_ignored);
2510 assert(!OtherMI->isWarnIfUnused());
2514 // It is very common for system headers to have tons of macro redefinitions
2515 // and for warnings to be disabled in system headers. If this is the case,
2516 // then don't bother calling MacroInfo::isIdenticalTo.
2517 if (!getDiagnostics().getSuppressSystemWarnings() ||
2518 !SourceMgr.isInSystemHeader(DefineTok.getLocation())) {
2519 if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused())
2520 Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used);
2522 // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and
2523 // C++ [cpp.predefined]p4, but allow it as an extension.
2524 if (OtherMI->isBuiltinMacro())
2525 Diag(MacroNameTok, diag::ext_pp_redef_builtin_macro);
2526 // Macros must be identical. This means all tokens and whitespace
2527 // separation must be the same. C99 6.10.3p2.
2528 else if (!OtherMI->isAllowRedefinitionsWithoutWarning() &&
2529 !MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) {
2530 Diag(MI->getDefinitionLoc(), diag::ext_pp_macro_redef)
2531 << MacroNameTok.getIdentifierInfo();
2532 Diag(OtherMI->getDefinitionLoc(), diag::note_previous_definition);
2535 if (OtherMI->isWarnIfUnused())
2536 WarnUnusedMacroLocs.erase(OtherMI->getDefinitionLoc());
2539 DefMacroDirective *MD =
2540 appendDefMacroDirective(MacroNameTok.getIdentifierInfo(), MI);
2542 assert(!MI->isUsed());
2543 // If we need warning for not using the macro, add its location in the
2544 // warn-because-unused-macro set. If it gets used it will be removed from set.
2545 if (getSourceManager().isInMainFile(MI->getDefinitionLoc()) &&
2546 !Diags->isIgnored(diag::pp_macro_not_used, MI->getDefinitionLoc())) {
2547 MI->setIsWarnIfUnused(true);
2548 WarnUnusedMacroLocs.insert(MI->getDefinitionLoc());
2551 // If the callbacks want to know, tell them about the macro definition.
2553 Callbacks->MacroDefined(MacroNameTok, MD);
2556 /// HandleUndefDirective - Implements \#undef.
2558 void Preprocessor::HandleUndefDirective() {
2562 ReadMacroName(MacroNameTok, MU_Undef);
2564 // Error reading macro name? If so, diagnostic already issued.
2565 if (MacroNameTok.is(tok::eod))
2568 // Check to see if this is the last token on the #undef line.
2569 CheckEndOfDirective("undef");
2571 // Okay, we have a valid identifier to undef.
2572 auto *II = MacroNameTok.getIdentifierInfo();
2573 auto MD = getMacroDefinition(II);
2575 // If the callbacks want to know, tell them about the macro #undef.
2576 // Note: no matter if the macro was defined or not.
2578 Callbacks->MacroUndefined(MacroNameTok, MD);
2580 // If the macro is not defined, this is a noop undef, just return.
2581 const MacroInfo *MI = MD.getMacroInfo();
2585 if (!MI->isUsed() && MI->isWarnIfUnused())
2586 Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used);
2588 if (MI->isWarnIfUnused())
2589 WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
2591 appendMacroDirective(MacroNameTok.getIdentifierInfo(),
2592 AllocateUndefMacroDirective(MacroNameTok.getLocation()));
2595 //===----------------------------------------------------------------------===//
2596 // Preprocessor Conditional Directive Handling.
2597 //===----------------------------------------------------------------------===//
2599 /// HandleIfdefDirective - Implements the \#ifdef/\#ifndef directive. isIfndef
2600 /// is true when this is a \#ifndef directive. ReadAnyTokensBeforeDirective is
2601 /// true if any tokens have been returned or pp-directives activated before this
2602 /// \#ifndef has been lexed.
2604 void Preprocessor::HandleIfdefDirective(Token &Result, bool isIfndef,
2605 bool ReadAnyTokensBeforeDirective) {
2607 Token DirectiveTok = Result;
2610 ReadMacroName(MacroNameTok);
2612 // Error reading macro name? If so, diagnostic already issued.
2613 if (MacroNameTok.is(tok::eod)) {
2614 // Skip code until we get to #endif. This helps with recovery by not
2615 // emitting an error when the #endif is reached.
2616 SkipExcludedConditionalBlock(DirectiveTok.getLocation(),
2617 /*Foundnonskip*/false, /*FoundElse*/false);
2621 // Check to see if this is the last token on the #if[n]def line.
2622 CheckEndOfDirective(isIfndef ? "ifndef" : "ifdef");
2624 IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
2625 auto MD = getMacroDefinition(MII);
2626 MacroInfo *MI = MD.getMacroInfo();
2628 if (CurPPLexer->getConditionalStackDepth() == 0) {
2629 // If the start of a top-level #ifdef and if the macro is not defined,
2630 // inform MIOpt that this might be the start of a proper include guard.
2631 // Otherwise it is some other form of unknown conditional which we can't
2633 if (!ReadAnyTokensBeforeDirective && !MI) {
2634 assert(isIfndef && "#ifdef shouldn't reach here");
2635 CurPPLexer->MIOpt.EnterTopLevelIfndef(MII, MacroNameTok.getLocation());
2637 CurPPLexer->MIOpt.EnterTopLevelConditional();
2640 // If there is a macro, process it.
2641 if (MI) // Mark it used.
2642 markMacroAsUsed(MI);
2646 Callbacks->Ifndef(DirectiveTok.getLocation(), MacroNameTok, MD);
2648 Callbacks->Ifdef(DirectiveTok.getLocation(), MacroNameTok, MD);
2651 // Should we include the stuff contained by this directive?
2652 if (!MI == isIfndef) {
2653 // Yes, remember that we are inside a conditional, then lex the next token.
2654 CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),
2655 /*wasskip*/false, /*foundnonskip*/true,
2656 /*foundelse*/false);
2658 // No, skip the contents of this block.
2659 SkipExcludedConditionalBlock(DirectiveTok.getLocation(),
2660 /*Foundnonskip*/false,
2661 /*FoundElse*/false);
2665 /// HandleIfDirective - Implements the \#if directive.
2667 void Preprocessor::HandleIfDirective(Token &IfToken,
2668 bool ReadAnyTokensBeforeDirective) {
2671 // Parse and evaluate the conditional expression.
2672 IdentifierInfo *IfNDefMacro = nullptr;
2673 const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation();
2674 const bool ConditionalTrue = EvaluateDirectiveExpression(IfNDefMacro);
2675 const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation();
2677 // If this condition is equivalent to #ifndef X, and if this is the first
2678 // directive seen, handle it for the multiple-include optimization.
2679 if (CurPPLexer->getConditionalStackDepth() == 0) {
2680 if (!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue)
2681 // FIXME: Pass in the location of the macro name, not the 'if' token.
2682 CurPPLexer->MIOpt.EnterTopLevelIfndef(IfNDefMacro, IfToken.getLocation());
2684 CurPPLexer->MIOpt.EnterTopLevelConditional();
2688 Callbacks->If(IfToken.getLocation(),
2689 SourceRange(ConditionalBegin, ConditionalEnd),
2690 (ConditionalTrue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False));
2692 // Should we include the stuff contained by this directive?
2693 if (ConditionalTrue) {
2694 // Yes, remember that we are inside a conditional, then lex the next token.
2695 CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false,
2696 /*foundnonskip*/true, /*foundelse*/false);
2698 // No, skip the contents of this block.
2699 SkipExcludedConditionalBlock(IfToken.getLocation(), /*Foundnonskip*/false,
2700 /*FoundElse*/false);
2704 /// HandleEndifDirective - Implements the \#endif directive.
2706 void Preprocessor::HandleEndifDirective(Token &EndifToken) {
2709 // Check that this is the whole directive.
2710 CheckEndOfDirective("endif");
2712 PPConditionalInfo CondInfo;
2713 if (CurPPLexer->popConditionalLevel(CondInfo)) {
2714 // No conditionals on the stack: this is an #endif without an #if.
2715 Diag(EndifToken, diag::err_pp_endif_without_if);
2719 // If this the end of a top-level #endif, inform MIOpt.
2720 if (CurPPLexer->getConditionalStackDepth() == 0)
2721 CurPPLexer->MIOpt.ExitTopLevelConditional();
2723 assert(!CondInfo.WasSkipping && !CurPPLexer->LexingRawMode &&
2724 "This code should only be reachable in the non-skipping case!");
2727 Callbacks->Endif(EndifToken.getLocation(), CondInfo.IfLoc);
2730 /// HandleElseDirective - Implements the \#else directive.
2732 void Preprocessor::HandleElseDirective(Token &Result) {
2735 // #else directive in a non-skipping conditional... start skipping.
2736 CheckEndOfDirective("else");
2738 PPConditionalInfo CI;
2739 if (CurPPLexer->popConditionalLevel(CI)) {
2740 Diag(Result, diag::pp_err_else_without_if);
2744 // If this is a top-level #else, inform the MIOpt.
2745 if (CurPPLexer->getConditionalStackDepth() == 0)
2746 CurPPLexer->MIOpt.EnterTopLevelConditional();
2748 // If this is a #else with a #else before it, report the error.
2749 if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else);
2752 Callbacks->Else(Result.getLocation(), CI.IfLoc);
2754 // Finally, skip the rest of the contents of this block.
2755 SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true,
2756 /*FoundElse*/true, Result.getLocation());
2759 /// HandleElifDirective - Implements the \#elif directive.
2761 void Preprocessor::HandleElifDirective(Token &ElifToken) {
2764 // #elif directive in a non-skipping conditional... start skipping.
2765 // We don't care what the condition is, because we will always skip it (since
2766 // the block immediately before it was included).
2767 const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation();
2768 DiscardUntilEndOfDirective();
2769 const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation();
2771 PPConditionalInfo CI;
2772 if (CurPPLexer->popConditionalLevel(CI)) {
2773 Diag(ElifToken, diag::pp_err_elif_without_if);
2777 // If this is a top-level #elif, inform the MIOpt.
2778 if (CurPPLexer->getConditionalStackDepth() == 0)
2779 CurPPLexer->MIOpt.EnterTopLevelConditional();
2781 // If this is a #elif with a #else before it, report the error.
2782 if (CI.FoundElse) Diag(ElifToken, diag::pp_err_elif_after_else);
2785 Callbacks->Elif(ElifToken.getLocation(),
2786 SourceRange(ConditionalBegin, ConditionalEnd),
2787 PPCallbacks::CVK_NotEvaluated, CI.IfLoc);
2789 // Finally, skip the rest of the contents of this block.
2790 SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true,
2791 /*FoundElse*/CI.FoundElse,
2792 ElifToken.getLocation());