//===--- PPDirectives.cpp - Directive Handling for Preprocessor -----------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

///

/// \file

/// Implements # directive processing for the Preprocessor.

///

//===----------------------------------------------------------------------===//

#include "clang/Basic/CharInfo.h"

#include "clang/Basic/FileManager.h"

#include "clang/Basic/IdentifierTable.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/Module.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/SourceManager.h"

#include "clang/Basic/TokenKinds.h"

#include "clang/Lex/CodeCompletionHandler.h"

#include "clang/Lex/HeaderSearch.h"

#include "clang/Lex/LexDiagnostic.h"

#include "clang/Lex/LiteralSupport.h"

#include "clang/Lex/MacroInfo.h"

#include "clang/Lex/ModuleLoader.h"

#include "clang/Lex/ModuleMap.h"

#include "clang/Lex/PPCallbacks.h"

#include "clang/Lex/Pragma.h"

#include "clang/Lex/Preprocessor.h"

#include "clang/Lex/PreprocessorOptions.h"

#include "clang/Lex/Token.h"

#include "clang/Lex/VariadicMacroSupport.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/ScopeExit.h"

#include "llvm/ADT/SmallString.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/StringSwitch.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/Support/AlignOf.h"

#include "llvm/Support/ErrorHandling.h"

#include "llvm/Support/Path.h"

#include <algorithm>

#include <cassert>

#include <cstring>

#include <new>

#include <string>

#include <utility>

using namespace clang;

//===----------------------------------------------------------------------===//

// Utility Methods for Preprocessor Directive Handling.

//===----------------------------------------------------------------------===//

MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) {

  auto *MIChain = new (BP) MacroInfoChain{L, MIChainHead};

  MIChainHead = MIChain;

  return &MIChain->MI;

}

DefMacroDirective *Preprocessor::AllocateDefMacroDirective(MacroInfo *MI,

                                                           SourceLocation Loc) {

  return new (BP) DefMacroDirective(MI, Loc);

}

UndefMacroDirective *

Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) {

  return new (BP) UndefMacroDirective(UndefLoc);

}

VisibilityMacroDirective *

Preprocessor::AllocateVisibilityMacroDirective(SourceLocation Loc,

                                               bool isPublic) {

  return new (BP) VisibilityMacroDirective(Loc, isPublic);

}

/// Read and discard all tokens remaining on the current line until

/// the tok::eod token is found.

SourceRange Preprocessor::DiscardUntilEndOfDirective() {

  Token Tmp;

  SourceRange Res;

  LexUnexpandedToken(Tmp);

  Res.setBegin(Tmp.getLocation());

  while (Tmp.isNot(tok::eod)) {

    assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens");

    LexUnexpandedToken(Tmp);

  }

  Res.setEnd(Tmp.getLocation());

  return Res;

}

/// Enumerates possible cases of #define/#undef a reserved identifier.

enum MacroDiag {

  MD_NoWarn,        //> Not a reserved identifier

  MD_KeywordDef,    //> Macro hides keyword, enabled by default

  MD_ReservedMacro  //> #define of #undef reserved id, disabled by default

};

/// Checks if the specified identifier is reserved in the specified

/// language.

/// This function does not check if the identifier is a keyword.

static bool isReservedId(StringRef Text, const LangOptions &Lang) {

  // C++ [macro.names], C11 7.1.3:

  // All identifiers that begin with an underscore and either an uppercase

  // letter or another underscore are always reserved for any use.

  if (Text.size() >= 2 && 
Text[0] == '_'3.66M
 &&

      
(835k
isUppercase(Text[1])835k
 || 
Text[1] == '_'534k
))

      return true;

  // C++ [global.names]

  // Each name that contains a double underscore ... is reserved to the

  // implementation for any use.

  if (Lang.CPlusPlus) {

    if (Text.find("__") != StringRef::npos)

      return true;

  }

  return false;

}

// The -fmodule-name option tells the compiler to textually include headers in

// the specified module, meaning clang won't build the specified module. This is

// useful in a number of situations, for instance, when building a library that

// vends a module map, one might want to avoid hitting intermediate build

// products containimg the the module map or avoid finding the system installed

// modulemap for that library.

static bool isForModuleBuilding(Module *M, StringRef CurrentModule,

                                StringRef ModuleName) {

  StringRef TopLevelName = M->getTopLevelModuleName();

  // When building framework Foo, we wanna make sure that Foo *and* Foo_Private

  // are textually included and no modules are built for both.

  if (M->getTopLevelModule()->IsFramework && 
CurrentModule == ModuleName18.1k
 &&

      
!CurrentModule.endswith("_Private")416
 && 
TopLevelName.endswith("_Private")416
)

    TopLevelName = TopLevelName.drop_back(8);

  return TopLevelName == CurrentModule;

}

static MacroDiag shouldWarnOnMacroDef(Preprocessor &PP, IdentifierInfo *II) {

  const LangOptions &Lang = PP.getLangOpts();

  StringRef Text = II->getName();

  if (isReservedId(Text, Lang))

    return MD_ReservedMacro;

  if (II->isKeyword(Lang))

    return MD_KeywordDef;

  if (Lang.CPlusPlus11 && 
(1.92M
Text.equals("override")1.92M
 || 
Text.equals("final")1.92M
))

    return MD_KeywordDef;

  return MD_NoWarn;

}

static MacroDiag shouldWarnOnMacroUndef(Preprocessor &PP, IdentifierInfo *II) {

  const LangOptions &Lang = PP.getLangOpts();

  StringRef Text = II->getName();

  // Do not warn on keyword undef.  It is generally harmless and widely used.

  if (isReservedId(Text, Lang))

    return MD_ReservedMacro;

  return MD_NoWarn;

}

// Return true if we want to issue a diagnostic by default if we

// encounter this name in a #include with the wrong case. For now,

// this includes the standard C and C++ headers, Posix headers,

// and Boost headers. Improper case for these #includes is a

// potential portability issue.

static bool warnByDefaultOnWrongCase(StringRef Include) {

  // If the first component of the path is "boost", treat this like a standard header

  // for the purposes of diagnostics.

  if (::llvm::sys::path::begin(Include)->equals_lower("boost"))

    return true;

  // "condition_variable" is the longest standard header name at 18 characters.

  // If the include file name is longer than that, it can't be a standard header.

  static const size_t MaxStdHeaderNameLen = 18u;

  if (Include.size() > MaxStdHeaderNameLen)

    return false;

  // Lowercase and normalize the search string.

  SmallString<32> LowerInclude{Include};

  for (char &Ch : LowerInclude) {

    // In the ASCII range?

    if (static_cast<unsigned char>(Ch) > 0x7f)

      return false; // Can't be a standard header

    // ASCII lowercase:

    if (Ch >= 'A' && Ch <= 'Z')

      Ch += 'a' - 'A';

    // Normalize path separators for comparison purposes.

    else if (::llvm::sys::path::is_separator(Ch))

      Ch = '/';

  }

  // The standard C/C++ and Posix headers

  return llvm::StringSwitch<bool>(LowerInclude)

    // C library headers

    .Cases("assert.h", "complex.h", "ctype.h", "errno.h", "fenv.h", true)

    .Cases("float.h", "inttypes.h", "iso646.h", "limits.h", "locale.h", true)

    .Cases("math.h", "setjmp.h", "signal.h", "stdalign.h", "stdarg.h", true)

    .Cases("stdatomic.h", "stdbool.h", "stddef.h", "stdint.h", "stdio.h", true)

    .Cases("stdlib.h", "stdnoreturn.h", "string.h", "tgmath.h", "threads.h", true)

    .Cases("time.h", "uchar.h", "wchar.h", "wctype.h", true)

    // C++ headers for C library facilities

    .Cases("cassert", "ccomplex", "cctype", "cerrno", "cfenv", true)

    .Cases("cfloat", "cinttypes", "ciso646", "climits", "clocale", true)

    .Cases("cmath", "csetjmp", "csignal", "cstdalign", "cstdarg", true)

    .Cases("cstdbool", "cstddef", "cstdint", "cstdio", "cstdlib", true)

    .Cases("cstring", "ctgmath", "ctime", "cuchar", "cwchar", true)

    .Case("cwctype", true)

    // C++ library headers

    .Cases("algorithm", "fstream", "list", "regex", "thread", true)

    .Cases("array", "functional", "locale", "scoped_allocator", "tuple", true)

    .Cases("atomic", "future", "map", "set", "type_traits", true)

    .Cases("bitset", "initializer_list", "memory", "shared_mutex", "typeindex", true)

    .Cases("chrono", "iomanip", "mutex", "sstream", "typeinfo", true)

    .Cases("codecvt", "ios", "new", "stack", "unordered_map", true)

    .Cases("complex", "iosfwd", "numeric", "stdexcept", "unordered_set", true)

    .Cases("condition_variable", "iostream", "ostream", "streambuf", "utility", true)

    .Cases("deque", "istream", "queue", "string", "valarray", true)

    .Cases("exception", "iterator", "random", "strstream", "vector", true)

    .Cases("forward_list", "limits", "ratio", "system_error", true)

    // POSIX headers (which aren't also C headers)

    .Cases("aio.h", "arpa/inet.h", "cpio.h", "dirent.h", "dlfcn.h", true)

    .Cases("fcntl.h", "fmtmsg.h", "fnmatch.h", "ftw.h", "glob.h", true)

    .Cases("grp.h", "iconv.h", "langinfo.h", "libgen.h", "monetary.h", true)

    .Cases("mqueue.h", "ndbm.h", "net/if.h", "netdb.h", "netinet/in.h", true)

    .Cases("netinet/tcp.h", "nl_types.h", "poll.h", "pthread.h", "pwd.h", true)

    .Cases("regex.h", "sched.h", "search.h", "semaphore.h", "spawn.h", true)

    .Cases("strings.h", "stropts.h", "sys/ipc.h", "sys/mman.h", "sys/msg.h", true)

    .Cases("sys/resource.h", "sys/select.h",  "sys/sem.h", "sys/shm.h", "sys/socket.h", true)

    .Cases("sys/stat.h", "sys/statvfs.h", "sys/time.h", "sys/times.h", "sys/types.h", true)

    .Cases("sys/uio.h", "sys/un.h", "sys/utsname.h", "sys/wait.h", "syslog.h", true)

    .Cases("tar.h", "termios.h", "trace.h", "ulimit.h", true)

    .Cases("unistd.h", "utime.h", "utmpx.h", "wordexp.h", true)

    .Default(false);

}

bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef,

                                  bool *ShadowFlag) {

  // Missing macro name?

  if (MacroNameTok.is(tok::eod))

    return Diag(MacroNameTok, diag::err_pp_missing_macro_name);

  IdentifierInfo *II = MacroNameTok.getIdentifierInfo();

  if (!II)

    return Diag(MacroNameTok, diag::err_pp_macro_not_identifier);

  if (II->isCPlusPlusOperatorKeyword()) {

    // C++ 2.5p2: Alternative tokens behave the same as its primary token

    // except for their spellings.

    Diag(MacroNameTok, getLangOpts().MicrosoftExt

                           ? 
diag::ext_pp_operator_used_as_macro_name15

                           : 
diag::err_pp_operator_used_as_macro_name3
)

        << II << MacroNameTok.getKind();

    // Allow #defining |and| and friends for Microsoft compatibility or

    // recovery when legacy C headers are included in C++.

  }

  if ((isDefineUndef != MU_Other) && 
II->getPPKeywordID() == tok::pp_defined34.5M
) {

    // Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4.

    return Diag(MacroNameTok, diag::err_defined_macro_name);

  }

  if (isDefineUndef == MU_Undef) {

    auto *MI = getMacroInfo(II);

    if (MI && 
MI->isBuiltinMacro()122k
) {

      // Warn if undefining "__LINE__" and other builtins, per C99 6.10.8/4

      // and C++ [cpp.predefined]p4], but allow it as an extension.

      Diag(MacroNameTok, diag::ext_pp_undef_builtin_macro);

    }

  }

  // If defining/undefining reserved identifier or a keyword, we need to issue

  // a warning.

  SourceLocation MacroNameLoc = MacroNameTok.getLocation();

  if (ShadowFlag)

    *ShadowFlag = false;

  if (!SourceMgr.isInSystemHeader(MacroNameLoc) &&

      
(SourceMgr.getBufferName(MacroNameLoc) != "<built-in>")4.11M
) {

    MacroDiag D = MD_NoWarn;

    if (isDefineUndef == MU_Define) {

      D = shouldWarnOnMacroDef(*this, II);

    }

    else if (isDefineUndef == MU_Undef)

      D = shouldWarnOnMacroUndef(*this, II);

    if (D == MD_KeywordDef) {

      // We do not want to warn on some patterns widely used in configuration

      // scripts.  This requires analyzing next tokens, so do not issue warnings

      // now, only inform caller.

      if (ShadowFlag)

        *ShadowFlag = true;

    }

    if (D == MD_ReservedMacro)

      Diag(MacroNameTok, diag::warn_pp_macro_is_reserved_id);

  }

  // Okay, we got a good identifier.

  return false;

}

/// Lex and validate a macro name, which occurs after a

/// \#define or \#undef.

///

/// This sets the token kind to eod and discards the rest of the macro line if

/// the macro name is invalid.

///

/// \param MacroNameTok Token that is expected to be a macro name.

/// \param isDefineUndef Context in which macro is used.

/// \param ShadowFlag Points to a flag that is set if macro shadows a keyword.

void Preprocessor::ReadMacroName(Token &MacroNameTok, MacroUse isDefineUndef,

                                 bool *ShadowFlag) {

  // Read the token, don't allow macro expansion on it.

  LexUnexpandedToken(MacroNameTok);

  if (MacroNameTok.is(tok::code_completion)) {

    if (CodeComplete)

      CodeComplete->CodeCompleteMacroName(isDefineUndef == MU_Define);

    setCodeCompletionReached();

    LexUnexpandedToken(MacroNameTok);

  }

  if (!CheckMacroName(MacroNameTok, isDefineUndef, ShadowFlag))

    return;

  // Invalid macro name, read and discard the rest of the line and set the

  // token kind to tok::eod if necessary.

  if (MacroNameTok.isNot(tok::eod)) {

    MacroNameTok.setKind(tok::eod);

    DiscardUntilEndOfDirective();

  }

}

/// Ensure that the next token is a tok::eod token.

///

/// If not, emit a diagnostic and consume up until the eod.  If EnableMacros is

/// true, then we consider macros that expand to zero tokens as being ok.

///

/// Returns the location of the end of the directive.

SourceLocation Preprocessor::CheckEndOfDirective(const char *DirType,

                                                 bool EnableMacros) {

  Token Tmp;

  // Lex unexpanded tokens for most directives: macros might expand to zero

  // tokens, causing us to miss diagnosing invalid lines.  Some directives (like

  // #line) allow empty macros.

  if (EnableMacros)

    Lex(Tmp);

  else

    LexUnexpandedToken(Tmp);

  // There should be no tokens after the directive, but we allow them as an

  // extension.

  while (Tmp.is(tok::comment))  // Skip comments in -C mode.

    LexUnexpandedToken(Tmp);

  if (Tmp.is(tok::eod))

    return Tmp.getLocation();

  // Add a fixit in GNU/C99/C++ mode.  Don't offer a fixit for strict-C89,

  // or if this is a macro-style preprocessing directive, because it is more

  // trouble than it is worth to insert /**/ and check that there is no /**/

  // in the range also.

  FixItHint Hint;

  if ((LangOpts.GNUMode || 
LangOpts.C991
 || 
LangOpts.CPlusPlus0
) &&

      !CurTokenLexer)

    Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//");

  Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint;

  return DiscardUntilEndOfDirective().getEnd();

}

Optional<unsigned> Preprocessor::getSkippedRangeForExcludedConditionalBlock(

    SourceLocation HashLoc) {

  if (!ExcludedConditionalDirectiveSkipMappings)

    return None;

  if (!HashLoc.isFileID())

    return None;

  std::pair<FileID, unsigned> HashFileOffset =

      SourceMgr.getDecomposedLoc(HashLoc);

  const llvm::MemoryBuffer *Buf = SourceMgr.getBuffer(HashFileOffset.first);

  auto It = ExcludedConditionalDirectiveSkipMappings->find(Buf);

  if (It == ExcludedConditionalDirectiveSkipMappings->end())

    return None;

  const PreprocessorSkippedRangeMapping &SkippedRanges = *It->getSecond();

  // Check if the offset of '#' is mapped in the skipped ranges.

  auto MappingIt = SkippedRanges.find(HashFileOffset.second);

  if (MappingIt == SkippedRanges.end())

    return None;

  unsigned BytesToSkip = MappingIt->getSecond();

  unsigned CurLexerBufferOffset = CurLexer->getCurrentBufferOffset();

  assert(CurLexerBufferOffset >= HashFileOffset.second &&

         "lexer is before the hash?");

  // Take into account the fact that the lexer has already advanced, so the

  // number of bytes to skip must be adjusted.

  unsigned LengthDiff = CurLexerBufferOffset - HashFileOffset.second;

  assert(BytesToSkip >= LengthDiff && "lexer is after the skipped range?");

  return BytesToSkip - LengthDiff;

}

/// SkipExcludedConditionalBlock - We just read a \#if or related directive and

/// decided that the subsequent tokens are in the \#if'd out portion of the

/// file.  Lex the rest of the file, until we see an \#endif.  If

/// FoundNonSkipPortion is true, then we have already emitted code for part of

/// this \#if directive, so \#else/\#elif blocks should never be entered.

/// If ElseOk is true, then \#else directives are ok, if not, then we have

/// already seen one so a \#else directive is a duplicate.  When this returns,

/// the caller can lex the first valid token.

void Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc,

                                                SourceLocation IfTokenLoc,

                                                bool FoundNonSkipPortion,

                                                bool FoundElse,

                                                SourceLocation ElseLoc) {

  ++NumSkipped;

  assert(!CurTokenLexer && CurPPLexer && "Lexing a macro, not a file?");

  if (PreambleConditionalStack.reachedEOFWhileSkipping())

    PreambleConditionalStack.clearSkipInfo();

  else

    CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/ false,

                                     FoundNonSkipPortion, FoundElse);

  // Enter raw mode to disable identifier lookup (and thus macro expansion),

  // disabling warnings, etc.

  CurPPLexer->LexingRawMode = true;

  Token Tok;

  if (auto SkipLength =

          getSkippedRangeForExcludedConditionalBlock(HashTokenLoc)) {

    // Skip to the next '#endif' / '#else' / '#elif'.

    CurLexer->skipOver(*SkipLength);

  }

  while (true) {

    CurLexer->Lex(Tok);

    if (Tok.is(tok::code_completion)) {

      if (CodeComplete)

        CodeComplete->CodeCompleteInConditionalExclusion();

      setCodeCompletionReached();

      continue;

    }

    // If this is the end of the buffer, we have an error.

    if (Tok.is(tok::eof)) {

      // We don't emit errors for unterminated conditionals here,

      // Lexer::LexEndOfFile can do that properly.

      // Just return and let the caller lex after this #include.

      if (PreambleConditionalStack.isRecording())

        PreambleConditionalStack.SkipInfo.emplace(

            HashTokenLoc, IfTokenLoc, FoundNonSkipPortion, FoundElse, ElseLoc);

      break;

    }

    // If this token is not a preprocessor directive, just skip it.

    if (Tok.isNot(tok::hash) || 
!Tok.isAtStartOfLine()133M
)

      continue;

    // We just parsed a # character at the start of a line, so we're in

    // directive mode.  Tell the lexer this so any newlines we see will be

    // converted into an EOD token (this terminates the macro).

    CurPPLexer->ParsingPreprocessorDirective = true;

    if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);

    // Read the next token, the directive flavor.

    LexUnexpandedToken(Tok);

    // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or

    // something bogus), skip it.

    if (Tok.isNot(tok::raw_identifier)) {

      CurPPLexer->ParsingPreprocessorDirective = false;

      // Restore comment saving mode.

      if (CurLexer) CurLexer->resetExtendedTokenMode();

      continue;

    }

    // If the first letter isn't i or e, it isn't intesting to us.  We know that

    // this is safe in the face of spelling differences, because there is no way

    // to spell an i/e in a strange way that is another letter.  Skipping this

    // allows us to avoid looking up the identifier info for #define/#undef and

    // other common directives.

    StringRef RI = Tok.getRawIdentifier();

    char FirstChar = RI[0];

    if (FirstChar >= 'a' && 
FirstChar <= 'z'133M
 &&

        
FirstChar != 'i'133M
 && 
FirstChar != 'e'128M
) {

      CurPPLexer->ParsingPreprocessorDirective = false;

      // Restore comment saving mode.

      if (CurLexer) CurLexer->resetExtendedTokenMode();

      continue;

    }

    // Get the identifier name without trigraphs or embedded newlines.  Note

    // that we can't use Tok.getIdentifierInfo() because its lookup is disabled

    // when skipping.

    char DirectiveBuf[20];

    StringRef Directive;

    if (!Tok.needsCleaning() && 
RI.size() < 2018.7M
) {

      Directive = RI;

    } else {

      std::string DirectiveStr = getSpelling(Tok);

      size_t IdLen = DirectiveStr.size();

      if (IdLen >= 20) {

        CurPPLexer->ParsingPreprocessorDirective = false;

        // Restore comment saving mode.

        if (CurLexer) CurLexer->resetExtendedTokenMode();

        continue;

      }

      memcpy(DirectiveBuf, &DirectiveStr[0], IdLen);

      Directive = StringRef(DirectiveBuf, IdLen);

    }

    if (Directive.startswith("if")) {

      StringRef Sub = Directive.substr(2);

      if (Sub.empty() ||   // "if"

          
Sub == "def"836k
 ||   // "ifdef"

          
Sub == "ndef"416k
) {  // "ifndef"

        // We know the entire #if/#ifdef/#ifndef block will be skipped, don't

        // bother parsing the condition.

        DiscardUntilEndOfDirective();

        CurPPLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true,

                                       /*foundnonskip*/false,

                                       /*foundelse*/false);

      }

    } else if (Directive[0] == 'e') {

      StringRef Sub = Directive.substr(1);

      if (Sub == "ndif") {  // "endif"

        PPConditionalInfo CondInfo;

        CondInfo.WasSkipping = true; // Silence bogus warning.

        bool InCond = CurPPLexer->popConditionalLevel(CondInfo);

        (void)InCond;  // Silence warning in no-asserts mode.

        assert(!InCond && "Can't be skipping if not in a conditional!");

        // If we popped the outermost skipping block, we're done skipping!

        if (!CondInfo.WasSkipping) {

          // Restore the value of LexingRawMode so that trailing comments

          // are handled correctly, if we've reached the outermost block.

          CurPPLexer->LexingRawMode = false;

          CheckEndOfDirective("endif");

          CurPPLexer->LexingRawMode = true;

          if (Callbacks)

            Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc);

          break;

        } else {

          DiscardUntilEndOfDirective();

        }

      } else 
if (6.04M
Sub == "lse"6.04M
) { // "else".

        // #else directive in a skipping conditional.  If not in some other

        // skipping conditional, and if #else hasn't already been seen, enter it

        // as a non-skipping conditional.

        PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();

        // If this is a #else with a #else before it, report the error.

        if (CondInfo.FoundElse) 
Diag(Tok, diag::pp_err_else_after_else)0
;

        // Note that we've seen a #else in this conditional.

        CondInfo.FoundElse = true;

        // If the conditional is at the top level, and the #if block wasn't

        // entered, enter the #else block now.

        if (!CondInfo.WasSkipping && 
!CondInfo.FoundNonSkip823k
) {

          CondInfo.FoundNonSkip = true;

          // Restore the value of LexingRawMode so that trailing comments

          // are handled correctly.

          CurPPLexer->LexingRawMode = false;

          CheckEndOfDirective("else");

          CurPPLexer->LexingRawMode = true;

          if (Callbacks)

            Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc);

          break;

        } else {

          DiscardUntilEndOfDirective();  // C99 6.10p4.

        }

      } else 
if (2.32M
Sub == "lif"2.32M
) {  // "elif".

        PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();

        // If this is a #elif with a #else before it, report the error.

        if (CondInfo.FoundElse) 
Diag(Tok, diag::pp_err_elif_after_else)0
;

        // If this is in a skipping block or if we're already handled this #if

        // block, don't bother parsing the condition.

        if (CondInfo.WasSkipping || 
CondInfo.FoundNonSkip136k
) {

          DiscardUntilEndOfDirective();

        } else {

          // Restore the value of LexingRawMode so that identifiers are

          // looked up, etc, inside the #elif expression.

          assert(CurPPLexer->LexingRawMode && "We have to be skipping here!");

          CurPPLexer->LexingRawMode = false;

          IdentifierInfo *IfNDefMacro = nullptr;

          DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);

          const bool CondValue = DER.Conditional;

          CurPPLexer->LexingRawMode = true;

          if (Callbacks) {

            Callbacks->Elif(

                Tok.getLocation(), DER.ExprRange,

                (CondValue ? 
PPCallbacks::CVK_True36.3k
 : 
PPCallbacks::CVK_False49.8k
),

                CondInfo.IfLoc);

          }

          // If this condition is true, enter it!

          if (CondValue) {

            CondInfo.FoundNonSkip = true;

            break;

          }

        }

      }

    }

    CurPPLexer->ParsingPreprocessorDirective = false;

    // Restore comment saving mode.

    if (CurLexer) CurLexer->resetExtendedTokenMode();

  }

  // Finally, if we are out of the conditional (saw an #endif or ran off the end

  // of the file, just stop skipping and return to lexing whatever came after

  // the #if block.

  CurPPLexer->LexingRawMode = false;

  // The last skipped range isn't actually skipped yet if it's truncated

  // by the end of the preamble; we'll resume parsing after the preamble.

  if (Callbacks && 
(4.32M
Tok.isNot(tok::eof)4.32M
 || 
!isRecordingPreamble()13
))

    Callbacks->SourceRangeSkipped(

        SourceRange(HashTokenLoc, CurPPLexer->getSourceLocation()),

        Tok.getLocation());

}

Module *Preprocessor::getModuleForLocation(SourceLocation Loc) {

  if (!SourceMgr.isInMainFile(Loc)) {

    // Try to determine the module of the include directive.

    // FIXME: Look into directly passing the FileEntry from LookupFile instead.

    FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getExpansionLoc(Loc));

    if (const FileEntry *EntryOfIncl = SourceMgr.getFileEntryForID(IDOfIncl)) {

      // The include comes from an included file.

      return HeaderInfo.getModuleMap()

          .findModuleForHeader(EntryOfIncl)

          .getModule();

    }

  }

  // This is either in the main file or not in a file at all. It belongs

  // to the current module, if there is one.

  return getLangOpts().CurrentModule.empty()

             ? 
nullptr24.2k

             : 
HeaderInfo.lookupModule(getLangOpts().CurrentModule)19.6k
;

}

const FileEntry *

Preprocessor::getModuleHeaderToIncludeForDiagnostics(SourceLocation IncLoc,

                                                     Module *M,

                                                     SourceLocation Loc) {

  assert(M && "no module to include");

  // If the context is the global module fragment of some module, we never

  // want to return that file; instead, we want the innermost include-guarded

  // header that it included.

  bool InGlobalModuleFragment = M->Kind == Module::GlobalModuleFragment;

  // If we have a module import syntax, we shouldn't include a header to

  // make a particular module visible.

  if ((getLangOpts().ObjC || 
getLangOpts().CPlusPlusModules275
 ||

       
getLangOpts().ModulesTS260
) &&

      
!InGlobalModuleFragment398
)

    return nullptr;

  Module *TopM = M->getTopLevelModule();

  Module *IncM = getModuleForLocation(IncLoc);

  // Walk up through the include stack, looking through textual headers of M

  // until we hit a non-textual header that we can #include. (We assume textual

  // headers of a module with non-textual headers aren't meant to be used to

  // import entities from the module.)

  auto &SM = getSourceManager();

  while (!Loc.isInvalid() && !SM.isInMainFile(Loc)) {

    auto ID = SM.getFileID(SM.getExpansionLoc(Loc));

    auto *FE = SM.getFileEntryForID(ID);

    if (!FE)

      break;

    if (InGlobalModuleFragment) {

      if (getHeaderSearchInfo().isFileMultipleIncludeGuarded(FE))

        return FE;

      Loc = SM.getIncludeLoc(ID);

      continue;

    }

    bool InTextualHeader = false;

    for (auto Header : HeaderInfo.getModuleMap().findAllModulesForHeader(FE)) {

      if (!Header.getModule()->isSubModuleOf(TopM))

        continue;

      if (!(Header.getRole() & ModuleMap::TextualHeader)) {

        // If this is an accessible, non-textual header of M's top-level module

        // that transitively includes the given location and makes the

        // corresponding module visible, this is the thing to #include.

        if (Header.isAccessibleFrom(IncM))

          return FE;

        // It's in a private header; we can't #include it.

        // FIXME: If there's a public header in some module that re-exports it,

        // then we could suggest including that, but it's not clear that's the

        // expected way to make this entity visible.

        continue;

      }

      InTextualHeader = true;

    }

    
if (236
!InTextualHeader236
)

      break;

    Loc = SM.getIncludeLoc(ID);

  }

  
return nullptr64
;

}

Optional<FileEntryRef> Preprocessor::LookupFile(

    SourceLocation FilenameLoc, StringRef Filename, bool isAngled,

    const DirectoryLookup *FromDir, const FileEntry *FromFile,

    const DirectoryLookup *&CurDir, SmallVectorImpl<char> *SearchPath,

    SmallVectorImpl<char> *RelativePath,

    ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped,

    bool *IsFrameworkFound, bool SkipCache) {

  Module *RequestingModule = getModuleForLocation(FilenameLoc);

  bool RequestingModuleIsModuleInterface = !SourceMgr.isInMainFile(FilenameLoc);

  // If the header lookup mechanism may be relative to the current inclusion

  // stack, record the parent #includes.

  SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 16>

      Includers;

  bool BuildSystemModule = false;

  if (!FromDir && 
!FromFile2.17M
) {

    FileID FID = getCurrentFileLexer()->getFileID();

    const FileEntry *FileEnt = SourceMgr.getFileEntryForID(FID);

    // If there is no file entry associated with this file, it must be the

    // predefines buffer or the module includes buffer. Any other file is not

    // lexed with a normal lexer, so it won't be scanned for preprocessor

    // directives.

    //

    // If we have the predefines buffer, resolve #include references (which come

    // from the -include command line argument) from the current working

    // directory instead of relative to the main file.

    //

    // If we have the module includes buffer, resolve #include references (which

    // come from header declarations in the module map) relative to the module

    // map file.

    if (!FileEnt) {

      if (FID == SourceMgr.getMainFileID() && 
MainFileDir19.5k
) {

        Includers.push_back(std::make_pair(nullptr, MainFileDir));

        BuildSystemModule = getCurrentModule()->IsSystem;

      } else 
if (5.87k
(FileEnt =

                    SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())))

        Includers.push_back(std::make_pair(FileEnt, *FileMgr.getDirectory(".")));

    } else {

      Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));

    }

    // MSVC searches the current include stack from top to bottom for

    // headers included by quoted include directives.

    // See: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx

    if (LangOpts.MSVCCompat && 
!isAngled932
) {

      for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {

        if (IsFileLexer(ISEntry))

          if ((FileEnt = ISEntry.ThePPLexer->getFileEntry()))

            Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));

      }

    }

  }

  CurDir = CurDirLookup;

  if (FromFile) {

    // We're supposed to start looking from after a particular file. Search

    // the include path until we find that file or run out of files.

    const DirectoryLookup *TmpCurDir = CurDir;

    const DirectoryLookup *TmpFromDir = nullptr;

    while (Optional<FileEntryRef> FE = HeaderInfo.LookupFile(

               Filename, FilenameLoc, isAngled, TmpFromDir, TmpCurDir,

               Includers, SearchPath, RelativePath, RequestingModule,

               SuggestedModule, /*IsMapped=*/nullptr,

               /*IsFrameworkFound=*/nullptr, SkipCache)) {

      // Keep looking as if this file did a #include_next.

      TmpFromDir = TmpCurDir;

      ++TmpFromDir;

      if (&FE->getFileEntry() == FromFile) {

        // Found it.

        FromDir = TmpFromDir;

        CurDir = TmpCurDir;

        break;

      }

    }

  }

  // Do a standard file entry lookup.

  Optional<FileEntryRef> FE = HeaderInfo.LookupFile(

      Filename, FilenameLoc, isAngled, FromDir, CurDir, Includers, SearchPath,

      RelativePath, RequestingModule, SuggestedModule, IsMapped,

      IsFrameworkFound, SkipCache, BuildSystemModule);

  if (FE) {

    if (SuggestedModule && 
!LangOpts.AsmPreprocessor2.08M
)

      HeaderInfo.getModuleMap().diagnoseHeaderInclusion(

          RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,

          Filename, &FE->getFileEntry());

    return FE;

  }

  const FileEntry *CurFileEnt;

  // Otherwise, see if this is a subframework header.  If so, this is relative

  // to one of the headers on the #include stack.  Walk the list of the current

  // headers on the #include stack and pass them to HeaderInfo.

  if (IsFileLexer()) {

    if ((CurFileEnt = CurPPLexer->getFileEntry())) {

      if (Optional<FileEntryRef> FE = HeaderInfo.LookupSubframeworkHeader(

              Filename, CurFileEnt, SearchPath, RelativePath, RequestingModule,

              SuggestedModule)) {

        if (SuggestedModule && !LangOpts.AsmPreprocessor)

          HeaderInfo.getModuleMap().diagnoseHeaderInclusion(

              RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,

              Filename, &FE->getFileEntry());

        return FE;

      }

    }

  }

  
for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack))9.45k
 {

    if (IsFileLexer(ISEntry)) {

      if ((CurFileEnt = ISEntry.ThePPLexer->getFileEntry())) {

        if (Optional<FileEntryRef> FE = HeaderInfo.LookupSubframeworkHeader(

                Filename, CurFileEnt, SearchPath, RelativePath,

                RequestingModule, SuggestedModule)) {

          if (SuggestedModule && !LangOpts.AsmPreprocessor)

            HeaderInfo.getModuleMap().diagnoseHeaderInclusion(

                RequestingModule, RequestingModuleIsModuleInterface,

                FilenameLoc, Filename, &FE->getFileEntry());

          return FE;

        }

      }

    }

  }

  // Otherwise, we really couldn't find the file.

  return None;

}

//===----------------------------------------------------------------------===//

// Preprocessor Directive Handling.

//===----------------------------------------------------------------------===//

class Preprocessor::ResetMacroExpansionHelper {

public:

  ResetMacroExpansionHelper(Preprocessor *pp)

    : PP(pp), save(pp->DisableMacroExpansion) {

    if (pp->MacroExpansionInDirectivesOverride)

      pp->DisableMacroExpansion = false;

  }

  ~ResetMacroExpansionHelper() {

    PP->DisableMacroExpansion = save;

  }

private:

  Preprocessor *PP;

  bool save;

};

/// Process a directive while looking for the through header or a #pragma

/// hdrstop. The following directives are handled:

/// #include (to check if it is the through header)

/// #define (to warn about macros that don't match the PCH)

/// #pragma (to check for pragma hdrstop).

/// All other directives are completely discarded.

void Preprocessor::HandleSkippedDirectiveWhileUsingPCH(Token &Result,

                                                       SourceLocation HashLoc) {

  if (const IdentifierInfo *II = Result.getIdentifierInfo()) {

    if (II->getPPKeywordID() == tok::pp_define) {

      return HandleDefineDirective(Result,

                                   /*ImmediatelyAfterHeaderGuard=*/false);

    }

    if (SkippingUntilPCHThroughHeader &&

        
II->getPPKeywordID() == tok::pp_include20
) {

      return HandleIncludeDirective(HashLoc, Result);

    }

    if (SkippingUntilPragmaHdrStop && II->getPPKeywordID() == tok::pp_pragma) {

      Lex(Result);

      auto *II = Result.getIdentifierInfo();

      if (II && II->getName() == "hdrstop")

        return HandlePragmaHdrstop(Result);

    }

  }

  DiscardUntilEndOfDirective();

}

/// HandleDirective - This callback is invoked when the lexer sees a # token

/// at the start of a line.  This consumes the directive, modifies the

/// lexer/preprocessor state, and advances the lexer(s) so that the next token

/// read is the correct one.

void Preprocessor::HandleDirective(Token &Result) {

  // FIXME: Traditional: # with whitespace before it not recognized by K&R?

  // We just parsed a # character at the start of a line, so we're in directive

  // mode.  Tell the lexer this so any newlines we see will be converted into an

  // EOD token (which terminates the directive).

  CurPPLexer->ParsingPreprocessorDirective = true;

  if (
CurLexer48.9M
) CurLexer->SetKeepWhitespaceMode(false);

  bool ImmediatelyAfterTopLevelIfndef =

      CurPPLexer->MIOpt.getImmediatelyAfterTopLevelIfndef();

  CurPPLexer->MIOpt.resetImmediatelyAfterTopLevelIfndef();

  ++NumDirectives;

  // We are about to read a token.  For the multiple-include optimization FA to

  // work, we have to remember if we had read any tokens *before* this

  // pp-directive.

  bool ReadAnyTokensBeforeDirective =CurPPLexer->MIOpt.getHasReadAnyTokensVal();

  // Save the '#' token in case we need to return it later.

  Token SavedHash = Result;

  // Read the next token, the directive flavor.  This isn't expanded due to

  // C99 6.10.3p8.

  LexUnexpandedToken(Result);

  // C99 6.10.3p11: Is this preprocessor directive in macro invocation?  e.g.:

  //   #define A(x) #x

  //   A(abc

  //     #warning blah

  //   def)

  // If so, the user is relying on undefined behavior, emit a diagnostic. Do

  // not support this for #include-like directives, since that can result in

  // terrible diagnostics, and does not work in GCC.

  if (InMacroArgs) {

    if (IdentifierInfo *II = Result.getIdentifierInfo()) {

      switch (II->getPPKeywordID()) {

      case tok::pp_include:

      case tok::pp_import:

      case tok::pp_include_next:

      case tok::pp___include_macros:

      case tok::pp_pragma:

        Diag(Result, diag::err_embedded_directive) << II->getName();

        Diag(*ArgMacro, diag::note_macro_expansion_here)

            << ArgMacro->getIdentifierInfo();

        DiscardUntilEndOfDirective();

        return;

      default:

        break;

      }

    }

    Diag(Result, diag::ext_embedded_directive);

  }

  // Temporarily enable macro expansion if set so

  // and reset to previous state when returning from this function.

  ResetMacroExpansionHelper helper(this);

  if (
SkippingUntilPCHThroughHeader48.9M
 || SkippingUntilPragmaHdrStop)

    return HandleSkippedDirectiveWhileUsingPCH(Result, SavedHash.getLocation());

  switch (Result.getKind()) {

  case tok::eod:

    return;   // null directive.

  case tok::code_completion:

    if (CodeComplete)

      CodeComplete->CodeCompleteDirective(

                                    CurPPLexer->getConditionalStackDepth() > 0);

    setCodeCompletionReached();

    return;

  case tok::numeric_constant:  // # 7  GNU line marker directive.

    if (getLangOpts().AsmPreprocessor)

      break;  // # 4 is not a preprocessor directive in .S files.

    return HandleDigitDirective(Result);

  default:

    IdentifierInfo *II = Result.getIdentifierInfo();

    if (!II) 
break6
; // Not an identifier.

    // Ask what the preprocessor keyword ID is.

    switch (II->getPPKeywordID()) {

    default: break;

    // C99 6.10.1 - Conditional Inclusion.

    case tok::pp_if:

      return HandleIfDirective(Result, SavedHash, ReadAnyTokensBeforeDirective);

    case tok::pp_ifdef:

      return HandleIfdefDirective(Result, SavedHash, false,

                                  true /*not valid for miopt*/);

    case tok::pp_ifndef:

      return HandleIfdefDirective(Result, SavedHash, true,

                                  ReadAnyTokensBeforeDirective);