static bool alwaysFitsInto64Bits(unsigned Radix, unsigned NumDigits)
{
    switch (Radix)
    {
    case 2:
        return NumDigits <= 64;
    case 8:
        return NumDigits <= 64 / 3; // Digits are groups of 3 bits.
    case 10:
        return NumDigits <= 19; // floor(log10(2^64))
    case 16:
        return NumDigits <= 64 / 4; // Digits are groups of 4 bits.
    default:
        llvm_unreachable("impossible Radix");
    }
}

    // Helper functions to lex the remainder of a token of the specific type.
    bool LexIdentifier(Token &Result, const char *CurPtr);
    bool LexNumericConstant(Token &Result, const char *CurPtr);
    bool LexStringLiteral(Token &Result, const char *CurPtr,
    tok::TokenKind Kind);
    bool LexRawStringLiteral(Token &Result, const char *CurPtr,
    tok::TokenKind Kind);
    bool LexAngledStringLiteral(Token &Result, const char *CurPtr);
    bool LexCharConstant(Token &Result, const char *CurPtr,
    tok::TokenKind Kind);
    bool LexEndOfFile(Token &Result, const char *CurPtr);
    bool SkipWhitespace(Token &Result, const char *CurPtr,
    bool &TokAtPhysicalStartOfLine);
    bool SkipLineComment(Token &Result, const char *CurPtr,
    bool &TokAtPhysicalStartOfLine);
    bool SkipBlockComment(Token &Result, const char *CurPtr,
    bool &TokAtPhysicalStartOfLine);
    bool SaveLineComment(Token &Result, const char *CurPtr);

class Token
{
    /// The location of the token. This is actually a SourceLocation.
    unsigned Loc;

    /// UintData - This holds either the length of the token text, when
    /// a normal token, or the end of the SourceRange when an annotation
    /// token.
    // 话说没必要啊，长度加偏移不就是end了么
    unsigned UintData;

    /// PtrData - This is a union of four different pointer types, which depends
    /// on what type of token this is:
    ///  Identifiers, keywords, etc:
    ///    This is an IdentifierInfo*, which contains the uniqued identifier
    ///    spelling.
    ///  Literals:  isLiteral() returns true.
    ///    This is a pointer to the start of the token in a text buffer, which
    ///    may be dirty (have trigraphs / escaped newlines).
    ///  Annotations (resolved type names, C++ scopes, etc): isAnnotation().
    ///    This is a pointer to sema-specific data for the annotation token.
    ///  Eof:
    //     This is a pointer to a Decl.
    ///  Other:
    ///    This is null.
    void *PtrData;

    /// Kind - The actual flavor of token this is.
    tok::TokenKind Kind;

    /// Flags - Bits we track about this token, members of the TokenFlags enum.
    unsigned short Flags;
}

// Various flags set per token:
enum TokenFlags
{
    StartOfLine = 0x01,  // At start of line or only after whitespace
   // (considering the line after macro expansion).
    LeadingSpace = 0x02,  // Whitespace exists before this token (considering 
   // whitespace after macro expansion).
    DisableExpand = 0x04,  // This identifier may never be macro expanded.
    NeedsCleaning = 0x08,  // Contained an escaped newline or trigraph.
    LeadingEmptyMacro = 0x10, // Empty macro exists before this token.
    HasUDSuffix = 0x20,    // This string or character literal has a ud-suffix.
    HasUCN = 0x40,         // This identifier contains a UCN.
    IgnoredComma = 0x80,   // This comma is not a macro argument separator (MS).
    StringifiedInMacro = 0x100, // This string or character literal is formed by
                                // macro stringizing or charizing operator.
};

/// \brief Implements the simple state machine that the Lexer class uses to
/// detect files subject to the 'multiple-include' optimization.
///
/// The public methods in this class are triggered by various
/// events that occur when a file is lexed, and after the entire file is lexed,
/// information about which macro (if any) controls the header is returned.
class MultipleIncludeOpt
{
    /// ReadAnyTokens - This is set to false when a file is first opened and true
    /// any time a token is returned to the client or a (non-multiple-include)
    /// directive is parsed.  When the final \#endif is parsed this is reset back
    /// to false, that way any tokens before the first \#ifdef or after the last
    /// \#endif can be easily detected.
    bool ReadAnyTokens;

    /// ImmediatelyAfterTopLevelIfndef - This is true when the only tokens
    /// processed in the file so far is an #ifndef and an identifier.  Used in
    /// the detection of header guards in a file.
    bool ImmediatelyAfterTopLevelIfndef;

    /// ReadAnyTokens - This is set to false when a file is first opened and true
    /// any time a token is returned to the client or a (non-multiple-include)
    /// directive is parsed.  When the final #endif is parsed this is reset back
    /// to false, that way any tokens before the first #ifdef or after the last
    /// #endif can be easily detected.
    bool DidMacroExpansion;

    /// TheMacro - The controlling macro for a file, if valid.
    ///
    const IdentifierInfo *TheMacro;

    /// DefinedMacro - The macro defined right after TheMacro, if any.
    const IdentifierInfo *DefinedMacro;

    SourceLocation MacroLoc;
    SourceLocation DefinedLoc;
}

MultipleIncludeOpt()
{
    ReadAnyTokens = false;
    ImmediatelyAfterTopLevelIfndef = false;
    DidMacroExpansion = false;
    TheMacro = nullptr;
    DefinedMacro = nullptr;
}

/// Invalidate - Permanently mark this file as not being suitable for the
/// include-file optimization.
void Invalidate()
{
    // If we have read tokens but have no controlling macro, the state-machine
    // below can never "accept".
    ReadAnyTokens = true;
    ImmediatelyAfterTopLevelIfndef = false;
    DefinedMacro = nullptr;
    TheMacro = nullptr;
}

/// \brief Called when entering a top-level \#ifndef directive (or the
/// "\#if !defined" equivalent) without any preceding tokens.
///
/// Note, we don't care about the input value of 'ReadAnyTokens'.  The caller
/// ensures that this is only called if there are no tokens read before the
/// \#ifndef.  The caller is required to do this, because reading the \#if
/// line obviously reads in in tokens.
void EnterTopLevelIfndef(const IdentifierInfo *M, SourceLocation Loc)
{
    // If the macro is already set, this is after the top-level #endif.
    if (TheMacro)
    return Invalidate();

    // If we have already expanded a macro by the end of the #ifndef line, then
    // there is a macro expansion *in* the #ifndef line.  This means that the
    // condition could evaluate differently when subsequently #included.  Reject
    // this.
    if (DidMacroExpansion)
    return Invalidate();

    // Remember that we're in the #if and that we have the macro.
    ReadAnyTokens = true;
    ImmediatelyAfterTopLevelIfndef = true;
    TheMacro = M;
    MacroLoc = Loc;
}

/// \brief Called when the lexer exits the top-level conditional.
void ExitTopLevelConditional()
{
    // If we have a macro, that means the top of the file was ok.  Set our state
    // back to "not having read any tokens" so we can detect anything after the
    // #endif.
    if (!TheMacro) return Invalidate();

    // At this point, we haven't "read any tokens" but we do have a controlling
    // macro.
    ReadAnyTokens = false;
    ImmediatelyAfterTopLevelIfndef = false;
}

/// This class represents an Apple concept known as a 'header map'.  To the
/// \#include file resolution process, it basically acts like a directory of
/// symlinks to files.  Its advantages are that it is dense and more efficient
/// to create and process than a directory of symlinks.
class HeaderMap
{
    std::unique_ptr<const llvm::MemoryBuffer> FileBuffer;
    bool NeedsBSwap;
}

struct HMapBucket
{
    uint32_t Key;          // Offset (into strings) of key.

    uint32_t Prefix;     // Offset (into strings) of value prefix.
    uint32_t Suffix;     // Offset (into strings) of value suffix.
};

struct HMapHeader
{
    uint32_t Magic;           // Magic word, also indicates byte order.
    uint16_t Version;         // Version number -- currently 1.
    uint16_t Reserved;        // Reserved for future use - zero for now.
    uint32_t StringsOffset;   // Offset to start of string pool.
    uint32_t NumEntries;      // Number of entries in the string table.
    uint32_t NumBuckets;      // Number of buckets (always a power of 2).
    uint32_t MaxValueLength;  // Length of longest result path (excluding nul).
    // An array of 'NumBuckets' HMapBucket objects follows this header.
    // Strings follow the buckets, at StringsOffset.
};

enum
{
    HMAP_HeaderMagicNumber = ('h' << 24) | ('m' << 16) | ('a' << 8) | 'p',
    HMAP_HeaderVersion = 1,

    HMAP_EmptyBucketKey = 0
};

/// HeaderMap::Create - This attempts to load the specified file as a header
/// map.  If it doesn't look like a HeaderMap, it gives up and returns null.
/// If it looks like a HeaderMap but is obviously corrupted, it puts a reason
/// into the string error argument and returns null.
const HeaderMap *HeaderMap::Create(const FileEntry *FE, FileManager &FM)
{
    // If the file is too small to be a header map, ignore it.
    unsigned FileSize = FE->getSize();
    if (FileSize <= sizeof(HMapHeader)) return nullptr;

    auto FileBuffer = FM.getBufferForFile(FE);
    if (!FileBuffer) return nullptr;  // Unreadable file?
    const char *FileStart = (*FileBuffer)->getBufferStart();

    // We know the file is at least as big as the header, check it now.
    const HMapHeader *Header = reinterpret_cast<const HMapHeader*>(FileStart);

    // Sniff it to see if it's a headermap by checking the magic number and
    // version.
    bool NeedsByteSwap;
    if (Header->Magic == HMAP_HeaderMagicNumber &&
    Header->Version == HMAP_HeaderVersion)
    NeedsByteSwap = false;
    else if (Header->Magic == llvm::ByteSwap_32(HMAP_HeaderMagicNumber) &&
    Header->Version == llvm::ByteSwap_16(HMAP_HeaderVersion))
    NeedsByteSwap = true;  // Mixed endianness headermap.
    else
    return nullptr;  // Not a header map.

    if (Header->Reserved != 0) return nullptr;

    // Okay, everything looks good, create the header map.
    return new HeaderMap(std::move(*FileBuffer), NeedsByteSwap);
}

struct HMapBucket
{
    uint32_t Key;          // Offset (into strings) of key.

    uint32_t Prefix;     // Offset (into strings) of value prefix.
    uint32_t Suffix;     // Offset (into strings) of value suffix.
};

/// getBucket - Return the specified hash table bucket from the header map,
/// bswap'ing its fields as appropriate.  If the bucket number is not valid,
/// this return a bucket with an empty key (0).
HMapBucket HeaderMap::getBucket(unsigned BucketNo) const
{
    HMapBucket Result;
    Result.Key = HMAP_EmptyBucketKey;

    const HMapBucket *BucketArray =
    reinterpret_cast<const HMapBucket*>(FileBuffer->getBufferStart() +
    sizeof(HMapHeader));

    const HMapBucket *BucketPtr = BucketArray + BucketNo;
    if ((const char*)(BucketPtr + 1) > FileBuffer->getBufferEnd())
    {
        Result.Prefix = 0;
        Result.Suffix = 0;
        return Result;  // Invalid buffer, corrupt hmap.
    }

    // Otherwise, the bucket is valid.  Load the values, bswapping as needed.
    Result.Key = getEndianAdjustedWord(BucketPtr->Key);
    Result.Prefix = getEndianAdjustedWord(BucketPtr->Prefix);
    Result.Suffix = getEndianAdjustedWord(BucketPtr->Suffix);
    return Result;
}

StringRef HeaderMap::lookupFilename(StringRef Filename,
SmallVectorImpl<char> &DestPath) const
{
    const HMapHeader &Hdr = getHeader();
    unsigned NumBuckets = getEndianAdjustedWord(Hdr.NumBuckets);

    // If the number of buckets is not a power of two, the headermap is corrupt.
    // Don't probe infinitely.
    if (NumBuckets & (NumBuckets - 1))
    return StringRef();

    // Linearly probe the hash table.
    for (unsigned Bucket = HashHMapKey(Filename);; ++Bucket)
    {
        HMapBucket B = getBucket(Bucket & (NumBuckets - 1));
        if (B.Key == HMAP_EmptyBucketKey) return StringRef(); // Hash miss.

        // See if the key matches.  If not, probe on.
        if (!Filename.equals_lower(getString(B.Key)))
        continue;

        // If so, we have a match in the hash table.  Construct the destination
        // path.
        StringRef Prefix = getString(B.Prefix);
        StringRef Suffix = getString(B.Suffix);
        DestPath.clear();
        DestPath.append(Prefix.begin(), Prefix.end());
        DestPath.append(Suffix.begin(), Suffix.end());
        return StringRef(DestPath.begin(), DestPath.size());
    }
}

struct HeaderFileInfo
{
    /// \brief True if this is a \#import'd or \#pragma once file.
    unsigned isImport : 1;

    /// \brief True if this is a \#pragma once file.
    unsigned isPragmaOnce : 1;

    /// DirInfo - Keep track of whether this is a system header, and if so,
    /// whether it is C++ clean or not.  This can be set by the include paths or
    /// by \#pragma gcc system_header.  This is an instance of
    /// SrcMgr::CharacteristicKind.
    unsigned DirInfo : 2;

    /// \brief Whether this header file info was supplied by an external source,
    /// and has not changed since.
    unsigned External : 1;

    /// \brief Whether this header is part of a module.
    unsigned isModuleHeader : 1;

    /// \brief Whether this header is part of the module that we are building.
    unsigned isCompilingModuleHeader : 1;

    /// \brief Whether this structure is considered to already have been
    /// "resolved", meaning that it was loaded from the external source.
    unsigned Resolved : 1;

    /// \brief Whether this is a header inside a framework that is currently
    /// being built. 
    ///
    /// When a framework is being built, the headers have not yet been placed
    /// into the appropriate framework subdirectories, and therefore are
    /// provided via a header map. This bit indicates when this is one of
    /// those framework headers.
    unsigned IndexHeaderMapHeader : 1;

    /// \brief Whether this file has been looked up as a header.
    unsigned IsValid : 1;

    /// \brief The number of times the file has been included already.
    unsigned short NumIncludes;

    /// \brief The ID number of the controlling macro.
    ///
    /// This ID number will be non-zero when there is a controlling
    /// macro whose IdentifierInfo may not yet have been loaded from
    /// external storage.
    unsigned ControllingMacroID;

    /// If this file has a \#ifndef XXX (or equivalent) guard that
    /// protects the entire contents of the file, this is the identifier
    /// for the macro that controls whether or not it has any effect.
    ///
    /// Note: Most clients should use getControllingMacro() to access
    /// the controlling macro of this header, since
    /// getControllingMacro() is able to load a controlling macro from
    /// external storage.
    const IdentifierInfo *ControllingMacro;
}

/// \#include search path information.  Requests for \#include "x" search the
/// directory of the \#including file first, then each directory in SearchDirs
/// consecutively. Requests for <x> search the current dir first, then each
/// directory in SearchDirs, starting at AngledDirIdx, consecutively.  If
/// NoCurDirSearch is true, then the check for the file in the current
/// directory is suppressed.
std::vector<DirectoryLookup> SearchDirs;
unsigned AngledDirIdx;
unsigned SystemDirIdx;
bool NoCurDirSearch;

/// \brief All of the preprocessor-specific data about files that are
/// included, indexed by the FileEntry's UID.
mutable std::vector<HeaderFileInfo> FileInfo;
/// HeaderMaps - This is a mapping from FileEntry -> HeaderMap, uniquing
/// headermaps.  This vector owns the headermap.
std::vector<std::pair<const FileEntry*, const HeaderMap*> > HeaderMaps;

const FileEntry *LookupFile(
StringRef Filename, SourceLocation IncludeLoc, bool isAngled,
const DirectoryLookup *FromDir, const DirectoryLookup *&CurDir,
ArrayRef<std::pair<const FileEntry *, const DirectoryEntry *>> Includers,
SmallVectorImpl<char> *SearchPath, SmallVectorImpl<char> *RelativePath,
Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule,
bool SkipCache = false);

if (llvm::sys::path::is_absolute(Filename))
{
    CurDir = nullptr;

    // If this was an #include_next "/absolute/file", fail.
    if (FromDir) return nullptr;

    if (SearchPath)
    SearchPath->clear();
    if (RelativePath)
    {
        RelativePath->clear();
        RelativePath->append(Filename.begin(), Filename.end());
    }
    // Otherwise, just return the file.
    return getFileAndSuggestModule(Filename, nullptr,
    /*IsSystemHeaderDir*/false,
    RequestingModule, SuggestedModule);
}

class PTHFileData
{
    const uint32_t TokenOff;
    const uint32_t PPCondOff;
}

static PTHFileData ReadData(const internal_key_type& k,
const unsigned char* d, unsigned)
{
    assert(k.first == 0x1 && "Only file lookups can match!");
    using namespace llvm::support;
    uint32_t x = endian::readNext<uint32_t, little, unaligned>(d);
    uint32_t y = endian::readNext<uint32_t, little, unaligned>(d);
    return PTHFileData(x, y);
}

class PTHLexer : public PreprocessorLexer
{
    SourceLocation FileStartLoc;

    /// TokBuf - Buffer from PTH file containing raw token data.
    const unsigned char* TokBuf;

    /// CurPtr - Pointer into current offset of the token buffer where
    ///  the next token will be read.
    const unsigned char* CurPtr;

    /// LastHashTokPtr - Pointer into TokBuf of the last processed '#'
    ///  token that appears at the start of a line.
    const unsigned char* LastHashTokPtr;

    /// PPCond - Pointer to a side table in the PTH file that provides a
    ///  a consise summary of the preproccessor conditional block structure.
    ///  This is used to perform quick skipping of conditional blocks.
    const unsigned char* PPCond;

    /// CurPPCondPtr - Pointer inside PPCond that refers to the next entry
    ///  to process when doing quick skipping of preprocessor blocks.
    const unsigned char* CurPPCondPtr;
}

bool PTHLexer::LexEndOfFile(Token &Result)
{
    // If we hit the end of the file while parsing a preprocessor directive,
    // end the preprocessor directive first.  The next token returned will
    // then be the end of file.
    if (ParsingPreprocessorDirective)
    {
        ParsingPreprocessorDirective = false; // Done parsing the "line".
        return true;  // Have a token.
    }

    assert(!LexingRawMode);

    // If we are in a #if directive, emit an error.
    while (!ConditionalStack.empty())
    {
        if (PP->getCodeCompletionFileLoc() != FileStartLoc)
        PP->Diag(ConditionalStack.back().IfLoc,
        diag::err_pp_unterminated_conditional);
        ConditionalStack.pop_back();
    }

    // Finally, let the preprocessor handle this.
    return PP->HandleEndOfFile(Result);
}

/// \brief Callback invoked when the lexer hits the end of the current file.
///
/// This either returns the EOF token and returns true, or
/// pops a level off the include stack and returns false, at which point the
/// client should call lex again.
bool HandleEndOfFile(Token &Result, bool isEndOfMacro = false);

//===--------------------------------------==//
// Read the raw token data.
//===--------------------------------------==//
using namespace llvm::support;

// Shadow CurPtr into an automatic variable.
const unsigned char *CurPtrShadow = CurPtr;

// Read in the data for the token.
unsigned Word0 = endian::readNext<uint32_t, little, aligned>(CurPtrShadow);
uint32_t IdentifierID =
endian::readNext<uint32_t, little, aligned>(CurPtrShadow);
uint32_t FileOffset =
endian::readNext<uint32_t, little, aligned>(CurPtrShadow);

tok::TokenKind TKind = (tok::TokenKind) (Word0 & 0xFF);
Token::TokenFlags TFlags = (Token::TokenFlags) ((Word0 >> 8) & 0xFF);
uint32_t Len = Word0 >> 16;

CurPtr = CurPtrShadow;

//===--------------------------------------==//
// Construct the token itself.
//===--------------------------------------==//

Tok.startToken();
Tok.setKind(TKind);
Tok.setFlag(TFlags);
assert(!LexingRawMode);
Tok.setLocation(FileStartLoc.getLocWithOffset(FileOffset));
Tok.setLength(Len);

// Handle identifiers.
if (Tok.isLiteral())
{
    Tok.setLiteralData((const char*)(PTHMgr.SpellingBase + IdentifierID));
}
else if (IdentifierID)
{
    MIOpt.ReadToken();
    IdentifierInfo *II = PTHMgr.GetIdentifierInfo(IdentifierID - 1);

    Tok.setIdentifierInfo(II);

    // Change the kind of this identifier to the appropriate token kind, e.g.
    // turning "for" into a keyword.
    Tok.setKind(II->getTokenID());

    if (II->isHandleIdentifierCase())
    return PP->HandleIdentifier(Tok);

    return true;
}

//===--------------------------------------==//
// Process the token.
//===--------------------------------------==//
if (TKind == tok::eof)
{
    // Save the end-of-file token.
    EofToken = Tok;

    assert(!ParsingPreprocessorDirective);
    assert(!LexingRawMode);

    return LexEndOfFile(Tok);
}

if (TKind == tok::hash && Tok.isAtStartOfLine())
{
    LastHashTokPtr = CurPtr - StoredTokenSize;
    assert(!LexingRawMode);
    PP->HandleDirective(Tok);

    return false;
}

if (TKind == tok::eod)
{
    assert(ParsingPreprocessorDirective);
    ParsingPreprocessorDirective = false;
    return true;
}

MIOpt.ReadToken();
return true;

/// \brief Callback 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 HandleDirective(Token &Result);

/// SkipBlock - Used by Preprocessor to skip the current conditional block.
bool PTHLexer::SkipBlock()

class PTHManager : public IdentifierInfoLookup
{

    class PTHStringLookupTrait;
    class PTHFileLookupTrait;
    typedef llvm::OnDiskChainedHashTable<PTHStringLookupTrait> PTHStringIdLookup;
    typedef llvm::OnDiskChainedHashTable<PTHFileLookupTrait> PTHFileLookup;

    /// The memory mapped PTH file.
    std::unique_ptr<const llvm::MemoryBuffer> Buf;

    /// Alloc - Allocator used for IdentifierInfo objects.
    llvm::BumpPtrAllocator Alloc;

    /// IdMap - A lazily generated cache mapping from persistent identifiers to
    ///  IdentifierInfo*.
    std::unique_ptr<IdentifierInfo *[], llvm::FreeDeleter> PerIDCache;

    /// FileLookup - Abstract data structure used for mapping between files
    ///  and token data in the PTH file.
    std::unique_ptr<PTHFileLookup> FileLookup;

    /// IdDataTable - Array representing the mapping from persistent IDs to the
    ///  data offset within the PTH file containing the information to
    ///  reconsitute an IdentifierInfo.
    const unsigned char* const IdDataTable;

    /// SortedIdTable - Abstract data structure mapping from strings to
    ///  persistent IDs.  This is used by get().
    std::unique_ptr<PTHStringIdLookup> StringIdLookup;

    /// NumIds - The number of identifiers in the PTH file.
    const unsigned NumIds;

    /// PP - The Preprocessor object that will use this PTHManager to create
    ///  PTHLexer objects.
    Preprocessor* PP;

    /// SpellingBase - The base offset within the PTH memory buffer that
    ///  contains the cached spellings for literals.
    const unsigned char* const SpellingBase;

    /// OriginalSourceFile - A null-terminated C-string that specifies the name
    ///  if the file (if any) that was to used to generate the PTH cache.
    const char* OriginalSourceFile;
}

/// Create - This method creates PTHManager objects.  The 'file' argument
///  is the name of the PTH file.  This method returns NULL upon failure.
static PTHManager *Create(StringRef file, DiagnosticsEngine &Diags);

/// get - Return the identifier token info for the specified named identifier.
///  Unlike the version in IdentifierTable, this returns a pointer instead
///  of a reference.  If the pointer is NULL then the IdentifierInfo cannot
///  be found.
IdentifierInfo *get(StringRef Name) override;

// Double check our assumption that the last character isn't '\0'.
assert(Name.empty() || Name.back() != '\0');
PTHStringIdLookup::iterator I =
StringIdLookup->find(std::make_pair(Name.data(), Name.size()));
if (I == StringIdLookup->end()) // No identifier found?
return nullptr;

// Match found.  Return the identifier!
assert(*I > 0);
return GetIdentifierInfo(*I - 1);

/// GetIdentifierInfo - Used to reconstruct IdentifierInfo objects from the
///  PTH file.
inline IdentifierInfo* GetIdentifierInfo(unsigned PersistentID)
{
    // Check if the IdentifierInfo has already been resolved.
    if (IdentifierInfo* II = PerIDCache[PersistentID])
    return II;
    return LazilyCreateIdentifierInfo(PersistentID);
}

using namespace llvm::support;
// Look in the PTH file for the string data for the IdentifierInfo object.
const unsigned char* TableEntry = IdDataTable + sizeof(uint32_t)*PersistentID;
const unsigned char *IDData =
(const unsigned char *)Buf->getBufferStart() +
endian::readNext<uint32_t, little, aligned>(TableEntry);
assert(IDData < (const unsigned char*)Buf->getBufferEnd());

// Allocate the object.
std::pair<IdentifierInfo, const unsigned char*> *Mem =
Alloc.Allocate<std::pair<IdentifierInfo, const unsigned char*> >();

Mem->second = IDData;
assert(IDData[0] != '\0');
IdentifierInfo *II = new ((void*)Mem) IdentifierInfo();

// Store the new IdentifierInfo in the cache.
PerIDCache[PersistentID] = II;
assert(II->getNameStart() && II->getNameStart()[0] != '\0');
return II;

PTHLexer *PTHManager::CreateLexer(FileID FID)
{
    const FileEntry *FE = PP->getSourceManager().getFileEntryForID(FID);
    if (!FE)
    return nullptr;

    using namespace llvm::support;

    // Lookup the FileEntry object in our file lookup data structure.  It will
    // return a variant that indicates whether or not there is an offset within
    // the PTH file that contains cached tokens.
    PTHFileLookup::iterator I = FileLookup->find(FE);

    if (I == FileLookup->end()) // No tokens available?
    return nullptr;

    const PTHFileData& FileData = *I;

    const unsigned char *BufStart = (const unsigned char *)Buf->getBufferStart();
    // Compute the offset of the token data within the buffer.
    const unsigned char* data = BufStart + FileData.getTokenOffset();

    // Get the location of pp-conditional table.
    const unsigned char* ppcond = BufStart + FileData.getPPCondOffset();
    uint32_t Len = endian::readNext<uint32_t, little, aligned>(ppcond);
    if (Len == 0) ppcond = nullptr;

    assert(PP && "No preprocessor set yet!");
    return new PTHLexer(*PP, FID, data, ppcond, *this);
}

class IdentifierInfo
{
    unsigned TokenID : 9; // Front-end token ID or tok::identifier.
    // Objective-C keyword ('protocol' in '@protocol') or builtin (__builtin_inf).
    // First NUM_OBJC_KEYWORDS values are for Objective-C, the remaining values
    // are for builtins.
    unsigned ObjCOrBuiltinID : 13;
    bool HasMacro : 1; // True if there is a #define for this.
    bool HadMacro : 1; // True if there was a #define for this.
    bool IsExtension : 1; // True if identifier is a lang extension.
    bool IsFutureCompatKeyword : 1; // True if identifier is a keyword in a
                                 // newer Standard or proposed Standard.
    bool IsPoisoned : 1; // True if identifier is poisoned.
    bool IsCPPOperatorKeyword : 1; // True if ident is a C++ operator keyword.
    bool NeedsHandleIdentifier : 1; // See "RecomputeNeedsHandleIdentifier".
    bool IsFromAST : 1; // True if identifier was loaded (at least 
                                 // partially) from an AST file.
    bool ChangedAfterLoad : 1; // True if identifier has changed from the
                                 // definition loaded from an AST file.
    bool RevertedTokenID : 1; // True if revertTokenIDToIdentifier was
                                 // called.
    bool OutOfDate : 1; // True if there may be additional
                                 // information about this identifier
                                 // stored externally.
    bool IsModulesImport : 1; // True if this is the 'import' contextual
                                 // keyword.
    // 30 bit left in 64-bit word.

    void *FETokenInfo;               // Managed by the language front-end.
    llvm::StringMapEntry<IdentifierInfo*> *Entry;
}

/// \brief Return the beginning of the actual null-terminated string for this
/// identifier.
///
const char *getNameStart() const
{
    if (Entry) return Entry->getKeyData();
    // FIXME: This is gross. It would be best not to embed specific details
    // of the PTH file format here.
    // The 'this' pointer really points to a
    // std::pair<IdentifierInfo, const char*>, where internal pointer
    // points to the external string data.
    typedef std::pair<IdentifierInfo, const char*> actualtype;
    return ((const actualtype*) this)->second;
}

/// \brief Efficiently return the length of this identifier info.
///
unsigned getLength() const
{
    if (Entry) return Entry->getKeyLength();
    // FIXME: This is gross. It would be best not to embed specific details
    // of the PTH file format here.
    // The 'this' pointer really points to a
    // std::pair<IdentifierInfo, const char*>, where internal pointer
    // points to the external string data.
    typedef std::pair<IdentifierInfo, const char*> actualtype;
    const char* p = ((const actualtype*) this)->second - 2;
    return (((unsigned)p[0]) | (((unsigned)p[1]) << 8)) - 1;
}

/// \brief Implements an efficient mapping from strings to IdentifierInfo nodes.
///
/// This has no other purpose, but this is an extremely performance-critical
/// piece of the code, as each occurrence of every identifier goes through
/// here when lexed.
class IdentifierTable
{
    // Shark shows that using MallocAllocator is *much* slower than using this
    // BumpPtrAllocator!
    typedef llvm::StringMap<IdentifierInfo*, llvm::BumpPtrAllocator> HashTableTy;
    HashTableTy HashTable;

    IdentifierInfoLookup* ExternalLookup;
}

/// \brief Return the identifier token info for the specified named
/// identifier.
IdentifierInfo &get(StringRef Name)
{
    auto &Entry = *HashTable.insert(std::make_pair(Name, nullptr)).first;

    IdentifierInfo *&II = Entry.second;
    if (II) return *II;

    // No entry; if we have an external lookup, look there first.
    if (ExternalLookup)
    {
        II = ExternalLookup->get(Name);
        if (II)
            return *II;
    }

    // Lookups failed, make a new IdentifierInfo.
    void *Mem = getAllocator().Allocate<IdentifierInfo>();
    II = new (Mem) IdentifierInfo();

    // Make sure getName() knows how to find the IdentifierInfo
    // contents.
    II->Entry = &Entry;

    return *II;
}

/// DeclarationNameExtra - Common base of the MultiKeywordSelector,
/// CXXSpecialName, and CXXOperatorIdName classes, all of which are
/// private classes that describe different kinds of names.
class DeclarationNameExtra
{
public:
    /// ExtraKind - The kind of "extra" information stored in the
    /// DeclarationName. See @c ExtraKindOrNumArgs for an explanation of
    /// how these enumerator values are used.
    enum ExtraKind
    {
        CXXConstructor = 0,
        CXXDestructor,
        CXXConversionFunction,
#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
CXXOperator##Name,
#include "clang/Basic/OperatorKinds.def"
        CXXLiteralOperator,
        CXXUsingDirective,
        NUM_EXTRA_KINDS
    };

    /// ExtraKindOrNumArgs - Either the kind of C++ special name or
    /// operator-id (if the value is one of the CXX* enumerators of
    /// ExtraKind), in which case the DeclarationNameExtra is also a
    /// CXXSpecialName, (for CXXConstructor, CXXDestructor, or
    /// CXXConversionFunction) CXXOperatorIdName, or CXXLiteralOperatorName,
    /// it may be also name common to C++ using-directives (CXXUsingDirective),
    /// otherwise it is NUM_EXTRA_KINDS+NumArgs, where NumArgs is the number of
    /// arguments in the Objective-C selector, in which case the
    /// DeclarationNameExtra is also a MultiKeywordSelector.
    unsigned ExtraKindOrNumArgs;
};

class MacroArgs
{
    unsigned NumUnexpArgTokens;
    bool VarargsElided;
    std::vector<std::vector<Token> > PreExpArgTokens;
    std::vector<Token> StringifiedArgs;
    MacroArgs *ArgCache;
}

const Token *MacroArgs::getUnexpArgument(unsigned Arg) const
{
    // The unexpanded argument tokens start immediately after the MacroArgs object
    // in memory.
    //这又是一个依赖于实现的东西啊，内存对齐呢！ 谁说当前对象末尾一定无缝隙链接Token啊
    const Token *Start = (const Token *)(this + 1);
    const Token *Result = Start;
    // Scan to find Arg.
    for (; Arg; ++Result)
    {
        assert(Result < Start + NumUnexpArgTokens && "Invalid arg #");
        if (Result->is(tok::eof))
            --Arg;
    }
    assert(Result < Start + NumUnexpArgTokens && "Invalid arg #");
    return Result;
}

static MacroArgs *create(const MacroInfo *MI,
        ArrayRef<Token> UnexpArgTokens,
        bool VarargsElided, Preprocessor &PP);

void MacroArgs::destroy(Preprocessor &PP)
{
    StringifiedArgs.clear();

    // Don't clear PreExpArgTokens, just clear the entries.  Clearing the entries
    // would deallocate the element vectors.
    for (unsigned i = 0, e = PreExpArgTokens.size(); i != e; ++i)
        PreExpArgTokens[i].clear();

    // Add this to the preprocessor's free list.
    //总的空闲头节点存储在PP.MacroArgCache里面
    //感觉这样的话只能进行头节点处理啊，多节点分配就崩了
    ArgCache = PP.MacroArgCache;
    PP.MacroArgCache = this;
}

MacroArgs *MacroArgs::deallocate()

MacroArgs *Next = ArgCache;

// Run the dtor to deallocate the vectors. this-> MacroArgs(); //

Release the memory for the object. free(this);

return Next;

const std::vector<Token> &
MacroArgs::getPreExpArgument(unsigned Arg, const MacroInfo *MI,
    Preprocessor &PP)
{
    assert(Arg < MI->getNumArgs() && "Invalid argument number!");

    // If we have already computed this, return it.
    if (PreExpArgTokens.size() < MI->getNumArgs())
        PreExpArgTokens.resize(MI->getNumArgs());

    std::vector<Token> &Result = PreExpArgTokens[Arg];
    if (!Result.empty()) return Result;

    SaveAndRestore<bool> PreExpandingMacroArgs(PP.InMacroArgPreExpansion, true);

    const Token *AT = getUnexpArgument(Arg);
    unsigned NumToks = getArgLength(AT) + 1;  // Include the EOF.

    // Otherwise, we have to pre-expand this argument, populating Result.  To do
    // this, we set up a fake TokenLexer to lex from the unexpanded argument
    // list.  With this installed, we lex expanded tokens until we hit the EOF
    // token at the end of the unexp list.
    PP.EnterTokenStream(AT, NumToks, false /*disable expand*/,
        false /*owns tokens*/);
}

PP.EnterTokenStream(AT, NumToks, false /*disable expand*/,
    false /*owns tokens*/);
// Lex all of the macro-expanded tokens into Result.
do
{
    Result.push_back(Token());
    Token &Tok = Result.back();
    PP.Lex(Tok);
}
while (Result.back().isNot(tok::eof));

// Pop the token stream off the top of the stack.  We know that the internal
// pointer inside of it is to the "end" of the token stream, but the stack
// will not otherwise be popped until the next token is lexed.  The problem is
// that the token may be lexed sometime after the vector of tokens itself is
// destroyed, which would be badness.
if (PP.InCachingLexMode())
    PP.ExitCachingLexMode();
PP.RemoveTopOfLexerStack();
return Result;

class MacroInfo
{
    //===--------------------------------------------------------------------===//
    // State set when the macro is defined.

    /// \brief The location the macro is defined.
    SourceLocation Location;
    /// \brief The location of the last token in the macro.
    SourceLocation EndLocation;

    /// \brief The list of arguments for a function-like macro.
    ///
    /// ArgumentList points to the first of NumArguments pointers.
    ///
    /// This can be empty, for, e.g. "#define X()".  In a C99-style variadic
    /// macro, this includes the \c __VA_ARGS__ identifier on the list.
    IdentifierInfo **ArgumentList;

    /// \see ArgumentList
    unsigned NumArguments;

    /// \brief This is the list of tokens that the macro is defined to.
    SmallVector<Token, 8> ReplacementTokens;

    /// \brief Length in characters of the macro definition.
    mutable unsigned DefinitionLength;
    mutable bool IsDefinitionLengthCached : 1;
}

unsigned MacroInfo::getDefinitionLengthSlow(SourceManager &SM) const
{
    assert(!IsDefinitionLengthCached);
    IsDefinitionLengthCached = true;

    if (ReplacementTokens.empty())
        return (DefinitionLength = 0);

    const Token &firstToken = ReplacementTokens.front();
    const Token &lastToken = ReplacementTokens.back();
    SourceLocation macroStart = firstToken.getLocation();
    SourceLocation macroEnd = lastToken.getLocation();
    assert(macroStart.isValid() && macroEnd.isValid());
    assert((macroStart.isFileID() || firstToken.is(tok::comment)) &&
        "Macro defined in macro?");
    assert((macroEnd.isFileID() || lastToken.is(tok::comment)) &&
        "Macro defined in macro?");
    std::pair<FileID, unsigned>
        startInfo = SM.getDecomposedExpansionLoc(macroStart);
    std::pair<FileID, unsigned>
        endInfo = SM.getDecomposedExpansionLoc(macroEnd);
    assert(startInfo.first == endInfo.first &&
        "Macro definition spanning multiple FileIDs ?");
    assert(startInfo.second <= endInfo.second);
    DefinitionLength = endInfo.second - startInfo.second;
    DefinitionLength += lastToken.getLength();

    return DefinitionLength;
}

//是否是函数宏还是对象宏.
bool IsFunctionLike : 1;

// 是否是C99的变参宏
bool IsC99Varargs : 1;

//是否是GNU的变参宏
bool IsGNUVarargs : 1;

//是否是语言内置宏，如__FILE__ __LINE__等
bool IsBuiltinMacro : 1;

/// \brief Whether this macro contains the sequence ", ## __VA_ARGS__"
bool HasCommaPasting : 1;

//===--------------------------------------------------------------------===//
// State that changes as the macro is used.

/// \brief True if we have started an expansion of this macro already.
///
/// This disables recursive expansion, which would be quite bad for things
/// like \#define A A.
bool IsDisabled : 1;

/// \brief True if this macro is either defined in the main file and has
/// been used, or if it is not defined in the main file.
///
/// This is used to emit -Wunused-macros diagnostics.
bool IsUsed : 1;

/// \brief True if this macro can be redefined without emitting a warning.
bool IsAllowRedefinitionsWithoutWarning : 1;

/// \brief Must warn if the macro is unused at the end of translation unit.
bool IsWarnIfUnused : 1;

/// \brief Whether this macro info was loaded from an AST file.
unsigned FromASTFile : 1;

/// \brief Whether this macro was used as header guard.
bool UsedForHeaderGuard : 1;

bool MacroInfo::isIdenticalTo(const MacroInfo &Other, Preprocessor &PP,
bool Syntactically) const
{
    bool Lexically = !Syntactically;

    // Check # tokens in replacement, number of args, and various flags all match.
    if (ReplacementTokens.size() != Other.ReplacementTokens.size() ||
        getNumArgs() != Other.getNumArgs() ||
        isFunctionLike() != Other.isFunctionLike() ||
        isC99Varargs() != Other.isC99Varargs() ||
        isGNUVarargs() != Other.isGNUVarargs())
        return false;

    if (Lexically)
    {
        // Check arguments.
        for (arg_iterator I = arg_begin(), OI = Other.arg_begin(), E = arg_end();
        I != E; ++I, ++OI)
            if (*I != *OI) return false;
    }

    // Check all the tokens.
    for (unsigned i = 0, e = ReplacementTokens.size(); i != e; ++i)
    {
        const Token &A = ReplacementTokens[i];
        const Token &B = Other.ReplacementTokens[i];
        if (A.getKind() != B.getKind())
            return false;

        // If this isn't the first first token, check that the whitespace and
        // start-of-line characteristics match.
        if (i != 0 &&
            (A.isAtStartOfLine() != B.isAtStartOfLine() ||
                A.hasLeadingSpace() != B.hasLeadingSpace()))
            return false;

        // If this is an identifier, it is easy.
        if (A.getIdentifierInfo() || B.getIdentifierInfo())
        {
            if (A.getIdentifierInfo() == B.getIdentifierInfo())
                continue;
            if (Lexically)
                return false;
            // With syntactic equivalence the parameter names can be different as long
            // as they are used in the same place.
            int AArgNum = getArgumentNum(A.getIdentifierInfo());
            if (AArgNum == -1)
                return false;
            if (AArgNum != Other.getArgumentNum(B.getIdentifierInfo()))
                return false;
            continue;
        }

        // Otherwise, check the spelling.
        if (PP.getSpelling(A) != PP.getSpelling(B))
            return false;
    }
}

enum Kind
{
    MD_Define, MD_Undefine, MD_Visibility
};

class MacroDirective
{
    /// \brief Previous macro directive for the same identifier, or NULL.
    MacroDirective *Previous;

    SourceLocation Loc;

    /// \brief MacroDirective kind.
    unsigned MDKind : 2;

    /// \brief True if the macro directive was loaded from a PCH file.
    bool IsFromPCH : 1;

    // Used by VisibilityMacroDirective ----------------------------------------//

    /// \brief Whether the macro has public visibility (when described in a
    /// module).
    bool IsPublic : 1;
}

class DefMacroDirective : public MacroDirective
{
    MacroInfo *Info;
}

class UndefMacroDirective : public MacroDirective

class VisibilityMacroDirective : public MacroDirective

MacroDirective::DefInfo MacroDirective::getDefinition()
{
    MacroDirective *MD = this;
    SourceLocation UndefLoc;
    Optional<bool> isPublic;
    for (; MD; MD = MD->getPrevious())
    {
        if (DefMacroDirective *DefMD = dyn_cast<DefMacroDirective>(MD))
            return DefInfo(DefMD, UndefLoc,
                !isPublic.hasValue() || isPublic.getValue());

        if (UndefMacroDirective *UndefMD = dyn_cast<UndefMacroDirective>(MD))
        {
            UndefLoc = UndefMD->getLocation();
            continue;
        }

        VisibilityMacroDirective *VisMD = cast<VisibilityMacroDirective>(MD);
        if (!isPublic.hasValue())
            isPublic = VisMD->isPublic();
    }

    return DefInfo(nullptr, UndefLoc,
        !isPublic.hasValue() || isPublic.getValue());
}

class ModuleMacro : public llvm::FoldingSetNode
{
    /// The name defined by the macro.
    IdentifierInfo *II;
    /// The body of the #define, or nullptr if this is a #undef.
    MacroInfo *Macro;
    /// The module that exports this macro.
    Module *OwningModule;
    /// The number of module macros that override this one.
    unsigned NumOverriddenBy;
    /// The number of modules whose macros are directly overridden by this one.
    unsigned NumOverrides;
    // ModuleMacro *OverriddenMacros[NumOverrides];
}

class MacroDefinition
{
    llvm::PointerIntPair<DefMacroDirective *, 1, bool> LatestLocalAndAmbiguous;
    ArrayRef<ModuleMacro *> ModuleMacros;
}

/// Macro - The macro we are expanding from.  This is null if expanding a
/// token stream.
///
MacroInfo *Macro;

/// ActualArgs - The actual arguments specified for a function-like macro, or
/// null.  The TokenLexer owns the pointed-to object.
MacroArgs *ActualArgs;

/// PP - The current preprocessor object we are expanding for.
///
Preprocessor &PP;

/// Tokens - This is the pointer to an array of tokens that the macro is
/// defined to, with arguments expanded for function-like macros.  If this is
/// a token stream, these are the tokens we are returning.  This points into
/// the macro definition we are lexing from, a cache buffer that is owned by
/// the preprocessor, or some other buffer that we may or may not own
/// (depending on OwnsTokens).
/// Note that if it points into Preprocessor's cache buffer, the Preprocessor
/// may update the pointer as needed.
const Token *Tokens;

/// NumTokens - This is the length of the Tokens array.
///
unsigned NumTokens;

/// CurToken - This is the next token that Lex will return.
///
unsigned CurToken;

/// ExpandLocStart/End - The source location range where this macro was
/// expanded.
SourceLocation ExpandLocStart, ExpandLocEnd;

/// \brief Source location pointing at the source location entry chunk that
/// was reserved for the current macro expansion.
SourceLocation MacroExpansionStart;

/// \brief The offset of the macro expansion in the
/// "source location address space".
unsigned MacroStartSLocOffset;

/// \brief Location of the macro definition.
SourceLocation MacroDefStart;
/// \brief Length of the macro definition.
unsigned MacroDefLength;

/// Lexical information about the expansion point of the macro: the identifier
/// that the macro expanded from had these properties.
bool AtStartOfLine : 1;
bool HasLeadingSpace : 1;

// NextTokGetsSpace - When this is true, the next token appended to the
// output list during function argument expansion will get a leading space,
// regardless of whether it had one to begin with or not. This is used for
// placemarker support. If still true after function argument expansion, the
// leading space will be applied to the first token following the macro
// expansion.
bool NextTokGetsSpace : 1;

/// OwnsTokens - This is true if this TokenLexer allocated the Tokens
/// array, and thus needs to free it when destroyed.  For simple object-like
/// macros (for example) we just point into the token buffer of the macro
/// definition, we don't make a copy of it.
bool OwnsTokens : 1;

/// DisableMacroExpansion - This is true when tokens lexed from the TokenLexer
/// should not be subject to further macro expansion.
bool DisableMacroExpansion : 1;

SmallVector<Token, 128> ResultToks;

// Loop through 'Tokens', expanding them into ResultToks.  Keep
// track of whether we change anything.  If not, no need to keep them.  If so,
// we install the newly expanded sequence as the new 'Tokens' list.
bool MadeChange = false;

const Token &CurTok = Tokens[i];
if (i != 0 && !Tokens[i - 1].is(tok::hashhash) && CurTok.hasLeadingSpace())
    NextTokGetsSpace = true;

if (CurTok.isOneOf(tok::hash, tok::hashat))
{
    int ArgNo = Macro->getArgumentNum(Tokens[i + 1].getIdentifierInfo());
    assert(ArgNo != -1 && "Token following # is not an argument?");

    SourceLocation ExpansionLocStart =
        getExpansionLocForMacroDefLoc(CurTok.getLocation());
    SourceLocation ExpansionLocEnd =
        getExpansionLocForMacroDefLoc(Tokens[i + 1].getLocation());

    Token Res;
    if (CurTok.is(tok::hash))  // Stringify
        Res = ActualArgs->getStringifiedArgument(ArgNo, PP,
            ExpansionLocStart,
            ExpansionLocEnd);
    else
    {
        // 'charify': don't bother caching these.
        Res = MacroArgs::StringifyArgument(ActualArgs->getUnexpArgument(ArgNo),
            PP, true,
            ExpansionLocStart,
            ExpansionLocEnd);
    }
    Res.setFlag(Token::StringifiedInMacro);

    // The stringified/charified string leading space flag gets set to match
    // the #/#@ operator.
    if (NextTokGetsSpace)
        Res.setFlag(Token::LeadingSpace);

    ResultToks.push_back(Res);
    MadeChange = true;
    ++i;  // Skip arg name.
    NextTokGetsSpace = false;
    continue;
}

// Find out if there is a paste (##) operator before or after the token.
bool NonEmptyPasteBefore =
    !ResultToks.empty() && ResultToks.back().is(tok::hashhash);
bool PasteBefore = i != 0 && Tokens[i - 1].is(tok::hashhash);
bool PasteAfter = i + 1 != e && Tokens[i + 1].is(tok::hashhash);
assert(!NonEmptyPasteBefore || PasteBefore);

// Otherwise, if this is not an argument token, just add the token to the
// output buffer.
IdentifierInfo *II = CurTok.getIdentifierInfo();
int ArgNo = II ? Macro->getArgumentNum(II) : -1;
if (ArgNo == -1)
{
    // This isn't an argument, just add it.
    ResultToks.push_back(CurTok);

    if (NextTokGetsSpace)
    {
        ResultToks.back().setFlag(Token::LeadingSpace);
        NextTokGetsSpace = false;
    }
    else if (PasteBefore && !NonEmptyPasteBefore)
        ResultToks.back().clearFlag(Token::LeadingSpace);

    continue;
}

// If it is not the LHS/RHS of a ## operator, we must pre-expand the
// argument and substitute the expanded tokens into the result.  This is
// C99 6.10.3.1p1.
if (!PasteBefore && !PasteAfter)
{
    const Token *ResultArgToks;

    // Only preexpand the argument if it could possibly need it.  This
    // avoids some work in common cases.
    const Token *ArgTok = ActualArgs->getUnexpArgument(ArgNo);
    if (ActualArgs->ArgNeedsPreexpansion(ArgTok, PP))
        ResultArgToks = &ActualArgs->getPreExpArgument(ArgNo, Macro, PP)[0];
    else
        ResultArgToks = ArgTok;  // Use non-preexpanded tokens.

// If the arg token expanded into anything, append it.
    if (ResultArgToks->isNot(tok::eof))
    {
        unsigned FirstResult = ResultToks.size();
        unsigned NumToks = MacroArgs::getArgLength(ResultArgToks);
        ResultToks.append(ResultArgToks, ResultArgToks + NumToks);

        // In Microsoft-compatibility mode, we follow MSVC's preprocessing
        // behavior by not considering single commas from nested macro
        // expansions as argument separators. Set a flag on the token so we can
        // test for this later when the macro expansion is processed.
        if (PP.getLangOpts().MSVCCompat && NumToks == 1 &&
            ResultToks.back().is(tok::comma))
            ResultToks.back().setFlag(Token::IgnoredComma);

        // If the '##' came from expanding an argument, turn it into 'unknown'
        // to avoid pasting.
        for (unsigned i = FirstResult, e = ResultToks.size(); i != e; ++i)
        {
            Token &Tok = ResultToks[i];
            if (Tok.is(tok::hashhash))
                Tok.setKind(tok::unknown);
        }

        if (ExpandLocStart.isValid())
        {
            updateLocForMacroArgTokens(CurTok.getLocation(),
                ResultToks.begin() + FirstResult,
                ResultToks.end());
        }

        // If any tokens were substituted from the argument, the whitespace
        // before the first token should match the whitespace of the arg
        // identifier.
        ResultToks[FirstResult].setFlagValue(Token::LeadingSpace,
            NextTokGetsSpace);
        NextTokGetsSpace = false;
    }
    continue;
}

/// \brief Creates SLocEntries and updates the locations of macro argument
/// tokens to their new expanded locations.
///
/// \param ArgIdDefLoc the location of the macro argument id inside the macro
/// definition.
/// \param Tokens the macro argument tokens to update.
void TokenLexer::updateLocForMacroArgTokens(SourceLocation ArgIdSpellLoc,
    Token *begin_tokens,
    Token *end_tokens)
{
    SourceManager &SM = PP.getSourceManager();

    SourceLocation InstLoc =
        getExpansionLocForMacroDefLoc(ArgIdSpellLoc);

    while (begin_tokens < end_tokens)
    {
        // If there's only one token just create a SLocEntry for it.
        if (end_tokens - begin_tokens == 1)
        {
            Token &Tok = *begin_tokens;
            Tok.setLocation(SM.createMacroArgExpansionLoc(Tok.getLocation(),
                InstLoc,
                Tok.getLength()));
            return;
        }

        updateConsecutiveMacroArgTokens(SM, InstLoc, begin_tokens, end_tokens);
    }
}

// \brief Finds the tokens that are consecutive (from the same FileID)
/// creates a single SLocEntry, and assigns SourceLocations to each token that
/// point to that SLocEntry. e.g for
///   assert(foo == bar);
/// There will be a single SLocEntry for the "foo == bar" chunk and locations
/// for the 'foo', '==', 'bar' tokens will point inside that chunk.
///
/// \arg begin_tokens will be updated to a position past all the found
/// consecutive tokens.
static void updateConsecutiveMacroArgTokens(SourceManager &SM,
    SourceLocation InstLoc,
    Token *&begin_tokens,
    Token * end_tokens)

assert(begin_tokens < end_tokens);

SourceLocation FirstLoc = begin_tokens->getLocation();
SourceLocation CurLoc = FirstLoc;

// Compare the source location offset of tokens and group together tokens that
// are close, even if their locations point to different FileIDs. e.g.
//
//  |bar    |  foo | cake   |  (3 tokens from 3 consecutive FileIDs)
//  ^                    ^
//  |bar       foo   cake|     (one SLocEntry chunk for all tokens)
//
// we can perform this "merge" since the token's spelling location depends
// on the relative offset.

Token *NextTok = begin_tokens + 1;
for (; NextTok < end_tokens; ++NextTok)
{
    SourceLocation NextLoc = NextTok->getLocation();
    if (CurLoc.isFileID() != NextLoc.isFileID())
        break; // Token from different kind of FileID.

    int RelOffs;
    if (!SM.isInSameSLocAddrSpace(CurLoc, NextLoc, &RelOffs))
        break; // Token from different local/loaded location.
 // Check that token is not before the previous token or more than 50
 // "characters" away.
    if (RelOffs < 0 || RelOffs > 50)
        break;
    CurLoc = NextLoc;
}

// For the consecutive tokens, find the length of the SLocEntry to contain
// all of them.
Token &LastConsecutiveTok = *(NextTok - 1);
int LastRelOffs = 0;
SM.isInSameSLocAddrSpace(FirstLoc, LastConsecutiveTok.getLocation(),
    &LastRelOffs);
unsigned FullLength = LastRelOffs + LastConsecutiveTok.getLength();

// Create a macro expansion SLocEntry that will "contain" all of the tokens.
SourceLocation Expansion =
    SM.createMacroArgExpansionLoc(FirstLoc, InstLoc, FullLength);

// Change the location of the tokens from the spelling location to the new
// expanded location.
for (; begin_tokens < NextTok; ++begin_tokens)
{
    Token &Tok = *begin_tokens;
    int RelOffs = 0;
    SM.isInSameSLocAddrSpace(FirstLoc, Tok.getLocation(), &RelOffs);
    Tok.setLocation(Expansion.getLocWithOffset(RelOffs));
}

// Okay, we have a token that is either the LHS or RHS of a paste (##)
// argument.  It gets substituted as its non-pre-expanded tokens.
const Token *ArgToks = ActualArgs->getUnexpArgument(ArgNo);
unsigned NumToks = MacroArgs::getArgLength(ArgToks);

if (NumToks)
{  // Not an empty argument?
// If this is the GNU ", ## __VA_ARGS__" extension, and we just learned
// that __VA_ARGS__ expands to multiple tokens, avoid a pasting error when
// the expander trys to paste ',' with the first token of the __VA_ARGS__
// expansion.
    if (NonEmptyPasteBefore && ResultToks.size() >= 2 &&
        ResultToks[ResultToks.size() - 2].is(tok::comma) &&
        (unsigned)ArgNo == Macro->getNumArgs() - 1 &&
        Macro->isVariadic())
    {
        // Remove the paste operator, report use of the extension.
        PP.Diag(ResultToks.pop_back_val().getLocation(), diag::ext_paste_comma);
    }

    ResultToks.append(ArgToks, ArgToks + NumToks);

    // If the '##' came from expanding an argument, turn it into 'unknown'
    // to avoid pasting.
    for (unsigned i = ResultToks.size() - NumToks, e = ResultToks.size();
    i != e; ++i)
    {
        Token &Tok = ResultToks[i];
        if (Tok.is(tok::hashhash))
            Tok.setKind(tok::unknown);
    }

    if (ExpandLocStart.isValid())
    {
        updateLocForMacroArgTokens(CurTok.getLocation(),
            ResultToks.end() - NumToks, ResultToks.end());
    }

    // If this token (the macro argument) was supposed to get leading
    // whitespace, transfer this information onto the first token of the
    // expansion.
    //
    // Do not do this if the paste operator occurs before the macro argument,
    // as in "A ## MACROARG".  In valid code, the first token will get
    // smooshed onto the preceding one anyway (forming AMACROARG).  In
    // assembler-with-cpp mode, invalid pastes are allowed through: in this
    // case, we do not want the extra whitespace to be added.  For example,
    // we want ". ## foo" -> ".foo" not ". foo".
    if (NextTokGetsSpace)
        ResultToks[ResultToks.size() - NumToks].setFlag(Token::LeadingSpace);

    NextTokGetsSpace = false;
    continue;
}

// If an empty argument is on the LHS or RHS of a paste, the standard (C99
// 6.10.3.3p2,3) calls for a bunch of placemarker stuff to occur.  We
// implement this by eating ## operators when a LHS or RHS expands to
// empty.
if (PasteAfter)
{
    // Discard the argument token and skip (don't copy to the expansion
    // buffer) the paste operator after it.
    ++i;
    continue;
}

if (MadeChange)
{
    assert(!OwnsTokens && "This would leak if we already own the token list");
    // This is deleted in the dtor.
    NumTokens = ResultToks.size();
    // The tokens will be added to Preprocessor's cache and will be removed
    // when this TokenLexer finishes lexing them.
    Tokens = PP.cacheMacroExpandedTokens(this, ResultToks);

    // The preprocessor cache of macro expanded tokens owns these tokens,not us.
    OwnsTokens = false;
}

/// Init - Initialize this TokenLexer to expand from the specified macro
/// with the specified argument information.  Note that this ctor takes
/// ownership of the ActualArgs pointer.  ILEnd specifies the location of the
/// ')' for a function-like macro or the identifier for an object-like macro.
void Init(Token &Tok, SourceLocation ILEnd, MacroInfo *MI,
    MacroArgs *ActualArgs);

void TokenLexer::destroy()
{
    // If this was a function-like macro that actually uses its arguments, delete
    // the expanded tokens.
    if (OwnsTokens)
    {
        delete[] Tokens;
        Tokens = nullptr;
        OwnsTokens = false;
    }

    // TokenLexer owns its formal arguments.
    if (ActualArgs) ActualArgs->destroy(PP);
}

destroy();

Macro = MI;
ActualArgs = Actuals;
CurToken = 0;

ExpandLocStart = Tok.getLocation();
ExpandLocEnd = ELEnd;
AtStartOfLine = Tok.isAtStartOfLine();
HasLeadingSpace = Tok.hasLeadingSpace();
NextTokGetsSpace = false;
Tokens = &*Macro->tokens_begin();
OwnsTokens = false;
DisableMacroExpansion = false;
NumTokens = Macro->tokens_end() - Macro->tokens_begin();
MacroExpansionStart = SourceLocation();

SourceManager &SM = PP.getSourceManager();
MacroStartSLocOffset = SM.getNextLocalOffset();

if (NumTokens > 0)
{
    assert(Tokens[0].getLocation().isValid());
    assert((Tokens[0].getLocation().isFileID() || Tokens[0].is(tok::comment)) &&
        "Macro defined in macro?");
    assert(ExpandLocStart.isValid());

    // Reserve a source location entry chunk for the length of the macro
    // definition. Tokens that get lexed directly from the definition will
    // have their locations pointing inside this chunk. This is to avoid
    // creating separate source location entries for each token.
    MacroDefStart = SM.getExpansionLoc(Tokens[0].getLocation());
    MacroDefLength = Macro->getDefinitionLength(SM);
    MacroExpansionStart = SM.createExpansionLoc(MacroDefStart,
        ExpandLocStart,
        ExpandLocEnd,
        MacroDefLength);
}

// If this is a function-like macro, expand the arguments and change
// Tokens to point to the expanded tokens.
if (Macro->isFunctionLike() && Macro->getNumArgs())
    ExpandFunctionArguments();

/// Lex - Lex and return a token from this macro stream.
///
bool TokenLexer::Lex(Token &Tok)

// Lexing off the end of the macro, pop this macro off the expansion stack.
if (isAtEnd())
{
    // If this is a macro (not a token stream), mark the macro enabled now
    // that it is no longer being expanded.
    if (Macro) Macro->EnableMacro();

    Tok.startToken();
    Tok.setFlagValue(Token::StartOfLine, AtStartOfLine);
    Tok.setFlagValue(Token::LeadingSpace, HasLeadingSpace || NextTokGetsSpace);
    if (CurToken == 0)
        Tok.setFlag(Token::LeadingEmptyMacro);
    return PP.HandleEndOfTokenLexer(Tok);
}

SourceManager &SM = PP.getSourceManager();

// If this is the first token of the expanded result, we inherit spacing
// properties later.
bool isFirstToken = CurToken == 0;

// Get the next token to return.
Tok = Tokens[CurToken++];

bool TokenIsFromPaste = false;

// If this token is followed by a token paste (##) operator, paste the tokens!
// Note that ## is a normal token when not expanding a macro.
if (!isAtEnd() && Macro &&
    (Tokens[CurToken].is(tok::hashhash) ||
        // Special processing of L#x macros in -fms-compatibility mode.
        // Microsoft compiler is able to form a wide string literal from
        // 'L#macro_arg' construct in a function-like macro.
        (PP.getLangOpts().MSVCCompat &&
            isWideStringLiteralFromMacro(Tok, Tokens[CurToken]))))
{
    // When handling the microsoft /##/ extension, the final token is
    // returned by PasteTokens, not the pasted token.
    if (PasteTokens(Tok))
        return true;

    TokenIsFromPaste = true;
}

/// PasteTokens - Tok is the LHS of a ## operator, and CurToken is the ##
/// operator.  Read the ## and RHS, and paste the LHS/RHS together.  If there
/// are more ## after it, chomp them iteratively.  Return the result as Tok.
/// If this returns true, the caller should immediately return the token.
bool TokenLexer::PasteTokens(Token &Tok)

// The token's current location indicate where the token was lexed from.  We
// need this information to compute the spelling of the token, but any
// diagnostics for the expanded token should appear as if they came from
// ExpansionLoc.  Pull this information together into a new SourceLocation
// that captures all of this.
if (ExpandLocStart.isValid() &&   // Don't do this for token streams.
    // Check that the token's location was not already set properly.
    SM.isBeforeInSLocAddrSpace(Tok.getLocation(), MacroStartSLocOffset))
{
    SourceLocation instLoc;
    if (Tok.is(tok::comment))
    {
        instLoc = SM.createExpansionLoc(Tok.getLocation(),
            ExpandLocStart,
            ExpandLocEnd,
            Tok.getLength());
    }
    else
    {
        instLoc = getExpansionLocForMacroDefLoc(Tok.getLocation());
    }

    Tok.setLocation(instLoc);
}

// Handle recursive expansion!
if (!Tok.isAnnotation() && Tok.getIdentifierInfo() != nullptr)
{
    // Change the kind of this identifier to the appropriate token kind, e.g.
    // turning "for" into a keyword.
    IdentifierInfo *II = Tok.getIdentifierInfo();
    Tok.setKind(II->getTokenID());

    // If this identifier was poisoned and from a paste, emit an error.  This
    // won't be handled by Preprocessor::HandleIdentifier because this is coming
    // from a macro expansion.
    if (II->isPoisoned() && TokenIsFromPaste)
    {
        PP.HandlePoisonedIdentifier(Tok);
    }

    if (!DisableMacroExpansion && II->isHandleIdentifierCase())
        return PP.HandleIdentifier(Tok);
}

    /// \brief Simple wrapper class for chaining callbacks.
class PPChainedCallbacks : public PPCallbacks
{
    virtual void anchor();
    std::unique_ptr<PPCallbacks> First, Second;

    public:
    PPChainedCallbacks(std::unique_ptr<PPCallbacks> _First,
    std::unique_ptr<PPCallbacks> _Second)
    : First(std::move(_First)), Second(std::move(_Second))
    {}
}

enum PragmaIntroducerKind
{
    /**
    * \brief The pragma was introduced via \#pragma.
    */
    PIK_HashPragma,

    /**
    * \brief The pragma was introduced via the C99 _Pragma(string-literal).
    */
    PIK__Pragma,

    /**
    * \brief The pragma was introduced via the Microsoft
    * __pragma(token-string).
    */
    PIK___pragma
};

class PragmaHandler
{
    std::string Name;
    public:
    explicit PragmaHandler(StringRef name) : Name(name)
    {}
    PragmaHandler()
    {}
    virtual ~PragmaHandler();

    StringRef getName() const
    {
        return Name;
    }
    virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
    Token &FirstToken) = 0;

    /// getIfNamespace - If this is a namespace, return it.  This is equivalent to
    /// using a dynamic_cast, but doesn't require RTTI.
    virtual PragmaNamespace *getIfNamespace()
    {
        return nullptr;
    }
};

/// PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas,
/// allowing hierarchical pragmas to be defined.  Common examples of namespaces
/// are "\#pragma GCC", "\#pragma STDC", and "\#pragma omp", but any namespaces
/// may be (potentially recursively) defined.
class PragmaNamespace : public PragmaHandler
{
    /// Handlers - This is a map of the handlers in this namespace with their name
    /// as key.
    ///
    llvm::StringMap<PragmaHandler*> Handlers;
}

void PragmaNamespace::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &Tok)
{
    // Read the 'namespace' that the directive is in, e.g. STDC.  Do not macro
    // expand it, the user can have a STDC #define, that should not affect this.
    PP.LexUnexpandedToken(Tok);

    // Get the handler for this token.  If there is no handler, ignore the pragma.
    PragmaHandler *Handler
    = FindHandler(Tok.getIdentifierInfo() ? Tok.getIdentifierInfo()->getName()
    : StringRef(),
    /*IgnoreNull=*/false);
    if (!Handler)
    {
        PP.Diag(Tok, diag::warn_pragma_ignored);
        return;
    }

    // Otherwise, pass it down.
    Handler->HandlePragma(PP, Introducer, Tok);
}

#define EMPTY(x)
#define INACTIVE(x) EMPTY(x)
INACTIVE(_Pragma("clang diagnostic ignored \"-Wconversion\""))

/// HandlePragmaOnce - Handle \#pragma once.  OnceTok is the 'once'.
///
void Preprocessor::HandlePragmaOnce(Token &OnceTok)
{
    if (isInPrimaryFile())
    {
        Diag(OnceTok, diag::pp_pragma_once_in_main_file);
        return;
    }

    // Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
    // Mark the file as a once-only file now.
    HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry());
}

#define MACRO_FOO an_str_value // 宏 MACRO_FOO 的第一种定义
/*
使用 MACRO_FOO 关联 an_str_value 的代码
*/
#pragma push_macro("MACRO_FOO") // 将 MACRO_FOO 关联的 an_str_value 先保存起来
#undef MACRO_FOO // 这句不能忘记, 否则会出现宏重复定义的警告信息. 

#define MACRO_FOO another_str_value // 宏 MACRO_FOO 的第二种定义
/*
使用 MACRO_FOO 关联 another_str_value 的代码
*/

// #undef MACRO_FOO // pop_macro 之前这句不需要, 因为并没有定义宏, 只是重新关联了字符串值而已.
#pragma pop_macro("MACRO_FOO") // 将宏 MACRO_FOO 的值恢复为之前保存的 an_str_value
/*
继续使用 MACRO_FOO 关联 an_str_value 的代码
*/ 

void Preprocessor::RegisterBuiltinPragmas()
{
    AddPragmaHandler(new PragmaOnceHandler());
    AddPragmaHandler(new PragmaMarkHandler());
    AddPragmaHandler(new PragmaPushMacroHandler());
    AddPragmaHandler(new PragmaPopMacroHandler());
    AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message));

    // #pragma GCC ...
    AddPragmaHandler("GCC", new PragmaPoisonHandler());
    AddPragmaHandler("GCC", new PragmaSystemHeaderHandler());
    AddPragmaHandler("GCC", new PragmaDependencyHandler());
    AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC"));
    AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning,
    "GCC"));
    AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error,
    "GCC"));
    // #pragma clang ...
    AddPragmaHandler("clang", new PragmaPoisonHandler());
    AddPragmaHandler("clang", new PragmaSystemHeaderHandler());
    AddPragmaHandler("clang", new PragmaDebugHandler());
    AddPragmaHandler("clang", new PragmaDependencyHandler());
    AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang"));
    AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler());

    AddPragmaHandler("STDC", new PragmaSTDC_FENV_ACCESSHandler());
    AddPragmaHandler("STDC", new PragmaSTDC_CX_LIMITED_RANGEHandler());
    AddPragmaHandler("STDC", new PragmaSTDC_UnknownHandler());

    // MS extensions.
    if (LangOpts.MicrosoftExt)
    {
        AddPragmaHandler(new PragmaWarningHandler());
        AddPragmaHandler(new PragmaIncludeAliasHandler());
        AddPragmaHandler(new PragmaRegionHandler("region"));
        AddPragmaHandler(new PragmaRegionHandler("endregion"));
    }
}

typedef std::vector<CondDirectiveLoc> CondDirectiveLocsTy;
/// \brief The locations of conditional directives in source order.
CondDirectiveLocsTy CondDirectiveLocs;

/// \brief Returns true if the given range intersects with a conditional
/// directive. if a \#if/\#endif block is fully contained within the range,
/// this function will return false.
bool rangeIntersectsConditionalDirective(SourceRange Range) const;

/// \brief Returns true if the given locations are in different regions,
/// separated by conditional directive blocks.
bool areInDifferentConditionalDirectiveRegion(SourceLocation LHS,
SourceLocation RHS) const
{
    return findConditionalDirectiveRegionLoc(LHS) !=
    findConditionalDirectiveRegionLoc(RHS);
}

SourceLocation findConditionalDirectiveRegionLoc(SourceLocation Loc) const;

SourceLocation PPConditionalDirectiveRecord::findConditionalDirectiveRegionLoc(
SourceLocation Loc) const {
    if (Loc.isInvalid())
    return SourceLocation();
    if (CondDirectiveLocs.empty())
    return SourceLocation();

    if (SourceMgr.isBeforeInTranslationUnit(CondDirectiveLocs.back().getLoc(),
    Loc))
    return CondDirectiveStack.back();

    CondDirectiveLocsTy::const_iterator
    low = std::lower_bound(CondDirectiveLocs.begin(), CondDirectiveLocs.end(),
    Loc, CondDirectiveLoc::Comp(SourceMgr));
    assert(low != CondDirectiveLocs.end());
    return low->getRegionLoc();
}

struct DefinedTracker
{
    /// Each time a Value is evaluated, it returns information about whether the
    /// parsed value is of the form defined(X), !defined(X) or is something else.
    enum TrackerState
    {
        DefinedMacro,        // defined(X)
        NotDefinedMacro,     // !defined(X)
        Unknown              // Something else.
    } State;
    /// TheMacro - When the state is DefinedMacro or NotDefinedMacro, this
    /// indicates the macro that was checked.
    IdentifierInfo *TheMacro;
};

enum EntityKind
{
    /// \brief Indicates a problem trying to load the preprocessed entity.
    InvalidKind,

    /// \brief A macro expansion.
    MacroExpansionKind,

    /// \defgroup Preprocessing directives
    /// @{

        /// \brief A macro definition.
        MacroDefinitionKind,

        /// \brief An inclusion directive, such as \c \#include, \c
        /// \#import, or \c \#include_next.
        InclusionDirectiveKind,

        /// @}

    FirstPreprocessingDirective = MacroDefinitionKind,
    LastPreprocessingDirective = InclusionDirectiveKind
};

class PreprocessedEntity
{
    public:
    /// \brief The kind of preprocessed entity an object describes.
    private:
    /// \brief The kind of preprocessed entity that this object describes.
    EntityKind Kind;

    /// \brief The source range that covers this preprocessed entity.
    SourceRange Range;

    protected:
    PreprocessedEntity(EntityKind Kind, SourceRange Range)
    : Kind(Kind), Range(Range)
    {}

    friend class PreprocessingRecord;

    public:
    /// \brief Retrieve the kind of preprocessed entity stored in this object.
    EntityKind getKind() const
    {
        return Kind;
    }

    /// \brief Retrieve the source range that covers this entire preprocessed 
    /// entity.
    SourceRange getSourceRange() const LLVM_READONLY
    {
        return Range;
    }

    /// \brief Returns true if there was a problem loading the preprocessed
    /// entity.
    bool isInvalid() const
    {
        return Kind == InvalidKind;
    }
}

llvm::PointerUnion<IdentifierInfo *, MacroDefinition *> NameOrDef;

/// \brief The set of preprocessed entities in this record, in order they
/// were seen.
std::vector<PreprocessedEntity *> PreprocessedEntities;

/// \brief The set of preprocessed entities in this record that have been
/// loaded from external sources.
///
/// The entries in this vector are loaded lazily from the external source,
/// and are referenced by the iterator using negative indices.
std::vector<PreprocessedEntity *> LoadedPreprocessedEntities;

/// \brief The set of ranges that were skipped by the preprocessor,
std::vector<SourceRange> SkippedRanges;

/// \brief Mapping from MacroInfo structures to their definitions.
llvm::DenseMap<const MacroInfo *, MacroDefinition *> MacroDefinitions;

void MacroExpands(const Token &Id, const MacroDirective *MD,
SourceRange Range, const MacroArgs *Args) override;
void MacroDefined(const Token &Id, const MacroDirective *MD) override;
void MacroUndefined(const Token &Id, const MacroDirective *MD) override;
void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
StringRef FileName, bool IsAngled,
CharSourceRange FilenameRange,
const FileEntry *File, StringRef SearchPath,
StringRef RelativePath,
const Module *Imported) override;
void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
const MacroDirective *MD) override;
void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
const MacroDirective *MD) override;
/// \brief Hook called whenever the 'defined' operator is seen.
void Defined(const Token &MacroNameTok, const MacroDirective *MD,
SourceRange Range) override;

void SourceRangeSkipped(SourceRange Range) override;

void addMacroExpansion(const Token &Id, const MacroInfo *MI,
SourceRange Range);

class PreprocessorLexer
{
    virtual void anchor();
    protected:
    Preprocessor *PP;              // Preprocessor object controlling lexing.

    /// The SourceManager FileID corresponding to the file being lexed.
    const FileID FID;

    /// \brief Number of SLocEntries before lexing the file.
    unsigned InitialNumSLocEntries;

    //===--------------------------------------------------------------------===//
    // Context-specific lexing flags set by the preprocessor.
    //===--------------------------------------------------------------------===//

    /// \brief True when parsing \#XXX; turns '\\n' into a tok::eod token.
    bool ParsingPreprocessorDirective;

    /// \brief True after \#include; turns \<xx> into a tok::angle_string_literal
    /// token.
    bool ParsingFilename;

    /// \brief True if in raw mode.
    ///
    /// Raw mode disables interpretation of tokens and is a far faster mode to
    /// lex in than non-raw-mode.  This flag:
    ///  1. If EOF of the current lexer is found, the include stack isn't popped.
    ///  2. Identifier information is not looked up for identifier tokens.  As an
    ///     effect of this, implicit macro expansion is naturally disabled.
    ///  3. "#" tokens at the start of a line are treated as normal tokens, not
    ///     implicitly transformed by the lexer.
    ///  4. All diagnostic messages are disabled.
    ///  5. No callbacks are made into the preprocessor.
    ///
    /// Note that in raw mode that the PP pointer may be null.
    bool LexingRawMode;

    /// \brief A state machine that detects the \#ifndef-wrapping a file
    /// idiom for the multiple-include optimization.
    MultipleIncludeOpt MIOpt;

    /// \brief Information about the set of \#if/\#ifdef/\#ifndef blocks
    /// we are currently in.
    SmallVector<PPConditionalInfo, 4> ConditionalStack;
}