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