Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/Preprocessor_8cpp_source.html below:

clang: lib/Lex/Preprocessor.cpp Source File

;

: PPOpts(

::move(PPOpts)), Diags(&diags), LangOpts(opts),

FileMgr(Headers.getFileMgr()), SourceMgr(

),

ScratchBuf(new

(SourceMgr)), HeaderInfo(Headers),

Identifiers(IILookup), PragmaHandlers(new

(StringRef())),

TUKind(TUKind), SkipMainFilePreamble(0,

),

CurSubmoduleState(&NullSubmoduleState) {

OwnsHeaderSearch = OwnsHeaders;

KeepComments =

;

KeepMacroComments =

;

SuppressIncludeNotFoundError =

;

DisableMacroExpansion =

;

MacroExpansionInDirectivesOverride =

;

InMacroArgs =

;

InMacroArgPreExpansion =

;

NumCachedTokenLexers = 0;

PragmasEnabled =

;

ParsingIfOrElifDirective =

;

PreprocessedOutput =

;

ReadMacrosFromExternalSource =

;

BuiltinInfo = std::make_unique<Builtin::Context>();

RegisterBuiltinPragmas();

RegisterBuiltinMacros();

(LangOpts.Borland) {

Ident__exception_info = Ident__exception_code =

;

Ident__abnormal_termination = Ident___exception_info =

;

Ident___exception_code = Ident___abnormal_termination =

;

Ident_GetExceptionInfo = Ident_GetExceptionCode =

;

Ident_AbnormalTermination =

;

IncrementalProcessing = LangOpts.IncrementalExtensions;

SkippingUntilPragmaHdrStop =

;

(!this->PPOpts->PCHThroughHeader.empty() &&

!this->PPOpts->ImplicitPCHInclude.empty())

SkippingUntilPCHThroughHeader =

;

(this->PPOpts->GeneratePreamble)

PreambleConditionalStack.startRecording();

MaxTokens = LangOpts.MaxTokens;

IncludeMacroStack.clear();

std::fill(TokenLexerCache, TokenLexerCache + NumCachedTokenLexers,

);

CurTokenLexer.reset();

(

*ArgList = MacroArgCache; ArgList;)

ArgList = ArgList->deallocate();

(OwnsHeaderSearch)

assert((!this->Target || this->Target == &

) &&

);

assert((!this->AuxTarget || this->AuxTarget == AuxTarget) &&

);

this->AuxTarget = AuxTarget;

BuiltinInfo->InitializeTarget(

, AuxTarget);

NumEnteredSourceFiles = 0;

PragmaHandlersBackup = std::move(PragmaHandlers);

PragmaHandlers = std::make_unique<PragmaNamespace>(StringRef());

RegisterBuiltinPragmas();

PredefinesFileID =

();

NumEnteredSourceFiles = 1;

PragmaHandlers = std::move(PragmaHandlersBackup);

(!DumpFlags)

;

llvm::errs() <<

;

llvm::errs() <<

;

llvm::errs() <<

;

llvm::errs() <<

;

llvm::errs() <<

<< StringRef(Start, Tok.

())

llvm::errs() <<

;

llvm::errs() <<

;

.

(llvm::errs(), SourceMgr);

llvm::errs() <<

;

(

i = 0, e = MI.

(); i != e; ++i) {

llvm::errs() <<

;

llvm::errs() <<

;

llvm::errs() <<

;

llvm::errs() << NumDirectives <<

;

llvm::errs() <<

<< NumDefined <<

;

llvm::errs() <<

<< NumUndefined <<

;

llvm::errs() <<

;

llvm::errs() <<

<< NumEnteredSourceFiles <<

;

llvm::errs() <<

<< MaxIncludeStackDepth <<

;

llvm::errs() <<

<< NumIf <<

;

llvm::errs() <<

<< NumElse <<

;

llvm::errs() <<

<< NumEndif <<

;

llvm::errs() <<

<< NumPragma <<

;

llvm::errs() << NumSkipped <<

;

llvm::errs() << NumMacroExpanded <<

<< NumFnMacroExpanded <<

<< NumBuiltinMacroExpanded <<

<< NumFastMacroExpanded <<

;

llvm::errs() << (NumFastTokenPaste+NumTokenPaste)

<<

<< NumFastTokenPaste <<

;

llvm::errs() <<

<<

() <<

;

llvm::errs() <<

<< BP.getTotalMemory();

llvm::errs() <<

<< llvm::capacity_in_bytes(MacroExpandedTokens);

llvm::errs() <<

<< Predefines.capacity();

llvm::errs() <<

<< llvm::capacity_in_bytes(CurSubmoduleState->Macros);

llvm::errs() <<

<< llvm::capacity_in_bytes(PragmaPushMacroInfo);

llvm::errs() <<

<< llvm::capacity_in_bytes(PoisonReasons);

llvm::errs() <<

<< llvm::capacity_in_bytes(CommentHandlers) <<

;

!ReadMacrosFromExternalSource) {

ReadMacrosFromExternalSource =

;

CurSubmoduleState->Macros.insert(std::make_pair(Macro.II, MacroState()));

CurSubmoduleState->Macros.begin();

BP.getTotalMemory()

+ llvm::capacity_in_bytes(MacroExpandedTokens)

+ Predefines.capacity()

+ llvm::capacity_in_bytes(CurSubmoduleState->Macros)

+ llvm::capacity_in_bytes(PragmaPushMacroInfo)

+ llvm::capacity_in_bytes(PoisonReasons)

+ llvm::capacity_in_bytes(CommentHandlers);

!ReadMacrosFromExternalSource) {

ReadMacrosFromExternalSource =

;

CurSubmoduleState->Macros.end();

std::equal(Tokens.begin(), Tokens.end(), MI->

());

StringRef BestSpelling;

Def = I->second.findDirectiveAtLoc(

, SourceMgr);

BestLocation = Location;

BestSpelling = I->first->getName();

CurLexerCallback = CurLexer->isDependencyDirectivesLexer()

? CLK_DependencyDirectivesLexer

(CurTokenLexer)

CurLexerCallback = CLK_TokenLexer;

CurLexerCallback = CLK_CachingLexer;

CompleteLine,

CompleteColumn) {

assert(CompleteLine && CompleteColumn &&

);

assert(!CodeCompletionFile &&

);

std::optional<llvm::MemoryBufferRef> Buffer =

*Position = Buffer->getBufferStart();

(

= 1;

< CompleteLine; ++

) {

(; *Position; ++Position) {

(*Position !=

&& *Position !=

)

((Position[1] ==

|| Position[1] ==

) &&

Position[0] != Position[1])

Position += CompleteColumn - 1;

(SkipMainFilePreamble.first &&

(Position - Buffer->getBufferStart() < SkipMainFilePreamble.first)

Position = Buffer->getBufferStart() + SkipMainFilePreamble.first;

(Position > Buffer->getBufferEnd())

Position = Buffer->getBufferEnd();

CodeCompletionFile =

;

CodeCompletionOffset = Position - Buffer->getBufferStart();

NewBuffer = llvm::WritableMemoryBuffer::getNewUninitMemBuffer(

Buffer->getBufferSize() + 1, Buffer->getBufferIdentifier());

*NewBuf = NewBuffer->getBufferStart();

*NewPos = std::copy(Buffer->getBufferStart(), Position, NewBuf);

std::copy(Position, Buffer->getBufferEnd(), NewPos+1);

(Tok.

(tok::raw_identifier) && !Tok.

()) {

II->getName();

*Ptr = Buffer.data();

StringRef(Ptr, Len);

(ExpansionLocStart.

())

ExpansionLocEnd, Str.size());

(Tok.

(tok::raw_identifier))

std::pair<FileID, unsigned> LocInfo =

.getDecomposedLoc(SpellingLoc);

StringRef Buffer =

.getBufferData(LocInfo.first, &

);

ScratchBuf->getToken(Buffer.data() + LocInfo.second, Length, DestPtr);

(!

().isCompilingModuleImplementation())

assert(NumEnteredSourceFiles == 0 &&

);

(SkipMainFilePreamble.first > 0)

CurLexer->SetByteOffset(SkipMainFilePreamble.first,

SkipMainFilePreamble.second);

std::unique_ptr<llvm::MemoryBuffer> SB =

llvm::MemoryBuffer::getMemBufferCopy(Predefines,

);

assert(SB &&

);

assert(FID.

() &&

);

setPredefinesFileID(FID);

(!PPOpts->PCHThroughHeader.empty()) {

,

,

,

,

,

,

<< PPOpts->PCHThroughHeader;

setPCHThroughHeaderFileID(

Preprocessor::setPCHThroughHeaderFileID(

FID) {

assert(PCHThroughHeaderFileID.

() &&

);

PCHThroughHeaderFileID = FID;

assert(PCHThroughHeaderFileID.

() &&

);

PCHThroughHeaderFileID.

();

PCHThroughHeaderFileID.

();

ReachedMainFileEOF =

;

UsingPCHThroughHeader = SkippingUntilPCHThroughHeader;

UsingPragmaHdrStop = SkippingUntilPragmaHdrStop;

CurLexerCallback(*

, Tok);

(Tok.

(tok::eof) && !InPredefines) {

ReachedMainFileEOF =

;

(UsingPCHThroughHeader && !SkippingUntilPCHThroughHeader)

(UsingPragmaHdrStop && !SkippingUntilPragmaHdrStop)

(ReachedMainFileEOF) {

(UsingPCHThroughHeader)

<< PPOpts->PCHThroughHeader << 1;

(!PPOpts->PCHWithHdrStopCreate)

Preprocessor::replayPreambleConditionalStack() {

(PreambleConditionalStack.isReplaying()) {

);

PreambleConditionalStack.doneReplaying();

(PreambleConditionalStack.reachedEOFWhileSkipping())

SkipExcludedConditionalBlock(

PreambleConditionalStack.SkipInfo->HashTokenLoc,

PreambleConditionalStack.SkipInfo->IfTokenLoc,

PreambleConditionalStack.SkipInfo->FoundNonSkipPortion,

PreambleConditionalStack.SkipInfo->FoundElse,

PreambleConditionalStack.SkipInfo->ElseLoc);

Callbacks->EndOfMainFile();

assert(!

.getRawIdentifier().empty() &&

);

PoisonReasons[II] = DiagID;

assert(Ident__exception_code && Ident__exception_info);

assert(Ident___exception_code && Ident___exception_info);

);

llvm::DenseMap<IdentifierInfo*,unsigned>::const_iterator it =

PoisonReasons.find(

.getIdentifierInfo());

(it == PoisonReasons.end())

Preprocessor::updateOutOfDateIdentifier(

&II)

{

);

CurrentIsPoisoned =

;

IsSpecialVariadicMacro =

&II == Ident__VA_ARGS__ || &II == Ident__VA_OPT__;

(IsSpecialVariadicMacro)

updateOutOfDateIdentifier(II);

(IsSpecialVariadicMacro)

*MI = MD.getMacroInfo();

assert(MI &&

);

(!DisableMacroExpansion) {

(!

.isExpandDisabled() && MI->isEnabled()) {

HandleMacroExpandedIdentifier(

, MD);

!InMacroArgs && !DisableMacroExpansion &&

CurLexerCallback != CLK_CachingLexer) {

NamedModuleImportPath.clear();

ModuleImportExpectsIdentifier =

;

CurLexerCallback = CLK_LexAfterModuleImport;

(!CurLexerCallback(*

,

))

(

.is(tok::code_completion) &&

.getIdentifierInfo()) {

.setIdentifierInfo(

);

(

().CPlusPlusModules && LexLevel == 1 &&

(

.getKind()) {

tok::l_paren:

tok::l_square:

tok::l_brace:

StdCXXImportSeqState.handleOpenBracket();

tok::r_paren:

tok::r_square:

StdCXXImportSeqState.handleCloseBracket();

StdCXXImportSeqState.handleCloseBrace();

tok::annot_module_include:

TrackGMFState.handleSemi();

StdCXXImportSeqState.handleSemi();

ModuleDeclState.handleSemi();

tok::header_name:

tok::annot_header_unit:

StdCXXImportSeqState.handleHeaderName();

TrackGMFState.handleExport();

StdCXXImportSeqState.handleExport();

ModuleDeclState.handleExport();

ModuleDeclState.handleColon();

ModuleDeclState.handlePeriod();

tok::identifier:

(StdCXXImportSeqState.atTopLevel()) {

(

.getIdentifierInfo()->isModulesImport()) {

TrackGMFState.handleImport(StdCXXImportSeqState.afterTopLevelSeq());

StdCXXImportSeqState.handleImport();

(StdCXXImportSeqState.afterImportSeq()) {

ModuleImportLoc =

.getLocation();

NamedModuleImportPath.clear();

ModuleImportExpectsIdentifier =

;

CurLexerCallback = CLK_LexAfterModuleImport;

TrackGMFState.handleModule(StdCXXImportSeqState.afterTopLevelSeq());

ModuleDeclState.handleModule();

ModuleDeclState.handleIdentifier(

.getIdentifierInfo());

(ModuleDeclState.isModuleCandidate())

TrackGMFState.handleMisc();

StdCXXImportSeqState.handleMisc();

ModuleDeclState.handleMisc();

CheckPoints[CurLexer->getFileID()].push_back(CurLexer->BufferPtr);

CheckPointCounter = 0;

LastTokenWasAt =

.is(tok::at);

((LexLevel == 0 || PreprocessToken) &&

(Tok.

(tok::unknown, tok::eof, tok::eod,

tok::annot_repl_input_end))

(Tokens !=

)

Tokens->push_back(Tok);

(FilenameTok.

(tok::less) && AllowMacroExpansion) {

FilenameBuffer.push_back(

);

(FilenameTok.

(tok::greater)) {

(FilenameTok.

(tok::eod, tok::eof)) {

(FilenameTok.

(), diag::err_expected) << tok::greater;

(Start, diag::note_matching) << tok::less;

(FilenameTok.

(tok::code_completion)) {

FilenameBuffer.push_back(

);

PreAppendSize = FilenameBuffer.size();

FilenameBuffer.resize(PreAppendSize + FilenameTok.

());

*BufPtr = &FilenameBuffer[PreAppendSize];

ActualLen =

(FilenameTok, BufPtr);

(BufPtr != &FilenameBuffer[PreAppendSize])

(&FilenameBuffer[PreAppendSize], BufPtr, ActualLen);

(FilenameTok.

() != ActualLen)

FilenameBuffer.resize(PreAppendSize + ActualLen);

FilenameTok.

(tok::header_name);

(FilenameBuffer, FilenameTok, Start, End);

}

(FilenameTok.

(tok::string_literal) && AllowMacroExpansion) {

StringRef Str =

(FilenameTok, FilenameBuffer);

(Str.size() >= 2 && Str.front() ==

&& Str.back() ==

)

FilenameTok.

(tok::header_name);

BracketDepth = 0;

Toks.emplace_back();

(Toks.back().getKind()) {

tok::l_paren:

tok::l_square:

tok::l_brace:

tok::r_paren:

tok::r_square:

tok::r_brace:

(BracketDepth == 0)

(BracketDepth == 0)

(NamedModuleImportPath.empty() &&

().CPlusPlusModules) {

(

.is(tok::colon) && ModuleDeclState.isNamedModule()) {

std::string Name = ModuleDeclState.getPrimaryName().str();

NamedModuleImportPath.push_back(

CurLexerCallback = CLK_LexAfterModuleImport;

ToksCopy = std::make_unique<Token[]>(Toks.size());

std::copy(Toks.begin(), Toks.end(), ToksCopy.get());

EnterTokenStream(std::move(ToksCopy), Toks.size(),

ImportingHeader =

.is(tok::header_name);

(ImportingHeader) {

Suffix.push_back(

);

(Suffix.back().isNot(tok::semi)) {

EnterTokens(Suffix);

(SemiLoc, diag::err_header_import_semi_in_macro);

ImportTok.

(tok::kw_import);

Action = HandleHeaderIncludeOrImport(

(Action.Kind) {

ImportAction::None:

ImportAction::ModuleBegin:

Suffix.emplace_back();

Suffix.back().startToken();

Suffix.back().setKind(tok::annot_module_begin);

Suffix.back().setLocation(SemiLoc);

Suffix.back().setAnnotationEndLoc(SemiLoc);

Suffix.back().setAnnotationValue(Action.ModuleForHeader);

ImportAction::ModuleImport:

ImportAction::HeaderUnitImport:

ImportAction::SkippedModuleImport:

Suffix[0].setKind(tok::annot_header_unit);

Suffix[0].setAnnotationEndLoc(Suffix[0].getLocation());

Suffix[0].setAnnotationValue(Action.ModuleForHeader);

ImportAction::Failure:

);

.setKind(tok::eof);

CurLexer->cutOffLexing();

EnterTokens(Suffix);

EnterTokens(Suffix);

(ModuleImportExpectsIdentifier &&

.getKind() == tok::identifier) {

NamedModuleImportPath.push_back(

std::make_pair(

.getIdentifierInfo(),

.getLocation()));

ModuleImportExpectsIdentifier =

;

CurLexerCallback = CLK_LexAfterModuleImport;

(!ModuleImportExpectsIdentifier &&

.getKind() == tok::period) {

ModuleImportExpectsIdentifier =

;

CurLexerCallback = CLK_LexAfterModuleImport;

(NamedModuleImportPath.empty() ||

.is(tok::eof))

(

.isNot(tok::semi)) {

Suffix.push_back(

);

(Suffix.back().isNot(tok::semi)) {

EnterTokens(Suffix);

SemiLoc = Suffix.back().getLocation();

std::string FlatModuleName;

(

&Piece : NamedModuleImportPath) {

(!FlatModuleName.empty() && FlatModuleName.back() !=

)

FlatModuleName +=

;

FlatModuleName += Piece.first->getName();

NamedModuleImportPath.clear();

NamedModuleImportPath.push_back(

*Imported =

;

Imported = TheModuleLoader.

(ModuleImportLoc,

NamedModuleImportPath,

Callbacks->moduleImport(ModuleImportLoc, NamedModuleImportPath, Imported);

(!Suffix.empty()) {

EnterTokens(Suffix);

CurSubmoduleState->VisibleModules.setVisible(

(ModuleImportLoc, diag::warn_module_conflict)

<<

[0]->getFullModuleName()

<< Conflict->getFullModuleName()

(!BuildingSubmoduleStack.empty() && M != BuildingSubmoduleStack.back().M)

BuildingSubmoduleStack.back().M->Imports.insert(M);

*DiagnosticTag,

AllowMacroExpansion) {

(

.isNot(tok::string_literal)) {

(

, diag::err_expected_string_literal)

<<

0 << DiagnosticTag;

StrToks.push_back(

);

(

.hasUDSuffix())

(

, diag::err_invalid_string_udl);

(AllowMacroExpansion)

}

(

.is(tok::string_literal));

assert(Literal.isOrdinary() &&

);

(Literal.hadError)

(Literal.Pascal) {

(StrToks[0].getLocation(), diag::err_expected_string_literal)

<<

0 << DiagnosticTag;

String = std::string(Literal.GetString());

assert(Tok.

(tok::numeric_constant));

NumberInvalid =

;

StringRef Spelling =

(Tok, IntegerBuffer, &NumberInvalid);

(Literal.hadError || !Literal.isIntegerLiteral() || Literal.hasUDSuffix())

llvm::APInt APVal(64, 0);

(Literal.GetIntegerValue(APVal))

= APVal.getLimitedValue();

assert(Handler &&

);

assert(!llvm::is_contained(CommentHandlers, Handler) &&

);

CommentHandlers.push_back(Handler);

std::vector<CommentHandler *>::iterator Pos =

llvm::find(CommentHandlers, Handler);

assert(Pos != CommentHandlers.end() &&

);

CommentHandlers.erase(Pos);

AnyPendingTokens =

;

(std::vector<CommentHandler *>::iterator H = CommentHandlers.begin(),

HEnd = CommentHandlers.end();

((*H)->HandleComment(*

, Comment))

AnyPendingTokens =

;

Preprocessor::emitMacroDeprecationWarning(

&

)

{

MacroAnnotations &A =

assert(A.DeprecationInfo &&

);

MacroAnnotationInfo &Info = *A.DeprecationInfo;

(Info.Message.empty())

<<

.getIdentifierInfo() << 1 << Info.Message;

(Info.Location, diag::note_pp_macro_annotation) << 0;

Preprocessor::emitRestrictExpansionWarning(

&

)

{

MacroAnnotations &A =

assert(A.RestrictExpansionInfo &&

);

MacroAnnotationInfo &Info = *A.RestrictExpansionInfo;

(Info.Message.empty())

(

, diag::warn_pragma_restrict_expansion_macro_use)

(

, diag::warn_pragma_restrict_expansion_macro_use)

<<

.getIdentifierInfo() << 1 << Info.Message;

(Info.Location, diag::note_pp_macro_annotation) << 1;

Preprocessor::emitRestrictInfNaNWarning(

&

,

DiagSelection)

{

(

, diag::warn_fp_nan_inf_when_disabled) << DiagSelection << 1;

IsUndef)

{

MacroAnnotations &A =

assert(A.FinalAnnotationLoc &&

);

<<

.getIdentifierInfo() << (IsUndef ? 0 : 1);

(*A.FinalAnnotationLoc, diag::note_pp_macro_annotation) << 2;

FirstRegionEndingAfterLoc = llvm::partition_point(

&

](

std::pair<SourceLocation, SourceLocation> &Region) {

(FirstRegionEndingAfterLoc != Map.end()) {

FirstRegionEndingAfterLoc->first,

);

(!Map.empty() && Map.back().first == Map.back().second)

TestInMap(SafeBufferOptOutMap,

);

LoadedSafeBufferOptOutMap.lookupLoadedOptOutMap(

, SourceMgr);

InSafeBufferOptOutRegion =

;

CurrentSafeBufferOptOutStart =

;

(!SafeBufferOptOutMap.empty()) {

[[maybe_unused]]

*PrevRegion = &SafeBufferOptOutMap.back();

assert(PrevRegion->first != PrevRegion->second &&

SafeBufferOptOutMap.emplace_back(

,

);

InSafeBufferOptOutRegion =

;

assert(!SafeBufferOptOutMap.empty() &&

);

*CurrRegion = &SafeBufferOptOutMap.back();

assert(CurrRegion->first == CurrRegion->second &&

);

CurrRegion->second =

;

InSafeBufferOptOutRegion;

StartLoc = CurrentSafeBufferOptOutStart;

InSafeBufferOptOutRegion;

assert(!InSafeBufferOptOutRegion &&

);

(

&[begin, end] : SafeBufferOptOutMap) {

SrcSeq.push_back(begin);

SrcSeq.push_back(end);

(SourceLocations.size() == 0)

assert(SourceLocations.size() % 2 == 0 &&

);

It = SourceLocations.begin();

LoadedSafeBufferOptOutMap.findAndConsLoadedOptOutMap(*It, SourceMgr);

Regions.emplace_back(

, End);

}

(It != SourceLocations.end());

(

It = CheckPoints.find(FID); It != CheckPoints.end()) {

*

=

;

(

*

: FileCheckPoints) {

Defines enum values for all the target-independent builtin functions.

Defines the clang::FileManager interface and associated types.

Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

Defines the clang::LangOptions interface.

llvm::MachO::Target Target

llvm::MachO::Record Record

Defines the clang::MacroInfo and clang::MacroDirective classes.

Defines the clang::Module class, which describes a module in the source code.

Defines the PreprocessorLexer interface.

static bool MacroDefinitionEquals(const MacroInfo *MI, ArrayRef< TokenValue > Tokens)

Compares macro tokens with a specified token value sequence.

static constexpr unsigned CheckPointStepSize

Minimum distance between two check points, in tokens.

Defines the clang::Preprocessor interface.

Defines the clang::SourceLocation class and associated facilities.

Defines the SourceManager interface.

__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)

virtual void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled)

Callback invoked when performing code completion inside the filename part of an #include directive.

virtual ~CodeCompletionHandler()

virtual void CodeCompleteNaturalLanguage()

Callback invoked when performing code completion in a part of the file where we expect natural langua...

Concrete class used by the front-end to report problems and issues.

virtual ~EmptylineHandler()

virtual ~ExternalPreprocessorSource()

virtual void updateOutOfDateIdentifier(const IdentifierInfo &II)=0

Update an out-of-date identifier.

A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...

Cached information about one file (either on disk or in the virtual file system).

An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...

Provides lookups to, and iteration over, IdentiferInfo objects.

One of these records is kept for each identifier that is lexed.

bool isModulesImport() const

Determine whether this is the contextual keyword import.

tok::TokenKind getTokenID() const

If this is a source-language token (e.g.

void setIsPoisoned(bool Value=true)

setIsPoisoned - Mark this identifier as poisoned.

bool isPoisoned() const

Return true if this token has been poisoned.

bool isOutOfDate() const

Determine whether the information for this identifier is out of date with respect to the external sou...

void setIsFutureCompatKeyword(bool Val)

StringRef getName() const

Return the actual identifier string.

bool isFutureCompatKeyword() const

is/setIsFutureCompatKeyword - Initialize information about whether or not this language token is a ke...

bool isExtensionToken() const

get/setExtension - Initialize information about whether or not this language token is an extension.

void AddKeywords(const LangOptions &LangOpts)

Populate the identifier table with info about the language keywords for the language specified by Lan...

@ FEM_UnsetOnCommandLine

Used only for FE option processing; this is only used to indicate that the user did not specify an ex...

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

MacroArgs - An instance of this class captures information about the formal arguments specified to a ...

A description of the current definition of a macro.

MacroInfo * getMacroInfo()

SourceLocation getLocation() const

Encapsulates the data about a macro definition (e.g.

const_tokens_iterator tokens_begin() const

unsigned getNumTokens() const

Return the number of tokens that this macro expands to.

const Token & getReplacementToken(unsigned Tok) const

bool isObjectLike() const

Abstract interface for a module loader.

virtual ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective)=0

Attempt to load the given module.

Represents a macro directive exported by a module.

Describes a module or submodule.

@ Hidden

All of the names in this module are hidden.

NumericLiteralParser - This performs strict semantic analysis of the content of a ppnumber,...

PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas, allowing hierarchical pragm...

A record of the steps taken while preprocessing a source file, including the various preprocessing di...

void setConditionalLevels(ArrayRef< PPConditionalInfo > CL)

void LexIncludeFilename(Token &FilenameTok)

Lex a token, producing a header-name token if possible.

bool markIncluded(FileEntryRef File)

Mark the file as included.

void FinalizeForModelFile()

Cleanup after model file parsing.

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

Complete the lexing of a string literal where the first token has already been lexed (see LexStringLi...

bool creatingPCHWithThroughHeader()

True if creating a PCH with a through header.

void DumpToken(const Token &Tok, bool DumpFlags=false) const

Print the token to stderr, used for debugging.

void InitializeForModelFile()

Initialize the preprocessor to parse a model file.

void CollectPpImportSuffix(SmallVectorImpl< Token > &Toks)

Collect the tokens of a C++20 pp-import-suffix.

void setCodeCompletionTokenRange(const SourceLocation Start, const SourceLocation End)

Set the code completion token range for detecting replacement range later on.

bool LexAfterModuleImport(Token &Result)

Lex a token following the 'import' contextual keyword.

macro_iterator macro_begin(bool IncludeExternalMacros=true) const

void CreateString(StringRef Str, Token &Tok, SourceLocation ExpansionLocStart=SourceLocation(), SourceLocation ExpansionLocEnd=SourceLocation())

Plop the specified string into a scratch buffer and set the specified token's location and length to ...

bool isSafeBufferOptOut(const SourceManager &SourceMgr, const SourceLocation &Loc) const

const char * getCheckPoint(FileID FID, const char *Start) const

Returns a pointer into the given file's buffer that's guaranteed to be between tokens.

IdentifierInfo * LookUpIdentifierInfo(Token &Identifier) const

Given a tok::raw_identifier token, look up the identifier information for the token and install it in...

void DumpMacro(const MacroInfo &MI) const

void setCodeCompletionReached()

Note that we hit the code-completion point.

bool SetCodeCompletionPoint(FileEntryRef File, unsigned Line, unsigned Column)

Specify the point at which code-completion will be performed.

void makeModuleVisible(Module *M, SourceLocation Loc)

bool isInImportingCXXNamedModules() const

If we're importing a standard C++20 Named Modules.

void Lex(Token &Result)

Lex the next token for this preprocessor.

const TranslationUnitKind TUKind

The kind of translation unit we are processing.

bool EnterSourceFile(FileID FID, ConstSearchDirIterator Dir, SourceLocation Loc, bool IsFirstIncludeOfFile=true)

Add a source file to the top of the include stack and start lexing tokens from it instead of the curr...

void addCommentHandler(CommentHandler *Handler)

Add the specified comment handler to the preprocessor.

void removeCommentHandler(CommentHandler *Handler)

Remove the specified comment handler.

void HandlePoisonedIdentifier(Token &Identifier)

Display reason for poisoned identifier.

bool HandleIdentifier(Token &Identifier)

Callback invoked when the lexer reads an identifier and has filled in the tokens IdentifierInfo membe...

void addPPCallbacks(std::unique_ptr< PPCallbacks > C)

bool enterOrExitSafeBufferOptOutRegion(bool isEnter, const SourceLocation &Loc)

Alter the state of whether this PP currently is in a "-Wunsafe-buffer-usage" opt-out region.

void EnterMainSourceFile()

Enter the specified FileID as the main source file, which implicitly adds the builtin defines etc.

const MacroAnnotations & getMacroAnnotations(const IdentifierInfo *II) const

IdentifierInfo * getIdentifierInfo(StringRef Name) const

Return information about the specified preprocessor identifier token.

macro_iterator macro_end(bool IncludeExternalMacros=true) const

SourceManager & getSourceManager() const

bool isBacktrackEnabled() const

True if EnableBacktrackAtThisPos() was called and caching of tokens is on.

MacroDefinition getMacroDefinition(const IdentifierInfo *II)

void SetPoisonReason(IdentifierInfo *II, unsigned DiagID)

Specifies the reason for poisoning an identifier.

bool getCommentRetentionState() const

Module * getCurrentModuleImplementation()

Retrieves the module whose implementation we're current compiling, if any.

MacroMap::const_iterator macro_iterator

void createPreprocessingRecord()

Create a new preprocessing record, which will keep track of all macro expansions, macro definitions,...

SourceLocation SplitToken(SourceLocation TokLoc, unsigned Length)

Split the first Length characters out of the token starting at TokLoc and return a location pointing ...

Module * getCurrentModule()

Retrieves the module that we're currently building, if any.

bool isPPInSafeBufferOptOutRegion()

void setCurrentFPEvalMethod(SourceLocation PragmaLoc, LangOptions::FPEvalMethodKind Val)

const TargetInfo & getTargetInfo() const

bool LexHeaderName(Token &Result, bool AllowMacroExpansion=true)

Lex a token, forming a header-name token if possible.

bool isPCHThroughHeader(const FileEntry *FE)

Returns true if the FileEntry is the PCH through header.

void DumpLocation(SourceLocation Loc) const

bool parseSimpleIntegerLiteral(Token &Tok, uint64_t &Value)

Parses a simple integer literal to get its numeric value.

void LexUnexpandedToken(Token &Result)

Just like Lex, but disables macro expansion of identifier tokens.

bool creatingPCHWithPragmaHdrStop()

True if creating a PCH with a #pragma hdrstop.

void Initialize(const TargetInfo &Target, const TargetInfo *AuxTarget=nullptr)

Initialize the preprocessor using information about the target.

FileID getPredefinesFileID() const

Returns the FileID for the preprocessor predefines.

StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const

Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...

bool HandleComment(Token &result, SourceRange Comment)

HeaderSearch & getHeaderSearchInfo() const

bool setDeserializedSafeBufferOptOutMap(const SmallVectorImpl< SourceLocation > &SrcLocSeqs)

ExternalPreprocessorSource * getExternalSource() const

bool isNextPPTokenLParen()

Determine whether the next preprocessor token to be lexed is a '('.

SmallVector< SourceLocation, 64 > serializeSafeBufferOptOutMap() const

void recomputeCurLexerKind()

Recompute the current lexer kind based on the CurLexer/ CurTokenLexer pointers.

Preprocessor(std::shared_ptr< PreprocessorOptions > PPOpts, DiagnosticsEngine &diags, const LangOptions &LangOpts, SourceManager &SM, HeaderSearch &Headers, ModuleLoader &TheModuleLoader, IdentifierInfoLookup *IILookup=nullptr, bool OwnsHeaderSearch=false, TranslationUnitKind TUKind=TU_Complete)

OptionalFileEntryRef LookupFile(SourceLocation FilenameLoc, StringRef Filename, bool isAngled, ConstSearchDirIterator FromDir, const FileEntry *FromFile, ConstSearchDirIterator *CurDir, SmallVectorImpl< char > *SearchPath, SmallVectorImpl< char > *RelativePath, ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped, bool *IsFrameworkFound, bool SkipCache=false, bool OpenFile=true, bool CacheFailures=true)

Given a "foo" or <foo> reference, look up the indicated file.

IdentifierTable & getIdentifierTable()

const LangOptions & getLangOpts() const

void setTUFPEvalMethod(LangOptions::FPEvalMethodKind Val)

void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled)

Hook used by the lexer to invoke the "included file" code completion point.

llvm::DenseMap< FileID, SafeBufferOptOutRegionsTy > LoadedRegions

void PoisonSEHIdentifiers(bool Poison=true)

size_t getTotalMemory() const

void LexTokensUntilEOF(std::vector< Token > *Tokens=nullptr)

Lex all tokens for this preprocessor until (and excluding) end of file.

bool usingPCHWithPragmaHdrStop()

True if using a PCH with a #pragma hdrstop.

void CodeCompleteNaturalLanguage()

Hook used by the lexer to invoke the "natural language" code completion point.

void EndSourceFile()

Inform the preprocessor callbacks that processing is complete.

DiagnosticsEngine & getDiagnostics() const

StringRef getLastMacroWithSpelling(SourceLocation Loc, ArrayRef< TokenValue > Tokens) const

Return the name of the macro defined before Loc that has spelling Tokens.

void setCodeCompletionIdentifierInfo(IdentifierInfo *Filter)

Set the code completion token for filtering purposes.

DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const

Forwarding function for diagnostics.

void SkipTokensWhileUsingPCH()

Skip tokens until after the #include of the through header or until after a #pragma hdrstop.

bool usingPCHWithThroughHeader()

True if using a PCH with a through header.

ScratchBuffer - This class exposes a simple interface for the dynamic construction of tokens.

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

void print(raw_ostream &OS, const SourceManager &SM) const

SourceLocation getLocWithOffset(IntTy Offset) const

Return a source location with the specified offset from this SourceLocation.

This class handles loading and caching of source files into memory.

bool isLocalSourceLocation(SourceLocation Loc) const

Returns true if Loc did not come from a PCH/Module.

OptionalFileEntryRef getFileEntryRefForID(FileID FID) const

Returns the FileEntryRef for the provided FileID.

FileID createFileID(FileEntryRef SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)

Create a new FileID that represents the specified file being #included from the specified IncludePosi...

FileID getMainFileID() const

Returns the FileID of the main source file.

const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const

Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer.

void overrideFileContents(FileEntryRef SourceFile, const llvm::MemoryBufferRef &Buffer)

Override the contents of the given source file by providing an already-allocated buffer.

bool isLoadedFileID(FileID FID) const

Returns true if FID came from a PCH/Module.

const FileEntry * getFileEntryForID(FileID FID) const

Returns the FileEntry record for the provided FileID.

SourceLocation createExpansionLoc(SourceLocation SpellingLoc, SourceLocation ExpansionLocStart, SourceLocation ExpansionLocEnd, unsigned Length, bool ExpansionIsTokenRange=true, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)

Creates an expansion SLocEntry for a macro use.

bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const

Determines the order of 2 source locations in the translation unit.

std::optional< llvm::MemoryBufferRef > getMemoryBufferForFileOrNone(FileEntryRef File)

Retrieve the memory buffer associated with the given file.

A trivial tuple used to represent a source range.

StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...

Exposes information about the current target.

Token - This structure provides full information about a lexed token.

IdentifierInfo * getIdentifierInfo() const

void setLiteralData(const char *Ptr)

bool hasUCN() const

Returns true if this token contains a universal character name.

bool isLiteral() const

Return true if this is a "literal", like a numeric constant, string, etc.

SourceLocation getLocation() const

Return a source location identifier for the specified offset in the current file.

unsigned getLength() const

void setLength(unsigned Len)

bool isExpandDisabled() const

Return true if this identifier token should never be expanded in the future, due to C99 6....

void setKind(tok::TokenKind K)

bool is(tok::TokenKind K) const

is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....

tok::TokenKind getKind() const

bool isAtStartOfLine() const

isAtStartOfLine - Return true if this token is at the start of a line.

bool hasLeadingSpace() const

Return true if this token has whitespace before it.

void setLocation(SourceLocation L)

bool hasLeadingEmptyMacro() const

Return true if this token has an empty macro before it.

void setRawIdentifierData(const char *Ptr)

bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const

bool isNot(tok::TokenKind K) const

bool isAnnotation() const

Return true if this is any of tok::annot_* kind tokens.

void startToken()

Reset all flags to cleared.

bool needsCleaning() const

Return true if this token has trigraphs or escaped newlines in it.

void setIdentifierInfo(IdentifierInfo *II)

void setFlagValue(TokenFlags Flag, bool Val)

Set a flag to either true or false.

Defines the clang::TargetInfo interface.

const char * getTokenName(TokenKind Kind) LLVM_READNONE

Determines the name of a token as used within the front end.

The JSON file list parser is used to communicate input to InstallAPI.

void expandUCNs(SmallVectorImpl< char > &Buf, StringRef Input)

Copy characters from Input to Buf, expanding any UCNs.

llvm::Registry< PragmaHandler > PragmaHandlerRegistry

Registry of pragma handlers added by plugins.

@ Result

The result type of a method or function.

TranslationUnitKind

Describes the kind of translation unit being processed.

@ TU_Prefix

The translation unit is a prefix to a translation unit, and is not complete.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4