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