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

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

clang: lib/Lex/PPLexerChange.cpp Source File

;

IncludeMacroStack.empty();

assert(IsFileLexer(IncludeMacroStack[0]) &&

);

llvm::drop_begin(IncludeMacroStack),

[&](

IncludeStackInfo &ISI) ->

{

IsFileLexer(ISI); });

(

IncludeStackInfo &ISI : llvm::reverse(IncludeMacroStack)) {

ISI.ThePPLexer;

IsFirstIncludeOfFile) {

assert(!CurTokenLexer &&

);

++NumEnteredSourceFiles;

(MaxIncludeStackDepth < IncludeMacroStack.size())

MaxIncludeStackDepth = IncludeMacroStack.size();

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

(

, diag::err_pp_error_opening_file)

*TheLexer =

(FID, *InputFile, *

, IsFirstIncludeOfFile);

FID != PredefinesFileID) {

TheLexer->DepDirectives = *DepDirectives;

EnterSourceFileWithLexer(TheLexer, CurDir);

Preprocessor::EnterSourceFileWithLexer(

*TheLexer,

(CurPPLexer || CurTokenLexer)

PushIncludeMacroStack();

CurLexer.reset(TheLexer);

CurPPLexer = TheLexer;

CurDirLookup = CurDir;

CurLexerSubmodule =

;

(CurLexerCallback != CLK_LexAfterModuleImport)

CurLexerCallback = TheLexer->isDependencyDirectivesLexer()

? CLK_DependencyDirectivesLexer

(Callbacks && !CurLexer->Is_PragmaLexer) {

Callbacks->LexedFileChanged(CurLexer->getFileID(),

std::unique_ptr<TokenLexer> TokLexer;

(NumCachedTokenLexers == 0) {

TokLexer = std::make_unique<TokenLexer>(Tok, ILEnd, Macro, Args, *

);

TokLexer = std::move(TokenLexerCache[--NumCachedTokenLexers]);

TokLexer->Init(Tok, ILEnd, Macro, Args);

PushIncludeMacroStack();

CurDirLookup =

;

CurTokenLexer = std::move(TokLexer);

(CurLexerCallback != CLK_LexAfterModuleImport)

CurLexerCallback = CLK_TokenLexer;

Preprocessor::EnterTokenStream(

*Toks,

NumToks,

DisableMacroExpansion,

OwnsTokens,

(CurLexerCallback == CLK_CachingLexer) {

assert(IsReinject &&

);

Toks, Toks + NumToks);

ExitCachingLexMode();

EnterTokenStream(Toks, NumToks, DisableMacroExpansion, OwnsTokens,

EnterCachingLexMode();

std::unique_ptr<TokenLexer> TokLexer;

(NumCachedTokenLexers == 0) {

TokLexer = std::make_unique<TokenLexer>(

Toks, NumToks, DisableMacroExpansion, OwnsTokens, IsReinject, *

);

TokLexer = std::move(TokenLexerCache[--NumCachedTokenLexers]);

TokLexer->Init(Toks, NumToks, DisableMacroExpansion, OwnsTokens,

PushIncludeMacroStack();

CurDirLookup =

;

CurTokenLexer = std::move(TokLexer);

(CurLexerCallback != CLK_LexAfterModuleImport)

CurLexerCallback = CLK_TokenLexer;

StringRef FilePath =

.getDir().getName();

StringRef

= FilePath;

(!

.empty()) {

(*CurDir == Dir) {

llvm::sys::path::append(

,

llvm::sys::path::filename(

.getName()));

= llvm::sys::path::parent_path(

);

Preprocessor::PropagateLineStartLeadingSpaceInfo(

&

) {

CurTokenLexer->PropagateLineStartLeadingSpaceInfo(

);

CurLexer->PropagateLineStartLeadingSpaceInfo(

);

*Preprocessor::getCurLexerEndPos() {

*EndPos = CurLexer->BufferEnd;

(EndPos != CurLexer->BufferStart &&

(EndPos[-1] ==

|| EndPos[-1] ==

)) {

(EndPos != CurLexer->BufferStart &&

(EndPos[-1] ==

|| EndPos[-1] ==

) &&

EndPos[-1] != EndPos[0])

SubMods.push_back(&Mod);

Preprocessor::diagnoseMissingHeaderInUmbrellaDir(

&Mod) {

std::optional<Module::Header> UmbrellaHeader =

assert(UmbrellaHeader &&

);

(

().isIgnored(diag::warn_uncovered_module_header,

(llvm::vfs::recursive_directory_iterator Entry(FS, Dir->

(), EC),

Entry != End && !EC; Entry.increment(EC)) {

llvm::StringSwitch;

(!StringSwitch<bool>(llvm::sys::path::extension(Entry->path()))

.Cases(

,

,

,

,

)

(

Header =

().getOptionalFileRef(Entry->path()))

(ExpectedHeadersLoc, diag::warn_uncovered_module_header)

assert(!CurTokenLexer &&

);

(IncludeMacroStack.empty() &&

(UnclosedSafeBufferOptOutLoc,

diag::err_pp_unclosed_pragma_unsafe_buffer_usage);

LeavingSubmodule = CurLexer && CurLexerSubmodule;

((LeavingSubmodule || IncludeMacroStack.empty()) &&

!BuildingSubmoduleStack.empty() &&

BuildingSubmoduleStack.back().IsPragma) {

(BuildingSubmoduleStack.back().ImportLoc,

diag::err_pp_module_begin_without_module_end);

*EndPos = getCurLexerEndPos();

CurLexer->BufferPtr = EndPos;

CurLexer->FormTokenWithChars(

, EndPos, tok::annot_module_end);

.setAnnotationValue(M);

MI->setUsedForHeaderGuard(

);

DefinedMacro != ControllingMacro &&

CurLexer->isFirstTimeLexingFile()) {

StringRef ControllingMacroName = ControllingMacro->getName();

StringRef DefinedMacroName = DefinedMacro->getName();

MaxHalfLength = std::max(ControllingMacroName.size(),

DefinedMacroName.size()) / 2;

ED = ControllingMacroName.edit_distance(

DefinedMacroName,

, MaxHalfLength);

(ED <= MaxHalfLength) {

diag::warn_header_guard)

diag::note_header_guard)

ControllingMacro->getName());

(PragmaARCCFCodeAuditedInfo.second.isValid() && !isEndOfMacro &&

!(CurLexer && CurLexer->Is_PragmaLexer)) {

(PragmaARCCFCodeAuditedInfo.second,

diag::err_pp_eof_in_arc_cf_code_audited);

(PragmaAssumeNonNullLoc.

() &&

!isEndOfMacro && !(CurLexer && CurLexer->Is_PragmaLexer)) {

PreambleRecordedPragmaAssumeNonNullLoc = PragmaAssumeNonNullLoc;

(PragmaAssumeNonNullLoc, diag::err_pp_eof_in_assume_nonnull);

LeavingPCHThroughHeader =

;

(!IncludeMacroStack.empty()) {

CodeCompletionFileLoc) {

assert(CurLexer &&

);

CurLexer->FormTokenWithChars(

, CurLexer->BufferEnd, tok::eof);

CurPPLexer =

;

(!isEndOfMacro && CurPPLexer &&

(PredefinesFileID.

() &&

CurPPLexer->

() == PredefinesFileID))) {

ExitedFromPredefinesFile =

;

(!isEndOfMacro && CurPPLexer) {

assert(PredefinesFileID.

() &&

);

ExitedFromPredefinesFile = (PredefinesFileID == ExitedFID);

(LeavingSubmodule) {

*EndPos = getCurLexerEndPos();

CurLexer->BufferPtr = EndPos;

CurLexer->FormTokenWithChars(

, EndPos, tok::annot_module_end);

.setAnnotationValue(M);

FoundPCHThroughHeader =

;

FoundPCHThroughHeader =

;

PropagateLineStartLeadingSpaceInfo(

);

(Callbacks && !isEndOfMacro && CurPPLexer) {

Callbacks->LexedFileChanged(CurPPLexer->

(),

(ExitedFromPredefinesFile) {

replayPreambleConditionalStack();

(PreambleRecordedPragmaAssumeNonNullLoc.

())

PragmaAssumeNonNullLoc = PreambleRecordedPragmaAssumeNonNullLoc;

(!isEndOfMacro && CurPPLexer && FoundPCHThroughHeader &&

LeavingPCHThroughHeader =

;

LeavingSubmodule;

assert(CurLexer &&

);

*EndPos = getCurLexerEndPos();

CurLexer->BufferPtr = EndPos;

CurLexer->FormTokenWithChars(

, EndPos, tok::annot_repl_input_end);

.setAnnotationValue(

);

CurLexer->FormTokenWithChars(

, EndPos, tok::eof);

(CurLexer->getFileLoc() == CodeCompletionFileLoc)

.setLocation(

.getLocation().getLocWithOffset(-1));

(CurLexer->getFileLoc(), diag::err_pp_through_header_not_seen)

<< PPOpts->PCHThroughHeader << 0;

CurPPLexer =

;

(WarnUnusedMacroLocsTy::iterator

I=WarnUnusedMacroLocs.begin(),

=WarnUnusedMacroLocs.end();

(*I, diag::pp_macro_not_used);

(

*M : AllMods)

diagnoseMissingHeaderInUmbrellaDir(*M);

assert(CurTokenLexer && !CurPPLexer &&

);

(!MacroExpandingLexersStack.empty() &&

MacroExpandingLexersStack.back().first == CurTokenLexer.get())

removeCachedMacroExpandedTokensOfLastLexer();

(NumCachedTokenLexers == TokenLexerCacheSize)

CurTokenLexer.reset();

TokenLexerCache[NumCachedTokenLexers++] = std::move(CurTokenLexer);

assert(!IncludeMacroStack.empty() &&

);

(NumCachedTokenLexers == TokenLexerCacheSize)

CurTokenLexer.reset();

TokenLexerCache[NumCachedTokenLexers++] = std::move(CurTokenLexer);

PopIncludeMacroStack();

assert(CurTokenLexer && !CurPPLexer &&

);

LexerWasInPPMode =

;

(

IncludeStackInfo &ISI : llvm::reverse(IncludeMacroStack)) {

(ISI.ThePPLexer ==

)

;

FoundLexer = ISI.ThePPLexer;

(Tok.

(tok::eod) && Tok.

(tok::eof))

(Tok.

(tok::eod)) {

assert(FoundLexer &&

);

(LexerWasInPPMode)

;

assert(!FoundLexer &&

);

BuildingSubmoduleStack.push_back(

BuildingSubmoduleInfo(M, ImportLoc, ForPragma, CurSubmoduleState,

PendingModuleMacroNames.size()));

Callbacks->EnteredSubmodule(M, ImportLoc, ForPragma);

R = Submodules.insert(std::make_pair(M, SubmoduleState()));

&State = R.first->second;

FirstTime = R.second;

&StartingMacros = NullSubmoduleState.Macros;

(

&Macro : StartingMacros) {

(!Macro.second.getLatest() &&

Macro.second.getOverriddenMacros().empty())

MacroState MS(Macro.second.getLatest());

MS.setOverriddenMacros(*

, Macro.second.getOverriddenMacros());

State.Macros.insert(std::make_pair(Macro.first, std::move(MS)));

BuildingSubmoduleStack.push_back(

BuildingSubmoduleInfo(M, ImportLoc, ForPragma, CurSubmoduleState,

PendingModuleMacroNames.size()));

Callbacks->EnteredSubmodule(M, ImportLoc, ForPragma);

CurSubmoduleState = &State;

Preprocessor::needModuleMacros()

{

(BuildingSubmoduleStack.empty())

(BuildingSubmoduleStack.empty() ||

BuildingSubmoduleStack.back().IsPragma != ForPragma) {

assert(ForPragma &&

);

&Info = BuildingSubmoduleStack.back();

*LeavingMod = Info.M;

(!needModuleMacros() ||

BuildingSubmoduleStack.pop_back();

Callbacks->LeftSubmodule(LeavingMod, ImportLoc, ForPragma);

(

I = Info.OuterPendingModuleMacroNames;

I != PendingModuleMacroNames.size(); ++I) {

*II = PendingModuleMacroNames[I];

(!VisitedMacros.insert(II).second)

MacroIt = CurSubmoduleState->Macros.find(II);

(MacroIt == CurSubmoduleState->Macros.end())

&Macro = MacroIt->second;

*OldState = Info.OuterSubmoduleState;

OldState = &NullSubmoduleState;

(OldState && OldState != CurSubmoduleState) {

&OldMacros = OldState->Macros;

OldMacroIt = OldMacros.find(II);

(OldMacroIt == OldMacros.end())

OldMD = OldMacroIt->second.getLatest();

ExplicitlyPublic =

;

(

*MD = Macro.getLatest(); MD != OldMD; MD = MD->

()) {

assert(MD &&

);

(

*VisMD = dyn_cast<VisibilityMacroDirective>(MD)) {

(VisMD->isPublic())

ExplicitlyPublic =

;

(!ExplicitlyPublic)

Def = DefMD->getInfo();

(Def || !Macro.getOverriddenMacros().empty())

Macro.setLatest(

);

Macro.setOverriddenMacros(*

, {});

PendingModuleMacroNames.resize(Info.OuterPendingModuleMacroNames);

CurSubmoduleState = Info.OuterSubmoduleState;

BuildingSubmoduleStack.pop_back();

Callbacks->LeftSubmodule(LeavingMod, ImportLoc, ForPragma);

Defines the clang::FileManager interface and associated types.

llvm::MachO::FileType FileType

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

static void collectAllSubModulesWithUmbrellaHeader(const Module &Mod, SmallVectorImpl< const Module * > &SubMods)

static void computeRelativePath(FileManager &FM, const DirectoryEntry *Dir, FileEntryRef File, SmallString< 128 > &Result)

Compute the relative path that names the given file relative to the given directory.

Defines the clang::Preprocessor interface.

Defines the SourceManager interface.

A directive for a defined macro or a macro imported from a module.

StringRef getName() const

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

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

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

Implements support for file system lookup, file system caching, and directory search management.

llvm::vfs::FileSystem & getVirtualFileSystem() const

OptionalDirectoryEntryRef getOptionalDirectoryRef(StringRef DirName, bool CacheFailure=true)

Get a DirectoryEntryRef if it exists, without doing anything on error.

static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)

Create a code modification hint that replaces the given source range with the given code string.

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

bool isCompilingModule() const

Are we compiling a module?

Lexer - This provides a simple interface that turns a text buffer into a stream of tokens.

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

Encapsulates changes to the "macros namespace" (the location where the macro name became active,...

const MacroDirective * getPrevious() const

Get previous definition of the macro with the same name.

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

bool resolveExports(Module *Mod, bool Complain)

Resolve all of the unresolved exports in the given module.

bool resolveConflicts(Module *Mod, bool Complain)

Resolve all of the unresolved conflicts in the given module.

bool isHeaderInUnavailableModule(FileEntryRef Header) const

Determine whether the given header is part of a module marked 'unavailable'.

bool resolveUses(Module *Mod, bool Complain)

Resolve all of the unresolved uses in the given module.

Describes a module or submodule.

StringRef getTopLevelModuleName() const

Retrieve the name of the top-level module.

llvm::iterator_range< submodule_iterator > submodules()

std::optional< Header > getUmbrellaHeaderAsWritten() const

Retrieve the umbrella header as written.

std::string getFullModuleName(bool AllowStringLiterals=false) const

Retrieve the full name of this module, including the path from its top-level module.

OptionalDirectoryEntryRef getEffectiveUmbrellaDir() const

Get the effective umbrella directory for this module: either the one explicitly written in the module...

const IdentifierInfo * GetDefinedMacro() const

If the ControllingMacro is followed by a macro definition, return the macro that was defined.

const IdentifierInfo * GetControllingMacroAtEndOfFile() const

Once the entire file has been lexed, if there is a controlling macro, return it.

SourceLocation GetDefinedLocation() const

SourceLocation GetMacroLocation() const

unsigned getInitialNumSLocEntries() const

Number of SLocEntries before lexing the file.

bool LexingRawMode

True if in raw mode.

bool ParsingPreprocessorDirective

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

MultipleIncludeOpt MIOpt

A state machine that detects the #ifndef-wrapping a file idiom for the multiple-include optimization.

OptionalFileEntryRef getFileEntry() const

getFileEntry - Return the FileEntry corresponding to this FileID.

virtual SourceLocation getSourceLocation()=0

Return the source location for the next observable location.

bool creatingPCHWithThroughHeader()

True if creating a PCH with a through header.

ModuleMacro * addModuleMacro(Module *Mod, IdentifierInfo *II, MacroInfo *Macro, ArrayRef< ModuleMacro * > Overrides, bool &IsNew)

Register an exported macro for a module and identifier.

bool isIncrementalProcessingEnabled() const

Returns true if incremental processing is enabled.

const MacroInfo * getMacroInfo(const IdentifierInfo *II) const

bool isRecordingPreamble() const

bool isInPrimaryFile() const

Return true if we're in the top-level file, not in a #include.

void EnterSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma)

bool HandleEndOfTokenLexer(Token &Result)

Callback invoked when the current TokenLexer hits the end of its token stream.

void makeModuleVisible(Module *M, SourceLocation Loc)

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...

SourceManager & getSourceManager() const

bool isMacroDefined(StringRef Id)

Module * getCurrentModule()

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

bool isPPInSafeBufferOptOutRegion()

FileManager & getFileManager() const

PreprocessorOptions & getPreprocessorOpts() const

Retrieve the preprocessor options used to initialize this preprocessor.

bool isPCHThroughHeader(const FileEntry *FE)

Returns true if the FileEntry is the PCH through header.

FileID getPredefinesFileID() const

Returns the FileID for the preprocessor predefines.

bool isCodeCompletionEnabled() const

Determine if we are performing code completion.

PreprocessorLexer * getCurrentFileLexer() const

Return the current file lexer being lexed from.

HeaderSearch & getHeaderSearchInfo() const

Module * LeaveSubmodule(bool ForPragma)

void recomputeCurLexerKind()

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

const LangOptions & getLangOpts() const

void RemoveTopOfLexerStack()

Pop the current lexer/macro exp off the top of the lexer stack.

bool HandleEndOfFile(Token &Result, bool isEndOfMacro=false)

Callback invoked when the lexer hits the end of the current file.

DiagnosticsEngine & getDiagnostics() const

void EnterMacro(Token &Tok, SourceLocation ILEnd, MacroInfo *Macro, MacroArgs *Args)

Add a Macro to the top of the include stack and start lexing tokens from it instead of the current bu...

DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const

Forwarding function for diagnostics.

void HandleMicrosoftCommentPaste(Token &Tok)

When the macro expander pastes together a comment (/##/) in Microsoft mode, this method handles updat...

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

SourceLocation getLocWithOffset(IntTy Offset) const

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

OptionalFileEntryRef getFileEntryRefForID(FileID FID) const

Returns the FileEntryRef for the provided FileID.

StringRef getBufferName(SourceLocation Loc, bool *Invalid=nullptr) const

Return the filename or buffer identifier of the buffer the location is in.

FileID translateFile(const FileEntry *SourceFile) const

Get the FileID for the given file.

unsigned local_sloc_entry_size() const

Get the number of local SLocEntries we have.

SourceLocation getLocForEndOfFile(FileID FID) const

Return the source location corresponding to the last byte of the specified file.

SourceLocation getIncludeLoc(FileID FID) const

Returns the include location if FID is a #include'd file otherwise it returns an invalid location.

void setNumCreatedFIDsForFileID(FileID FID, unsigned NumFIDs, bool Force=false)

Set the number of FileIDs (files and macros) that were created during preprocessing of FID,...

const FileEntry * getFileEntryForID(FileID FID) const

Returns the FileEntry record for the provided FileID.

SourceLocation getLocForStartOfFile(FileID FID) const

Return the source location corresponding to the first byte of the specified file.

SrcMgr::CharacteristicKind getFileCharacteristic(SourceLocation Loc) const

Return the file characteristic of the specified source location, indicating whether this is a normal ...

std::optional< llvm::MemoryBufferRef > getBufferOrNone(FileID FID, SourceLocation Loc=SourceLocation()) const

Return the buffer for the specified FileID.

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

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)) {....

bool isNot(tok::TokenKind K) const

CharacteristicKind

Indicates whether a file or directory holds normal user code, system code, or system code which is im...

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

@ Result

The result type of a method or function.

@ TU_Complete

The translation unit is a complete translation unit.

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