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