Preprocessor.cpp | Explore in Territory

//===- Preprocessor.cpp - C Language Family Preprocessor Implementation ---===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
//  This file implements the Preprocessor interface.
//
//===----------------------------------------------------------------------===//
//
// Options to support:
//   -H       - Print the name of each header file used.
//   -d[DNI] - Dump various things.
//   -fworking-directory - #line's with preprocessor's working dir.
//   -fpreprocessed
//   -dependency-file,-M,-MM,-MF,-MG,-MP,-MT,-MQ,-MD,-MMD
//   -W*
//   -w
//
// Messages to emit:
//   "Multiple include guards may be useful for:\n"
//
//===----------------------------------------------------------------------===//

#include "clang/Lex/Preprocessor.h"
#include "clang/Basic/Builtins.h"
#include "clang/Basic/FileManager.h"
#include "clang/Basic/FileSystemStatCache.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/Module.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Lex/CodeCompletionHandler.h"
#include "clang/Lex/ExternalPreprocessorSource.h"
#include "clang/Lex/HeaderSearch.h"
#include "clang/Lex/LexDiagnostic.h"
#include "clang/Lex/Lexer.h"
#include "clang/Lex/LiteralSupport.h"
#include "clang/Lex/MacroArgs.h"
#include "clang/Lex/MacroInfo.h"
#include "clang/Lex/ModuleLoader.h"
#include "clang/Lex/Pragma.h"
#include "clang/Lex/PreprocessingRecord.h"
#include "clang/Lex/PreprocessorLexer.h"
#include "clang/Lex/PreprocessorOptions.h"
#include "clang/Lex/ScratchBuffer.h"
#include "clang/Lex/Token.h"
#include "clang/Lex/TokenLexer.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/Support/Capacity.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>

usingnamespaceclang;

/// Minimum distance between two check points, in tokens.
static constexpr unsigned CheckPointStepSize = …;

LLVM_INSTANTIATE_REGISTRY(…)

ExternalPreprocessorSource::~ExternalPreprocessorSource() = default;

Preprocessor::Preprocessor(std::shared_ptr<PreprocessorOptions> PPOpts,
                           DiagnosticsEngine &diags, const LangOptions &opts,
                           SourceManager &SM, HeaderSearch &Headers,
                           ModuleLoader &TheModuleLoader,
                           IdentifierInfoLookup *IILookup, bool OwnsHeaders,
                           TranslationUnitKind TUKind)
    : … { … }

Preprocessor::~Preprocessor() { … }

void Preprocessor::Initialize(const TargetInfo &Target,
                              const TargetInfo *AuxTarget) { … }

void Preprocessor::InitializeForModelFile() { … }

void Preprocessor::FinalizeForModelFile() { … }

void Preprocessor::DumpToken(const Token &Tok, bool DumpFlags) const { … }

void Preprocessor::DumpLocation(SourceLocation Loc) const { … }

void Preprocessor::DumpMacro(const MacroInfo &MI) const { … }

void Preprocessor::PrintStats() { … }

Preprocessor::macro_iterator
Preprocessor::macro_begin(bool IncludeExternalMacros) const { … }

size_t Preprocessor::getTotalMemory() const { … }

Preprocessor::macro_iterator
Preprocessor::macro_end(bool IncludeExternalMacros) const { … }

/// Compares macro tokens with a specified token value sequence.
static bool MacroDefinitionEquals(const MacroInfo *MI,
                                  ArrayRef<TokenValue> Tokens) { … }

StringRef Preprocessor::getLastMacroWithSpelling(
                                    SourceLocation Loc,
                                    ArrayRef<TokenValue> Tokens) const { … }

void Preprocessor::recomputeCurLexerKind() { … }

bool Preprocessor::SetCodeCompletionPoint(FileEntryRef File,
                                          unsigned CompleteLine,
                                          unsigned CompleteColumn) { … }

void Preprocessor::CodeCompleteIncludedFile(llvm::StringRef Dir,
                                            bool IsAngled) { … }

void Preprocessor::CodeCompleteNaturalLanguage() { … }

/// getSpelling - This method is used to get the spelling of a token into a
/// SmallVector. Note that the returned StringRef may not point to the
/// supplied buffer if a copy can be avoided.
StringRef Preprocessor::getSpelling(const Token &Tok,
                                          SmallVectorImpl<char> &Buffer,
                                          bool *Invalid) const { … }

/// CreateString - Plop the specified string into a scratch buffer and return a
/// location for it.  If specified, the source location provides a source
/// location for the token.
void Preprocessor::CreateString(StringRef Str, Token &Tok,
                                SourceLocation ExpansionLocStart,
                                SourceLocation ExpansionLocEnd) { … }

SourceLocation Preprocessor::SplitToken(SourceLocation Loc, unsigned Length) { … }

Module *Preprocessor::getCurrentModule() { … }

Module *Preprocessor::getCurrentModuleImplementation() { … }

//===----------------------------------------------------------------------===//
// Preprocessor Initialization Methods
//===----------------------------------------------------------------------===//

/// EnterMainSourceFile - Enter the specified FileID as the main source file,
/// which implicitly adds the builtin defines etc.
void Preprocessor::EnterMainSourceFile() { … }

void Preprocessor::setPCHThroughHeaderFileID(FileID FID) { … }

bool Preprocessor::isPCHThroughHeader(const FileEntry *FE) { … }

bool Preprocessor::creatingPCHWithThroughHeader() { … }

bool Preprocessor::usingPCHWithThroughHeader() { … }

bool Preprocessor::creatingPCHWithPragmaHdrStop() { … }

bool Preprocessor::usingPCHWithPragmaHdrStop() { … }

/// Skip tokens until after the #include of the through header or
/// until after a #pragma hdrstop is seen. Tokens in the predefines file
/// and the main file may be skipped. If the end of the predefines file
/// is reached, skipping continues into the main file. If the end of the
/// main file is reached, it's a fatal error.
void Preprocessor::SkipTokensWhileUsingPCH() { … }

void Preprocessor::replayPreambleConditionalStack() { … }

void Preprocessor::EndSourceFile() { … }

//===----------------------------------------------------------------------===//
// Lexer Event Handling.
//===----------------------------------------------------------------------===//

/// LookUpIdentifierInfo - Given a tok::raw_identifier token, look up the
/// identifier information for the token and install it into the token,
/// updating the token kind accordingly.
IdentifierInfo *Preprocessor::LookUpIdentifierInfo(Token &Identifier) const { … }

void Preprocessor::SetPoisonReason(IdentifierInfo *II, unsigned DiagID) { … }

void Preprocessor::PoisonSEHIdentifiers(bool Poison) { … }

void Preprocessor::HandlePoisonedIdentifier(Token & Identifier) { … }

void Preprocessor::updateOutOfDateIdentifier(const IdentifierInfo &II) const { … }

/// HandleIdentifier - This callback is invoked when the lexer reads an
/// identifier.  This callback looks up the identifier in the map and/or
/// potentially macro expands it or turns it into a named token (like 'for').
///
/// Note that callers of this method are guarded by checking the
/// IdentifierInfo's 'isHandleIdentifierCase' bit.  If this method changes, the
/// IdentifierInfo methods that compute these properties will need to change to
/// match.
bool Preprocessor::HandleIdentifier(Token &Identifier) { … }

void Preprocessor::Lex(Token &Result) { … }

void Preprocessor::LexTokensUntilEOF(std::vector<Token> *Tokens) { … }

/// Lex a header-name token (including one formed from header-name-tokens if
/// \p AllowMacroExpansion is \c true).
///
/// \param FilenameTok Filled in with the next token. On success, this will
///        be either a header_name token. On failure, it will be whatever other
///        token was found instead.
/// \param AllowMacroExpansion If \c true, allow the header name to be formed
///        by macro expansion (concatenating tokens as necessary if the first
///        token is a '<').
/// \return \c true if we reached EOD or EOF while looking for a > token in
///         a concatenated header name and diagnosed it. \c false otherwise.
bool Preprocessor::LexHeaderName(Token &FilenameTok, bool AllowMacroExpansion) { … }

/// Collect the tokens of a C++20 pp-import-suffix.
void Preprocessor::CollectPpImportSuffix(SmallVectorImpl<Token> &Toks) { … }


/// Lex a token following the 'import' contextual keyword.
///
///     pp-import: [C++20]
///           import header-name pp-import-suffix[opt] ;
///           import header-name-tokens pp-import-suffix[opt] ;
/// [ObjC]    @ import module-name ;
/// [Clang]   import module-name ;
///
///     header-name-tokens:
///           string-literal
///           < [any sequence of preprocessing-tokens other than >] >
///
///     module-name:
///           module-name-qualifier[opt] identifier
///
///     module-name-qualifier
///           module-name-qualifier[opt] identifier .
///
/// We respond to a pp-import by importing macros from the named module.
bool Preprocessor::LexAfterModuleImport(Token &Result) { … }

void Preprocessor::makeModuleVisible(Module *M, SourceLocation Loc) { … }

bool Preprocessor::FinishLexStringLiteral(Token &Result, std::string &String,
                                          const char *DiagnosticTag,
                                          bool AllowMacroExpansion) { … }

bool Preprocessor::parseSimpleIntegerLiteral(Token &Tok, uint64_t &Value) { … }

void Preprocessor::addCommentHandler(CommentHandler *Handler) { … }

void Preprocessor::removeCommentHandler(CommentHandler *Handler) { … }

bool Preprocessor::HandleComment(Token &result, SourceRange Comment) { … }

void Preprocessor::emitMacroDeprecationWarning(const Token &Identifier) const { … }

void Preprocessor::emitRestrictExpansionWarning(const Token &Identifier) const { … }

void Preprocessor::emitRestrictInfNaNWarning(const Token &Identifier,
                                             unsigned DiagSelection) const { … }

void Preprocessor::emitFinalMacroWarning(const Token &Identifier,
                                         bool IsUndef) const { … }

bool Preprocessor::isSafeBufferOptOut(const SourceManager &SourceMgr,
                                      const SourceLocation &Loc) const { … }

bool Preprocessor::enterOrExitSafeBufferOptOutRegion(
    bool isEnter, const SourceLocation &Loc) { … }

bool Preprocessor::isPPInSafeBufferOptOutRegion() { … }
bool Preprocessor::isPPInSafeBufferOptOutRegion(SourceLocation &StartLoc) { … }

SmallVector<SourceLocation, 64>
Preprocessor::serializeSafeBufferOptOutMap() const { … }

bool Preprocessor::setDeserializedSafeBufferOptOutMap(
    const SmallVectorImpl<SourceLocation> &SourceLocations) { … }

ModuleLoader::~ModuleLoader() = default;

CommentHandler::~CommentHandler() = default;

EmptylineHandler::~EmptylineHandler() = default;

CodeCompletionHandler::~CodeCompletionHandler() = default;

void Preprocessor::createPreprocessingRecord() { … }

const char *Preprocessor::getCheckPoint(FileID FID, const char *Start) const { … }
llvm/clang/lib/Lex/Preprocessor.cpp
