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(SourceLocation L) {
58 auto *MIChain = new (BP) MacroInfoChain{L, MIChainHead};
59 MIChainHead = MIChain;
63 DefMacroDirective *Preprocessor::AllocateDefMacroDirective(MacroInfo *MI,
65 return new (BP) DefMacroDirective(MI, Loc);
69 Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) {
70 return new (BP) UndefMacroDirective(UndefLoc);
73 VisibilityMacroDirective *
74 Preprocessor::AllocateVisibilityMacroDirective(SourceLocation Loc,
76 return new (BP) VisibilityMacroDirective(Loc, isPublic);
79 /// \brief Read and discard all tokens remaining on the current line until
80 /// the tok::eod token is found.
81 void Preprocessor::DiscardUntilEndOfDirective() {
84 LexUnexpandedToken(Tmp);
85 assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens");
86 } while (Tmp.isNot(tok::eod));
89 /// \brief Enumerates possible cases of #define/#undef a reserved identifier.
91 MD_NoWarn, //> Not a reserved identifier
92 MD_KeywordDef, //> Macro hides keyword, enabled by default
93 MD_ReservedMacro //> #define of #undef reserved id, disabled by default
96 /// \brief Checks if the specified identifier is reserved in the specified
98 /// This function does not check if the identifier is a keyword.
99 static bool isReservedId(StringRef Text, const LangOptions &Lang) {
100 // C++ [macro.names], C11 7.1.3:
101 // All identifiers that begin with an underscore and either an uppercase
102 // letter or another underscore are always reserved for any use.
103 if (Text.size() >= 2 && Text[0] == '_' &&
104 (isUppercase(Text[1]) || Text[1] == '_'))
106 // C++ [global.names]
107 // Each name that contains a double underscore ... is reserved to the
108 // implementation for any use.
109 if (Lang.CPlusPlus) {
110 if (Text.find("__") != StringRef::npos)
116 static MacroDiag shouldWarnOnMacroDef(Preprocessor &PP, IdentifierInfo *II) {
117 const LangOptions &Lang = PP.getLangOpts();
118 StringRef Text = II->getName();
119 if (isReservedId(Text, Lang))
120 return MD_ReservedMacro;
121 if (II->isKeyword(Lang))
122 return MD_KeywordDef;
123 if (Lang.CPlusPlus11 && (Text.equals("override") || Text.equals("final")))
124 return MD_KeywordDef;
128 static MacroDiag shouldWarnOnMacroUndef(Preprocessor &PP, IdentifierInfo *II) {
129 const LangOptions &Lang = PP.getLangOpts();
130 StringRef Text = II->getName();
131 // Do not warn on keyword undef. It is generally harmless and widely used.
132 if (isReservedId(Text, Lang))
133 return MD_ReservedMacro;
137 // Return true if we want to issue a diagnostic by default if we
138 // encounter this name in a #include with the wrong case. For now,
139 // this includes the standard C and C++ headers, Posix headers,
140 // and Boost headers. Improper case for these #includes is a
141 // potential portability issue.
142 static bool warnByDefaultOnWrongCase(StringRef Include) {
143 // If the first component of the path is "boost", treat this like a standard header
144 // for the purposes of diagnostics.
145 if (::llvm::sys::path::begin(Include)->equals_lower("boost"))
148 // "condition_variable" is the longest standard header name at 18 characters.
149 // If the include file name is longer than that, it can't be a standard header.
150 static const size_t MaxStdHeaderNameLen = 18u;
151 if (Include.size() > MaxStdHeaderNameLen)
154 // Lowercase and normalize the search string.
155 SmallString<32> LowerInclude{Include};
156 for (char &Ch : LowerInclude) {
157 // In the ASCII range?
158 if (static_cast<unsigned char>(Ch) > 0x7f)
159 return false; // Can't be a standard header
161 if (Ch >= 'A' && Ch <= 'Z')
163 // Normalize path separators for comparison purposes.
164 else if (::llvm::sys::path::is_separator(Ch))
168 // The standard C/C++ and Posix headers
169 return llvm::StringSwitch<bool>(LowerInclude)
171 .Cases("assert.h", "complex.h", "ctype.h", "errno.h", "fenv.h", true)
172 .Cases("float.h", "inttypes.h", "iso646.h", "limits.h", "locale.h", true)
173 .Cases("math.h", "setjmp.h", "signal.h", "stdalign.h", "stdarg.h", true)
174 .Cases("stdatomic.h", "stdbool.h", "stddef.h", "stdint.h", "stdio.h", true)
175 .Cases("stdlib.h", "stdnoreturn.h", "string.h", "tgmath.h", "threads.h", true)
176 .Cases("time.h", "uchar.h", "wchar.h", "wctype.h", true)
178 // C++ headers for C library facilities
179 .Cases("cassert", "ccomplex", "cctype", "cerrno", "cfenv", true)
180 .Cases("cfloat", "cinttypes", "ciso646", "climits", "clocale", true)
181 .Cases("cmath", "csetjmp", "csignal", "cstdalign", "cstdarg", true)
182 .Cases("cstdbool", "cstddef", "cstdint", "cstdio", "cstdlib", true)
183 .Cases("cstring", "ctgmath", "ctime", "cuchar", "cwchar", true)
184 .Case("cwctype", true)
186 // C++ library headers
187 .Cases("algorithm", "fstream", "list", "regex", "thread", true)
188 .Cases("array", "functional", "locale", "scoped_allocator", "tuple", true)
189 .Cases("atomic", "future", "map", "set", "type_traits", true)
190 .Cases("bitset", "initializer_list", "memory", "shared_mutex", "typeindex", true)
191 .Cases("chrono", "iomanip", "mutex", "sstream", "typeinfo", true)
192 .Cases("codecvt", "ios", "new", "stack", "unordered_map", true)
193 .Cases("complex", "iosfwd", "numeric", "stdexcept", "unordered_set", true)
194 .Cases("condition_variable", "iostream", "ostream", "streambuf", "utility", true)
195 .Cases("deque", "istream", "queue", "string", "valarray", true)
196 .Cases("exception", "iterator", "random", "strstream", "vector", true)
197 .Cases("forward_list", "limits", "ratio", "system_error", true)
199 // POSIX headers (which aren't also C headers)
200 .Cases("aio.h", "arpa/inet.h", "cpio.h", "dirent.h", "dlfcn.h", true)
201 .Cases("fcntl.h", "fmtmsg.h", "fnmatch.h", "ftw.h", "glob.h", true)
202 .Cases("grp.h", "iconv.h", "langinfo.h", "libgen.h", "monetary.h", true)
203 .Cases("mqueue.h", "ndbm.h", "net/if.h", "netdb.h", "netinet/in.h", true)
204 .Cases("netinet/tcp.h", "nl_types.h", "poll.h", "pthread.h", "pwd.h", true)
205 .Cases("regex.h", "sched.h", "search.h", "semaphore.h", "spawn.h", true)
206 .Cases("strings.h", "stropts.h", "sys/ipc.h", "sys/mman.h", "sys/msg.h", true)
207 .Cases("sys/resource.h", "sys/select.h", "sys/sem.h", "sys/shm.h", "sys/socket.h", true)
208 .Cases("sys/stat.h", "sys/statvfs.h", "sys/time.h", "sys/times.h", "sys/types.h", true)
209 .Cases("sys/uio.h", "sys/un.h", "sys/utsname.h", "sys/wait.h", "syslog.h", true)
210 .Cases("tar.h", "termios.h", "trace.h", "ulimit.h", true)
211 .Cases("unistd.h", "utime.h", "utmpx.h", "wordexp.h", true)
215 bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
217 // Missing macro name?
218 if (MacroNameTok.is(tok::eod))
219 return Diag(MacroNameTok, diag::err_pp_missing_macro_name);
221 IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
223 bool Invalid = false;
224 std::string Spelling = getSpelling(MacroNameTok, &Invalid);
226 return Diag(MacroNameTok, diag::err_pp_macro_not_identifier);
227 II = getIdentifierInfo(Spelling);
229 if (!II->isCPlusPlusOperatorKeyword())
230 return Diag(MacroNameTok, diag::err_pp_macro_not_identifier);
232 // C++ 2.5p2: Alternative tokens behave the same as its primary token
233 // except for their spellings.
234 Diag(MacroNameTok, getLangOpts().MicrosoftExt
235 ? diag::ext_pp_operator_used_as_macro_name
236 : diag::err_pp_operator_used_as_macro_name)
237 << II << MacroNameTok.getKind();
239 // Allow #defining |and| and friends for Microsoft compatibility or
240 // recovery when legacy C headers are included in C++.
241 MacroNameTok.setIdentifierInfo(II);
244 if ((isDefineUndef != MU_Other) && II->getPPKeywordID() == tok::pp_defined) {
245 // Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4.
246 return Diag(MacroNameTok, diag::err_defined_macro_name);
249 if (isDefineUndef == MU_Undef) {
250 auto *MI = getMacroInfo(II);
251 if (MI && MI->isBuiltinMacro()) {
252 // Warn if undefining "__LINE__" and other builtins, per C99 6.10.8/4
253 // and C++ [cpp.predefined]p4], but allow it as an extension.
254 Diag(MacroNameTok, diag::ext_pp_undef_builtin_macro);
258 // If defining/undefining reserved identifier or a keyword, we need to issue
260 SourceLocation MacroNameLoc = MacroNameTok.getLocation();
263 if (!SourceMgr.isInSystemHeader(MacroNameLoc) &&
264 (SourceMgr.getBufferName(MacroNameLoc) != "<built-in>")) {
265 MacroDiag D = MD_NoWarn;
266 if (isDefineUndef == MU_Define) {
267 D = shouldWarnOnMacroDef(*this, II);
269 else if (isDefineUndef == MU_Undef)
270 D = shouldWarnOnMacroUndef(*this, II);
271 if (D == MD_KeywordDef) {
272 // We do not want to warn on some patterns widely used in configuration
273 // scripts. This requires analyzing next tokens, so do not issue warnings
274 // now, only inform caller.
278 if (D == MD_ReservedMacro)
279 Diag(MacroNameTok, diag::warn_pp_macro_is_reserved_id);
282 // Okay, we got a good identifier.
286 /// \brief Lex and validate a macro name, which occurs after a
287 /// \#define or \#undef.
289 /// This sets the token kind to eod and discards the rest of the macro line if
290 /// the macro name is invalid.
292 /// \param MacroNameTok Token that is expected to be a macro name.
293 /// \param isDefineUndef Context in which macro is used.
294 /// \param ShadowFlag Points to a flag that is set if macro shadows a keyword.
295 void Preprocessor::ReadMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
297 // Read the token, don't allow macro expansion on it.
298 LexUnexpandedToken(MacroNameTok);
300 if (MacroNameTok.is(tok::code_completion)) {
302 CodeComplete->CodeCompleteMacroName(isDefineUndef == MU_Define);
303 setCodeCompletionReached();
304 LexUnexpandedToken(MacroNameTok);
307 if (!CheckMacroName(MacroNameTok, isDefineUndef, ShadowFlag))
310 // Invalid macro name, read and discard the rest of the line and set the
311 // token kind to tok::eod if necessary.
312 if (MacroNameTok.isNot(tok::eod)) {
313 MacroNameTok.setKind(tok::eod);
314 DiscardUntilEndOfDirective();
318 /// \brief Ensure that the next token is a tok::eod token.
320 /// If not, emit a diagnostic and consume up until the eod. If EnableMacros is
321 /// true, then we consider macros that expand to zero tokens as being ok.
322 void Preprocessor::CheckEndOfDirective(const char *DirType, bool EnableMacros) {
324 // Lex unexpanded tokens for most directives: macros might expand to zero
325 // tokens, causing us to miss diagnosing invalid lines. Some directives (like
326 // #line) allow empty macros.
330 LexUnexpandedToken(Tmp);
332 // There should be no tokens after the directive, but we allow them as an
334 while (Tmp.is(tok::comment)) // Skip comments in -C mode.
335 LexUnexpandedToken(Tmp);
337 if (Tmp.isNot(tok::eod)) {
338 // Add a fixit in GNU/C99/C++ mode. Don't offer a fixit for strict-C89,
339 // or if this is a macro-style preprocessing directive, because it is more
340 // trouble than it is worth to insert /**/ and check that there is no /**/
341 // in the range also.
343 if ((LangOpts.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) &&
345 Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//");
346 Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint;
347 DiscardUntilEndOfDirective();
351 /// SkipExcludedConditionalBlock - We just read a \#if or related directive and
352 /// decided that the subsequent tokens are in the \#if'd out portion of the
353 /// file. Lex the rest of the file, until we see an \#endif. If
354 /// FoundNonSkipPortion is true, then we have already emitted code for part of
355 /// this \#if directive, so \#else/\#elif blocks should never be entered.
356 /// If ElseOk is true, then \#else directives are ok, if not, then we have
357 /// already seen one so a \#else directive is a duplicate. When this returns,
358 /// the caller can lex the first valid token.
359 void Preprocessor::SkipExcludedConditionalBlock(SourceLocation IfTokenLoc,
360 bool FoundNonSkipPortion,
362 SourceLocation ElseLoc) {
364 assert(!CurTokenLexer && CurPPLexer && "Lexing a macro, not a file?");
366 CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/false,
367 FoundNonSkipPortion, FoundElse);
370 PTHSkipExcludedConditionalBlock();
374 // Enter raw mode to disable identifier lookup (and thus macro expansion),
375 // disabling warnings, etc.
376 CurPPLexer->LexingRawMode = true;
381 if (Tok.is(tok::code_completion)) {
383 CodeComplete->CodeCompleteInConditionalExclusion();
384 setCodeCompletionReached();
388 // If this is the end of the buffer, we have an error.
389 if (Tok.is(tok::eof)) {
390 // Emit errors for each unterminated conditional on the stack, including
392 while (!CurPPLexer->ConditionalStack.empty()) {
393 if (CurLexer->getFileLoc() != CodeCompletionFileLoc)
394 Diag(CurPPLexer->ConditionalStack.back().IfLoc,
395 diag::err_pp_unterminated_conditional);
396 CurPPLexer->ConditionalStack.pop_back();
399 // Just return and let the caller lex after this #include.
403 // If this token is not a preprocessor directive, just skip it.
404 if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine())
407 // We just parsed a # character at the start of a line, so we're in
408 // directive mode. Tell the lexer this so any newlines we see will be
409 // converted into an EOD token (this terminates the macro).
410 CurPPLexer->ParsingPreprocessorDirective = true;
411 if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);
414 // Read the next token, the directive flavor.
415 LexUnexpandedToken(Tok);
417 // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or
418 // something bogus), skip it.
419 if (Tok.isNot(tok::raw_identifier)) {
420 CurPPLexer->ParsingPreprocessorDirective = false;
421 // Restore comment saving mode.
422 if (CurLexer) CurLexer->resetExtendedTokenMode();
426 // If the first letter isn't i or e, it isn't intesting to us. We know that
427 // this is safe in the face of spelling differences, because there is no way
428 // to spell an i/e in a strange way that is another letter. Skipping this
429 // allows us to avoid looking up the identifier info for #define/#undef and
430 // other common directives.
431 StringRef RI = Tok.getRawIdentifier();
433 char FirstChar = RI[0];
434 if (FirstChar >= 'a' && FirstChar <= 'z' &&
435 FirstChar != 'i' && FirstChar != 'e') {
436 CurPPLexer->ParsingPreprocessorDirective = false;
437 // Restore comment saving mode.
438 if (CurLexer) CurLexer->resetExtendedTokenMode();
442 // Get the identifier name without trigraphs or embedded newlines. Note
443 // that we can't use Tok.getIdentifierInfo() because its lookup is disabled
445 char DirectiveBuf[20];
447 if (!Tok.needsCleaning() && RI.size() < 20) {
450 std::string DirectiveStr = getSpelling(Tok);
451 size_t IdLen = DirectiveStr.size();
453 CurPPLexer->ParsingPreprocessorDirective = false;
454 // Restore comment saving mode.
455 if (CurLexer) CurLexer->resetExtendedTokenMode();
458 memcpy(DirectiveBuf, &DirectiveStr[0], IdLen);
459 Directive = StringRef(DirectiveBuf, IdLen);
462 if (Directive.startswith("if")) {
463 StringRef Sub = Directive.substr(2);
464 if (Sub.empty() || // "if"
465 Sub == "def" || // "ifdef"
466 Sub == "ndef") { // "ifndef"
467 // We know the entire #if/#ifdef/#ifndef block will be skipped, don't
468 // bother parsing the condition.
469 DiscardUntilEndOfDirective();
470 CurPPLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true,
471 /*foundnonskip*/false,
474 } else if (Directive[0] == 'e') {
475 StringRef Sub = Directive.substr(1);
476 if (Sub == "ndif") { // "endif"
477 PPConditionalInfo CondInfo;
478 CondInfo.WasSkipping = true; // Silence bogus warning.
479 bool InCond = CurPPLexer->popConditionalLevel(CondInfo);
480 (void)InCond; // Silence warning in no-asserts mode.
481 assert(!InCond && "Can't be skipping if not in a conditional!");
483 // If we popped the outermost skipping block, we're done skipping!
484 if (!CondInfo.WasSkipping) {
485 // Restore the value of LexingRawMode so that trailing comments
486 // are handled correctly, if we've reached the outermost block.
487 CurPPLexer->LexingRawMode = false;
488 CheckEndOfDirective("endif");
489 CurPPLexer->LexingRawMode = true;
491 Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc);
494 DiscardUntilEndOfDirective();
496 } else if (Sub == "lse") { // "else".
497 // #else directive in a skipping conditional. If not in some other
498 // skipping conditional, and if #else hasn't already been seen, enter it
499 // as a non-skipping conditional.
500 PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
502 // If this is a #else with a #else before it, report the error.
503 if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_else_after_else);
505 // Note that we've seen a #else in this conditional.
506 CondInfo.FoundElse = true;
508 // If the conditional is at the top level, and the #if block wasn't
509 // entered, enter the #else block now.
510 if (!CondInfo.WasSkipping && !CondInfo.FoundNonSkip) {
511 CondInfo.FoundNonSkip = true;
512 // Restore the value of LexingRawMode so that trailing comments
513 // are handled correctly.
514 CurPPLexer->LexingRawMode = false;
515 CheckEndOfDirective("else");
516 CurPPLexer->LexingRawMode = true;
518 Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc);
521 DiscardUntilEndOfDirective(); // C99 6.10p4.
523 } else if (Sub == "lif") { // "elif".
524 PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
526 // If this is a #elif with a #else before it, report the error.
527 if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_elif_after_else);
529 // If this is in a skipping block or if we're already handled this #if
530 // block, don't bother parsing the condition.
531 if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
532 DiscardUntilEndOfDirective();
534 const SourceLocation CondBegin = CurPPLexer->getSourceLocation();
535 // Restore the value of LexingRawMode so that identifiers are
536 // looked up, etc, inside the #elif expression.
537 assert(CurPPLexer->LexingRawMode && "We have to be skipping here!");
538 CurPPLexer->LexingRawMode = false;
539 IdentifierInfo *IfNDefMacro = nullptr;
540 const bool CondValue = EvaluateDirectiveExpression(IfNDefMacro);
541 CurPPLexer->LexingRawMode = true;
543 const SourceLocation CondEnd = CurPPLexer->getSourceLocation();
544 Callbacks->Elif(Tok.getLocation(),
545 SourceRange(CondBegin, CondEnd),
546 (CondValue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False), CondInfo.IfLoc);
548 // If this condition is true, enter it!
550 CondInfo.FoundNonSkip = true;
557 CurPPLexer->ParsingPreprocessorDirective = false;
558 // Restore comment saving mode.
559 if (CurLexer) CurLexer->resetExtendedTokenMode();
562 // Finally, if we are out of the conditional (saw an #endif or ran off the end
563 // of the file, just stop skipping and return to lexing whatever came after
565 CurPPLexer->LexingRawMode = false;
568 SourceLocation BeginLoc = ElseLoc.isValid() ? ElseLoc : IfTokenLoc;
569 Callbacks->SourceRangeSkipped(SourceRange(BeginLoc, Tok.getLocation()));
573 void Preprocessor::PTHSkipExcludedConditionalBlock() {
576 assert(CurPTHLexer->LexingRawMode == false);
578 // Skip to the next '#else', '#elif', or #endif.
579 if (CurPTHLexer->SkipBlock()) {
580 // We have reached an #endif. Both the '#' and 'endif' tokens
581 // have been consumed by the PTHLexer. Just pop off the condition level.
582 PPConditionalInfo CondInfo;
583 bool InCond = CurPTHLexer->popConditionalLevel(CondInfo);
584 (void)InCond; // Silence warning in no-asserts mode.
585 assert(!InCond && "Can't be skipping if not in a conditional!");
589 // We have reached a '#else' or '#elif'. Lex the next token to get
590 // the directive flavor.
592 LexUnexpandedToken(Tok);
594 // We can actually look up the IdentifierInfo here since we aren't in
596 tok::PPKeywordKind K = Tok.getIdentifierInfo()->getPPKeywordID();
598 if (K == tok::pp_else) {
599 // #else: Enter the else condition. We aren't in a nested condition
600 // since we skip those. We're always in the one matching the last
601 // blocked we skipped.
602 PPConditionalInfo &CondInfo = CurPTHLexer->peekConditionalLevel();
603 // Note that we've seen a #else in this conditional.
604 CondInfo.FoundElse = true;
606 // If the #if block wasn't entered then enter the #else block now.
607 if (!CondInfo.FoundNonSkip) {
608 CondInfo.FoundNonSkip = true;
610 // Scan until the eod token.
611 CurPTHLexer->ParsingPreprocessorDirective = true;
612 DiscardUntilEndOfDirective();
613 CurPTHLexer->ParsingPreprocessorDirective = false;
618 // Otherwise skip this block.
622 assert(K == tok::pp_elif);
623 PPConditionalInfo &CondInfo = CurPTHLexer->peekConditionalLevel();
625 // If this is a #elif with a #else before it, report the error.
626 if (CondInfo.FoundElse)
627 Diag(Tok, diag::pp_err_elif_after_else);
629 // If this is in a skipping block or if we're already handled this #if
630 // block, don't bother parsing the condition. We just skip this block.
631 if (CondInfo.FoundNonSkip)
634 // Evaluate the condition of the #elif.
635 IdentifierInfo *IfNDefMacro = nullptr;
636 CurPTHLexer->ParsingPreprocessorDirective = true;
637 bool ShouldEnter = EvaluateDirectiveExpression(IfNDefMacro);
638 CurPTHLexer->ParsingPreprocessorDirective = false;
640 // If this condition is true, enter it!
642 CondInfo.FoundNonSkip = true;
646 // Otherwise, skip this block and go to the next one.
650 Module *Preprocessor::getModuleForLocation(SourceLocation Loc) {
651 if (!SourceMgr.isInMainFile(Loc)) {
652 // Try to determine the module of the include directive.
653 // FIXME: Look into directly passing the FileEntry from LookupFile instead.
654 FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getExpansionLoc(Loc));
655 if (const FileEntry *EntryOfIncl = SourceMgr.getFileEntryForID(IDOfIncl)) {
656 // The include comes from an included file.
657 return HeaderInfo.getModuleMap()
658 .findModuleForHeader(EntryOfIncl)
663 // This is either in the main file or not in a file at all. It belongs
664 // to the current module, if there is one.
665 return getLangOpts().CurrentModule.empty()
667 : HeaderInfo.lookupModule(getLangOpts().CurrentModule);
671 Preprocessor::getModuleHeaderToIncludeForDiagnostics(SourceLocation IncLoc,
673 SourceLocation Loc) {
674 assert(M && "no module to include");
676 // If we have a module import syntax, we shouldn't include a header to
677 // make a particular module visible.
678 if (getLangOpts().ObjC2)
681 Module *TopM = M->getTopLevelModule();
682 Module *IncM = getModuleForLocation(IncLoc);
684 // Walk up through the include stack, looking through textual headers of M
685 // until we hit a non-textual header that we can #include. (We assume textual
686 // headers of a module with non-textual headers aren't meant to be used to
687 // import entities from the module.)
688 auto &SM = getSourceManager();
689 while (!Loc.isInvalid() && !SM.isInMainFile(Loc)) {
690 auto ID = SM.getFileID(SM.getExpansionLoc(Loc));
691 auto *FE = SM.getFileEntryForID(ID);
695 bool InTextualHeader = false;
696 for (auto Header : HeaderInfo.getModuleMap().findAllModulesForHeader(FE)) {
697 if (!Header.getModule()->isSubModuleOf(TopM))
700 if (!(Header.getRole() & ModuleMap::TextualHeader)) {
701 // If this is an accessible, non-textual header of M's top-level module
702 // that transitively includes the given location and makes the
703 // corresponding module visible, this is the thing to #include.
704 if (Header.isAccessibleFrom(IncM))
707 // It's in a private header; we can't #include it.
708 // FIXME: If there's a public header in some module that re-exports it,
709 // then we could suggest including that, but it's not clear that's the
710 // expected way to make this entity visible.
714 InTextualHeader = true;
717 if (!InTextualHeader)
720 Loc = SM.getIncludeLoc(ID);
726 const FileEntry *Preprocessor::LookupFile(
727 SourceLocation FilenameLoc, StringRef Filename, bool isAngled,
728 const DirectoryLookup *FromDir, const FileEntry *FromFile,
729 const DirectoryLookup *&CurDir, SmallVectorImpl<char> *SearchPath,
730 SmallVectorImpl<char> *RelativePath,
731 ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped, bool SkipCache) {
732 Module *RequestingModule = getModuleForLocation(FilenameLoc);
733 bool RequestingModuleIsModuleInterface = !SourceMgr.isInMainFile(FilenameLoc);
735 // If the header lookup mechanism may be relative to the current inclusion
736 // stack, record the parent #includes.
737 SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 16>
739 bool BuildSystemModule = false;
740 if (!FromDir && !FromFile) {
741 FileID FID = getCurrentFileLexer()->getFileID();
742 const FileEntry *FileEnt = SourceMgr.getFileEntryForID(FID);
744 // If there is no file entry associated with this file, it must be the
745 // predefines buffer or the module includes buffer. Any other file is not
746 // lexed with a normal lexer, so it won't be scanned for preprocessor
749 // If we have the predefines buffer, resolve #include references (which come
750 // from the -include command line argument) from the current working
751 // directory instead of relative to the main file.
753 // If we have the module includes buffer, resolve #include references (which
754 // come from header declarations in the module map) relative to the module
757 if (FID == SourceMgr.getMainFileID() && MainFileDir) {
758 Includers.push_back(std::make_pair(nullptr, MainFileDir));
759 BuildSystemModule = getCurrentModule()->IsSystem;
760 } else if ((FileEnt =
761 SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())))
762 Includers.push_back(std::make_pair(FileEnt, FileMgr.getDirectory(".")));
764 Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
767 // MSVC searches the current include stack from top to bottom for
768 // headers included by quoted include directives.
769 // See: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx
770 if (LangOpts.MSVCCompat && !isAngled) {
771 for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {
772 if (IsFileLexer(ISEntry))
773 if ((FileEnt = ISEntry.ThePPLexer->getFileEntry()))
774 Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
779 CurDir = CurDirLookup;
782 // We're supposed to start looking from after a particular file. Search
783 // the include path until we find that file or run out of files.
784 const DirectoryLookup *TmpCurDir = CurDir;
785 const DirectoryLookup *TmpFromDir = nullptr;
786 while (const FileEntry *FE = HeaderInfo.LookupFile(
787 Filename, FilenameLoc, isAngled, TmpFromDir, TmpCurDir,
788 Includers, SearchPath, RelativePath, RequestingModule,
789 SuggestedModule, /*IsMapped=*/nullptr, SkipCache)) {
790 // Keep looking as if this file did a #include_next.
791 TmpFromDir = TmpCurDir;
793 if (FE == FromFile) {
795 FromDir = TmpFromDir;
802 // Do a standard file entry lookup.
803 const FileEntry *FE = HeaderInfo.LookupFile(
804 Filename, FilenameLoc, isAngled, FromDir, CurDir, Includers, SearchPath,
805 RelativePath, RequestingModule, SuggestedModule, IsMapped, SkipCache,
808 if (SuggestedModule && !LangOpts.AsmPreprocessor)
809 HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
810 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,
815 const FileEntry *CurFileEnt;
816 // Otherwise, see if this is a subframework header. If so, this is relative
817 // to one of the headers on the #include stack. Walk the list of the current
818 // headers on the #include stack and pass them to HeaderInfo.
820 if ((CurFileEnt = CurPPLexer->getFileEntry())) {
821 if ((FE = HeaderInfo.LookupSubframeworkHeader(Filename, CurFileEnt,
822 SearchPath, RelativePath,
825 if (SuggestedModule && !LangOpts.AsmPreprocessor)
826 HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
827 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,
834 for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {
835 if (IsFileLexer(ISEntry)) {
836 if ((CurFileEnt = ISEntry.ThePPLexer->getFileEntry())) {
837 if ((FE = HeaderInfo.LookupSubframeworkHeader(
838 Filename, CurFileEnt, SearchPath, RelativePath,
839 RequestingModule, SuggestedModule))) {
840 if (SuggestedModule && !LangOpts.AsmPreprocessor)
841 HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
842 RequestingModule, RequestingModuleIsModuleInterface,
843 FilenameLoc, Filename, FE);
850 // Otherwise, we really couldn't find the file.
854 //===----------------------------------------------------------------------===//
855 // Preprocessor Directive Handling.
856 //===----------------------------------------------------------------------===//
858 class Preprocessor::ResetMacroExpansionHelper {
860 ResetMacroExpansionHelper(Preprocessor *pp)
861 : PP(pp), save(pp->DisableMacroExpansion) {
862 if (pp->MacroExpansionInDirectivesOverride)
863 pp->DisableMacroExpansion = false;
866 ~ResetMacroExpansionHelper() {
867 PP->DisableMacroExpansion = save;
875 /// HandleDirective - This callback is invoked when the lexer sees a # token
876 /// at the start of a line. This consumes the directive, modifies the
877 /// lexer/preprocessor state, and advances the lexer(s) so that the next token
878 /// read is the correct one.
879 void Preprocessor::HandleDirective(Token &Result) {
880 // FIXME: Traditional: # with whitespace before it not recognized by K&R?
882 // We just parsed a # character at the start of a line, so we're in directive
883 // mode. Tell the lexer this so any newlines we see will be converted into an
884 // EOD token (which terminates the directive).
885 CurPPLexer->ParsingPreprocessorDirective = true;
886 if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);
888 bool ImmediatelyAfterTopLevelIfndef =
889 CurPPLexer->MIOpt.getImmediatelyAfterTopLevelIfndef();
890 CurPPLexer->MIOpt.resetImmediatelyAfterTopLevelIfndef();
894 // We are about to read a token. For the multiple-include optimization FA to
895 // work, we have to remember if we had read any tokens *before* this
897 bool ReadAnyTokensBeforeDirective =CurPPLexer->MIOpt.getHasReadAnyTokensVal();
899 // Save the '#' token in case we need to return it later.
900 Token SavedHash = Result;
902 // Read the next token, the directive flavor. This isn't expanded due to
904 LexUnexpandedToken(Result);
906 // C99 6.10.3p11: Is this preprocessor directive in macro invocation? e.g.:
911 // If so, the user is relying on undefined behavior, emit a diagnostic. Do
912 // not support this for #include-like directives, since that can result in
913 // terrible diagnostics, and does not work in GCC.
915 if (IdentifierInfo *II = Result.getIdentifierInfo()) {
916 switch (II->getPPKeywordID()) {
917 case tok::pp_include:
919 case tok::pp_include_next:
920 case tok::pp___include_macros:
922 Diag(Result, diag::err_embedded_directive) << II->getName();
923 DiscardUntilEndOfDirective();
929 Diag(Result, diag::ext_embedded_directive);
932 // Temporarily enable macro expansion if set so
933 // and reset to previous state when returning from this function.
934 ResetMacroExpansionHelper helper(this);
936 switch (Result.getKind()) {
938 return; // null directive.
939 case tok::code_completion:
941 CodeComplete->CodeCompleteDirective(
942 CurPPLexer->getConditionalStackDepth() > 0);
943 setCodeCompletionReached();
945 case tok::numeric_constant: // # 7 GNU line marker directive.
946 if (getLangOpts().AsmPreprocessor)
947 break; // # 4 is not a preprocessor directive in .S files.
948 return HandleDigitDirective(Result);
950 IdentifierInfo *II = Result.getIdentifierInfo();
951 if (!II) break; // Not an identifier.
953 // Ask what the preprocessor keyword ID is.
954 switch (II->getPPKeywordID()) {
956 // C99 6.10.1 - Conditional Inclusion.
958 return HandleIfDirective(Result, ReadAnyTokensBeforeDirective);
960 return HandleIfdefDirective(Result, false, true/*not valid for miopt*/);
962 return HandleIfdefDirective(Result, true, ReadAnyTokensBeforeDirective);
964 return HandleElifDirective(Result);
966 return HandleElseDirective(Result);
968 return HandleEndifDirective(Result);
970 // C99 6.10.2 - Source File Inclusion.
971 case tok::pp_include:
973 return HandleIncludeDirective(SavedHash.getLocation(), Result);
974 case tok::pp___include_macros:
976 return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result);
978 // C99 6.10.3 - Macro Replacement.
980 return HandleDefineDirective(Result, ImmediatelyAfterTopLevelIfndef);
982 return HandleUndefDirective();
984 // C99 6.10.4 - Line Control.
986 return HandleLineDirective();
988 // C99 6.10.5 - Error Directive.
990 return HandleUserDiagnosticDirective(Result, false);
992 // C99 6.10.6 - Pragma Directive.
994 return HandlePragmaDirective(SavedHash.getLocation(), PIK_HashPragma);
998 return HandleImportDirective(SavedHash.getLocation(), Result);
999 case tok::pp_include_next:
1000 return HandleIncludeNextDirective(SavedHash.getLocation(), Result);
1002 case tok::pp_warning:
1003 Diag(Result, diag::ext_pp_warning_directive);
1004 return HandleUserDiagnosticDirective(Result, true);
1006 return HandleIdentSCCSDirective(Result);
1008 return HandleIdentSCCSDirective(Result);
1009 case tok::pp_assert:
1010 //isExtension = true; // FIXME: implement #assert
1012 case tok::pp_unassert:
1013 //isExtension = true; // FIXME: implement #unassert
1016 case tok::pp___public_macro:
1017 if (getLangOpts().Modules)
1018 return HandleMacroPublicDirective(Result);
1021 case tok::pp___private_macro:
1022 if (getLangOpts().Modules)
1023 return HandleMacroPrivateDirective();
1029 // If this is a .S file, treat unknown # directives as non-preprocessor
1030 // directives. This is important because # may be a comment or introduce
1031 // various pseudo-ops. Just return the # token and push back the following
1032 // token to be lexed next time.
1033 if (getLangOpts().AsmPreprocessor) {
1034 auto Toks = llvm::make_unique<Token[]>(2);
1035 // Return the # and the token after it.
1036 Toks[0] = SavedHash;
1039 // If the second token is a hashhash token, then we need to translate it to
1040 // unknown so the token lexer doesn't try to perform token pasting.
1041 if (Result.is(tok::hashhash))
1042 Toks[1].setKind(tok::unknown);
1044 // Enter this token stream so that we re-lex the tokens. Make sure to
1045 // enable macro expansion, in case the token after the # is an identifier
1046 // that is expanded.
1047 EnterTokenStream(std::move(Toks), 2, false);
1051 // If we reached here, the preprocessing token is not valid!
1052 Diag(Result, diag::err_pp_invalid_directive);
1054 // Read the rest of the PP line.
1055 DiscardUntilEndOfDirective();
1057 // Okay, we're done parsing the directive.
1060 /// GetLineValue - Convert a numeric token into an unsigned value, emitting
1061 /// Diagnostic DiagID if it is invalid, and returning the value in Val.
1062 static bool GetLineValue(Token &DigitTok, unsigned &Val,
1063 unsigned DiagID, Preprocessor &PP,
1064 bool IsGNULineDirective=false) {
1065 if (DigitTok.isNot(tok::numeric_constant)) {
1066 PP.Diag(DigitTok, DiagID);
1068 if (DigitTok.isNot(tok::eod))
1069 PP.DiscardUntilEndOfDirective();
1073 SmallString<64> IntegerBuffer;
1074 IntegerBuffer.resize(DigitTok.getLength());
1075 const char *DigitTokBegin = &IntegerBuffer[0];
1076 bool Invalid = false;
1077 unsigned ActualLength = PP.getSpelling(DigitTok, DigitTokBegin, &Invalid);
1081 // Verify that we have a simple digit-sequence, and compute the value. This
1082 // is always a simple digit string computed in decimal, so we do this manually
1085 for (unsigned i = 0; i != ActualLength; ++i) {
1086 // C++1y [lex.fcon]p1:
1087 // Optional separating single quotes in a digit-sequence are ignored
1088 if (DigitTokBegin[i] == '\'')
1091 if (!isDigit(DigitTokBegin[i])) {
1092 PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i),
1093 diag::err_pp_line_digit_sequence) << IsGNULineDirective;
1094 PP.DiscardUntilEndOfDirective();
1098 unsigned NextVal = Val*10+(DigitTokBegin[i]-'0');
1099 if (NextVal < Val) { // overflow.
1100 PP.Diag(DigitTok, DiagID);
1101 PP.DiscardUntilEndOfDirective();
1107 if (DigitTokBegin[0] == '0' && Val)
1108 PP.Diag(DigitTok.getLocation(), diag::warn_pp_line_decimal)
1109 << IsGNULineDirective;
1114 /// \brief Handle a \#line directive: C99 6.10.4.
1116 /// The two acceptable forms are:
1118 /// # line digit-sequence
1119 /// # line digit-sequence "s-char-sequence"
1121 void Preprocessor::HandleLineDirective() {
1122 // Read the line # and string argument. Per C99 6.10.4p5, these tokens are
1127 // Validate the number and convert it to an unsigned.
1129 if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer,*this))
1133 Diag(DigitTok, diag::ext_pp_line_zero);
1135 // Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a
1136 // number greater than 2147483647". C90 requires that the line # be <= 32767.
1137 unsigned LineLimit = 32768U;
1138 if (LangOpts.C99 || LangOpts.CPlusPlus11)
1139 LineLimit = 2147483648U;
1140 if (LineNo >= LineLimit)
1141 Diag(DigitTok, diag::ext_pp_line_too_big) << LineLimit;
1142 else if (LangOpts.CPlusPlus11 && LineNo >= 32768U)
1143 Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big);
1145 int FilenameID = -1;
1149 // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a
1150 // string followed by eod.
1151 if (StrTok.is(tok::eod))
1153 else if (StrTok.isNot(tok::string_literal)) {
1154 Diag(StrTok, diag::err_pp_line_invalid_filename);
1155 return DiscardUntilEndOfDirective();
1156 } else if (StrTok.hasUDSuffix()) {
1157 Diag(StrTok, diag::err_invalid_string_udl);
1158 return DiscardUntilEndOfDirective();
1160 // Parse and validate the string, converting it into a unique ID.
1161 StringLiteralParser Literal(StrTok, *this);
1162 assert(Literal.isAscii() && "Didn't allow wide strings in");
1163 if (Literal.hadError)
1164 return DiscardUntilEndOfDirective();
1165 if (Literal.Pascal) {
1166 Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
1167 return DiscardUntilEndOfDirective();
1169 FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());
1171 // Verify that there is nothing after the string, other than EOD. Because
1172 // of C99 6.10.4p5, macros that expand to empty tokens are ok.
1173 CheckEndOfDirective("line", true);
1176 // Take the file kind of the file containing the #line directive. #line
1177 // directives are often used for generated sources from the same codebase, so
1178 // the new file should generally be classified the same way as the current
1179 // file. This is visible in GCC's pre-processed output, which rewrites #line
1180 // to GNU line markers.
1181 SrcMgr::CharacteristicKind FileKind =
1182 SourceMgr.getFileCharacteristic(DigitTok.getLocation());
1184 SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, false,
1188 Callbacks->FileChanged(CurPPLexer->getSourceLocation(),
1189 PPCallbacks::RenameFile, FileKind);
1192 /// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line
1193 /// marker directive.
1194 static bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit,
1195 SrcMgr::CharacteristicKind &FileKind,
1200 if (FlagTok.is(tok::eod)) return false;
1201 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))
1208 if (FlagTok.is(tok::eod)) return false;
1209 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))
1211 } else if (FlagVal == 2) {
1214 SourceManager &SM = PP.getSourceManager();
1215 // If we are leaving the current presumed file, check to make sure the
1216 // presumed include stack isn't empty!
1218 SM.getDecomposedExpansionLoc(FlagTok.getLocation()).first;
1219 PresumedLoc PLoc = SM.getPresumedLoc(FlagTok.getLocation());
1220 if (PLoc.isInvalid())
1223 // If there is no include loc (main file) or if the include loc is in a
1224 // different physical file, then we aren't in a "1" line marker flag region.
1225 SourceLocation IncLoc = PLoc.getIncludeLoc();
1226 if (IncLoc.isInvalid() ||
1227 SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) {
1228 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop);
1229 PP.DiscardUntilEndOfDirective();
1234 if (FlagTok.is(tok::eod)) return false;
1235 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))
1239 // We must have 3 if there are still flags.
1241 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
1242 PP.DiscardUntilEndOfDirective();
1246 FileKind = SrcMgr::C_System;
1249 if (FlagTok.is(tok::eod)) return false;
1250 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))
1253 // We must have 4 if there is yet another flag.
1255 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
1256 PP.DiscardUntilEndOfDirective();
1260 FileKind = SrcMgr::C_ExternCSystem;
1263 if (FlagTok.is(tok::eod)) return false;
1265 // There are no more valid flags here.
1266 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
1267 PP.DiscardUntilEndOfDirective();
1271 /// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is
1272 /// one of the following forms:
1275 /// # 42 "file" ('1' | '2')?
1276 /// # 42 "file" ('1' | '2')? '3' '4'?
1278 void Preprocessor::HandleDigitDirective(Token &DigitTok) {
1279 // Validate the number and convert it to an unsigned. GNU does not have a
1280 // line # limit other than it fit in 32-bits.
1282 if (GetLineValue(DigitTok, LineNo, diag::err_pp_linemarker_requires_integer,
1289 bool IsFileEntry = false, IsFileExit = false;
1290 int FilenameID = -1;
1291 SrcMgr::CharacteristicKind FileKind = SrcMgr::C_User;
1293 // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a
1294 // string followed by eod.
1295 if (StrTok.is(tok::eod)) {
1296 // Treat this like "#line NN", which doesn't change file characteristics.
1297 FileKind = SourceMgr.getFileCharacteristic(DigitTok.getLocation());
1298 } else if (StrTok.isNot(tok::string_literal)) {
1299 Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
1300 return DiscardUntilEndOfDirective();
1301 } else if (StrTok.hasUDSuffix()) {
1302 Diag(StrTok, diag::err_invalid_string_udl);
1303 return DiscardUntilEndOfDirective();
1305 // Parse and validate the string, converting it into a unique ID.
1306 StringLiteralParser Literal(StrTok, *this);
1307 assert(Literal.isAscii() && "Didn't allow wide strings in");
1308 if (Literal.hadError)
1309 return DiscardUntilEndOfDirective();
1310 if (Literal.Pascal) {
1311 Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
1312 return DiscardUntilEndOfDirective();
1314 FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());
1316 // If a filename was present, read any flags that are present.
1317 if (ReadLineMarkerFlags(IsFileEntry, IsFileExit, FileKind, *this))
1321 // Create a line note with this information.
1322 SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, IsFileEntry,
1323 IsFileExit, FileKind);
1325 // If the preprocessor has callbacks installed, notify them of the #line
1326 // change. This is used so that the line marker comes out in -E mode for
1329 PPCallbacks::FileChangeReason Reason = PPCallbacks::RenameFile;
1331 Reason = PPCallbacks::EnterFile;
1332 else if (IsFileExit)
1333 Reason = PPCallbacks::ExitFile;
1335 Callbacks->FileChanged(CurPPLexer->getSourceLocation(), Reason, FileKind);
1339 /// HandleUserDiagnosticDirective - Handle a #warning or #error directive.
1341 void Preprocessor::HandleUserDiagnosticDirective(Token &Tok,
1343 // PTH doesn't emit #warning or #error directives.
1345 return CurPTHLexer->DiscardToEndOfLine();
1347 // Read the rest of the line raw. We do this because we don't want macros
1348 // to be expanded and we don't require that the tokens be valid preprocessing
1349 // tokens. For example, this is allowed: "#warning ` 'foo". GCC does
1350 // collapse multiple consequtive white space between tokens, but this isn't
1351 // specified by the standard.
1352 SmallString<128> Message;
1353 CurLexer->ReadToEndOfLine(&Message);
1355 // Find the first non-whitespace character, so that we can make the
1356 // diagnostic more succinct.
1357 StringRef Msg = StringRef(Message).ltrim(' ');
1360 Diag(Tok, diag::pp_hash_warning) << Msg;
1362 Diag(Tok, diag::err_pp_hash_error) << Msg;
1365 /// HandleIdentSCCSDirective - Handle a #ident/#sccs directive.
1367 void Preprocessor::HandleIdentSCCSDirective(Token &Tok) {
1368 // Yes, this directive is an extension.
1369 Diag(Tok, diag::ext_pp_ident_directive);
1371 // Read the string argument.
1375 // If the token kind isn't a string, it's a malformed directive.
1376 if (StrTok.isNot(tok::string_literal) &&
1377 StrTok.isNot(tok::wide_string_literal)) {
1378 Diag(StrTok, diag::err_pp_malformed_ident);
1379 if (StrTok.isNot(tok::eod))
1380 DiscardUntilEndOfDirective();
1384 if (StrTok.hasUDSuffix()) {
1385 Diag(StrTok, diag::err_invalid_string_udl);
1386 return DiscardUntilEndOfDirective();
1389 // Verify that there is nothing after the string, other than EOD.
1390 CheckEndOfDirective("ident");
1393 bool Invalid = false;
1394 std::string Str = getSpelling(StrTok, &Invalid);
1396 Callbacks->Ident(Tok.getLocation(), Str);
1400 /// \brief Handle a #public directive.
1401 void Preprocessor::HandleMacroPublicDirective(Token &Tok) {
1403 ReadMacroName(MacroNameTok, MU_Undef);
1405 // Error reading macro name? If so, diagnostic already issued.
1406 if (MacroNameTok.is(tok::eod))
1409 // Check to see if this is the last token on the #__public_macro line.
1410 CheckEndOfDirective("__public_macro");
1412 IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
1413 // Okay, we finally have a valid identifier to undef.
1414 MacroDirective *MD = getLocalMacroDirective(II);
1416 // If the macro is not defined, this is an error.
1418 Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;
1422 // Note that this macro has now been exported.
1423 appendMacroDirective(II, AllocateVisibilityMacroDirective(
1424 MacroNameTok.getLocation(), /*IsPublic=*/true));
1427 /// \brief Handle a #private directive.
1428 void Preprocessor::HandleMacroPrivateDirective() {
1430 ReadMacroName(MacroNameTok, MU_Undef);
1432 // Error reading macro name? If so, diagnostic already issued.
1433 if (MacroNameTok.is(tok::eod))
1436 // Check to see if this is the last token on the #__private_macro line.
1437 CheckEndOfDirective("__private_macro");
1439 IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
1440 // Okay, we finally have a valid identifier to undef.
1441 MacroDirective *MD = getLocalMacroDirective(II);
1443 // If the macro is not defined, this is an error.
1445 Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;
1449 // Note that this macro has now been marked private.
1450 appendMacroDirective(II, AllocateVisibilityMacroDirective(
1451 MacroNameTok.getLocation(), /*IsPublic=*/false));
1454 //===----------------------------------------------------------------------===//
1455 // Preprocessor Include Directive Handling.
1456 //===----------------------------------------------------------------------===//
1458 /// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully
1459 /// checked and spelled filename, e.g. as an operand of \#include. This returns
1460 /// true if the input filename was in <>'s or false if it were in ""'s. The
1461 /// caller is expected to provide a buffer that is large enough to hold the
1462 /// spelling of the filename, but is also expected to handle the case when
1463 /// this method decides to use a different buffer.
1464 bool Preprocessor::GetIncludeFilenameSpelling(SourceLocation Loc,
1465 StringRef &Buffer) {
1466 // Get the text form of the filename.
1467 assert(!Buffer.empty() && "Can't have tokens with empty spellings!");
1469 // Make sure the filename is <x> or "x".
1471 if (Buffer[0] == '<') {
1472 if (Buffer.back() != '>') {
1473 Diag(Loc, diag::err_pp_expects_filename);
1474 Buffer = StringRef();
1478 } else if (Buffer[0] == '"') {
1479 if (Buffer.back() != '"') {
1480 Diag(Loc, diag::err_pp_expects_filename);
1481 Buffer = StringRef();
1486 Diag(Loc, diag::err_pp_expects_filename);
1487 Buffer = StringRef();
1491 // Diagnose #include "" as invalid.
1492 if (Buffer.size() <= 2) {
1493 Diag(Loc, diag::err_pp_empty_filename);
1494 Buffer = StringRef();
1498 // Skip the brackets.
1499 Buffer = Buffer.substr(1, Buffer.size()-2);
1503 // \brief Handle cases where the \#include name is expanded from a macro
1504 // as multiple tokens, which need to be glued together.
1506 // This occurs for code like:
1508 // \#define FOO <a/b.h>
1511 // because in this case, "<a/b.h>" is returned as 7 tokens, not one.
1513 // This code concatenates and consumes tokens up to the '>' token. It returns
1514 // false if the > was found, otherwise it returns true if it finds and consumes
1516 bool Preprocessor::ConcatenateIncludeName(SmallString<128> &FilenameBuffer,
1517 SourceLocation &End) {
1521 while (CurTok.isNot(tok::eod)) {
1522 End = CurTok.getLocation();
1524 // FIXME: Provide code completion for #includes.
1525 if (CurTok.is(tok::code_completion)) {
1526 setCodeCompletionReached();
1531 // Append the spelling of this token to the buffer. If there was a space
1532 // before it, add it now.
1533 if (CurTok.hasLeadingSpace())
1534 FilenameBuffer.push_back(' ');
1536 // Get the spelling of the token, directly into FilenameBuffer if possible.
1537 size_t PreAppendSize = FilenameBuffer.size();
1538 FilenameBuffer.resize(PreAppendSize+CurTok.getLength());
1540 const char *BufPtr = &FilenameBuffer[PreAppendSize];
1541 unsigned ActualLen = getSpelling(CurTok, BufPtr);
1543 // If the token was spelled somewhere else, copy it into FilenameBuffer.
1544 if (BufPtr != &FilenameBuffer[PreAppendSize])
1545 memcpy(&FilenameBuffer[PreAppendSize], BufPtr, ActualLen);
1547 // Resize FilenameBuffer to the correct size.
1548 if (CurTok.getLength() != ActualLen)
1549 FilenameBuffer.resize(PreAppendSize+ActualLen);
1551 // If we found the '>' marker, return success.
1552 if (CurTok.is(tok::greater))
1558 // If we hit the eod marker, emit an error and return true so that the caller
1559 // knows the EOD has been read.
1560 Diag(CurTok.getLocation(), diag::err_pp_expects_filename);
1564 /// \brief Push a token onto the token stream containing an annotation.
1565 void Preprocessor::EnterAnnotationToken(SourceRange Range,
1566 tok::TokenKind Kind,
1567 void *AnnotationVal) {
1568 // FIXME: Produce this as the current token directly, rather than
1569 // allocating a new token for it.
1570 auto Tok = llvm::make_unique<Token[]>(1);
1571 Tok[0].startToken();
1572 Tok[0].setKind(Kind);
1573 Tok[0].setLocation(Range.getBegin());
1574 Tok[0].setAnnotationEndLoc(Range.getEnd());
1575 Tok[0].setAnnotationValue(AnnotationVal);
1576 EnterTokenStream(std::move(Tok), 1, true);
1579 /// \brief Produce a diagnostic informing the user that a #include or similar
1580 /// was implicitly treated as a module import.
1581 static void diagnoseAutoModuleImport(
1582 Preprocessor &PP, SourceLocation HashLoc, Token &IncludeTok,
1583 ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> Path,
1584 SourceLocation PathEnd) {
1585 assert(PP.getLangOpts().ObjC2 && "no import syntax available");
1587 SmallString<128> PathString;
1588 for (size_t I = 0, N = Path.size(); I != N; ++I) {
1591 PathString += Path[I].first->getName();
1593 int IncludeKind = 0;
1595 switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) {
1596 case tok::pp_include:
1600 case tok::pp_import:
1604 case tok::pp_include_next:
1608 case tok::pp___include_macros:
1613 llvm_unreachable("unknown include directive kind");
1616 CharSourceRange ReplaceRange(SourceRange(HashLoc, PathEnd),
1617 /*IsTokenRange=*/false);
1618 PP.Diag(HashLoc, diag::warn_auto_module_import)
1619 << IncludeKind << PathString
1620 << FixItHint::CreateReplacement(ReplaceRange,
1621 ("@import " + PathString + ";").str());
1624 // Given a vector of path components and a string containing the real
1625 // path to the file, build a properly-cased replacement in the vector,
1626 // and return true if the replacement should be suggested.
1627 static bool trySimplifyPath(SmallVectorImpl<StringRef> &Components,
1628 StringRef RealPathName) {
1629 auto RealPathComponentIter = llvm::sys::path::rbegin(RealPathName);
1630 auto RealPathComponentEnd = llvm::sys::path::rend(RealPathName);
1632 bool SuggestReplacement = false;
1633 // Below is a best-effort to handle ".." in paths. It is admittedly
1634 // not 100% correct in the presence of symlinks.
1635 for (auto &Component : llvm::reverse(Components)) {
1636 if ("." == Component) {
1637 } else if (".." == Component) {
1641 } else if (RealPathComponentIter != RealPathComponentEnd) {
1642 if (Component != *RealPathComponentIter) {
1643 // If these path components differ by more than just case, then we
1644 // may be looking at symlinked paths. Bail on this diagnostic to avoid
1645 // noisy false positives.
1646 SuggestReplacement = RealPathComponentIter->equals_lower(Component);
1647 if (!SuggestReplacement)
1649 Component = *RealPathComponentIter;
1651 ++RealPathComponentIter;
1654 return SuggestReplacement;
1657 /// HandleIncludeDirective - The "\#include" tokens have just been read, read
1658 /// the file to be included from the lexer, then include it! This is a common
1659 /// routine with functionality shared between \#include, \#include_next and
1660 /// \#import. LookupFrom is set when this is a \#include_next directive, it
1661 /// specifies the file to start searching from.
1662 void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc,
1664 const DirectoryLookup *LookupFrom,
1665 const FileEntry *LookupFromFile,
1668 CurPPLexer->LexIncludeFilename(FilenameTok);
1670 // Reserve a buffer to get the spelling.
1671 SmallString<128> FilenameBuffer;
1674 SourceLocation CharEnd; // the end of this directive, in characters
1676 switch (FilenameTok.getKind()) {
1678 // If the token kind is EOD, the error has already been diagnosed.
1681 case tok::angle_string_literal:
1682 case tok::string_literal:
1683 Filename = getSpelling(FilenameTok, FilenameBuffer);
1684 End = FilenameTok.getLocation();
1685 CharEnd = End.getLocWithOffset(FilenameTok.getLength());
1689 // This could be a <foo/bar.h> file coming from a macro expansion. In this
1690 // case, glue the tokens together into FilenameBuffer and interpret those.
1691 FilenameBuffer.push_back('<');
1692 if (ConcatenateIncludeName(FilenameBuffer, End))
1693 return; // Found <eod> but no ">"? Diagnostic already emitted.
1694 Filename = FilenameBuffer;
1695 CharEnd = End.getLocWithOffset(1);
1698 Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);
1699 DiscardUntilEndOfDirective();
1703 CharSourceRange FilenameRange
1704 = CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd);
1705 StringRef OriginalFilename = Filename;
1707 GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
1708 // If GetIncludeFilenameSpelling set the start ptr to null, there was an
1710 if (Filename.empty()) {
1711 DiscardUntilEndOfDirective();
1715 // Verify that there is nothing after the filename, other than EOD. Note that
1716 // we allow macros that expand to nothing after the filename, because this
1717 // falls into the category of "#include pp-tokens new-line" specified in
1719 CheckEndOfDirective(IncludeTok.getIdentifierInfo()->getNameStart(), true);
1721 // Check that we don't have infinite #include recursion.
1722 if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) {
1723 Diag(FilenameTok, diag::err_pp_include_too_deep);
1727 // Complain about attempts to #include files in an audit pragma.
1728 if (PragmaARCCFCodeAuditedLoc.isValid()) {
1729 Diag(HashLoc, diag::err_pp_include_in_arc_cf_code_audited);
1730 Diag(PragmaARCCFCodeAuditedLoc, diag::note_pragma_entered_here);
1732 // Immediately leave the pragma.
1733 PragmaARCCFCodeAuditedLoc = SourceLocation();
1736 // Complain about attempts to #include files in an assume-nonnull pragma.
1737 if (PragmaAssumeNonNullLoc.isValid()) {
1738 Diag(HashLoc, diag::err_pp_include_in_assume_nonnull);
1739 Diag(PragmaAssumeNonNullLoc, diag::note_pragma_entered_here);
1741 // Immediately leave the pragma.
1742 PragmaAssumeNonNullLoc = SourceLocation();
1745 if (HeaderInfo.HasIncludeAliasMap()) {
1746 // Map the filename with the brackets still attached. If the name doesn't
1747 // map to anything, fall back on the filename we've already gotten the
1749 StringRef NewName = HeaderInfo.MapHeaderToIncludeAlias(OriginalFilename);
1750 if (!NewName.empty())
1754 // Search include directories.
1755 bool IsMapped = false;
1756 const DirectoryLookup *CurDir;
1757 SmallString<1024> SearchPath;
1758 SmallString<1024> RelativePath;
1759 // We get the raw path only if we have 'Callbacks' to which we later pass
1761 ModuleMap::KnownHeader SuggestedModule;
1762 SourceLocation FilenameLoc = FilenameTok.getLocation();
1763 SmallString<128> NormalizedPath;
1764 if (LangOpts.MSVCCompat) {
1765 NormalizedPath = Filename.str();
1766 #ifndef LLVM_ON_WIN32
1767 llvm::sys::path::native(NormalizedPath);
1770 const FileEntry *File = LookupFile(
1771 FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename,
1772 isAngled, LookupFrom, LookupFromFile, CurDir,
1773 Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr,
1774 &SuggestedModule, &IsMapped);
1778 // Give the clients a chance to recover.
1779 SmallString<128> RecoveryPath;
1780 if (Callbacks->FileNotFound(Filename, RecoveryPath)) {
1781 if (const DirectoryEntry *DE = FileMgr.getDirectory(RecoveryPath)) {
1782 // Add the recovery path to the list of search paths.
1783 DirectoryLookup DL(DE, SrcMgr::C_User, false);
1784 HeaderInfo.AddSearchPath(DL, isAngled);
1786 // Try the lookup again, skipping the cache.
1789 LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled,
1790 LookupFrom, LookupFromFile, CurDir, nullptr, nullptr,
1791 &SuggestedModule, &IsMapped, /*SkipCache*/ true);
1796 if (!SuppressIncludeNotFoundError) {
1797 // If the file could not be located and it was included via angle
1798 // brackets, we can attempt a lookup as though it were a quoted path to
1799 // provide the user with a possible fixit.
1803 LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, false,
1804 LookupFrom, LookupFromFile, CurDir,
1805 Callbacks ? &SearchPath : nullptr,
1806 Callbacks ? &RelativePath : nullptr, &SuggestedModule, &IsMapped);
1808 SourceRange Range(FilenameTok.getLocation(), CharEnd);
1809 Diag(FilenameTok, diag::err_pp_file_not_found_not_fatal) <<
1811 FixItHint::CreateReplacement(Range, "\"" + Filename.str() + "\"");
1815 // If the file is still not found, just go with the vanilla diagnostic
1817 Diag(FilenameTok, diag::err_pp_file_not_found) << Filename
1822 // Should we enter the source file? Set to false if either the source file is
1823 // known to have no effect beyond its effect on module visibility -- that is,
1824 // if it's got an include guard that is already defined or is a modular header
1825 // we've imported or already built.
1826 bool ShouldEnter = true;
1828 // Determine whether we should try to import the module for this #include, if
1829 // there is one. Don't do so if precompiled module support is disabled or we
1830 // are processing this module textually (because we're building the module).
1831 if (File && SuggestedModule && getLangOpts().Modules &&
1832 SuggestedModule.getModule()->getTopLevelModuleName() !=
1833 getLangOpts().CurrentModule) {
1834 // If this include corresponds to a module but that module is
1835 // unavailable, diagnose the situation and bail out.
1836 // FIXME: Remove this; loadModule does the same check (but produces
1837 // slightly worse diagnostics).
1838 if (!SuggestedModule.getModule()->isAvailable()) {
1839 Module::Requirement Requirement;
1840 Module::UnresolvedHeaderDirective MissingHeader;
1841 Module *M = SuggestedModule.getModule();
1842 // Identify the cause.
1843 (void)M->isAvailable(getLangOpts(), getTargetInfo(), Requirement,
1845 if (MissingHeader.FileNameLoc.isValid()) {
1846 Diag(MissingHeader.FileNameLoc, diag::err_module_header_missing)
1847 << MissingHeader.IsUmbrella << MissingHeader.FileName;
1849 Diag(M->DefinitionLoc, diag::err_module_unavailable)
1850 << M->getFullModuleName() << Requirement.second << Requirement.first;
1852 Diag(FilenameTok.getLocation(),
1853 diag::note_implicit_top_level_module_import_here)
1854 << M->getTopLevelModuleName();
1858 // Compute the module access path corresponding to this module.
1859 // FIXME: Should we have a second loadModule() overload to avoid this
1860 // extra lookup step?
1861 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
1862 for (Module *Mod = SuggestedModule.getModule(); Mod; Mod = Mod->Parent)
1863 Path.push_back(std::make_pair(getIdentifierInfo(Mod->Name),
1864 FilenameTok.getLocation()));
1865 std::reverse(Path.begin(), Path.end());
1867 // Warn that we're replacing the include/import with a module import.
1868 // We only do this in Objective-C, where we have a module-import syntax.
1869 if (getLangOpts().ObjC2)
1870 diagnoseAutoModuleImport(*this, HashLoc, IncludeTok, Path, CharEnd);
1872 // Load the module to import its macros. We'll make the declarations
1873 // visible when the parser gets here.
1874 // FIXME: Pass SuggestedModule in here rather than converting it to a path
1875 // and making the module loader convert it back again.
1876 ModuleLoadResult Imported = TheModuleLoader.loadModule(
1877 IncludeTok.getLocation(), Path, Module::Hidden,
1878 /*IsIncludeDirective=*/true);
1879 assert((Imported == nullptr || Imported == SuggestedModule.getModule()) &&
1880 "the imported module is different than the suggested one");
1883 ShouldEnter = false;
1884 else if (Imported.isMissingExpected()) {
1885 // We failed to find a submodule that we assumed would exist (because it
1886 // was in the directory of an umbrella header, for instance), but no
1887 // actual module containing it exists (because the umbrella header is
1888 // incomplete). Treat this as a textual inclusion.
1889 SuggestedModule = ModuleMap::KnownHeader();
1890 } else if (Imported.isConfigMismatch()) {
1891 // On a configuration mismatch, enter the header textually. We still know
1892 // that it's part of the corresponding module.
1894 // We hit an error processing the import. Bail out.
1895 if (hadModuleLoaderFatalFailure()) {
1896 // With a fatal failure in the module loader, we abort parsing.
1897 Token &Result = IncludeTok;
1899 Result.startToken();
1900 CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
1901 CurLexer->cutOffLexing();
1903 assert(CurPTHLexer && "#include but no current lexer set!");
1904 CurPTHLexer->getEOF(Result);
1911 // The #included file will be considered to be a system header if either it is
1912 // in a system include directory, or if the #includer is a system include
1914 SrcMgr::CharacteristicKind FileCharacter =
1915 SourceMgr.getFileCharacteristic(FilenameTok.getLocation());
1917 FileCharacter = std::max(HeaderInfo.getFileDirFlavor(File), FileCharacter);
1919 // Ask HeaderInfo if we should enter this #include file. If not, #including
1920 // this file will have no effect.
1921 bool SkipHeader = false;
1922 if (ShouldEnter && File &&
1923 !HeaderInfo.ShouldEnterIncludeFile(*this, File, isImport,
1924 getLangOpts().Modules,
1925 SuggestedModule.getModule())) {
1926 ShouldEnter = false;
1931 // Notify the callback object that we've seen an inclusion directive.
1932 Callbacks->InclusionDirective(
1933 HashLoc, IncludeTok,
1934 LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled,
1935 FilenameRange, File, SearchPath, RelativePath,
1936 ShouldEnter ? nullptr : SuggestedModule.getModule());
1937 if (SkipHeader && !SuggestedModule.getModule())
1938 Callbacks->FileSkipped(*File, FilenameTok, FileCharacter);
1944 // FIXME: If we have a suggested module, and we've already visited this file,
1945 // don't bother entering it again. We know it has no further effect.
1947 // Issue a diagnostic if the name of the file on disk has a different case
1948 // than the one we're about to open.
1949 const bool CheckIncludePathPortability =
1950 !IsMapped && File && !File->tryGetRealPathName().empty();
1952 if (CheckIncludePathPortability) {
1953 StringRef Name = LangOpts.MSVCCompat ? NormalizedPath.str() : Filename;
1954 StringRef RealPathName = File->tryGetRealPathName();
1955 SmallVector<StringRef, 16> Components(llvm::sys::path::begin(Name),
1956 llvm::sys::path::end(Name));
1958 if (trySimplifyPath(Components, RealPathName)) {
1959 SmallString<128> Path;
1960 Path.reserve(Name.size()+2);
1961 Path.push_back(isAngled ? '<' : '"');
1962 bool isLeadingSeparator = llvm::sys::path::is_absolute(Name);
1963 for (auto Component : Components) {
1964 if (isLeadingSeparator)
1965 isLeadingSeparator = false;
1967 Path.append(Component);
1968 // Append the separator the user used, or the close quote
1970 Path.size() <= Filename.size() ? Filename[Path.size()-1] :
1971 (isAngled ? '>' : '"'));
1973 // For user files and known standard headers, by default we issue a diagnostic.
1974 // For other system headers, we don't. They can be controlled separately.
1975 auto DiagId = (FileCharacter == SrcMgr::C_User || warnByDefaultOnWrongCase(Name)) ?
1976 diag::pp_nonportable_path : diag::pp_nonportable_system_path;
1977 SourceRange Range(FilenameTok.getLocation(), CharEnd);
1978 Diag(FilenameTok, DiagId) << Path <<
1979 FixItHint::CreateReplacement(Range, Path);
1983 // If we don't need to enter the file, stop now.
1985 // If this is a module import, make it visible if needed.
1986 if (auto *M = SuggestedModule.getModule()) {
1987 // When building a pch, -fmodule-name tells the compiler to textually
1988 // include headers in the specified module. But it is possible that
1989 // ShouldEnter is false because we are skipping the header. In that
1990 // case, We are not importing the specified module.
1991 if (SkipHeader && getLangOpts().CompilingPCH &&
1992 M->getTopLevelModuleName() == getLangOpts().CurrentModule)
1995 makeModuleVisible(M, HashLoc);
1997 if (IncludeTok.getIdentifierInfo()->getPPKeywordID() !=
1998 tok::pp___include_macros)
1999 EnterAnnotationToken(SourceRange(HashLoc, End),
2000 tok::annot_module_include, M);
2005 // Look up the file, create a File ID for it.
2006 SourceLocation IncludePos = End;
2007 // If the filename string was the result of macro expansions, set the include
2008 // position on the file where it will be included and after the expansions.
2009 if (IncludePos.isMacroID())
2010 IncludePos = SourceMgr.getExpansionRange(IncludePos).second;
2011 FileID FID = SourceMgr.createFileID(File, IncludePos, FileCharacter);
2012 assert(FID.isValid() && "Expected valid file ID");
2014 // If all is good, enter the new file!
2015 if (EnterSourceFile(FID, CurDir, FilenameTok.getLocation()))
2018 // Determine if we're switching to building a new submodule, and which one.
2019 if (auto *M = SuggestedModule.getModule()) {
2020 // When building a pch, -fmodule-name tells the compiler to textually
2021 // include headers in the specified module. We are not building the
2022 // specified module.
2023 if (getLangOpts().CompilingPCH &&
2024 M->getTopLevelModuleName() == getLangOpts().CurrentModule)
2027 assert(!CurLexerSubmodule && "should not have marked this as a module yet");
2028 CurLexerSubmodule = M;
2030 // Let the macro handling code know that any future macros are within
2031 // the new submodule.
2032 EnterSubmodule(M, HashLoc, /*ForPragma*/false);
2034 // Let the parser know that any future declarations are within the new
2036 // FIXME: There's no point doing this if we're handling a #__include_macros
2038 EnterAnnotationToken(SourceRange(HashLoc, End), tok::annot_module_begin, M);
2042 /// HandleIncludeNextDirective - Implements \#include_next.
2044 void Preprocessor::HandleIncludeNextDirective(SourceLocation HashLoc,
2045 Token &IncludeNextTok) {
2046 Diag(IncludeNextTok, diag::ext_pp_include_next_directive);
2048 // #include_next is like #include, except that we start searching after
2049 // the current found directory. If we can't do this, issue a
2051 const DirectoryLookup *Lookup = CurDirLookup;
2052 const FileEntry *LookupFromFile = nullptr;
2053 if (isInPrimaryFile() && LangOpts.IsHeaderFile) {
2054 // If the main file is a header, then it's either for PCH/AST generation,
2055 // or libclang opened it. Either way, handle it as a normal include below
2056 // and do not complain about include_next.
2057 } else if (isInPrimaryFile()) {
2059 Diag(IncludeNextTok, diag::pp_include_next_in_primary);
2060 } else if (CurLexerSubmodule) {
2061 // Start looking up in the directory *after* the one in which the current
2062 // file would be found, if any.
2063 assert(CurPPLexer && "#include_next directive in macro?");
2064 LookupFromFile = CurPPLexer->getFileEntry();
2066 } else if (!Lookup) {
2067 Diag(IncludeNextTok, diag::pp_include_next_absolute_path);
2069 // Start looking up in the next directory.
2073 return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup,
2077 /// HandleMicrosoftImportDirective - Implements \#import for Microsoft Mode
2078 void Preprocessor::HandleMicrosoftImportDirective(Token &Tok) {
2079 // The Microsoft #import directive takes a type library and generates header
2080 // files from it, and includes those. This is beyond the scope of what clang
2081 // does, so we ignore it and error out. However, #import can optionally have
2082 // trailing attributes that span multiple lines. We're going to eat those
2083 // so we can continue processing from there.
2084 Diag(Tok, diag::err_pp_import_directive_ms );
2086 // Read tokens until we get to the end of the directive. Note that the
2087 // directive can be split over multiple lines using the backslash character.
2088 DiscardUntilEndOfDirective();
2091 /// HandleImportDirective - Implements \#import.
2093 void Preprocessor::HandleImportDirective(SourceLocation HashLoc,
2095 if (!LangOpts.ObjC1) { // #import is standard for ObjC.
2096 if (LangOpts.MSVCCompat)
2097 return HandleMicrosoftImportDirective(ImportTok);
2098 Diag(ImportTok, diag::ext_pp_import_directive);
2100 return HandleIncludeDirective(HashLoc, ImportTok, nullptr, nullptr, true);
2103 /// HandleIncludeMacrosDirective - The -imacros command line option turns into a
2104 /// pseudo directive in the predefines buffer. This handles it by sucking all
2105 /// tokens through the preprocessor and discarding them (only keeping the side
2106 /// effects on the preprocessor).
2107 void Preprocessor::HandleIncludeMacrosDirective(SourceLocation HashLoc,
2108 Token &IncludeMacrosTok) {
2109 // This directive should only occur in the predefines buffer. If not, emit an
2110 // error and reject it.
2111 SourceLocation Loc = IncludeMacrosTok.getLocation();
2112 if (SourceMgr.getBufferName(Loc) != "<built-in>") {
2113 Diag(IncludeMacrosTok.getLocation(),
2114 diag::pp_include_macros_out_of_predefines);
2115 DiscardUntilEndOfDirective();
2119 // Treat this as a normal #include for checking purposes. If this is
2120 // successful, it will push a new lexer onto the include stack.
2121 HandleIncludeDirective(HashLoc, IncludeMacrosTok);
2126 assert(TmpTok.isNot(tok::eof) && "Didn't find end of -imacros!");
2127 } while (TmpTok.isNot(tok::hashhash));
2130 //===----------------------------------------------------------------------===//
2131 // Preprocessor Macro Directive Handling.
2132 //===----------------------------------------------------------------------===//
2134 /// ReadMacroDefinitionArgList - The ( starting an argument list of a macro
2135 /// definition has just been read. Lex the rest of the arguments and the
2136 /// closing ), updating MI with what we learn. Return true if an error occurs
2137 /// parsing the arg list.
2138 bool Preprocessor::ReadMacroDefinitionArgList(MacroInfo *MI, Token &Tok) {
2139 SmallVector<IdentifierInfo*, 32> Arguments;
2142 LexUnexpandedToken(Tok);
2143 switch (Tok.getKind()) {
2145 // Found the end of the argument list.
2146 if (Arguments.empty()) // #define FOO()
2148 // Otherwise we have #define FOO(A,)
2149 Diag(Tok, diag::err_pp_expected_ident_in_arg_list);
2151 case tok::ellipsis: // #define X(... -> C99 varargs
2153 Diag(Tok, LangOpts.CPlusPlus11 ?
2154 diag::warn_cxx98_compat_variadic_macro :
2155 diag::ext_variadic_macro);
2157 // OpenCL v1.2 s6.9.e: variadic macros are not supported.
2158 if (LangOpts.OpenCL) {
2159 Diag(Tok, diag::err_pp_opencl_variadic_macros);
2163 // Lex the token after the identifier.
2164 LexUnexpandedToken(Tok);
2165 if (Tok.isNot(tok::r_paren)) {
2166 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
2169 // Add the __VA_ARGS__ identifier as an argument.
2170 Arguments.push_back(Ident__VA_ARGS__);
2171 MI->setIsC99Varargs();
2172 MI->setArgumentList(Arguments, BP);
2174 case tok::eod: // #define X(
2175 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
2178 // Handle keywords and identifiers here to accept things like
2179 // #define Foo(for) for.
2180 IdentifierInfo *II = Tok.getIdentifierInfo();
2183 Diag(Tok, diag::err_pp_invalid_tok_in_arg_list);
2187 // If this is already used as an argument, it is used multiple times (e.g.
2189 if (std::find(Arguments.begin(), Arguments.end(), II) !=
2190 Arguments.end()) { // C99 6.10.3p6
2191 Diag(Tok, diag::err_pp_duplicate_name_in_arg_list) << II;
2195 // Add the argument to the macro info.
2196 Arguments.push_back(II);
2198 // Lex the token after the identifier.
2199 LexUnexpandedToken(Tok);
2201 switch (Tok.getKind()) {
2202 default: // #define X(A B
2203 Diag(Tok, diag::err_pp_expected_comma_in_arg_list);
2205 case tok::r_paren: // #define X(A)
2206 MI->setArgumentList(Arguments, BP);
2208 case tok::comma: // #define X(A,
2210 case tok::ellipsis: // #define X(A... -> GCC extension
2211 // Diagnose extension.
2212 Diag(Tok, diag::ext_named_variadic_macro);
2214 // Lex the token after the identifier.
2215 LexUnexpandedToken(Tok);
2216 if (Tok.isNot(tok::r_paren)) {
2217 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
2221 MI->setIsGNUVarargs();
2222 MI->setArgumentList(Arguments, BP);
2229 static bool isConfigurationPattern(Token &MacroName, MacroInfo *MI,
2230 const LangOptions &LOptions) {
2231 if (MI->getNumTokens() == 1) {
2232 const Token &Value = MI->getReplacementToken(0);
2234 // Macro that is identity, like '#define inline inline' is a valid pattern.
2235 if (MacroName.getKind() == Value.getKind())
2238 // Macro that maps a keyword to the same keyword decorated with leading/
2239 // trailing underscores is a valid pattern:
2240 // #define inline __inline
2241 // #define inline __inline__
2242 // #define inline _inline (in MS compatibility mode)
2243 StringRef MacroText = MacroName.getIdentifierInfo()->getName();
2244 if (IdentifierInfo *II = Value.getIdentifierInfo()) {
2245 if (!II->isKeyword(LOptions))
2247 StringRef ValueText = II->getName();
2248 StringRef TrimmedValue = ValueText;
2249 if (!ValueText.startswith("__")) {
2250 if (ValueText.startswith("_"))
2251 TrimmedValue = TrimmedValue.drop_front(1);
2255 TrimmedValue = TrimmedValue.drop_front(2);
2256 if (TrimmedValue.endswith("__"))
2257 TrimmedValue = TrimmedValue.drop_back(2);
2259 return TrimmedValue.equals(MacroText);
2266 return MacroName.isOneOf(tok::kw_extern, tok::kw_inline, tok::kw_static,
2268 MI->getNumTokens() == 0;
2271 /// HandleDefineDirective - Implements \#define. This consumes the entire macro
2272 /// line then lets the caller lex the next real token.
2273 void Preprocessor::HandleDefineDirective(Token &DefineTok,
2274 bool ImmediatelyAfterHeaderGuard) {
2278 bool MacroShadowsKeyword;
2279 ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword);
2281 // Error reading macro name? If so, diagnostic already issued.
2282 if (MacroNameTok.is(tok::eod))
2285 Token LastTok = MacroNameTok;
2287 // If we are supposed to keep comments in #defines, reenable comment saving
2289 if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments);
2291 // Create the new macro.
2292 MacroInfo *MI = AllocateMacroInfo(MacroNameTok.getLocation());
2295 LexUnexpandedToken(Tok);
2297 // If this is a function-like macro definition, parse the argument list,
2298 // marking each of the identifiers as being used as macro arguments. Also,
2299 // check other constraints on the first token of the macro body.
2300 if (Tok.is(tok::eod)) {
2301 if (ImmediatelyAfterHeaderGuard) {
2302 // Save this macro information since it may part of a header guard.
2303 CurPPLexer->MIOpt.SetDefinedMacro(MacroNameTok.getIdentifierInfo(),
2304 MacroNameTok.getLocation());
2306 // If there is no body to this macro, we have no special handling here.
2307 } else if (Tok.hasLeadingSpace()) {
2308 // This is a normal token with leading space. Clear the leading space
2309 // marker on the first token to get proper expansion.
2310 Tok.clearFlag(Token::LeadingSpace);
2311 } else if (Tok.is(tok::l_paren)) {
2312 // This is a function-like macro definition. Read the argument list.
2313 MI->setIsFunctionLike();
2314 if (ReadMacroDefinitionArgList(MI, LastTok)) {
2315 // Throw away the rest of the line.
2316 if (CurPPLexer->ParsingPreprocessorDirective)
2317 DiscardUntilEndOfDirective();
2321 // If this is a definition of a variadic C99 function-like macro, not using
2322 // the GNU named varargs extension, enabled __VA_ARGS__.
2324 // "Poison" __VA_ARGS__, which can only appear in the expansion of a macro.
2325 // This gets unpoisoned where it is allowed.
2326 assert(Ident__VA_ARGS__->isPoisoned() && "__VA_ARGS__ should be poisoned!");
2327 if (MI->isC99Varargs())
2328 Ident__VA_ARGS__->setIsPoisoned(false);
2330 // Read the first token after the arg list for down below.
2331 LexUnexpandedToken(Tok);
2332 } else if (LangOpts.C99 || LangOpts.CPlusPlus11) {
2333 // C99 requires whitespace between the macro definition and the body. Emit
2334 // a diagnostic for something like "#define X+".
2335 Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name);
2337 // C90 6.8 TC1 says: "In the definition of an object-like macro, if the
2338 // first character of a replacement list is not a character required by
2339 // subclause 5.2.1, then there shall be white-space separation between the
2340 // identifier and the replacement list.". 5.2.1 lists this set:
2341 // "A-Za-z0-9!"#%&'()*+,_./:;<=>?[\]^_{|}~" as well as whitespace, which
2342 // is irrelevant here.
2343 bool isInvalid = false;
2344 if (Tok.is(tok::at)) // @ is not in the list above.
2346 else if (Tok.is(tok::unknown)) {
2347 // If we have an unknown token, it is something strange like "`". Since
2348 // all of valid characters would have lexed into a single character
2349 // token of some sort, we know this is not a valid case.
2353 Diag(Tok, diag::ext_missing_whitespace_after_macro_name);
2355 Diag(Tok, diag::warn_missing_whitespace_after_macro_name);
2358 if (!Tok.is(tok::eod))
2361 // Read the rest of the macro body.
2362 if (MI->isObjectLike()) {
2363 // Object-like macros are very simple, just read their body.
2364 while (Tok.isNot(tok::eod)) {
2366 MI->AddTokenToBody(Tok);
2367 // Get the next token of the macro.
2368 LexUnexpandedToken(Tok);
2371 // Otherwise, read the body of a function-like macro. While we are at it,
2372 // check C99 6.10.3.2p1: ensure that # operators are followed by macro
2373 // parameters in function-like macro expansions.
2374 while (Tok.isNot(tok::eod)) {
2377 if (!Tok.isOneOf(tok::hash, tok::hashat, tok::hashhash)) {
2378 MI->AddTokenToBody(Tok);
2380 // Get the next token of the macro.
2381 LexUnexpandedToken(Tok);
2385 // If we're in -traditional mode, then we should ignore stringification
2386 // and token pasting. Mark the tokens as unknown so as not to confuse
2388 if (getLangOpts().TraditionalCPP) {
2389 Tok.setKind(tok::unknown);
2390 MI->AddTokenToBody(Tok);
2392 // Get the next token of the macro.
2393 LexUnexpandedToken(Tok);
2397 if (Tok.is(tok::hashhash)) {
2398 // If we see token pasting, check if it looks like the gcc comma
2399 // pasting extension. We'll use this information to suppress
2400 // diagnostics later on.
2402 // Get the next token of the macro.
2403 LexUnexpandedToken(Tok);
2405 if (Tok.is(tok::eod)) {
2406 MI->AddTokenToBody(LastTok);
2410 unsigned NumTokens = MI->getNumTokens();
2411 if (NumTokens && Tok.getIdentifierInfo() == Ident__VA_ARGS__ &&
2412 MI->getReplacementToken(NumTokens-1).is(tok::comma))
2413 MI->setHasCommaPasting();
2415 // Things look ok, add the '##' token to the macro.
2416 MI->AddTokenToBody(LastTok);
2420 // Get the next token of the macro.
2421 LexUnexpandedToken(Tok);
2423 // Check for a valid macro arg identifier.
2424 if (Tok.getIdentifierInfo() == nullptr ||
2425 MI->getArgumentNum(Tok.getIdentifierInfo()) == -1) {
2427 // If this is assembler-with-cpp mode, we accept random gibberish after
2428 // the '#' because '#' is often a comment character. However, change
2429 // the kind of the token to tok::unknown so that the preprocessor isn't
2431 if (getLangOpts().AsmPreprocessor && Tok.isNot(tok::eod)) {
2432 LastTok.setKind(tok::unknown);
2433 MI->AddTokenToBody(LastTok);
2436 Diag(Tok, diag::err_pp_stringize_not_parameter)
2437 << LastTok.is(tok::hashat);
2439 // Disable __VA_ARGS__ again.
2440 Ident__VA_ARGS__->setIsPoisoned(true);
2445 // Things look ok, add the '#' and param name tokens to the macro.
2446 MI->AddTokenToBody(LastTok);
2447 MI->AddTokenToBody(Tok);
2450 // Get the next token of the macro.
2451 LexUnexpandedToken(Tok);
2455 if (MacroShadowsKeyword &&
2456 !isConfigurationPattern(MacroNameTok, MI, getLangOpts())) {
2457 Diag(MacroNameTok, diag::warn_pp_macro_hides_keyword);
2460 // Disable __VA_ARGS__ again.
2461 Ident__VA_ARGS__->setIsPoisoned(true);
2463 // Check that there is no paste (##) operator at the beginning or end of the
2464 // replacement list.
2465 unsigned NumTokens = MI->getNumTokens();
2466 if (NumTokens != 0) {
2467 if (MI->getReplacementToken(0).is(tok::hashhash)) {
2468 Diag(MI->getReplacementToken(0), diag::err_paste_at_start);
2471 if (MI->getReplacementToken(NumTokens-1).is(tok::hashhash)) {
2472 Diag(MI->getReplacementToken(NumTokens-1), diag::err_paste_at_end);
2477 MI->setDefinitionEndLoc(LastTok.getLocation());
2479 // Finally, if this identifier already had a macro defined for it, verify that
2480 // the macro bodies are identical, and issue diagnostics if they are not.
2481 if (const MacroInfo *OtherMI=getMacroInfo(MacroNameTok.getIdentifierInfo())) {
2482 // In Objective-C, ignore attempts to directly redefine the builtin
2483 // definitions of the ownership qualifiers. It's still possible to
2485 auto isObjCProtectedMacro = [](const IdentifierInfo *II) -> bool {
2486 return II->isStr("__strong") ||
2487 II->isStr("__weak") ||
2488 II->isStr("__unsafe_unretained") ||
2489 II->isStr("__autoreleasing");
2491 if (getLangOpts().ObjC1 &&
2492 SourceMgr.getFileID(OtherMI->getDefinitionLoc())
2493 == getPredefinesFileID() &&
2494 isObjCProtectedMacro(MacroNameTok.getIdentifierInfo())) {
2495 // Warn if it changes the tokens.
2496 if ((!getDiagnostics().getSuppressSystemWarnings() ||
2497 !SourceMgr.isInSystemHeader(DefineTok.getLocation())) &&
2498 !MI->isIdenticalTo(*OtherMI, *this,
2499 /*Syntactic=*/LangOpts.MicrosoftExt)) {
2500 Diag(MI->getDefinitionLoc(), diag::warn_pp_objc_macro_redef_ignored);
2502 assert(!OtherMI->isWarnIfUnused());
2506 // It is very common for system headers to have tons of macro redefinitions
2507 // and for warnings to be disabled in system headers. If this is the case,
2508 // then don't bother calling MacroInfo::isIdenticalTo.
2509 if (!getDiagnostics().getSuppressSystemWarnings() ||
2510 !SourceMgr.isInSystemHeader(DefineTok.getLocation())) {
2511 if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused())
2512 Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used);
2514 // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and
2515 // C++ [cpp.predefined]p4, but allow it as an extension.
2516 if (OtherMI->isBuiltinMacro())
2517 Diag(MacroNameTok, diag::ext_pp_redef_builtin_macro);
2518 // Macros must be identical. This means all tokens and whitespace
2519 // separation must be the same. C99 6.10.3p2.
2520 else if (!OtherMI->isAllowRedefinitionsWithoutWarning() &&
2521 !MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) {
2522 Diag(MI->getDefinitionLoc(), diag::ext_pp_macro_redef)
2523 << MacroNameTok.getIdentifierInfo();
2524 Diag(OtherMI->getDefinitionLoc(), diag::note_previous_definition);
2527 if (OtherMI->isWarnIfUnused())
2528 WarnUnusedMacroLocs.erase(OtherMI->getDefinitionLoc());
2531 DefMacroDirective *MD =
2532 appendDefMacroDirective(MacroNameTok.getIdentifierInfo(), MI);
2534 assert(!MI->isUsed());
2535 // If we need warning for not using the macro, add its location in the
2536 // warn-because-unused-macro set. If it gets used it will be removed from set.
2537 if (getSourceManager().isInMainFile(MI->getDefinitionLoc()) &&
2538 !Diags->isIgnored(diag::pp_macro_not_used, MI->getDefinitionLoc())) {
2539 MI->setIsWarnIfUnused(true);
2540 WarnUnusedMacroLocs.insert(MI->getDefinitionLoc());
2543 // If the callbacks want to know, tell them about the macro definition.
2545 Callbacks->MacroDefined(MacroNameTok, MD);
2548 /// HandleUndefDirective - Implements \#undef.
2550 void Preprocessor::HandleUndefDirective() {
2554 ReadMacroName(MacroNameTok, MU_Undef);
2556 // Error reading macro name? If so, diagnostic already issued.
2557 if (MacroNameTok.is(tok::eod))
2560 // Check to see if this is the last token on the #undef line.
2561 CheckEndOfDirective("undef");
2563 // Okay, we have a valid identifier to undef.
2564 auto *II = MacroNameTok.getIdentifierInfo();
2565 auto MD = getMacroDefinition(II);
2566 UndefMacroDirective *Undef = nullptr;
2568 // If the macro is not defined, this is a noop undef.
2569 if (const MacroInfo *MI = MD.getMacroInfo()) {
2570 if (!MI->isUsed() && MI->isWarnIfUnused())
2571 Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used);
2573 if (MI->isWarnIfUnused())
2574 WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
2576 Undef = AllocateUndefMacroDirective(MacroNameTok.getLocation());
2579 // If the callbacks want to know, tell them about the macro #undef.
2580 // Note: no matter if the macro was defined or not.
2582 Callbacks->MacroUndefined(MacroNameTok, MD, Undef);
2585 appendMacroDirective(II, Undef);
2588 //===----------------------------------------------------------------------===//
2589 // Preprocessor Conditional Directive Handling.
2590 //===----------------------------------------------------------------------===//
2592 /// HandleIfdefDirective - Implements the \#ifdef/\#ifndef directive. isIfndef
2593 /// is true when this is a \#ifndef directive. ReadAnyTokensBeforeDirective is
2594 /// true if any tokens have been returned or pp-directives activated before this
2595 /// \#ifndef has been lexed.
2597 void Preprocessor::HandleIfdefDirective(Token &Result, bool isIfndef,
2598 bool ReadAnyTokensBeforeDirective) {
2600 Token DirectiveTok = Result;
2603 ReadMacroName(MacroNameTok);
2605 // Error reading macro name? If so, diagnostic already issued.
2606 if (MacroNameTok.is(tok::eod)) {
2607 // Skip code until we get to #endif. This helps with recovery by not
2608 // emitting an error when the #endif is reached.
2609 SkipExcludedConditionalBlock(DirectiveTok.getLocation(),
2610 /*Foundnonskip*/false, /*FoundElse*/false);
2614 // Check to see if this is the last token on the #if[n]def line.
2615 CheckEndOfDirective(isIfndef ? "ifndef" : "ifdef");
2617 IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
2618 auto MD = getMacroDefinition(MII);
2619 MacroInfo *MI = MD.getMacroInfo();
2621 if (CurPPLexer->getConditionalStackDepth() == 0) {
2622 // If the start of a top-level #ifdef and if the macro is not defined,
2623 // inform MIOpt that this might be the start of a proper include guard.
2624 // Otherwise it is some other form of unknown conditional which we can't
2626 if (!ReadAnyTokensBeforeDirective && !MI) {
2627 assert(isIfndef && "#ifdef shouldn't reach here");
2628 CurPPLexer->MIOpt.EnterTopLevelIfndef(MII, MacroNameTok.getLocation());
2630 CurPPLexer->MIOpt.EnterTopLevelConditional();
2633 // If there is a macro, process it.
2634 if (MI) // Mark it used.
2635 markMacroAsUsed(MI);
2639 Callbacks->Ifndef(DirectiveTok.getLocation(), MacroNameTok, MD);
2641 Callbacks->Ifdef(DirectiveTok.getLocation(), MacroNameTok, MD);
2644 // Should we include the stuff contained by this directive?
2645 if (!MI == isIfndef) {
2646 // Yes, remember that we are inside a conditional, then lex the next token.
2647 CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),
2648 /*wasskip*/false, /*foundnonskip*/true,
2649 /*foundelse*/false);
2651 // No, skip the contents of this block.
2652 SkipExcludedConditionalBlock(DirectiveTok.getLocation(),
2653 /*Foundnonskip*/false,
2654 /*FoundElse*/false);
2658 /// HandleIfDirective - Implements the \#if directive.
2660 void Preprocessor::HandleIfDirective(Token &IfToken,
2661 bool ReadAnyTokensBeforeDirective) {
2664 // Parse and evaluate the conditional expression.
2665 IdentifierInfo *IfNDefMacro = nullptr;
2666 const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation();
2667 const bool ConditionalTrue = EvaluateDirectiveExpression(IfNDefMacro);
2668 const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation();
2670 // If this condition is equivalent to #ifndef X, and if this is the first
2671 // directive seen, handle it for the multiple-include optimization.
2672 if (CurPPLexer->getConditionalStackDepth() == 0) {
2673 if (!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue)
2674 // FIXME: Pass in the location of the macro name, not the 'if' token.
2675 CurPPLexer->MIOpt.EnterTopLevelIfndef(IfNDefMacro, IfToken.getLocation());
2677 CurPPLexer->MIOpt.EnterTopLevelConditional();
2681 Callbacks->If(IfToken.getLocation(),
2682 SourceRange(ConditionalBegin, ConditionalEnd),
2683 (ConditionalTrue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False));
2685 // Should we include the stuff contained by this directive?
2686 if (ConditionalTrue) {
2687 // Yes, remember that we are inside a conditional, then lex the next token.
2688 CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false,
2689 /*foundnonskip*/true, /*foundelse*/false);
2691 // No, skip the contents of this block.
2692 SkipExcludedConditionalBlock(IfToken.getLocation(), /*Foundnonskip*/false,
2693 /*FoundElse*/false);
2697 /// HandleEndifDirective - Implements the \#endif directive.
2699 void Preprocessor::HandleEndifDirective(Token &EndifToken) {
2702 // Check that this is the whole directive.
2703 CheckEndOfDirective("endif");
2705 PPConditionalInfo CondInfo;
2706 if (CurPPLexer->popConditionalLevel(CondInfo)) {
2707 // No conditionals on the stack: this is an #endif without an #if.
2708 Diag(EndifToken, diag::err_pp_endif_without_if);
2712 // If this the end of a top-level #endif, inform MIOpt.
2713 if (CurPPLexer->getConditionalStackDepth() == 0)
2714 CurPPLexer->MIOpt.ExitTopLevelConditional();
2716 assert(!CondInfo.WasSkipping && !CurPPLexer->LexingRawMode &&
2717 "This code should only be reachable in the non-skipping case!");
2720 Callbacks->Endif(EndifToken.getLocation(), CondInfo.IfLoc);
2723 /// HandleElseDirective - Implements the \#else directive.
2725 void Preprocessor::HandleElseDirective(Token &Result) {
2728 // #else directive in a non-skipping conditional... start skipping.
2729 CheckEndOfDirective("else");
2731 PPConditionalInfo CI;
2732 if (CurPPLexer->popConditionalLevel(CI)) {
2733 Diag(Result, diag::pp_err_else_without_if);
2737 // If this is a top-level #else, inform the MIOpt.
2738 if (CurPPLexer->getConditionalStackDepth() == 0)
2739 CurPPLexer->MIOpt.EnterTopLevelConditional();
2741 // If this is a #else with a #else before it, report the error.
2742 if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else);
2745 Callbacks->Else(Result.getLocation(), CI.IfLoc);
2747 // Finally, skip the rest of the contents of this block.
2748 SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true,
2749 /*FoundElse*/true, Result.getLocation());
2752 /// HandleElifDirective - Implements the \#elif directive.
2754 void Preprocessor::HandleElifDirective(Token &ElifToken) {
2757 // #elif directive in a non-skipping conditional... start skipping.
2758 // We don't care what the condition is, because we will always skip it (since
2759 // the block immediately before it was included).
2760 const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation();
2761 DiscardUntilEndOfDirective();
2762 const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation();
2764 PPConditionalInfo CI;
2765 if (CurPPLexer->popConditionalLevel(CI)) {
2766 Diag(ElifToken, diag::pp_err_elif_without_if);
2770 // If this is a top-level #elif, inform the MIOpt.
2771 if (CurPPLexer->getConditionalStackDepth() == 0)
2772 CurPPLexer->MIOpt.EnterTopLevelConditional();
2774 // If this is a #elif with a #else before it, report the error.
2775 if (CI.FoundElse) Diag(ElifToken, diag::pp_err_elif_after_else);
2778 Callbacks->Elif(ElifToken.getLocation(),
2779 SourceRange(ConditionalBegin, ConditionalEnd),
2780 PPCallbacks::CVK_NotEvaluated, CI.IfLoc);
2782 // Finally, skip the rest of the contents of this block.
2783 SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true,
2784 /*FoundElse*/CI.FoundElse,
2785 ElifToken.getLocation());