• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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"
16 #include "clang/Basic/FileManager.h"
17 #include "clang/Basic/SourceManager.h"
18 #include "clang/Lex/CodeCompletionHandler.h"
19 #include "clang/Lex/HeaderSearch.h"
20 #include "clang/Lex/HeaderSearchOptions.h"
21 #include "clang/Lex/LexDiagnostic.h"
22 #include "clang/Lex/LiteralSupport.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 
AllocateMacroInfo()41 MacroInfo *Preprocessor::AllocateMacroInfo() {
42   MacroInfoChain *MIChain = BP.Allocate<MacroInfoChain>();
43   MIChain->Next = MIChainHead;
44   MIChainHead = MIChain;
45   return &MIChain->MI;
46 }
47 
AllocateMacroInfo(SourceLocation L)48 MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) {
49   MacroInfo *MI = AllocateMacroInfo();
50   new (MI) MacroInfo(L);
51   return MI;
52 }
53 
AllocateDeserializedMacroInfo(SourceLocation L,unsigned SubModuleID)54 MacroInfo *Preprocessor::AllocateDeserializedMacroInfo(SourceLocation L,
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 
AllocateDefMacroDirective(MacroInfo * MI,SourceLocation Loc)70 DefMacroDirective *Preprocessor::AllocateDefMacroDirective(MacroInfo *MI,
71                                                            SourceLocation Loc) {
72   return new (BP) DefMacroDirective(MI, Loc);
73 }
74 
75 UndefMacroDirective *
AllocateUndefMacroDirective(SourceLocation UndefLoc)76 Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) {
77   return new (BP) UndefMacroDirective(UndefLoc);
78 }
79 
80 VisibilityMacroDirective *
AllocateVisibilityMacroDirective(SourceLocation Loc,bool isPublic)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.
DiscardUntilEndOfDirective()88 void Preprocessor::DiscardUntilEndOfDirective() {
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.
isReservedId(StringRef Text,const LangOptions & Lang)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 
shouldWarnOnMacroDef(Preprocessor & PP,IdentifierInfo * II)123 static MacroDiag shouldWarnOnMacroDef(Preprocessor &PP, IdentifierInfo *II) {
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 
shouldWarnOnMacroUndef(Preprocessor & PP,IdentifierInfo * II)135 static MacroDiag shouldWarnOnMacroUndef(Preprocessor &PP, IdentifierInfo *II) {
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.
warnByDefaultOnWrongCase(StringRef Include)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 
CheckMacroName(Token & MacroNameTok,MacroUse isDefineUndef,bool * ShadowFlag)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.
ReadMacroName(Token & MacroNameTok,MacroUse isDefineUndef,bool * ShadowFlag)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);
310     setCodeCompletionReached();
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);
321     DiscardUntilEndOfDirective();
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.
CheckEndOfDirective(const char * DirType,bool EnableMacros)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;
354     DiscardUntilEndOfDirective();
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.
SkipExcludedConditionalBlock(SourceLocation IfTokenLoc,bool FoundNonSkipPortion,bool FoundElse,SourceLocation ElseLoc)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();
391       setCodeCompletionReached();
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.
476         DiscardUntilEndOfDirective();
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 {
501           DiscardUntilEndOfDirective();
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) {
539           DiscardUntilEndOfDirective();
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 
PTHSkipExcludedConditionalBlock()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.
603     tok::PPKeywordKind K = Tok.getIdentifierInfo()->getPPKeywordID();
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;
619         DiscardUntilEndOfDirective();
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 
getModuleForLocation(SourceLocation Loc)657 Module *Preprocessor::getModuleForLocation(SourceLocation Loc) {
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 
getModuleContainingLocation(SourceLocation Loc)677 Module *Preprocessor::getModuleContainingLocation(SourceLocation Loc) {
678   return HeaderInfo.getModuleMap().inferModuleFromLocation(
679       FullSourceLoc(Loc, SourceMgr));
680 }
681 
682 const FileEntry *
getModuleHeaderToIncludeForDiagnostics(SourceLocation IncLoc,SourceLocation Loc)683 Preprocessor::getModuleHeaderToIncludeForDiagnostics(SourceLocation IncLoc,
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.
691   Module *M = getModuleContainingLocation(Loc);
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 
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)738 const FileEntry *Preprocessor::LookupFile(
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.
754   SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 16>
755       Includers;
756   bool BuildSystemModule = false;
757   if (!FromDir && !FromFile) {
758     FileID FID = getCurrentFileLexer()->getFileID();
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)
827       HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
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)
844           HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
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)
860             HeaderInfo.getModuleMap().diagnoseHeaderInclusion(
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 
877 class Preprocessor::ResetMacroExpansionHelper {
878 public:
ResetMacroExpansionHelper(Preprocessor * pp)879   ResetMacroExpansionHelper(Preprocessor *pp)
880     : PP(pp), save(pp->DisableMacroExpansion) {
881     if (pp->MacroExpansionInDirectivesOverride)
882       pp->DisableMacroExpansion = false;
883   }
884 
~ResetMacroExpansionHelper()885   ~ResetMacroExpansionHelper() {
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.
HandleDirective(Token & Result)898 void Preprocessor::HandleDirective(Token &Result) {
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 =
908       CurPPLexer->MIOpt.getImmediatelyAfterTopLevelIfndef();
909   CurPPLexer->MIOpt.resetImmediatelyAfterTopLevelIfndef();
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();
942         DiscardUntilEndOfDirective();
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);
962     setCodeCompletionReached();
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.
1074   DiscardUntilEndOfDirective();
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.
GetLineValue(Token & DigitTok,unsigned & Val,unsigned DiagID,Preprocessor & PP,bool IsGNULineDirective=false)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))
1088       PP.DiscardUntilEndOfDirective();
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;
1113       PP.DiscardUntilEndOfDirective();
1114       return true;
1115     }
1116 
1117     unsigned NextVal = Val*10+(DigitTokBegin[i]-'0');
1118     if (NextVal < Val) { // overflow.
1119       PP.Diag(DigitTok, DiagID);
1120       PP.DiscardUntilEndOfDirective();
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
HandleLineDirective(Token & Tok)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(),
1199                            PPCallbacks::RenameFile,
1200                            SrcMgr::C_User);
1201 }
1202 
1203 /// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line
1204 /// marker directive.
ReadLineMarkerFlags(bool & IsFileEntry,bool & IsFileExit,bool & IsSystemHeader,bool & IsExternCHeader,Preprocessor & PP)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 
1225     SourceManager &SM = PP.getSourceManager();
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);
1240       PP.DiscardUntilEndOfDirective();
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);
1253     PP.DiscardUntilEndOfDirective();
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);
1267     PP.DiscardUntilEndOfDirective();
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);
1278   PP.DiscardUntilEndOfDirective();
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 ///
HandleDigitDirective(Token & DigitTok)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) {
1341     PPCallbacks::FileChangeReason Reason = PPCallbacks::RenameFile;
1342     if (IsFileEntry)
1343       Reason = PPCallbacks::EnterFile;
1344     else if (IsFileExit)
1345       Reason = PPCallbacks::ExitFile;
1346     SrcMgr::CharacteristicKind FileKind = SrcMgr::C_User;
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 ///
HandleUserDiagnosticDirective(Token & Tok,bool isWarning)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 ///
HandleIdentSCCSDirective(Token & Tok)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))
1397       DiscardUntilEndOfDirective();
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.
HandleMacroPublicDirective(Token & Tok)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.
1431   MacroDirective *MD = getLocalMacroDirective(II);
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.
HandleMacroPrivateDirective(Token & Tok)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.
1458   MacroDirective *MD = getLocalMacroDirective(II);
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.
GetIncludeFilenameSpelling(SourceLocation Loc,StringRef & Buffer)1481 bool Preprocessor::GetIncludeFilenameSpelling(SourceLocation Loc,
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.
ConcatenateIncludeName(SmallString<128> & FilenameBuffer,SourceLocation & End)1533 bool Preprocessor::ConcatenateIncludeName(SmallString<128> &FilenameBuffer,
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)) {
1543       setCodeCompletionReached();
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.
EnterAnnotationToken(Preprocessor & PP,SourceLocation Begin,SourceLocation End,tok::TokenKind Kind,void * AnnotationVal)1582 static void EnterAnnotationToken(Preprocessor &PP,
1583                                  SourceLocation Begin, SourceLocation End,
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.
diagnoseAutoModuleImport(Preprocessor & PP,SourceLocation HashLoc,Token & IncludeTok,ArrayRef<std::pair<IdentifierInfo *,SourceLocation>> Path,SourceLocation PathEnd)1598 static void diagnoseAutoModuleImport(
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.
trySimplifyPath(SmallVectorImpl<StringRef> & Components,StringRef RealPathName)1644 static bool trySimplifyPath(SmallVectorImpl<StringRef> &Components,
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.
HandleIncludeDirective(SourceLocation HashLoc,Token & IncludeTok,const DirectoryLookup * LookupFrom,const FileEntry * LookupFromFile,bool isImport)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;
1690   SourceLocation End;
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);
1716     DiscardUntilEndOfDirective();
1717     return;
1718   }
1719 
1720   CharSourceRange FilenameRange
1721     = CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd);
1722   StringRef OriginalFilename = Filename;
1723   bool isAngled =
1724     GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
1725   // If GetIncludeFilenameSpelling set the start ptr to null, there was an
1726   // error.
1727   if (Filename.empty()) {
1728     DiscardUntilEndOfDirective();
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() !=
1849           getLangOpts().CurrentModule) {
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()
1857              ->HasIncompatibleModuleFile) {
1858       clang::Module::Requirement Requirement;
1859       clang::Module::UnresolvedHeaderDirective MissingHeader;
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?
1880     SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
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.
1911       if (hadModuleLoaderFatalFailure()) {
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();
1957     SmallVector<StringRef, 16> Components(llvm::sys::path::begin(Name),
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 <<
1978         FixItHint::CreateReplacement(Range, 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 ///
HandleIncludeNextDirective(SourceLocation HashLoc,Token & IncludeNextTok)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
HandleMicrosoftImportDirective(Token & Tok)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.
2077   DiscardUntilEndOfDirective();
2078 }
2079 
2080 /// HandleImportDirective - Implements \#import.
2081 ///
HandleImportDirective(SourceLocation HashLoc,Token & ImportTok)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).
HandleIncludeMacrosDirective(SourceLocation HashLoc,Token & IncludeMacrosTok)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);
2104     DiscardUntilEndOfDirective();
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.
ReadMacroDefinitionArgList(MacroInfo * MI,Token & Tok)2127 bool Preprocessor::ReadMacroDefinitionArgList(MacroInfo *MI, Token &Tok) {
2128   SmallVector<IdentifierInfo*, 32> Arguments;
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 
isConfigurationPattern(Token & MacroName,MacroInfo * MI,const LangOptions & LOptions)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.
HandleDefineDirective(Token & DefineTok,bool ImmediatelyAfterHeaderGuard)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)
2306         DiscardUntilEndOfDirective();
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.
2485       if ((!getDiagnostics().getSuppressSystemWarnings() ||
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.
2498     if (!getDiagnostics().getSuppressSystemWarnings() ||
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.
2526   if (getSourceManager().isInMainFile(MI->getDefinitionLoc()) &&
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 ///
HandleUndefDirective(Token & UndefTok)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 ///
HandleIfdefDirective(Token & Result,bool isIfndef,bool ReadAnyTokensBeforeDirective)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 ///
HandleIfDirective(Token & IfToken,bool ReadAnyTokensBeforeDirective)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 ///
HandleEndifDirective(Token & EndifToken)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 ///
HandleElseDirective(Token & Result)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 ///
HandleElifDirective(Token & ElifToken)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();
2749   DiscardUntilEndOfDirective();
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),
2768                     PPCallbacks::CVK_NotEvaluated, CI.IfLoc);
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 }
2775