contrib/llvm/tools/clang/lib/Lex/PPDirectives.cpp

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