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/PreprocessorOptions.h"
34 #include "clang/Lex/PTHLexer.h"
35 #include "clang/Lex/Token.h"
36 #include "llvm/ADT/ArrayRef.h"
37 #include "llvm/ADT/SmallString.h"
38 #include "llvm/ADT/SmallVector.h"
39 #include "llvm/ADT/STLExtras.h"
40 #include "llvm/ADT/StringSwitch.h"
41 #include "llvm/ADT/StringRef.h"
42 #include "llvm/Support/AlignOf.h"
43 #include "llvm/Support/ErrorHandling.h"
44 #include "llvm/Support/Path.h"
52 using namespace clang;
54 //===----------------------------------------------------------------------===//
55 // Utility Methods for Preprocessor Directive Handling.
56 //===----------------------------------------------------------------------===//
58 MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) {
59 auto *MIChain = new (BP) MacroInfoChain{L, MIChainHead};
60 MIChainHead = MIChain;
64 DefMacroDirective *Preprocessor::AllocateDefMacroDirective(MacroInfo *MI,
66 return new (BP) DefMacroDirective(MI, Loc);
70 Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) {
71 return new (BP) UndefMacroDirective(UndefLoc);
74 VisibilityMacroDirective *
75 Preprocessor::AllocateVisibilityMacroDirective(SourceLocation Loc,
77 return new (BP) VisibilityMacroDirective(Loc, isPublic);
80 /// \brief Read and discard all tokens remaining on the current line until
81 /// the tok::eod token is found.
82 void Preprocessor::DiscardUntilEndOfDirective() {
85 LexUnexpandedToken(Tmp);
86 assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens");
87 } while (Tmp.isNot(tok::eod));
90 /// \brief Enumerates possible cases of #define/#undef a reserved identifier.
92 MD_NoWarn, //> Not a reserved identifier
93 MD_KeywordDef, //> Macro hides keyword, enabled by default
94 MD_ReservedMacro //> #define of #undef reserved id, disabled by default
97 /// \brief Checks if the specified identifier is reserved in the specified
99 /// This function does not check if the identifier is a keyword.
100 static bool isReservedId(StringRef Text, const LangOptions &Lang) {
101 // C++ [macro.names], C11 7.1.3:
102 // All identifiers that begin with an underscore and either an uppercase
103 // letter or another underscore are always reserved for any use.
104 if (Text.size() >= 2 && Text[0] == '_' &&
105 (isUppercase(Text[1]) || Text[1] == '_'))
107 // C++ [global.names]
108 // Each name that contains a double underscore ... is reserved to the
109 // implementation for any use.
110 if (Lang.CPlusPlus) {
111 if (Text.find("__") != StringRef::npos)
117 static MacroDiag shouldWarnOnMacroDef(Preprocessor &PP, IdentifierInfo *II) {
118 const LangOptions &Lang = PP.getLangOpts();
119 StringRef Text = II->getName();
120 if (isReservedId(Text, Lang))
121 return MD_ReservedMacro;
122 if (II->isKeyword(Lang))
123 return MD_KeywordDef;
124 if (Lang.CPlusPlus11 && (Text.equals("override") || Text.equals("final")))
125 return MD_KeywordDef;
129 static MacroDiag shouldWarnOnMacroUndef(Preprocessor &PP, IdentifierInfo *II) {
130 const LangOptions &Lang = PP.getLangOpts();
131 StringRef Text = II->getName();
132 // Do not warn on keyword undef. It is generally harmless and widely used.
133 if (isReservedId(Text, Lang))
134 return MD_ReservedMacro;
138 // Return true if we want to issue a diagnostic by default if we
139 // encounter this name in a #include with the wrong case. For now,
140 // this includes the standard C and C++ headers, Posix headers,
141 // and Boost headers. Improper case for these #includes is a
142 // potential portability issue.
143 static bool warnByDefaultOnWrongCase(StringRef Include) {
144 // If the first component of the path is "boost", treat this like a standard header
145 // for the purposes of diagnostics.
146 if (::llvm::sys::path::begin(Include)->equals_lower("boost"))
149 // "condition_variable" is the longest standard header name at 18 characters.
150 // If the include file name is longer than that, it can't be a standard header.
151 static const size_t MaxStdHeaderNameLen = 18u;
152 if (Include.size() > MaxStdHeaderNameLen)
155 // Lowercase and normalize the search string.
156 SmallString<32> LowerInclude{Include};
157 for (char &Ch : LowerInclude) {
158 // In the ASCII range?
159 if (static_cast<unsigned char>(Ch) > 0x7f)
160 return false; // Can't be a standard header
162 if (Ch >= 'A' && Ch <= 'Z')
164 // Normalize path separators for comparison purposes.
165 else if (::llvm::sys::path::is_separator(Ch))
169 // The standard C/C++ and Posix headers
170 return llvm::StringSwitch<bool>(LowerInclude)
172 .Cases("assert.h", "complex.h", "ctype.h", "errno.h", "fenv.h", true)
173 .Cases("float.h", "inttypes.h", "iso646.h", "limits.h", "locale.h", true)
174 .Cases("math.h", "setjmp.h", "signal.h", "stdalign.h", "stdarg.h", true)
175 .Cases("stdatomic.h", "stdbool.h", "stddef.h", "stdint.h", "stdio.h", true)
176 .Cases("stdlib.h", "stdnoreturn.h", "string.h", "tgmath.h", "threads.h", true)
177 .Cases("time.h", "uchar.h", "wchar.h", "wctype.h", true)
179 // C++ headers for C library facilities
180 .Cases("cassert", "ccomplex", "cctype", "cerrno", "cfenv", true)
181 .Cases("cfloat", "cinttypes", "ciso646", "climits", "clocale", true)
182 .Cases("cmath", "csetjmp", "csignal", "cstdalign", "cstdarg", true)
183 .Cases("cstdbool", "cstddef", "cstdint", "cstdio", "cstdlib", true)
184 .Cases("cstring", "ctgmath", "ctime", "cuchar", "cwchar", true)
185 .Case("cwctype", true)
187 // C++ library headers
188 .Cases("algorithm", "fstream", "list", "regex", "thread", true)
189 .Cases("array", "functional", "locale", "scoped_allocator", "tuple", true)
190 .Cases("atomic", "future", "map", "set", "type_traits", true)
191 .Cases("bitset", "initializer_list", "memory", "shared_mutex", "typeindex", true)
192 .Cases("chrono", "iomanip", "mutex", "sstream", "typeinfo", true)
193 .Cases("codecvt", "ios", "new", "stack", "unordered_map", true)
194 .Cases("complex", "iosfwd", "numeric", "stdexcept", "unordered_set", true)
195 .Cases("condition_variable", "iostream", "ostream", "streambuf", "utility", true)
196 .Cases("deque", "istream", "queue", "string", "valarray", true)
197 .Cases("exception", "iterator", "random", "strstream", "vector", true)
198 .Cases("forward_list", "limits", "ratio", "system_error", true)
200 // POSIX headers (which aren't also C headers)
201 .Cases("aio.h", "arpa/inet.h", "cpio.h", "dirent.h", "dlfcn.h", true)
202 .Cases("fcntl.h", "fmtmsg.h", "fnmatch.h", "ftw.h", "glob.h", true)
203 .Cases("grp.h", "iconv.h", "langinfo.h", "libgen.h", "monetary.h", true)
204 .Cases("mqueue.h", "ndbm.h", "net/if.h", "netdb.h", "netinet/in.h", true)
205 .Cases("netinet/tcp.h", "nl_types.h", "poll.h", "pthread.h", "pwd.h", true)
206 .Cases("regex.h", "sched.h", "search.h", "semaphore.h", "spawn.h", true)
207 .Cases("strings.h", "stropts.h", "sys/ipc.h", "sys/mman.h", "sys/msg.h", true)
208 .Cases("sys/resource.h", "sys/select.h", "sys/sem.h", "sys/shm.h", "sys/socket.h", true)
209 .Cases("sys/stat.h", "sys/statvfs.h", "sys/time.h", "sys/times.h", "sys/types.h", true)
210 .Cases("sys/uio.h", "sys/un.h", "sys/utsname.h", "sys/wait.h", "syslog.h", true)
211 .Cases("tar.h", "termios.h", "trace.h", "ulimit.h", true)
212 .Cases("unistd.h", "utime.h", "utmpx.h", "wordexp.h", true)
216 bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
218 // Missing macro name?
219 if (MacroNameTok.is(tok::eod))
220 return Diag(MacroNameTok, diag::err_pp_missing_macro_name);
222 IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
224 bool Invalid = false;
225 std::string Spelling = getSpelling(MacroNameTok, &Invalid);
227 return Diag(MacroNameTok, diag::err_pp_macro_not_identifier);
228 II = getIdentifierInfo(Spelling);
230 if (!II->isCPlusPlusOperatorKeyword())
231 return Diag(MacroNameTok, diag::err_pp_macro_not_identifier);
233 // C++ 2.5p2: Alternative tokens behave the same as its primary token
234 // except for their spellings.
235 Diag(MacroNameTok, getLangOpts().MicrosoftExt
236 ? diag::ext_pp_operator_used_as_macro_name
237 : diag::err_pp_operator_used_as_macro_name)
238 << II << MacroNameTok.getKind();
240 // Allow #defining |and| and friends for Microsoft compatibility or
241 // recovery when legacy C headers are included in C++.
242 MacroNameTok.setIdentifierInfo(II);
245 if ((isDefineUndef != MU_Other) && II->getPPKeywordID() == tok::pp_defined) {
246 // Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4.
247 return Diag(MacroNameTok, diag::err_defined_macro_name);
250 if (isDefineUndef == MU_Undef) {
251 auto *MI = getMacroInfo(II);
252 if (MI && MI->isBuiltinMacro()) {
253 // Warn if undefining "__LINE__" and other builtins, per C99 6.10.8/4
254 // and C++ [cpp.predefined]p4], but allow it as an extension.
255 Diag(MacroNameTok, diag::ext_pp_undef_builtin_macro);
259 // If defining/undefining reserved identifier or a keyword, we need to issue
261 SourceLocation MacroNameLoc = MacroNameTok.getLocation();
264 if (!SourceMgr.isInSystemHeader(MacroNameLoc) &&
265 (SourceMgr.getBufferName(MacroNameLoc) != "<built-in>")) {
266 MacroDiag D = MD_NoWarn;
267 if (isDefineUndef == MU_Define) {
268 D = shouldWarnOnMacroDef(*this, II);
270 else if (isDefineUndef == MU_Undef)
271 D = shouldWarnOnMacroUndef(*this, II);
272 if (D == MD_KeywordDef) {
273 // We do not want to warn on some patterns widely used in configuration
274 // scripts. This requires analyzing next tokens, so do not issue warnings
275 // now, only inform caller.
279 if (D == MD_ReservedMacro)
280 Diag(MacroNameTok, diag::warn_pp_macro_is_reserved_id);
283 // Okay, we got a good identifier.
287 /// \brief Lex and validate a macro name, which occurs after a
288 /// \#define or \#undef.
290 /// This sets the token kind to eod and discards the rest of the macro line if
291 /// the macro name is invalid.
293 /// \param MacroNameTok Token that is expected to be a macro name.
294 /// \param isDefineUndef Context in which macro is used.
295 /// \param ShadowFlag Points to a flag that is set if macro shadows a keyword.
296 void Preprocessor::ReadMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
298 // Read the token, don't allow macro expansion on it.
299 LexUnexpandedToken(MacroNameTok);
301 if (MacroNameTok.is(tok::code_completion)) {
303 CodeComplete->CodeCompleteMacroName(isDefineUndef == MU_Define);
304 setCodeCompletionReached();
305 LexUnexpandedToken(MacroNameTok);
308 if (!CheckMacroName(MacroNameTok, isDefineUndef, ShadowFlag))
311 // Invalid macro name, read and discard the rest of the line and set the
312 // token kind to tok::eod if necessary.
313 if (MacroNameTok.isNot(tok::eod)) {
314 MacroNameTok.setKind(tok::eod);
315 DiscardUntilEndOfDirective();
319 /// \brief Ensure that the next token is a tok::eod token.
321 /// If not, emit a diagnostic and consume up until the eod. If EnableMacros is
322 /// true, then we consider macros that expand to zero tokens as being ok.
323 void Preprocessor::CheckEndOfDirective(const char *DirType, bool EnableMacros) {
325 // Lex unexpanded tokens for most directives: macros might expand to zero
326 // tokens, causing us to miss diagnosing invalid lines. Some directives (like
327 // #line) allow empty macros.
331 LexUnexpandedToken(Tmp);
333 // There should be no tokens after the directive, but we allow them as an
335 while (Tmp.is(tok::comment)) // Skip comments in -C mode.
336 LexUnexpandedToken(Tmp);
338 if (Tmp.isNot(tok::eod)) {
339 // Add a fixit in GNU/C99/C++ mode. Don't offer a fixit for strict-C89,
340 // or if this is a macro-style preprocessing directive, because it is more
341 // trouble than it is worth to insert /**/ and check that there is no /**/
342 // in the range also.
344 if ((LangOpts.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) &&
346 Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//");
347 Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint;
348 DiscardUntilEndOfDirective();
352 /// SkipExcludedConditionalBlock - We just read a \#if or related directive and
353 /// decided that the subsequent tokens are in the \#if'd out portion of the
354 /// file. Lex the rest of the file, until we see an \#endif. If
355 /// FoundNonSkipPortion is true, then we have already emitted code for part of
356 /// this \#if directive, so \#else/\#elif blocks should never be entered.
357 /// If ElseOk is true, then \#else directives are ok, if not, then we have
358 /// already seen one so a \#else directive is a duplicate. When this returns,
359 /// the caller can lex the first valid token.
360 void Preprocessor::SkipExcludedConditionalBlock(SourceLocation IfTokenLoc,
361 bool FoundNonSkipPortion,
363 SourceLocation ElseLoc) {
365 assert(!CurTokenLexer && CurPPLexer && "Lexing a macro, not a file?");
367 CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/false,
368 FoundNonSkipPortion, FoundElse);
371 PTHSkipExcludedConditionalBlock();
375 // Enter raw mode to disable identifier lookup (and thus macro expansion),
376 // disabling warnings, etc.
377 CurPPLexer->LexingRawMode = true;
382 if (Tok.is(tok::code_completion)) {
384 CodeComplete->CodeCompleteInConditionalExclusion();
385 setCodeCompletionReached();
389 // If this is the end of the buffer, we have an error.
390 if (Tok.is(tok::eof)) {
391 // Emit errors for each unterminated conditional on the stack, including
393 while (!CurPPLexer->ConditionalStack.empty()) {
394 if (CurLexer->getFileLoc() != CodeCompletionFileLoc)
395 Diag(CurPPLexer->ConditionalStack.back().IfLoc,
396 diag::err_pp_unterminated_conditional);
397 CurPPLexer->ConditionalStack.pop_back();
400 // Just return and let the caller lex after this #include.
404 // If this token is not a preprocessor directive, just skip it.
405 if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine())
408 // We just parsed a # character at the start of a line, so we're in
409 // directive mode. Tell the lexer this so any newlines we see will be
410 // converted into an EOD token (this terminates the macro).
411 CurPPLexer->ParsingPreprocessorDirective = true;
412 if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);
415 // Read the next token, the directive flavor.
416 LexUnexpandedToken(Tok);
418 // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or
419 // something bogus), skip it.
420 if (Tok.isNot(tok::raw_identifier)) {
421 CurPPLexer->ParsingPreprocessorDirective = false;
422 // Restore comment saving mode.
423 if (CurLexer) CurLexer->resetExtendedTokenMode();
427 // If the first letter isn't i or e, it isn't intesting to us. We know that
428 // this is safe in the face of spelling differences, because there is no way
429 // to spell an i/e in a strange way that is another letter. Skipping this
430 // allows us to avoid looking up the identifier info for #define/#undef and
431 // other common directives.
432 StringRef RI = Tok.getRawIdentifier();
434 char FirstChar = RI[0];
435 if (FirstChar >= 'a' && FirstChar <= 'z' &&
436 FirstChar != 'i' && FirstChar != 'e') {
437 CurPPLexer->ParsingPreprocessorDirective = false;
438 // Restore comment saving mode.
439 if (CurLexer) CurLexer->resetExtendedTokenMode();
443 // Get the identifier name without trigraphs or embedded newlines. Note
444 // that we can't use Tok.getIdentifierInfo() because its lookup is disabled
446 char DirectiveBuf[20];
448 if (!Tok.needsCleaning() && RI.size() < 20) {
451 std::string DirectiveStr = getSpelling(Tok);
452 size_t IdLen = DirectiveStr.size();
454 CurPPLexer->ParsingPreprocessorDirective = false;
455 // Restore comment saving mode.
456 if (CurLexer) CurLexer->resetExtendedTokenMode();
459 memcpy(DirectiveBuf, &DirectiveStr[0], IdLen);
460 Directive = StringRef(DirectiveBuf, IdLen);
463 if (Directive.startswith("if")) {
464 StringRef Sub = Directive.substr(2);
465 if (Sub.empty() || // "if"
466 Sub == "def" || // "ifdef"
467 Sub == "ndef") { // "ifndef"
468 // We know the entire #if/#ifdef/#ifndef block will be skipped, don't
469 // bother parsing the condition.
470 DiscardUntilEndOfDirective();
471 CurPPLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true,
472 /*foundnonskip*/false,
475 } else if (Directive[0] == 'e') {
476 StringRef Sub = Directive.substr(1);
477 if (Sub == "ndif") { // "endif"
478 PPConditionalInfo CondInfo;
479 CondInfo.WasSkipping = true; // Silence bogus warning.
480 bool InCond = CurPPLexer->popConditionalLevel(CondInfo);
481 (void)InCond; // Silence warning in no-asserts mode.
482 assert(!InCond && "Can't be skipping if not in a conditional!");
484 // If we popped the outermost skipping block, we're done skipping!
485 if (!CondInfo.WasSkipping) {
486 // Restore the value of LexingRawMode so that trailing comments
487 // are handled correctly, if we've reached the outermost block.
488 CurPPLexer->LexingRawMode = false;
489 CheckEndOfDirective("endif");
490 CurPPLexer->LexingRawMode = true;
492 Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc);
495 DiscardUntilEndOfDirective();
497 } else if (Sub == "lse") { // "else".
498 // #else directive in a skipping conditional. If not in some other
499 // skipping conditional, and if #else hasn't already been seen, enter it
500 // as a non-skipping conditional.
501 PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
503 // If this is a #else with a #else before it, report the error.
504 if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_else_after_else);
506 // Note that we've seen a #else in this conditional.
507 CondInfo.FoundElse = true;
509 // If the conditional is at the top level, and the #if block wasn't
510 // entered, enter the #else block now.
511 if (!CondInfo.WasSkipping && !CondInfo.FoundNonSkip) {
512 CondInfo.FoundNonSkip = true;
513 // Restore the value of LexingRawMode so that trailing comments
514 // are handled correctly.
515 CurPPLexer->LexingRawMode = false;
516 CheckEndOfDirective("else");
517 CurPPLexer->LexingRawMode = true;
519 Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc);
522 DiscardUntilEndOfDirective(); // C99 6.10p4.
524 } else if (Sub == "lif") { // "elif".
525 PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
527 // If this is a #elif with a #else before it, report the error.
528 if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_elif_after_else);
530 // If this is in a skipping block or if we're already handled this #if
531 // block, don't bother parsing the condition.
532 if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
533 DiscardUntilEndOfDirective();
535 const SourceLocation CondBegin = CurPPLexer->getSourceLocation();
536 // Restore the value of LexingRawMode so that identifiers are
537 // looked up, etc, inside the #elif expression.
538 assert(CurPPLexer->LexingRawMode && "We have to be skipping here!");
539 CurPPLexer->LexingRawMode = false;
540 IdentifierInfo *IfNDefMacro = nullptr;
541 const bool CondValue = EvaluateDirectiveExpression(IfNDefMacro).Conditional;
542 CurPPLexer->LexingRawMode = true;
544 const SourceLocation CondEnd = CurPPLexer->getSourceLocation();
545 Callbacks->Elif(Tok.getLocation(),
546 SourceRange(CondBegin, CondEnd),
547 (CondValue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False), CondInfo.IfLoc);
549 // If this condition is true, enter it!
551 CondInfo.FoundNonSkip = true;
558 CurPPLexer->ParsingPreprocessorDirective = false;
559 // Restore comment saving mode.
560 if (CurLexer) CurLexer->resetExtendedTokenMode();
563 // Finally, if we are out of the conditional (saw an #endif or ran off the end
564 // of the file, just stop skipping and return to lexing whatever came after
566 CurPPLexer->LexingRawMode = false;
569 SourceLocation BeginLoc = ElseLoc.isValid() ? ElseLoc : IfTokenLoc;
570 Callbacks->SourceRangeSkipped(SourceRange(BeginLoc, Tok.getLocation()));
574 void Preprocessor::PTHSkipExcludedConditionalBlock() {
577 assert(CurPTHLexer->LexingRawMode == false);
579 // Skip to the next '#else', '#elif', or #endif.
580 if (CurPTHLexer->SkipBlock()) {
581 // We have reached an #endif. Both the '#' and 'endif' tokens
582 // have been consumed by the PTHLexer. Just pop off the condition level.
583 PPConditionalInfo CondInfo;
584 bool InCond = CurPTHLexer->popConditionalLevel(CondInfo);
585 (void)InCond; // Silence warning in no-asserts mode.
586 assert(!InCond && "Can't be skipping if not in a conditional!");
590 // We have reached a '#else' or '#elif'. Lex the next token to get
591 // the directive flavor.
593 LexUnexpandedToken(Tok);
595 // We can actually look up the IdentifierInfo here since we aren't in
597 tok::PPKeywordKind K = Tok.getIdentifierInfo()->getPPKeywordID();
599 if (K == tok::pp_else) {
600 // #else: Enter the else condition. We aren't in a nested condition
601 // since we skip those. We're always in the one matching the last
602 // blocked we skipped.
603 PPConditionalInfo &CondInfo = CurPTHLexer->peekConditionalLevel();
604 // Note that we've seen a #else in this conditional.
605 CondInfo.FoundElse = true;
607 // If the #if block wasn't entered then enter the #else block now.
608 if (!CondInfo.FoundNonSkip) {
609 CondInfo.FoundNonSkip = true;
611 // Scan until the eod token.
612 CurPTHLexer->ParsingPreprocessorDirective = true;
613 DiscardUntilEndOfDirective();
614 CurPTHLexer->ParsingPreprocessorDirective = false;
619 // Otherwise skip this block.
623 assert(K == tok::pp_elif);
624 PPConditionalInfo &CondInfo = CurPTHLexer->peekConditionalLevel();
626 // If this is a #elif with a #else before it, report the error.
627 if (CondInfo.FoundElse)
628 Diag(Tok, diag::pp_err_elif_after_else);
630 // If this is in a skipping block or if we're already handled this #if
631 // block, don't bother parsing the condition. We just skip this block.
632 if (CondInfo.FoundNonSkip)
635 // Evaluate the condition of the #elif.
636 IdentifierInfo *IfNDefMacro = nullptr;
637 CurPTHLexer->ParsingPreprocessorDirective = true;
638 bool ShouldEnter = EvaluateDirectiveExpression(IfNDefMacro).Conditional;
639 CurPTHLexer->ParsingPreprocessorDirective = false;
641 // If this condition is true, enter it!
643 CondInfo.FoundNonSkip = true;
647 // Otherwise, skip this block and go to the next one.
651 Module *Preprocessor::getModuleForLocation(SourceLocation Loc) {
652 if (!SourceMgr.isInMainFile(Loc)) {
653 // Try to determine the module of the include directive.
654 // FIXME: Look into directly passing the FileEntry from LookupFile instead.
655 FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getExpansionLoc(Loc));
656 if (const FileEntry *EntryOfIncl = SourceMgr.getFileEntryForID(IDOfIncl)) {
657 // The include comes from an included file.
658 return HeaderInfo.getModuleMap()
659 .findModuleForHeader(EntryOfIncl)
664 // This is either in the main file or not in a file at all. It belongs
665 // to the current module, if there is one.
666 return getLangOpts().CurrentModule.empty()
668 : HeaderInfo.lookupModule(getLangOpts().CurrentModule);
672 Preprocessor::getModuleHeaderToIncludeForDiagnostics(SourceLocation IncLoc,
674 SourceLocation Loc) {
675 assert(M && "no module to include");
677 // If we have a module import syntax, we shouldn't include a header to
678 // make a particular module visible.
679 if (getLangOpts().ObjC2)
682 Module *TopM = M->getTopLevelModule();
683 Module *IncM = getModuleForLocation(IncLoc);
685 // Walk up through the include stack, looking through textual headers of M
686 // until we hit a non-textual header that we can #include. (We assume textual
687 // headers of a module with non-textual headers aren't meant to be used to
688 // import entities from the module.)
689 auto &SM = getSourceManager();
690 while (!Loc.isInvalid() && !SM.isInMainFile(Loc)) {
691 auto ID = SM.getFileID(SM.getExpansionLoc(Loc));
692 auto *FE = SM.getFileEntryForID(ID);
696 bool InTextualHeader = false;
697 for (auto Header : HeaderInfo.getModuleMap().findAllModulesForHeader(FE)) {
698 if (!Header.getModule()->isSubModuleOf(TopM))
701 if (!(Header.getRole() & ModuleMap::TextualHeader)) {
702 // If this is an accessible, non-textual header of M's top-level module
703 // that transitively includes the given location and makes the
704 // corresponding module visible, this is the thing to #include.
705 if (Header.isAccessibleFrom(IncM))
708 // It's in a private header; we can't #include it.
709 // FIXME: If there's a public header in some module that re-exports it,
710 // then we could suggest including that, but it's not clear that's the
711 // expected way to make this entity visible.
715 InTextualHeader = true;
718 if (!InTextualHeader)
721 Loc = SM.getIncludeLoc(ID);
727 const FileEntry *Preprocessor::LookupFile(
728 SourceLocation FilenameLoc, StringRef Filename, bool isAngled,
729 const DirectoryLookup *FromDir, const FileEntry *FromFile,
730 const DirectoryLookup *&CurDir, SmallVectorImpl<char> *SearchPath,
731 SmallVectorImpl<char> *RelativePath,
732 ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped, bool SkipCache) {
733 Module *RequestingModule = getModuleForLocation(FilenameLoc);
734 bool RequestingModuleIsModuleInterface = !SourceMgr.isInMainFile(FilenameLoc);
736 // If the header lookup mechanism may be relative to the current inclusion
737 // stack, record the parent #includes.
738 SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 16>
740 bool BuildSystemModule = false;
741 if (!FromDir && !FromFile) {
742 FileID FID = getCurrentFileLexer()->getFileID();
743 const FileEntry *FileEnt = SourceMgr.getFileEntryForID(FID);
745 // If there is no file entry associated with this file, it must be the
746 // predefines buffer or the module includes buffer. Any other file is not
747 // lexed with a normal lexer, so it won't be scanned for preprocessor
750 // If we have the predefines buffer, resolve #include references (which come
751 // from the -include command line argument) from the current working
752 // directory instead of relative to the main file.
754 // If we have the module includes buffer, resolve #include references (which
755 // come from header declarations in the module map) relative to the module
758 if (FID == SourceMgr.getMainFileID() && MainFileDir) {
759 Includers.push_back(std::make_pair(nullptr, MainFileDir));
760 BuildSystemModule = getCurrentModule()->IsSystem;
761 } else if ((FileEnt =
762 SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())))
763 Includers.push_back(std::make_pair(FileEnt, FileMgr.getDirectory(".")));
765 Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
768 // MSVC searches the current include stack from top to bottom for
769 // headers included by quoted include directives.
770 // See: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx
771 if (LangOpts.MSVCCompat && !isAngled) {
772 for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {
773 if (IsFileLexer(ISEntry))
774 if ((FileEnt = ISEntry.ThePPLexer->getFileEntry()))
775 Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
780 CurDir = CurDirLookup;
783 // We're supposed to start looking from after a particular file. Search
784 // the include path until we find that file or run out of files.
785 const DirectoryLookup *TmpCurDir = CurDir;
786 const DirectoryLookup *TmpFromDir = nullptr;
787 while (const FileEntry *FE = HeaderInfo.LookupFile(
788 Filename, FilenameLoc, isAngled, TmpFromDir, TmpCurDir,
789 Includers, SearchPath, RelativePath, RequestingModule,
790 SuggestedModule, /*IsMapped=*/nullptr, SkipCache)) {
791 // Keep looking as if this file did a #include_next.
792 TmpFromDir = TmpCurDir;
794 if (FE == FromFile) {
796 FromDir = TmpFromDir;
803 // Do a standard file entry lookup.
804 const FileEntry *FE = HeaderInfo.LookupFile(
805 Filename, FilenameLoc, isAngled, FromDir, CurDir, Includers, SearchPath,
806 RelativePath, RequestingModule, SuggestedModule, IsMapped, SkipCache,
809 if (SuggestedModule && !LangOpts.AsmPreprocessor)
810 HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
811 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,
816 const FileEntry *CurFileEnt;
817 // Otherwise, see if this is a subframework header. If so, this is relative
818 // to one of the headers on the #include stack. Walk the list of the current
819 // headers on the #include stack and pass them to HeaderInfo.
821 if ((CurFileEnt = CurPPLexer->getFileEntry())) {
822 if ((FE = HeaderInfo.LookupSubframeworkHeader(Filename, CurFileEnt,
823 SearchPath, RelativePath,
826 if (SuggestedModule && !LangOpts.AsmPreprocessor)
827 HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
828 RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,
835 for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {
836 if (IsFileLexer(ISEntry)) {
837 if ((CurFileEnt = ISEntry.ThePPLexer->getFileEntry())) {
838 if ((FE = HeaderInfo.LookupSubframeworkHeader(
839 Filename, CurFileEnt, SearchPath, RelativePath,
840 RequestingModule, SuggestedModule))) {
841 if (SuggestedModule && !LangOpts.AsmPreprocessor)
842 HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
843 RequestingModule, RequestingModuleIsModuleInterface,
844 FilenameLoc, Filename, FE);
851 // Otherwise, we really couldn't find the file.
855 //===----------------------------------------------------------------------===//
856 // Preprocessor Directive Handling.
857 //===----------------------------------------------------------------------===//
859 class Preprocessor::ResetMacroExpansionHelper {
861 ResetMacroExpansionHelper(Preprocessor *pp)
862 : PP(pp), save(pp->DisableMacroExpansion) {
863 if (pp->MacroExpansionInDirectivesOverride)
864 pp->DisableMacroExpansion = false;
867 ~ResetMacroExpansionHelper() {
868 PP->DisableMacroExpansion = save;
876 /// HandleDirective - This callback is invoked when the lexer sees a # token
877 /// at the start of a line. This consumes the directive, modifies the
878 /// lexer/preprocessor state, and advances the lexer(s) so that the next token
879 /// read is the correct one.
880 void Preprocessor::HandleDirective(Token &Result) {
881 // FIXME: Traditional: # with whitespace before it not recognized by K&R?
883 // We just parsed a # character at the start of a line, so we're in directive
884 // mode. Tell the lexer this so any newlines we see will be converted into an
885 // EOD token (which terminates the directive).
886 CurPPLexer->ParsingPreprocessorDirective = true;
887 if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);
889 bool ImmediatelyAfterTopLevelIfndef =
890 CurPPLexer->MIOpt.getImmediatelyAfterTopLevelIfndef();
891 CurPPLexer->MIOpt.resetImmediatelyAfterTopLevelIfndef();
895 // We are about to read a token. For the multiple-include optimization FA to
896 // work, we have to remember if we had read any tokens *before* this
898 bool ReadAnyTokensBeforeDirective =CurPPLexer->MIOpt.getHasReadAnyTokensVal();
900 // Save the '#' token in case we need to return it later.
901 Token SavedHash = Result;
903 // Read the next token, the directive flavor. This isn't expanded due to
905 LexUnexpandedToken(Result);
907 // C99 6.10.3p11: Is this preprocessor directive in macro invocation? e.g.:
912 // If so, the user is relying on undefined behavior, emit a diagnostic. Do
913 // not support this for #include-like directives, since that can result in
914 // terrible diagnostics, and does not work in GCC.
916 if (IdentifierInfo *II = Result.getIdentifierInfo()) {
917 switch (II->getPPKeywordID()) {
918 case tok::pp_include:
920 case tok::pp_include_next:
921 case tok::pp___include_macros:
923 Diag(Result, diag::err_embedded_directive) << II->getName();
924 DiscardUntilEndOfDirective();
930 Diag(Result, diag::ext_embedded_directive);
933 // Temporarily enable macro expansion if set so
934 // and reset to previous state when returning from this function.
935 ResetMacroExpansionHelper helper(this);
937 switch (Result.getKind()) {
939 return; // null directive.
940 case tok::code_completion:
942 CodeComplete->CodeCompleteDirective(
943 CurPPLexer->getConditionalStackDepth() > 0);
944 setCodeCompletionReached();
946 case tok::numeric_constant: // # 7 GNU line marker directive.
947 if (getLangOpts().AsmPreprocessor)
948 break; // # 4 is not a preprocessor directive in .S files.
949 return HandleDigitDirective(Result);
951 IdentifierInfo *II = Result.getIdentifierInfo();
952 if (!II) break; // Not an identifier.
954 // Ask what the preprocessor keyword ID is.
955 switch (II->getPPKeywordID()) {
957 // C99 6.10.1 - Conditional Inclusion.
959 return HandleIfDirective(Result, ReadAnyTokensBeforeDirective);
961 return HandleIfdefDirective(Result, false, true/*not valid for miopt*/);
963 return HandleIfdefDirective(Result, true, ReadAnyTokensBeforeDirective);
965 return HandleElifDirective(Result);
967 return HandleElseDirective(Result);
969 return HandleEndifDirective(Result);
971 // C99 6.10.2 - Source File Inclusion.
972 case tok::pp_include:
974 return HandleIncludeDirective(SavedHash.getLocation(), Result);
975 case tok::pp___include_macros:
977 return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result);
979 // C99 6.10.3 - Macro Replacement.
981 return HandleDefineDirective(Result, ImmediatelyAfterTopLevelIfndef);
983 return HandleUndefDirective();
985 // C99 6.10.4 - Line Control.
987 return HandleLineDirective();
989 // C99 6.10.5 - Error Directive.
991 return HandleUserDiagnosticDirective(Result, false);
993 // C99 6.10.6 - Pragma Directive.
995 return HandlePragmaDirective(SavedHash.getLocation(), PIK_HashPragma);
999 return HandleImportDirective(SavedHash.getLocation(), Result);
1000 case tok::pp_include_next:
1001 return HandleIncludeNextDirective(SavedHash.getLocation(), Result);
1003 case tok::pp_warning:
1004 Diag(Result, diag::ext_pp_warning_directive);
1005 return HandleUserDiagnosticDirective(Result, true);
1007 return HandleIdentSCCSDirective(Result);
1009 return HandleIdentSCCSDirective(Result);
1010 case tok::pp_assert:
1011 //isExtension = true; // FIXME: implement #assert
1013 case tok::pp_unassert:
1014 //isExtension = true; // FIXME: implement #unassert
1017 case tok::pp___public_macro:
1018 if (getLangOpts().Modules)
1019 return HandleMacroPublicDirective(Result);
1022 case tok::pp___private_macro:
1023 if (getLangOpts().Modules)
1024 return HandleMacroPrivateDirective();
1030 // If this is a .S file, treat unknown # directives as non-preprocessor
1031 // directives. This is important because # may be a comment or introduce
1032 // various pseudo-ops. Just return the # token and push back the following
1033 // token to be lexed next time.
1034 if (getLangOpts().AsmPreprocessor) {
1035 auto Toks = llvm::make_unique<Token[]>(2);
1036 // Return the # and the token after it.
1037 Toks[0] = SavedHash;
1040 // If the second token is a hashhash token, then we need to translate it to
1041 // unknown so the token lexer doesn't try to perform token pasting.
1042 if (Result.is(tok::hashhash))
1043 Toks[1].setKind(tok::unknown);
1045 // Enter this token stream so that we re-lex the tokens. Make sure to
1046 // enable macro expansion, in case the token after the # is an identifier
1047 // that is expanded.
1048 EnterTokenStream(std::move(Toks), 2, false);
1052 // If we reached here, the preprocessing token is not valid!
1053 Diag(Result, diag::err_pp_invalid_directive);
1055 // Read the rest of the PP line.
1056 DiscardUntilEndOfDirective();
1058 // Okay, we're done parsing the directive.
1061 /// GetLineValue - Convert a numeric token into an unsigned value, emitting
1062 /// Diagnostic DiagID if it is invalid, and returning the value in Val.
1063 static bool GetLineValue(Token &DigitTok, unsigned &Val,
1064 unsigned DiagID, Preprocessor &PP,
1065 bool IsGNULineDirective=false) {
1066 if (DigitTok.isNot(tok::numeric_constant)) {
1067 PP.Diag(DigitTok, DiagID);
1069 if (DigitTok.isNot(tok::eod))
1070 PP.DiscardUntilEndOfDirective();
1074 SmallString<64> IntegerBuffer;
1075 IntegerBuffer.resize(DigitTok.getLength());
1076 const char *DigitTokBegin = &IntegerBuffer[0];
1077 bool Invalid = false;
1078 unsigned ActualLength = PP.getSpelling(DigitTok, DigitTokBegin, &Invalid);
1082 // Verify that we have a simple digit-sequence, and compute the value. This
1083 // is always a simple digit string computed in decimal, so we do this manually
1086 for (unsigned i = 0; i != ActualLength; ++i) {
1087 // C++1y [lex.fcon]p1:
1088 // Optional separating single quotes in a digit-sequence are ignored
1089 if (DigitTokBegin[i] == '\'')
1092 if (!isDigit(DigitTokBegin[i])) {
1093 PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i),
1094 diag::err_pp_line_digit_sequence) << IsGNULineDirective;
1095 PP.DiscardUntilEndOfDirective();
1099 unsigned NextVal = Val*10+(DigitTokBegin[i]-'0');
1100 if (NextVal < Val) { // overflow.
1101 PP.Diag(DigitTok, DiagID);
1102 PP.DiscardUntilEndOfDirective();
1108 if (DigitTokBegin[0] == '0' && Val)
1109 PP.Diag(DigitTok.getLocation(), diag::warn_pp_line_decimal)
1110 << IsGNULineDirective;
1115 /// \brief Handle a \#line directive: C99 6.10.4.
1117 /// The two acceptable forms are:
1119 /// # line digit-sequence
1120 /// # line digit-sequence "s-char-sequence"
1122 void Preprocessor::HandleLineDirective() {
1123 // Read the line # and string argument. Per C99 6.10.4p5, these tokens are
1128 // Validate the number and convert it to an unsigned.
1130 if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer,*this))
1134 Diag(DigitTok, diag::ext_pp_line_zero);
1136 // Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a
1137 // number greater than 2147483647". C90 requires that the line # be <= 32767.
1138 unsigned LineLimit = 32768U;
1139 if (LangOpts.C99 || LangOpts.CPlusPlus11)
1140 LineLimit = 2147483648U;
1141 if (LineNo >= LineLimit)
1142 Diag(DigitTok, diag::ext_pp_line_too_big) << LineLimit;
1143 else if (LangOpts.CPlusPlus11 && LineNo >= 32768U)
1144 Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big);
1146 int FilenameID = -1;
1150 // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a
1151 // string followed by eod.
1152 if (StrTok.is(tok::eod))
1154 else if (StrTok.isNot(tok::string_literal)) {
1155 Diag(StrTok, diag::err_pp_line_invalid_filename);
1156 return DiscardUntilEndOfDirective();
1157 } else if (StrTok.hasUDSuffix()) {
1158 Diag(StrTok, diag::err_invalid_string_udl);
1159 return DiscardUntilEndOfDirective();
1161 // Parse and validate the string, converting it into a unique ID.
1162 StringLiteralParser Literal(StrTok, *this);
1163 assert(Literal.isAscii() && "Didn't allow wide strings in");
1164 if (Literal.hadError)
1165 return DiscardUntilEndOfDirective();
1166 if (Literal.Pascal) {
1167 Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
1168 return DiscardUntilEndOfDirective();
1170 FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());
1172 // Verify that there is nothing after the string, other than EOD. Because
1173 // of C99 6.10.4p5, macros that expand to empty tokens are ok.
1174 CheckEndOfDirective("line", true);
1177 // Take the file kind of the file containing the #line directive. #line
1178 // directives are often used for generated sources from the same codebase, so
1179 // the new file should generally be classified the same way as the current
1180 // file. This is visible in GCC's pre-processed output, which rewrites #line
1181 // to GNU line markers.
1182 SrcMgr::CharacteristicKind FileKind =
1183 SourceMgr.getFileCharacteristic(DigitTok.getLocation());
1185 SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, false,
1189 Callbacks->FileChanged(CurPPLexer->getSourceLocation(),
1190 PPCallbacks::RenameFile, FileKind);
1193 /// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line
1194 /// marker directive.
1195 static bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit,
1196 SrcMgr::CharacteristicKind &FileKind,
1201 if (FlagTok.is(tok::eod)) return false;
1202 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))
1209 if (FlagTok.is(tok::eod)) return false;
1210 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))
1212 } else if (FlagVal == 2) {
1215 SourceManager &SM = PP.getSourceManager();
1216 // If we are leaving the current presumed file, check to make sure the
1217 // presumed include stack isn't empty!
1219 SM.getDecomposedExpansionLoc(FlagTok.getLocation()).first;
1220 PresumedLoc PLoc = SM.getPresumedLoc(FlagTok.getLocation());
1221 if (PLoc.isInvalid())
1224 // If there is no include loc (main file) or if the include loc is in a
1225 // different physical file, then we aren't in a "1" line marker flag region.
1226 SourceLocation IncLoc = PLoc.getIncludeLoc();
1227 if (IncLoc.isInvalid() ||
1228 SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) {
1229 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop);
1230 PP.DiscardUntilEndOfDirective();
1235 if (FlagTok.is(tok::eod)) return false;
1236 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))
1240 // We must have 3 if there are still flags.
1242 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
1243 PP.DiscardUntilEndOfDirective();
1247 FileKind = SrcMgr::C_System;
1250 if (FlagTok.is(tok::eod)) return false;
1251 if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))
1254 // We must have 4 if there is yet another flag.
1256 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
1257 PP.DiscardUntilEndOfDirective();
1261 FileKind = SrcMgr::C_ExternCSystem;
1264 if (FlagTok.is(tok::eod)) return false;
1266 // There are no more valid flags here.
1267 PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
1268 PP.DiscardUntilEndOfDirective();
1272 /// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is
1273 /// one of the following forms:
1276 /// # 42 "file" ('1' | '2')?
1277 /// # 42 "file" ('1' | '2')? '3' '4'?
1279 void Preprocessor::HandleDigitDirective(Token &DigitTok) {
1280 // Validate the number and convert it to an unsigned. GNU does not have a
1281 // line # limit other than it fit in 32-bits.
1283 if (GetLineValue(DigitTok, LineNo, diag::err_pp_linemarker_requires_integer,
1290 bool IsFileEntry = false, IsFileExit = false;
1291 int FilenameID = -1;
1292 SrcMgr::CharacteristicKind FileKind = SrcMgr::C_User;
1294 // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a
1295 // string followed by eod.
1296 if (StrTok.is(tok::eod)) {
1297 // Treat this like "#line NN", which doesn't change file characteristics.
1298 FileKind = SourceMgr.getFileCharacteristic(DigitTok.getLocation());
1299 } else if (StrTok.isNot(tok::string_literal)) {
1300 Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
1301 return DiscardUntilEndOfDirective();
1302 } else if (StrTok.hasUDSuffix()) {
1303 Diag(StrTok, diag::err_invalid_string_udl);
1304 return DiscardUntilEndOfDirective();
1306 // Parse and validate the string, converting it into a unique ID.
1307 StringLiteralParser Literal(StrTok, *this);
1308 assert(Literal.isAscii() && "Didn't allow wide strings in");
1309 if (Literal.hadError)
1310 return DiscardUntilEndOfDirective();
1311 if (Literal.Pascal) {
1312 Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
1313 return DiscardUntilEndOfDirective();
1315 FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());
1317 // If a filename was present, read any flags that are present.
1318 if (ReadLineMarkerFlags(IsFileEntry, IsFileExit, FileKind, *this))
1322 // Create a line note with this information.
1323 SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, IsFileEntry,
1324 IsFileExit, FileKind);
1326 // If the preprocessor has callbacks installed, notify them of the #line
1327 // change. This is used so that the line marker comes out in -E mode for
1330 PPCallbacks::FileChangeReason Reason = PPCallbacks::RenameFile;
1332 Reason = PPCallbacks::EnterFile;
1333 else if (IsFileExit)
1334 Reason = PPCallbacks::ExitFile;
1336 Callbacks->FileChanged(CurPPLexer->getSourceLocation(), Reason, FileKind);
1340 /// HandleUserDiagnosticDirective - Handle a #warning or #error directive.
1342 void Preprocessor::HandleUserDiagnosticDirective(Token &Tok,
1344 // PTH doesn't emit #warning or #error directives.
1346 return CurPTHLexer->DiscardToEndOfLine();
1348 // Read the rest of the line raw. We do this because we don't want macros
1349 // to be expanded and we don't require that the tokens be valid preprocessing
1350 // tokens. For example, this is allowed: "#warning ` 'foo". GCC does
1351 // collapse multiple consequtive white space between tokens, but this isn't
1352 // specified by the standard.
1353 SmallString<128> Message;
1354 CurLexer->ReadToEndOfLine(&Message);
1356 // Find the first non-whitespace character, so that we can make the
1357 // diagnostic more succinct.
1358 StringRef Msg = StringRef(Message).ltrim(' ');
1361 Diag(Tok, diag::pp_hash_warning) << Msg;
1363 Diag(Tok, diag::err_pp_hash_error) << Msg;
1366 /// HandleIdentSCCSDirective - Handle a #ident/#sccs directive.
1368 void Preprocessor::HandleIdentSCCSDirective(Token &Tok) {
1369 // Yes, this directive is an extension.
1370 Diag(Tok, diag::ext_pp_ident_directive);
1372 // Read the string argument.
1376 // If the token kind isn't a string, it's a malformed directive.
1377 if (StrTok.isNot(tok::string_literal) &&
1378 StrTok.isNot(tok::wide_string_literal)) {
1379 Diag(StrTok, diag::err_pp_malformed_ident);
1380 if (StrTok.isNot(tok::eod))
1381 DiscardUntilEndOfDirective();
1385 if (StrTok.hasUDSuffix()) {
1386 Diag(StrTok, diag::err_invalid_string_udl);
1387 return DiscardUntilEndOfDirective();
1390 // Verify that there is nothing after the string, other than EOD.
1391 CheckEndOfDirective("ident");
1394 bool Invalid = false;
1395 std::string Str = getSpelling(StrTok, &Invalid);
1397 Callbacks->Ident(Tok.getLocation(), Str);
1401 /// \brief Handle a #public directive.
1402 void Preprocessor::HandleMacroPublicDirective(Token &Tok) {
1404 ReadMacroName(MacroNameTok, MU_Undef);
1406 // Error reading macro name? If so, diagnostic already issued.
1407 if (MacroNameTok.is(tok::eod))
1410 // Check to see if this is the last token on the #__public_macro line.
1411 CheckEndOfDirective("__public_macro");
1413 IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
1414 // Okay, we finally have a valid identifier to undef.
1415 MacroDirective *MD = getLocalMacroDirective(II);
1417 // If the macro is not defined, this is an error.
1419 Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;
1423 // Note that this macro has now been exported.
1424 appendMacroDirective(II, AllocateVisibilityMacroDirective(
1425 MacroNameTok.getLocation(), /*IsPublic=*/true));
1428 /// \brief Handle a #private directive.
1429 void Preprocessor::HandleMacroPrivateDirective() {
1431 ReadMacroName(MacroNameTok, MU_Undef);
1433 // Error reading macro name? If so, diagnostic already issued.
1434 if (MacroNameTok.is(tok::eod))
1437 // Check to see if this is the last token on the #__private_macro line.
1438 CheckEndOfDirective("__private_macro");
1440 IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
1441 // Okay, we finally have a valid identifier to undef.
1442 MacroDirective *MD = getLocalMacroDirective(II);
1444 // If the macro is not defined, this is an error.
1446 Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;
1450 // Note that this macro has now been marked private.
1451 appendMacroDirective(II, AllocateVisibilityMacroDirective(
1452 MacroNameTok.getLocation(), /*IsPublic=*/false));
1455 //===----------------------------------------------------------------------===//
1456 // Preprocessor Include Directive Handling.
1457 //===----------------------------------------------------------------------===//
1459 /// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully
1460 /// checked and spelled filename, e.g. as an operand of \#include. This returns
1461 /// true if the input filename was in <>'s or false if it were in ""'s. The
1462 /// caller is expected to provide a buffer that is large enough to hold the
1463 /// spelling of the filename, but is also expected to handle the case when
1464 /// this method decides to use a different buffer.
1465 bool Preprocessor::GetIncludeFilenameSpelling(SourceLocation Loc,
1466 StringRef &Buffer) {
1467 // Get the text form of the filename.
1468 assert(!Buffer.empty() && "Can't have tokens with empty spellings!");
1470 // Make sure the filename is <x> or "x".
1472 if (Buffer[0] == '<') {
1473 if (Buffer.back() != '>') {
1474 Diag(Loc, diag::err_pp_expects_filename);
1475 Buffer = StringRef();
1479 } else if (Buffer[0] == '"') {
1480 if (Buffer.back() != '"') {
1481 Diag(Loc, diag::err_pp_expects_filename);
1482 Buffer = StringRef();
1487 Diag(Loc, diag::err_pp_expects_filename);
1488 Buffer = StringRef();
1492 // Diagnose #include "" as invalid.
1493 if (Buffer.size() <= 2) {
1494 Diag(Loc, diag::err_pp_empty_filename);
1495 Buffer = StringRef();
1499 // Skip the brackets.
1500 Buffer = Buffer.substr(1, Buffer.size()-2);
1504 // \brief Handle cases where the \#include name is expanded from a macro
1505 // as multiple tokens, which need to be glued together.
1507 // This occurs for code like:
1509 // \#define FOO <a/b.h>
1512 // because in this case, "<a/b.h>" is returned as 7 tokens, not one.
1514 // This code concatenates and consumes tokens up to the '>' token. It returns
1515 // false if the > was found, otherwise it returns true if it finds and consumes
1517 bool Preprocessor::ConcatenateIncludeName(SmallString<128> &FilenameBuffer,
1518 SourceLocation &End) {
1522 while (CurTok.isNot(tok::eod)) {
1523 End = CurTok.getLocation();
1525 // FIXME: Provide code completion for #includes.
1526 if (CurTok.is(tok::code_completion)) {
1527 setCodeCompletionReached();
1532 // Append the spelling of this token to the buffer. If there was a space
1533 // before it, add it now.
1534 if (CurTok.hasLeadingSpace())
1535 FilenameBuffer.push_back(' ');
1537 // Get the spelling of the token, directly into FilenameBuffer if possible.
1538 size_t PreAppendSize = FilenameBuffer.size();
1539 FilenameBuffer.resize(PreAppendSize+CurTok.getLength());
1541 const char *BufPtr = &FilenameBuffer[PreAppendSize];
1542 unsigned ActualLen = getSpelling(CurTok, BufPtr);
1544 // If the token was spelled somewhere else, copy it into FilenameBuffer.
1545 if (BufPtr != &FilenameBuffer[PreAppendSize])
1546 memcpy(&FilenameBuffer[PreAppendSize], BufPtr, ActualLen);
1548 // Resize FilenameBuffer to the correct size.
1549 if (CurTok.getLength() != ActualLen)
1550 FilenameBuffer.resize(PreAppendSize+ActualLen);
1552 // If we found the '>' marker, return success.
1553 if (CurTok.is(tok::greater))
1559 // If we hit the eod marker, emit an error and return true so that the caller
1560 // knows the EOD has been read.
1561 Diag(CurTok.getLocation(), diag::err_pp_expects_filename);
1565 /// \brief Push a token onto the token stream containing an annotation.
1566 void Preprocessor::EnterAnnotationToken(SourceRange Range,
1567 tok::TokenKind Kind,
1568 void *AnnotationVal) {
1569 // FIXME: Produce this as the current token directly, rather than
1570 // allocating a new token for it.
1571 auto Tok = llvm::make_unique<Token[]>(1);
1572 Tok[0].startToken();
1573 Tok[0].setKind(Kind);
1574 Tok[0].setLocation(Range.getBegin());
1575 Tok[0].setAnnotationEndLoc(Range.getEnd());
1576 Tok[0].setAnnotationValue(AnnotationVal);
1577 EnterTokenStream(std::move(Tok), 1, true);
1580 /// \brief Produce a diagnostic informing the user that a #include or similar
1581 /// was implicitly treated as a module import.
1582 static void diagnoseAutoModuleImport(
1583 Preprocessor &PP, SourceLocation HashLoc, Token &IncludeTok,
1584 ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> Path,
1585 SourceLocation PathEnd) {
1586 assert(PP.getLangOpts().ObjC2 && "no import syntax available");
1588 SmallString<128> PathString;
1589 for (size_t I = 0, N = Path.size(); I != N; ++I) {
1592 PathString += Path[I].first->getName();
1594 int IncludeKind = 0;
1596 switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) {
1597 case tok::pp_include:
1601 case tok::pp_import:
1605 case tok::pp_include_next:
1609 case tok::pp___include_macros:
1614 llvm_unreachable("unknown include directive kind");
1617 CharSourceRange ReplaceRange(SourceRange(HashLoc, PathEnd),
1618 /*IsTokenRange=*/false);
1619 PP.Diag(HashLoc, diag::warn_auto_module_import)
1620 << IncludeKind << PathString
1621 << FixItHint::CreateReplacement(ReplaceRange,
1622 ("@import " + PathString + ";").str());
1625 // Given a vector of path components and a string containing the real
1626 // path to the file, build a properly-cased replacement in the vector,
1627 // and return true if the replacement should be suggested.
1628 static bool trySimplifyPath(SmallVectorImpl<StringRef> &Components,
1629 StringRef RealPathName) {
1630 auto RealPathComponentIter = llvm::sys::path::rbegin(RealPathName);
1631 auto RealPathComponentEnd = llvm::sys::path::rend(RealPathName);
1633 bool SuggestReplacement = false;
1634 // Below is a best-effort to handle ".." in paths. It is admittedly
1635 // not 100% correct in the presence of symlinks.
1636 for (auto &Component : llvm::reverse(Components)) {
1637 if ("." == Component) {
1638 } else if (".." == Component) {
1642 } else if (RealPathComponentIter != RealPathComponentEnd) {
1643 if (Component != *RealPathComponentIter) {
1644 // If these path components differ by more than just case, then we
1645 // may be looking at symlinked paths. Bail on this diagnostic to avoid
1646 // noisy false positives.
1647 SuggestReplacement = RealPathComponentIter->equals_lower(Component);
1648 if (!SuggestReplacement)
1650 Component = *RealPathComponentIter;
1652 ++RealPathComponentIter;
1655 return SuggestReplacement;
1658 bool Preprocessor::checkModuleIsAvailable(const LangOptions &LangOpts,
1659 const TargetInfo &TargetInfo,
1660 DiagnosticsEngine &Diags, Module *M) {
1661 Module::Requirement Requirement;
1662 Module::UnresolvedHeaderDirective MissingHeader;
1663 if (M->isAvailable(LangOpts, TargetInfo, Requirement, MissingHeader))
1666 if (MissingHeader.FileNameLoc.isValid()) {
1667 Diags.Report(MissingHeader.FileNameLoc, diag::err_module_header_missing)
1668 << MissingHeader.IsUmbrella << MissingHeader.FileName;
1670 // FIXME: Track the location at which the requirement was specified, and
1672 Diags.Report(M->DefinitionLoc, diag::err_module_unavailable)
1673 << M->getFullModuleName() << Requirement.second << Requirement.first;
1678 /// HandleIncludeDirective - The "\#include" tokens have just been read, read
1679 /// the file to be included from the lexer, then include it! This is a common
1680 /// routine with functionality shared between \#include, \#include_next and
1681 /// \#import. LookupFrom is set when this is a \#include_next directive, it
1682 /// specifies the file to start searching from.
1683 void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc,
1685 const DirectoryLookup *LookupFrom,
1686 const FileEntry *LookupFromFile,
1689 CurPPLexer->LexIncludeFilename(FilenameTok);
1691 // Reserve a buffer to get the spelling.
1692 SmallString<128> FilenameBuffer;
1695 SourceLocation CharEnd; // the end of this directive, in characters
1697 switch (FilenameTok.getKind()) {
1699 // If the token kind is EOD, the error has already been diagnosed.
1702 case tok::angle_string_literal:
1703 case tok::string_literal:
1704 Filename = getSpelling(FilenameTok, FilenameBuffer);
1705 End = FilenameTok.getLocation();
1706 CharEnd = End.getLocWithOffset(FilenameTok.getLength());
1710 // This could be a <foo/bar.h> file coming from a macro expansion. In this
1711 // case, glue the tokens together into FilenameBuffer and interpret those.
1712 FilenameBuffer.push_back('<');
1713 if (ConcatenateIncludeName(FilenameBuffer, End))
1714 return; // Found <eod> but no ">"? Diagnostic already emitted.
1715 Filename = FilenameBuffer;
1716 CharEnd = End.getLocWithOffset(1);
1719 Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);
1720 DiscardUntilEndOfDirective();
1724 CharSourceRange FilenameRange
1725 = CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd);
1726 StringRef OriginalFilename = Filename;
1728 GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
1729 // If GetIncludeFilenameSpelling set the start ptr to null, there was an
1731 if (Filename.empty()) {
1732 DiscardUntilEndOfDirective();
1736 // Verify that there is nothing after the filename, other than EOD. Note that
1737 // we allow macros that expand to nothing after the filename, because this
1738 // falls into the category of "#include pp-tokens new-line" specified in
1740 CheckEndOfDirective(IncludeTok.getIdentifierInfo()->getNameStart(), true);
1742 // Check that we don't have infinite #include recursion.
1743 if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) {
1744 Diag(FilenameTok, diag::err_pp_include_too_deep);
1748 // Complain about attempts to #include files in an audit pragma.
1749 if (PragmaARCCFCodeAuditedLoc.isValid()) {
1750 Diag(HashLoc, diag::err_pp_include_in_arc_cf_code_audited);
1751 Diag(PragmaARCCFCodeAuditedLoc, diag::note_pragma_entered_here);
1753 // Immediately leave the pragma.
1754 PragmaARCCFCodeAuditedLoc = SourceLocation();
1757 // Complain about attempts to #include files in an assume-nonnull pragma.
1758 if (PragmaAssumeNonNullLoc.isValid()) {
1759 Diag(HashLoc, diag::err_pp_include_in_assume_nonnull);
1760 Diag(PragmaAssumeNonNullLoc, diag::note_pragma_entered_here);
1762 // Immediately leave the pragma.
1763 PragmaAssumeNonNullLoc = SourceLocation();
1766 if (HeaderInfo.HasIncludeAliasMap()) {
1767 // Map the filename with the brackets still attached. If the name doesn't
1768 // map to anything, fall back on the filename we've already gotten the
1770 StringRef NewName = HeaderInfo.MapHeaderToIncludeAlias(OriginalFilename);
1771 if (!NewName.empty())
1775 // Search include directories.
1776 bool IsMapped = false;
1777 const DirectoryLookup *CurDir;
1778 SmallString<1024> SearchPath;
1779 SmallString<1024> RelativePath;
1780 // We get the raw path only if we have 'Callbacks' to which we later pass
1782 ModuleMap::KnownHeader SuggestedModule;
1783 SourceLocation FilenameLoc = FilenameTok.getLocation();
1784 SmallString<128> NormalizedPath;
1785 if (LangOpts.MSVCCompat) {
1786 NormalizedPath = Filename.str();
1787 #ifndef LLVM_ON_WIN32
1788 llvm::sys::path::native(NormalizedPath);
1791 const FileEntry *File = LookupFile(
1792 FilenameLoc, LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename,
1793 isAngled, LookupFrom, LookupFromFile, CurDir,
1794 Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr,
1795 &SuggestedModule, &IsMapped);
1799 // Give the clients a chance to recover.
1800 SmallString<128> RecoveryPath;
1801 if (Callbacks->FileNotFound(Filename, RecoveryPath)) {
1802 if (const DirectoryEntry *DE = FileMgr.getDirectory(RecoveryPath)) {
1803 // Add the recovery path to the list of search paths.
1804 DirectoryLookup DL(DE, SrcMgr::C_User, false);
1805 HeaderInfo.AddSearchPath(DL, isAngled);
1807 // Try the lookup again, skipping the cache.
1810 LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled,
1811 LookupFrom, LookupFromFile, CurDir, nullptr, nullptr,
1812 &SuggestedModule, &IsMapped, /*SkipCache*/ true);
1817 if (!SuppressIncludeNotFoundError) {
1818 // If the file could not be located and it was included via angle
1819 // brackets, we can attempt a lookup as though it were a quoted path to
1820 // provide the user with a possible fixit.
1824 LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, false,
1825 LookupFrom, LookupFromFile, CurDir,
1826 Callbacks ? &SearchPath : nullptr,
1827 Callbacks ? &RelativePath : nullptr, &SuggestedModule, &IsMapped);
1829 SourceRange Range(FilenameTok.getLocation(), CharEnd);
1830 Diag(FilenameTok, diag::err_pp_file_not_found_not_fatal) <<
1832 FixItHint::CreateReplacement(Range, "\"" + Filename.str() + "\"");
1836 // If the file is still not found, just go with the vanilla diagnostic
1838 Diag(FilenameTok, diag::err_pp_file_not_found) << Filename
1843 // Should we enter the source file? Set to false if either the source file is
1844 // known to have no effect beyond its effect on module visibility -- that is,
1845 // if it's got an include guard that is already defined or is a modular header
1846 // we've imported or already built.
1847 bool ShouldEnter = true;
1849 if (PPOpts->SingleFileParseMode)
1850 ShouldEnter = false;
1852 // Determine whether we should try to import the module for this #include, if
1853 // there is one. Don't do so if precompiled module support is disabled or we
1854 // are processing this module textually (because we're building the module).
1855 if (ShouldEnter && File && SuggestedModule && getLangOpts().Modules &&
1856 SuggestedModule.getModule()->getTopLevelModuleName() !=
1857 getLangOpts().CurrentModule) {
1858 // If this include corresponds to a module but that module is
1859 // unavailable, diagnose the situation and bail out.
1860 // FIXME: Remove this; loadModule does the same check (but produces
1861 // slightly worse diagnostics).
1862 if (checkModuleIsAvailable(getLangOpts(), getTargetInfo(), getDiagnostics(),
1863 SuggestedModule.getModule())) {
1864 Diag(FilenameTok.getLocation(),
1865 diag::note_implicit_top_level_module_import_here)
1866 << SuggestedModule.getModule()->getTopLevelModuleName();
1870 // Compute the module access path corresponding to this module.
1871 // FIXME: Should we have a second loadModule() overload to avoid this
1872 // extra lookup step?
1873 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
1874 for (Module *Mod = SuggestedModule.getModule(); Mod; Mod = Mod->Parent)
1875 Path.push_back(std::make_pair(getIdentifierInfo(Mod->Name),
1876 FilenameTok.getLocation()));
1877 std::reverse(Path.begin(), Path.end());
1879 // Warn that we're replacing the include/import with a module import.
1880 // We only do this in Objective-C, where we have a module-import syntax.
1881 if (getLangOpts().ObjC2)
1882 diagnoseAutoModuleImport(*this, HashLoc, IncludeTok, Path, CharEnd);
1884 // Load the module to import its macros. We'll make the declarations
1885 // visible when the parser gets here.
1886 // FIXME: Pass SuggestedModule in here rather than converting it to a path
1887 // and making the module loader convert it back again.
1888 ModuleLoadResult Imported = TheModuleLoader.loadModule(
1889 IncludeTok.getLocation(), Path, Module::Hidden,
1890 /*IsIncludeDirective=*/true);
1891 assert((Imported == nullptr || Imported == SuggestedModule.getModule()) &&
1892 "the imported module is different than the suggested one");
1895 ShouldEnter = false;
1896 else if (Imported.isMissingExpected()) {
1897 // We failed to find a submodule that we assumed would exist (because it
1898 // was in the directory of an umbrella header, for instance), but no
1899 // actual module containing it exists (because the umbrella header is
1900 // incomplete). Treat this as a textual inclusion.
1901 SuggestedModule = ModuleMap::KnownHeader();
1902 } else if (Imported.isConfigMismatch()) {
1903 // On a configuration mismatch, enter the header textually. We still know
1904 // that it's part of the corresponding module.
1906 // We hit an error processing the import. Bail out.
1907 if (hadModuleLoaderFatalFailure()) {
1908 // With a fatal failure in the module loader, we abort parsing.
1909 Token &Result = IncludeTok;
1911 Result.startToken();
1912 CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
1913 CurLexer->cutOffLexing();
1915 assert(CurPTHLexer && "#include but no current lexer set!");
1916 CurPTHLexer->getEOF(Result);
1923 // The #included file will be considered to be a system header if either it is
1924 // in a system include directory, or if the #includer is a system include
1926 SrcMgr::CharacteristicKind FileCharacter =
1927 SourceMgr.getFileCharacteristic(FilenameTok.getLocation());
1929 FileCharacter = std::max(HeaderInfo.getFileDirFlavor(File), FileCharacter);
1931 // Ask HeaderInfo if we should enter this #include file. If not, #including
1932 // this file will have no effect.
1933 bool SkipHeader = false;
1934 if (ShouldEnter && File &&
1935 !HeaderInfo.ShouldEnterIncludeFile(*this, File, isImport,
1936 getLangOpts().Modules,
1937 SuggestedModule.getModule())) {
1938 ShouldEnter = false;
1943 // Notify the callback object that we've seen an inclusion directive.
1944 Callbacks->InclusionDirective(
1945 HashLoc, IncludeTok,
1946 LangOpts.MSVCCompat ? NormalizedPath.c_str() : Filename, isAngled,
1947 FilenameRange, File, SearchPath, RelativePath,
1948 ShouldEnter ? nullptr : SuggestedModule.getModule());
1949 if (SkipHeader && !SuggestedModule.getModule())
1950 Callbacks->FileSkipped(*File, FilenameTok, FileCharacter);
1956 // FIXME: If we have a suggested module, and we've already visited this file,
1957 // don't bother entering it again. We know it has no further effect.
1959 // Issue a diagnostic if the name of the file on disk has a different case
1960 // than the one we're about to open.
1961 const bool CheckIncludePathPortability =
1962 !IsMapped && File && !File->tryGetRealPathName().empty();
1964 if (CheckIncludePathPortability) {
1965 StringRef Name = LangOpts.MSVCCompat ? NormalizedPath.str() : Filename;
1966 StringRef RealPathName = File->tryGetRealPathName();
1967 SmallVector<StringRef, 16> Components(llvm::sys::path::begin(Name),
1968 llvm::sys::path::end(Name));
1970 if (trySimplifyPath(Components, RealPathName)) {
1971 SmallString<128> Path;
1972 Path.reserve(Name.size()+2);
1973 Path.push_back(isAngled ? '<' : '"');
1974 bool isLeadingSeparator = llvm::sys::path::is_absolute(Name);
1975 for (auto Component : Components) {
1976 if (isLeadingSeparator)
1977 isLeadingSeparator = false;
1979 Path.append(Component);
1980 // Append the separator the user used, or the close quote
1982 Path.size() <= Filename.size() ? Filename[Path.size()-1] :
1983 (isAngled ? '>' : '"'));
1985 // For user files and known standard headers, by default we issue a diagnostic.
1986 // For other system headers, we don't. They can be controlled separately.
1987 auto DiagId = (FileCharacter == SrcMgr::C_User || warnByDefaultOnWrongCase(Name)) ?
1988 diag::pp_nonportable_path : diag::pp_nonportable_system_path;
1989 SourceRange Range(FilenameTok.getLocation(), CharEnd);
1990 Diag(FilenameTok, DiagId) << Path <<
1991 FixItHint::CreateReplacement(Range, Path);
1995 // If we don't need to enter the file, stop now.
1997 // If this is a module import, make it visible if needed.
1998 if (auto *M = SuggestedModule.getModule()) {
1999 // When building a pch, -fmodule-name tells the compiler to textually
2000 // include headers in the specified module. But it is possible that
2001 // ShouldEnter is false because we are skipping the header. In that
2002 // case, We are not importing the specified module.
2003 if (SkipHeader && getLangOpts().CompilingPCH &&
2004 M->getTopLevelModuleName() == getLangOpts().CurrentModule)
2007 makeModuleVisible(M, HashLoc);
2009 if (IncludeTok.getIdentifierInfo()->getPPKeywordID() !=
2010 tok::pp___include_macros)
2011 EnterAnnotationToken(SourceRange(HashLoc, End),
2012 tok::annot_module_include, M);
2017 // Look up the file, create a File ID for it.
2018 SourceLocation IncludePos = End;
2019 // If the filename string was the result of macro expansions, set the include
2020 // position on the file where it will be included and after the expansions.
2021 if (IncludePos.isMacroID())
2022 IncludePos = SourceMgr.getExpansionRange(IncludePos).second;
2023 FileID FID = SourceMgr.createFileID(File, IncludePos, FileCharacter);
2024 assert(FID.isValid() && "Expected valid file ID");
2026 // If all is good, enter the new file!
2027 if (EnterSourceFile(FID, CurDir, FilenameTok.getLocation()))
2030 // Determine if we're switching to building a new submodule, and which one.
2031 if (auto *M = SuggestedModule.getModule()) {
2032 // When building a pch, -fmodule-name tells the compiler to textually
2033 // include headers in the specified module. We are not building the
2034 // specified module.
2035 if (getLangOpts().CompilingPCH &&
2036 M->getTopLevelModuleName() == getLangOpts().CurrentModule)
2039 assert(!CurLexerSubmodule && "should not have marked this as a module yet");
2040 CurLexerSubmodule = M;
2042 // Let the macro handling code know that any future macros are within
2043 // the new submodule.
2044 EnterSubmodule(M, HashLoc, /*ForPragma*/false);
2046 // Let the parser know that any future declarations are within the new
2048 // FIXME: There's no point doing this if we're handling a #__include_macros
2050 EnterAnnotationToken(SourceRange(HashLoc, End), tok::annot_module_begin, M);
2054 /// HandleIncludeNextDirective - Implements \#include_next.
2056 void Preprocessor::HandleIncludeNextDirective(SourceLocation HashLoc,
2057 Token &IncludeNextTok) {
2058 Diag(IncludeNextTok, diag::ext_pp_include_next_directive);
2060 // #include_next is like #include, except that we start searching after
2061 // the current found directory. If we can't do this, issue a
2063 const DirectoryLookup *Lookup = CurDirLookup;
2064 const FileEntry *LookupFromFile = nullptr;
2065 if (isInPrimaryFile() && LangOpts.IsHeaderFile) {
2066 // If the main file is a header, then it's either for PCH/AST generation,
2067 // or libclang opened it. Either way, handle it as a normal include below
2068 // and do not complain about include_next.
2069 } else if (isInPrimaryFile()) {
2071 Diag(IncludeNextTok, diag::pp_include_next_in_primary);
2072 } else if (CurLexerSubmodule) {
2073 // Start looking up in the directory *after* the one in which the current
2074 // file would be found, if any.
2075 assert(CurPPLexer && "#include_next directive in macro?");
2076 LookupFromFile = CurPPLexer->getFileEntry();
2078 } else if (!Lookup) {
2079 Diag(IncludeNextTok, diag::pp_include_next_absolute_path);
2081 // Start looking up in the next directory.
2085 return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup,
2089 /// HandleMicrosoftImportDirective - Implements \#import for Microsoft Mode
2090 void Preprocessor::HandleMicrosoftImportDirective(Token &Tok) {
2091 // The Microsoft #import directive takes a type library and generates header
2092 // files from it, and includes those. This is beyond the scope of what clang
2093 // does, so we ignore it and error out. However, #import can optionally have
2094 // trailing attributes that span multiple lines. We're going to eat those
2095 // so we can continue processing from there.
2096 Diag(Tok, diag::err_pp_import_directive_ms );
2098 // Read tokens until we get to the end of the directive. Note that the
2099 // directive can be split over multiple lines using the backslash character.
2100 DiscardUntilEndOfDirective();
2103 /// HandleImportDirective - Implements \#import.
2105 void Preprocessor::HandleImportDirective(SourceLocation HashLoc,
2107 if (!LangOpts.ObjC1) { // #import is standard for ObjC.
2108 if (LangOpts.MSVCCompat)
2109 return HandleMicrosoftImportDirective(ImportTok);
2110 Diag(ImportTok, diag::ext_pp_import_directive);
2112 return HandleIncludeDirective(HashLoc, ImportTok, nullptr, nullptr, true);
2115 /// HandleIncludeMacrosDirective - The -imacros command line option turns into a
2116 /// pseudo directive in the predefines buffer. This handles it by sucking all
2117 /// tokens through the preprocessor and discarding them (only keeping the side
2118 /// effects on the preprocessor).
2119 void Preprocessor::HandleIncludeMacrosDirective(SourceLocation HashLoc,
2120 Token &IncludeMacrosTok) {
2121 // This directive should only occur in the predefines buffer. If not, emit an
2122 // error and reject it.
2123 SourceLocation Loc = IncludeMacrosTok.getLocation();
2124 if (SourceMgr.getBufferName(Loc) != "<built-in>") {
2125 Diag(IncludeMacrosTok.getLocation(),
2126 diag::pp_include_macros_out_of_predefines);
2127 DiscardUntilEndOfDirective();
2131 // Treat this as a normal #include for checking purposes. If this is
2132 // successful, it will push a new lexer onto the include stack.
2133 HandleIncludeDirective(HashLoc, IncludeMacrosTok);
2138 assert(TmpTok.isNot(tok::eof) && "Didn't find end of -imacros!");
2139 } while (TmpTok.isNot(tok::hashhash));
2142 //===----------------------------------------------------------------------===//
2143 // Preprocessor Macro Directive Handling.
2144 //===----------------------------------------------------------------------===//
2146 /// ReadMacroDefinitionArgList - The ( starting an argument list of a macro
2147 /// definition has just been read. Lex the rest of the arguments and the
2148 /// closing ), updating MI with what we learn. Return true if an error occurs
2149 /// parsing the arg list.
2150 bool Preprocessor::ReadMacroDefinitionArgList(MacroInfo *MI, Token &Tok) {
2151 SmallVector<IdentifierInfo*, 32> Arguments;
2154 LexUnexpandedToken(Tok);
2155 switch (Tok.getKind()) {
2157 // Found the end of the argument list.
2158 if (Arguments.empty()) // #define FOO()
2160 // Otherwise we have #define FOO(A,)
2161 Diag(Tok, diag::err_pp_expected_ident_in_arg_list);
2163 case tok::ellipsis: // #define X(... -> C99 varargs
2165 Diag(Tok, LangOpts.CPlusPlus11 ?
2166 diag::warn_cxx98_compat_variadic_macro :
2167 diag::ext_variadic_macro);
2169 // OpenCL v1.2 s6.9.e: variadic macros are not supported.
2170 if (LangOpts.OpenCL) {
2171 Diag(Tok, diag::err_pp_opencl_variadic_macros);
2175 // Lex the token after the identifier.
2176 LexUnexpandedToken(Tok);
2177 if (Tok.isNot(tok::r_paren)) {
2178 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
2181 // Add the __VA_ARGS__ identifier as an argument.
2182 Arguments.push_back(Ident__VA_ARGS__);
2183 MI->setIsC99Varargs();
2184 MI->setArgumentList(Arguments, BP);
2186 case tok::eod: // #define X(
2187 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
2190 // Handle keywords and identifiers here to accept things like
2191 // #define Foo(for) for.
2192 IdentifierInfo *II = Tok.getIdentifierInfo();
2195 Diag(Tok, diag::err_pp_invalid_tok_in_arg_list);
2199 // If this is already used as an argument, it is used multiple times (e.g.
2201 if (std::find(Arguments.begin(), Arguments.end(), II) !=
2202 Arguments.end()) { // C99 6.10.3p6
2203 Diag(Tok, diag::err_pp_duplicate_name_in_arg_list) << II;
2207 // Add the argument to the macro info.
2208 Arguments.push_back(II);
2210 // Lex the token after the identifier.
2211 LexUnexpandedToken(Tok);
2213 switch (Tok.getKind()) {
2214 default: // #define X(A B
2215 Diag(Tok, diag::err_pp_expected_comma_in_arg_list);
2217 case tok::r_paren: // #define X(A)
2218 MI->setArgumentList(Arguments, BP);
2220 case tok::comma: // #define X(A,
2222 case tok::ellipsis: // #define X(A... -> GCC extension
2223 // Diagnose extension.
2224 Diag(Tok, diag::ext_named_variadic_macro);
2226 // Lex the token after the identifier.
2227 LexUnexpandedToken(Tok);
2228 if (Tok.isNot(tok::r_paren)) {
2229 Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
2233 MI->setIsGNUVarargs();
2234 MI->setArgumentList(Arguments, BP);
2241 static bool isConfigurationPattern(Token &MacroName, MacroInfo *MI,
2242 const LangOptions &LOptions) {
2243 if (MI->getNumTokens() == 1) {
2244 const Token &Value = MI->getReplacementToken(0);
2246 // Macro that is identity, like '#define inline inline' is a valid pattern.
2247 if (MacroName.getKind() == Value.getKind())
2250 // Macro that maps a keyword to the same keyword decorated with leading/
2251 // trailing underscores is a valid pattern:
2252 // #define inline __inline
2253 // #define inline __inline__
2254 // #define inline _inline (in MS compatibility mode)
2255 StringRef MacroText = MacroName.getIdentifierInfo()->getName();
2256 if (IdentifierInfo *II = Value.getIdentifierInfo()) {
2257 if (!II->isKeyword(LOptions))
2259 StringRef ValueText = II->getName();
2260 StringRef TrimmedValue = ValueText;
2261 if (!ValueText.startswith("__")) {
2262 if (ValueText.startswith("_"))
2263 TrimmedValue = TrimmedValue.drop_front(1);
2267 TrimmedValue = TrimmedValue.drop_front(2);
2268 if (TrimmedValue.endswith("__"))
2269 TrimmedValue = TrimmedValue.drop_back(2);
2271 return TrimmedValue.equals(MacroText);
2278 return MacroName.isOneOf(tok::kw_extern, tok::kw_inline, tok::kw_static,
2280 MI->getNumTokens() == 0;
2283 /// HandleDefineDirective - Implements \#define. This consumes the entire macro
2284 /// line then lets the caller lex the next real token.
2285 void Preprocessor::HandleDefineDirective(Token &DefineTok,
2286 bool ImmediatelyAfterHeaderGuard) {
2290 bool MacroShadowsKeyword;
2291 ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword);
2293 // Error reading macro name? If so, diagnostic already issued.
2294 if (MacroNameTok.is(tok::eod))
2297 Token LastTok = MacroNameTok;
2299 // If we are supposed to keep comments in #defines, reenable comment saving
2301 if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments);
2303 // Create the new macro.
2304 MacroInfo *MI = AllocateMacroInfo(MacroNameTok.getLocation());
2307 LexUnexpandedToken(Tok);
2309 // If this is a function-like macro definition, parse the argument list,
2310 // marking each of the identifiers as being used as macro arguments. Also,
2311 // check other constraints on the first token of the macro body.
2312 if (Tok.is(tok::eod)) {
2313 if (ImmediatelyAfterHeaderGuard) {
2314 // Save this macro information since it may part of a header guard.
2315 CurPPLexer->MIOpt.SetDefinedMacro(MacroNameTok.getIdentifierInfo(),
2316 MacroNameTok.getLocation());
2318 // If there is no body to this macro, we have no special handling here.
2319 } else if (Tok.hasLeadingSpace()) {
2320 // This is a normal token with leading space. Clear the leading space
2321 // marker on the first token to get proper expansion.
2322 Tok.clearFlag(Token::LeadingSpace);
2323 } else if (Tok.is(tok::l_paren)) {
2324 // This is a function-like macro definition. Read the argument list.
2325 MI->setIsFunctionLike();
2326 if (ReadMacroDefinitionArgList(MI, LastTok)) {
2327 // Throw away the rest of the line.
2328 if (CurPPLexer->ParsingPreprocessorDirective)
2329 DiscardUntilEndOfDirective();
2333 // If this is a definition of a variadic C99 function-like macro, not using
2334 // the GNU named varargs extension, enabled __VA_ARGS__.
2336 // "Poison" __VA_ARGS__, which can only appear in the expansion of a macro.
2337 // This gets unpoisoned where it is allowed.
2338 assert(Ident__VA_ARGS__->isPoisoned() && "__VA_ARGS__ should be poisoned!");
2339 if (MI->isC99Varargs())
2340 Ident__VA_ARGS__->setIsPoisoned(false);
2342 // Read the first token after the arg list for down below.
2343 LexUnexpandedToken(Tok);
2344 } else if (LangOpts.C99 || LangOpts.CPlusPlus11) {
2345 // C99 requires whitespace between the macro definition and the body. Emit
2346 // a diagnostic for something like "#define X+".
2347 Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name);
2349 // C90 6.8 TC1 says: "In the definition of an object-like macro, if the
2350 // first character of a replacement list is not a character required by
2351 // subclause 5.2.1, then there shall be white-space separation between the
2352 // identifier and the replacement list.". 5.2.1 lists this set:
2353 // "A-Za-z0-9!"#%&'()*+,_./:;<=>?[\]^_{|}~" as well as whitespace, which
2354 // is irrelevant here.
2355 bool isInvalid = false;
2356 if (Tok.is(tok::at)) // @ is not in the list above.
2358 else if (Tok.is(tok::unknown)) {
2359 // If we have an unknown token, it is something strange like "`". Since
2360 // all of valid characters would have lexed into a single character
2361 // token of some sort, we know this is not a valid case.
2365 Diag(Tok, diag::ext_missing_whitespace_after_macro_name);
2367 Diag(Tok, diag::warn_missing_whitespace_after_macro_name);
2370 if (!Tok.is(tok::eod))
2373 // Read the rest of the macro body.
2374 if (MI->isObjectLike()) {
2375 // Object-like macros are very simple, just read their body.
2376 while (Tok.isNot(tok::eod)) {
2378 MI->AddTokenToBody(Tok);
2379 // Get the next token of the macro.
2380 LexUnexpandedToken(Tok);
2383 // Otherwise, read the body of a function-like macro. While we are at it,
2384 // check C99 6.10.3.2p1: ensure that # operators are followed by macro
2385 // parameters in function-like macro expansions.
2386 while (Tok.isNot(tok::eod)) {
2389 if (!Tok.isOneOf(tok::hash, tok::hashat, tok::hashhash)) {
2390 MI->AddTokenToBody(Tok);
2392 // Get the next token of the macro.
2393 LexUnexpandedToken(Tok);
2397 // If we're in -traditional mode, then we should ignore stringification
2398 // and token pasting. Mark the tokens as unknown so as not to confuse
2400 if (getLangOpts().TraditionalCPP) {
2401 Tok.setKind(tok::unknown);
2402 MI->AddTokenToBody(Tok);
2404 // Get the next token of the macro.
2405 LexUnexpandedToken(Tok);
2409 if (Tok.is(tok::hashhash)) {
2410 // If we see token pasting, check if it looks like the gcc comma
2411 // pasting extension. We'll use this information to suppress
2412 // diagnostics later on.
2414 // Get the next token of the macro.
2415 LexUnexpandedToken(Tok);
2417 if (Tok.is(tok::eod)) {
2418 MI->AddTokenToBody(LastTok);
2422 unsigned NumTokens = MI->getNumTokens();
2423 if (NumTokens && Tok.getIdentifierInfo() == Ident__VA_ARGS__ &&
2424 MI->getReplacementToken(NumTokens-1).is(tok::comma))
2425 MI->setHasCommaPasting();
2427 // Things look ok, add the '##' token to the macro.
2428 MI->AddTokenToBody(LastTok);
2432 // Get the next token of the macro.
2433 LexUnexpandedToken(Tok);
2435 // Check for a valid macro arg identifier.
2436 if (Tok.getIdentifierInfo() == nullptr ||
2437 MI->getArgumentNum(Tok.getIdentifierInfo()) == -1) {
2439 // If this is assembler-with-cpp mode, we accept random gibberish after
2440 // the '#' because '#' is often a comment character. However, change
2441 // the kind of the token to tok::unknown so that the preprocessor isn't
2443 if (getLangOpts().AsmPreprocessor && Tok.isNot(tok::eod)) {
2444 LastTok.setKind(tok::unknown);
2445 MI->AddTokenToBody(LastTok);
2448 Diag(Tok, diag::err_pp_stringize_not_parameter)
2449 << LastTok.is(tok::hashat);
2451 // Disable __VA_ARGS__ again.
2452 Ident__VA_ARGS__->setIsPoisoned(true);
2457 // Things look ok, add the '#' and param name tokens to the macro.
2458 MI->AddTokenToBody(LastTok);
2459 MI->AddTokenToBody(Tok);
2462 // Get the next token of the macro.
2463 LexUnexpandedToken(Tok);
2467 if (MacroShadowsKeyword &&
2468 !isConfigurationPattern(MacroNameTok, MI, getLangOpts())) {
2469 Diag(MacroNameTok, diag::warn_pp_macro_hides_keyword);
2472 // Disable __VA_ARGS__ again.
2473 Ident__VA_ARGS__->setIsPoisoned(true);
2475 // Check that there is no paste (##) operator at the beginning or end of the
2476 // replacement list.
2477 unsigned NumTokens = MI->getNumTokens();
2478 if (NumTokens != 0) {
2479 if (MI->getReplacementToken(0).is(tok::hashhash)) {
2480 Diag(MI->getReplacementToken(0), diag::err_paste_at_start);
2483 if (MI->getReplacementToken(NumTokens-1).is(tok::hashhash)) {
2484 Diag(MI->getReplacementToken(NumTokens-1), diag::err_paste_at_end);
2489 MI->setDefinitionEndLoc(LastTok.getLocation());
2491 // Finally, if this identifier already had a macro defined for it, verify that
2492 // the macro bodies are identical, and issue diagnostics if they are not.
2493 if (const MacroInfo *OtherMI=getMacroInfo(MacroNameTok.getIdentifierInfo())) {
2494 // In Objective-C, ignore attempts to directly redefine the builtin
2495 // definitions of the ownership qualifiers. It's still possible to
2497 auto isObjCProtectedMacro = [](const IdentifierInfo *II) -> bool {
2498 return II->isStr("__strong") ||
2499 II->isStr("__weak") ||
2500 II->isStr("__unsafe_unretained") ||
2501 II->isStr("__autoreleasing");
2503 if (getLangOpts().ObjC1 &&
2504 SourceMgr.getFileID(OtherMI->getDefinitionLoc())
2505 == getPredefinesFileID() &&
2506 isObjCProtectedMacro(MacroNameTok.getIdentifierInfo())) {
2507 // Warn if it changes the tokens.
2508 if ((!getDiagnostics().getSuppressSystemWarnings() ||
2509 !SourceMgr.isInSystemHeader(DefineTok.getLocation())) &&
2510 !MI->isIdenticalTo(*OtherMI, *this,
2511 /*Syntactic=*/LangOpts.MicrosoftExt)) {
2512 Diag(MI->getDefinitionLoc(), diag::warn_pp_objc_macro_redef_ignored);
2514 assert(!OtherMI->isWarnIfUnused());
2518 // It is very common for system headers to have tons of macro redefinitions
2519 // and for warnings to be disabled in system headers. If this is the case,
2520 // then don't bother calling MacroInfo::isIdenticalTo.
2521 if (!getDiagnostics().getSuppressSystemWarnings() ||
2522 !SourceMgr.isInSystemHeader(DefineTok.getLocation())) {
2523 if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused())
2524 Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used);
2526 // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and
2527 // C++ [cpp.predefined]p4, but allow it as an extension.
2528 if (OtherMI->isBuiltinMacro())
2529 Diag(MacroNameTok, diag::ext_pp_redef_builtin_macro);
2530 // Macros must be identical. This means all tokens and whitespace
2531 // separation must be the same. C99 6.10.3p2.
2532 else if (!OtherMI->isAllowRedefinitionsWithoutWarning() &&
2533 !MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) {
2534 Diag(MI->getDefinitionLoc(), diag::ext_pp_macro_redef)
2535 << MacroNameTok.getIdentifierInfo();
2536 Diag(OtherMI->getDefinitionLoc(), diag::note_previous_definition);
2539 if (OtherMI->isWarnIfUnused())
2540 WarnUnusedMacroLocs.erase(OtherMI->getDefinitionLoc());
2543 DefMacroDirective *MD =
2544 appendDefMacroDirective(MacroNameTok.getIdentifierInfo(), MI);
2546 assert(!MI->isUsed());
2547 // If we need warning for not using the macro, add its location in the
2548 // warn-because-unused-macro set. If it gets used it will be removed from set.
2549 if (getSourceManager().isInMainFile(MI->getDefinitionLoc()) &&
2550 !Diags->isIgnored(diag::pp_macro_not_used, MI->getDefinitionLoc())) {
2551 MI->setIsWarnIfUnused(true);
2552 WarnUnusedMacroLocs.insert(MI->getDefinitionLoc());
2555 // If the callbacks want to know, tell them about the macro definition.
2557 Callbacks->MacroDefined(MacroNameTok, MD);
2560 /// HandleUndefDirective - Implements \#undef.
2562 void Preprocessor::HandleUndefDirective() {
2566 ReadMacroName(MacroNameTok, MU_Undef);
2568 // Error reading macro name? If so, diagnostic already issued.
2569 if (MacroNameTok.is(tok::eod))
2572 // Check to see if this is the last token on the #undef line.
2573 CheckEndOfDirective("undef");
2575 // Okay, we have a valid identifier to undef.
2576 auto *II = MacroNameTok.getIdentifierInfo();
2577 auto MD = getMacroDefinition(II);
2578 UndefMacroDirective *Undef = nullptr;
2580 // If the macro is not defined, this is a noop undef.
2581 if (const MacroInfo *MI = MD.getMacroInfo()) {
2582 if (!MI->isUsed() && MI->isWarnIfUnused())
2583 Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used);
2585 if (MI->isWarnIfUnused())
2586 WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
2588 Undef = AllocateUndefMacroDirective(MacroNameTok.getLocation());
2591 // If the callbacks want to know, tell them about the macro #undef.
2592 // Note: no matter if the macro was defined or not.
2594 Callbacks->MacroUndefined(MacroNameTok, MD, Undef);
2597 appendMacroDirective(II, Undef);
2600 //===----------------------------------------------------------------------===//
2601 // Preprocessor Conditional Directive Handling.
2602 //===----------------------------------------------------------------------===//
2604 /// HandleIfdefDirective - Implements the \#ifdef/\#ifndef directive. isIfndef
2605 /// is true when this is a \#ifndef directive. ReadAnyTokensBeforeDirective is
2606 /// true if any tokens have been returned or pp-directives activated before this
2607 /// \#ifndef has been lexed.
2609 void Preprocessor::HandleIfdefDirective(Token &Result, bool isIfndef,
2610 bool ReadAnyTokensBeforeDirective) {
2612 Token DirectiveTok = Result;
2615 ReadMacroName(MacroNameTok);
2617 // Error reading macro name? If so, diagnostic already issued.
2618 if (MacroNameTok.is(tok::eod)) {
2619 // Skip code until we get to #endif. This helps with recovery by not
2620 // emitting an error when the #endif is reached.
2621 SkipExcludedConditionalBlock(DirectiveTok.getLocation(),
2622 /*Foundnonskip*/false, /*FoundElse*/false);
2626 // Check to see if this is the last token on the #if[n]def line.
2627 CheckEndOfDirective(isIfndef ? "ifndef" : "ifdef");
2629 IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
2630 auto MD = getMacroDefinition(MII);
2631 MacroInfo *MI = MD.getMacroInfo();
2633 if (CurPPLexer->getConditionalStackDepth() == 0) {
2634 // If the start of a top-level #ifdef and if the macro is not defined,
2635 // inform MIOpt that this might be the start of a proper include guard.
2636 // Otherwise it is some other form of unknown conditional which we can't
2638 if (!ReadAnyTokensBeforeDirective && !MI) {
2639 assert(isIfndef && "#ifdef shouldn't reach here");
2640 CurPPLexer->MIOpt.EnterTopLevelIfndef(MII, MacroNameTok.getLocation());
2642 CurPPLexer->MIOpt.EnterTopLevelConditional();
2645 // If there is a macro, process it.
2646 if (MI) // Mark it used.
2647 markMacroAsUsed(MI);
2651 Callbacks->Ifndef(DirectiveTok.getLocation(), MacroNameTok, MD);
2653 Callbacks->Ifdef(DirectiveTok.getLocation(), MacroNameTok, MD);
2656 // Should we include the stuff contained by this directive?
2657 if (PPOpts->SingleFileParseMode && !MI) {
2658 // In 'single-file-parse mode' undefined identifiers trigger parsing of all
2659 // the directive blocks.
2660 CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),
2661 /*wasskip*/false, /*foundnonskip*/false,
2662 /*foundelse*/false);
2663 } else if (!MI == isIfndef) {
2664 // Yes, remember that we are inside a conditional, then lex the next token.
2665 CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),
2666 /*wasskip*/false, /*foundnonskip*/true,
2667 /*foundelse*/false);
2669 // No, skip the contents of this block.
2670 SkipExcludedConditionalBlock(DirectiveTok.getLocation(),
2671 /*Foundnonskip*/false,
2672 /*FoundElse*/false);
2676 /// HandleIfDirective - Implements the \#if directive.
2678 void Preprocessor::HandleIfDirective(Token &IfToken,
2679 bool ReadAnyTokensBeforeDirective) {
2682 // Parse and evaluate the conditional expression.
2683 IdentifierInfo *IfNDefMacro = nullptr;
2684 const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation();
2685 const DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);
2686 const bool ConditionalTrue = DER.Conditional;
2687 const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation();
2689 // If this condition is equivalent to #ifndef X, and if this is the first
2690 // directive seen, handle it for the multiple-include optimization.
2691 if (CurPPLexer->getConditionalStackDepth() == 0) {
2692 if (!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue)
2693 // FIXME: Pass in the location of the macro name, not the 'if' token.
2694 CurPPLexer->MIOpt.EnterTopLevelIfndef(IfNDefMacro, IfToken.getLocation());
2696 CurPPLexer->MIOpt.EnterTopLevelConditional();
2700 Callbacks->If(IfToken.getLocation(),
2701 SourceRange(ConditionalBegin, ConditionalEnd),
2702 (ConditionalTrue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False));
2704 // Should we include the stuff contained by this directive?
2705 if (PPOpts->SingleFileParseMode && DER.IncludedUndefinedIds) {
2706 // In 'single-file-parse mode' undefined identifiers trigger parsing of all
2707 // the directive blocks.
2708 CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false,
2709 /*foundnonskip*/false, /*foundelse*/false);
2710 } else if (ConditionalTrue) {
2711 // Yes, remember that we are inside a conditional, then lex the next token.
2712 CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false,
2713 /*foundnonskip*/true, /*foundelse*/false);
2715 // No, skip the contents of this block.
2716 SkipExcludedConditionalBlock(IfToken.getLocation(), /*Foundnonskip*/false,
2717 /*FoundElse*/false);
2721 /// HandleEndifDirective - Implements the \#endif directive.
2723 void Preprocessor::HandleEndifDirective(Token &EndifToken) {
2726 // Check that this is the whole directive.
2727 CheckEndOfDirective("endif");
2729 PPConditionalInfo CondInfo;
2730 if (CurPPLexer->popConditionalLevel(CondInfo)) {
2731 // No conditionals on the stack: this is an #endif without an #if.
2732 Diag(EndifToken, diag::err_pp_endif_without_if);
2736 // If this the end of a top-level #endif, inform MIOpt.
2737 if (CurPPLexer->getConditionalStackDepth() == 0)
2738 CurPPLexer->MIOpt.ExitTopLevelConditional();
2740 assert(!CondInfo.WasSkipping && !CurPPLexer->LexingRawMode &&
2741 "This code should only be reachable in the non-skipping case!");
2744 Callbacks->Endif(EndifToken.getLocation(), CondInfo.IfLoc);
2747 /// HandleElseDirective - Implements the \#else directive.
2749 void Preprocessor::HandleElseDirective(Token &Result) {
2752 // #else directive in a non-skipping conditional... start skipping.
2753 CheckEndOfDirective("else");
2755 PPConditionalInfo CI;
2756 if (CurPPLexer->popConditionalLevel(CI)) {
2757 Diag(Result, diag::pp_err_else_without_if);
2761 // If this is a top-level #else, inform the MIOpt.
2762 if (CurPPLexer->getConditionalStackDepth() == 0)
2763 CurPPLexer->MIOpt.EnterTopLevelConditional();
2765 // If this is a #else with a #else before it, report the error.
2766 if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else);
2769 Callbacks->Else(Result.getLocation(), CI.IfLoc);
2771 if (PPOpts->SingleFileParseMode && !CI.FoundNonSkip) {
2772 // In 'single-file-parse mode' undefined identifiers trigger parsing of all
2773 // the directive blocks.
2774 CurPPLexer->pushConditionalLevel(CI.IfLoc, /*wasskip*/false,
2775 /*foundnonskip*/false, /*foundelse*/true);
2779 // Finally, skip the rest of the contents of this block.
2780 SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true,
2781 /*FoundElse*/true, Result.getLocation());
2784 /// HandleElifDirective - Implements the \#elif directive.
2786 void Preprocessor::HandleElifDirective(Token &ElifToken) {
2789 // #elif directive in a non-skipping conditional... start skipping.
2790 // We don't care what the condition is, because we will always skip it (since
2791 // the block immediately before it was included).
2792 const SourceLocation ConditionalBegin = CurPPLexer->getSourceLocation();
2793 DiscardUntilEndOfDirective();
2794 const SourceLocation ConditionalEnd = CurPPLexer->getSourceLocation();
2796 PPConditionalInfo CI;
2797 if (CurPPLexer->popConditionalLevel(CI)) {
2798 Diag(ElifToken, diag::pp_err_elif_without_if);
2802 // If this is a top-level #elif, inform the MIOpt.
2803 if (CurPPLexer->getConditionalStackDepth() == 0)
2804 CurPPLexer->MIOpt.EnterTopLevelConditional();
2806 // If this is a #elif with a #else before it, report the error.
2807 if (CI.FoundElse) Diag(ElifToken, diag::pp_err_elif_after_else);
2810 Callbacks->Elif(ElifToken.getLocation(),
2811 SourceRange(ConditionalBegin, ConditionalEnd),
2812 PPCallbacks::CVK_NotEvaluated, CI.IfLoc);
2814 if (PPOpts->SingleFileParseMode && !CI.FoundNonSkip) {
2815 // In 'single-file-parse mode' undefined identifiers trigger parsing of all
2816 // the directive blocks.
2817 CurPPLexer->pushConditionalLevel(ElifToken.getLocation(), /*wasskip*/false,
2818 /*foundnonskip*/false, /*foundelse*/false);
2822 // Finally, skip the rest of the contents of this block.
2823 SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true,
2824 /*FoundElse*/CI.FoundElse,
2825 ElifToken.getLocation());