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

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

clang: include/clang/Frontend/CompilerInstance.h Source File

serialization {

CodeCompleteConsumer;

DiagnosticsEngine;

DiagnosticConsumer;

InMemoryModuleCache;

std::shared_ptr<CompilerInvocation> Invocation;

std::shared_ptr<Preprocessor> PP;

std::unique_ptr<ASTConsumer> Consumer;

std::unique_ptr<CodeCompleteConsumer> CompletionConsumer;

std::unique_ptr<Sema> TheSema;

std::unique_ptr<llvm::TimerGroup> timerGroup;

std::unique_ptr<llvm::Timer> FrontendTimer;

std::shared_ptr<ModuleDependencyCollector> ModuleDepCollector;

std::shared_ptr<PCHContainerOperations> ThePCHContainerOperations;

std::vector<std::shared_ptr<DependencyCollector>> DependencyCollectors;

FailedModulesSet {

llvm::StringSet<> Failed;

hasAlreadyFailed(StringRef module) {

Failed.count(module) > 0; }

addFailed(StringRef module) { Failed.insert(module); }

std::shared_ptr<FailedModulesSet> FailedModules;

std::map<std::string, std::string, std::less<>> BuiltModules;

DeleteBuiltModules =

;

BuildGlobalModuleIndex =

;

HaveFullGlobalModuleIndex =

;

DisableGeneratingGlobalModuleIndex =

;

std::unique_ptr<raw_ostream> OwnedVerboseOutputStream;

raw_ostream *VerboseOutputStream = &llvm::errs();

std::optional<llvm::sys::fs::TempFile>

;

OutputFile(std::string filename,

std::optional<llvm::sys::fs::TempFile> file)

:

(std::move(filename)),

(std::move(file)) {}

std::list<OutputFile> OutputFiles;

std::unique_ptr<llvm::raw_pwrite_stream> OutputStream;

std::shared_ptr<PCHContainerOperations> PCHContainerOps =

std::make_shared<PCHContainerOperations>(),

assert(Invocation &&

);

BuildGlobalModuleIndex = Build;

Invocation->getCodeGenOpts();

Invocation->getCodeGenOpts();

Invocation->getDependencyOutputOpts();

Invocation->getDependencyOutputOpts();

Invocation->getDiagnosticOpts();

Invocation->getDiagnosticOpts();

Invocation->getFileSystemOpts();

Invocation->getFileSystemOpts();

Invocation->getFrontendOpts();

Invocation->getFrontendOpts();

Invocation->getHeaderSearchOpts();

Invocation->getHeaderSearchOpts();

Invocation->getHeaderSearchOptsPtr();

Invocation->getAPINotesOpts();

Invocation->getLangOptsPtr();

Invocation->getPreprocessorOpts();

Invocation->getPreprocessorOpts();

Invocation->getPreprocessorOutputOpts();

Invocation->getPreprocessorOutputOpts();

Invocation->getTargetOpts();

Invocation->getTargetOpts();

assert(Diagnostics &&

);

assert(Diagnostics &&

);

assert(Diagnostics && Diagnostics->getClient() &&

);

*Diagnostics->getClient();

*VerboseOutputStream;

assert(

&&

);

assert(

&&

);

assert(FileMgr &&

);

assert(FileMgr &&

);

llvm::BuryPointer(FileMgr.get());

FileMgr.resetWithoutRelease();

assert(SourceMgr &&

);

assert(SourceMgr &&

);

llvm::BuryPointer(SourceMgr.get());

SourceMgr.resetWithoutRelease();

assert(PP &&

);

llvm::BuryPointer(

std::shared_ptr<Preprocessor>(PP));

assert(Context &&

);

assert(Context &&

);

llvm::BuryPointer(Context.get());

Context.resetWithoutRelease();

assert(Consumer &&

);

()

{

(

)TheSema; }

assert(TheSema &&

);

std::shared_ptr<ModuleDependencyCollector> Collector);

ThePCHContainerOperations;

assert(Invocation &&

);

*Writer = ThePCHContainerOperations->getWriterOrNull(Format);

Diagnostics->Report(diag::err_module_format_unhandled) << Format;

llvm::report_fatal_error(

);

assert(Invocation &&

);

*Reader = ThePCHContainerOperations->getReaderOrNull(Format);

Diagnostics->Report(diag::err_module_format_unhandled) << Format;

llvm::report_fatal_error(

);

assert(CompletionConsumer &&

);

*CompletionConsumer;

assert(FrontendTimer &&

);

*FrontendTimer;

FailedModules = std::make_shared<FailedModulesSet>();

FailedModules;

ShouldOwnClient =

);

ShouldOwnClient =

,

AllowPCHWithCompilerErrors,

*DeserializationListener,

OwnDeserializationListener);

StringRef

, StringRef Sysroot,

<std::shared_ptr<ModuleFileExtension>> Extensions,

<std::shared_ptr<DependencyCollector>> DependencyCollectors,

*DeserializationListener,

OwnDeserializationListener,

,

UseGlobalModuleIndex);

Binary =

, StringRef BaseInput =

, StringRef Extension =

,

RemoveFileOnSignal =

,

CreateMissingDirectories =

,

ForceUseTemporary =

);

std::unique_ptr<raw_pwrite_stream>

(StringRef OutputPath,

Binary,

RemoveFileOnSignal,

UseTemporary,

CreateMissingDirectories =

);

createOutputFileImpl(StringRef OutputPath,

Binary,

RemoveFileOnSignal,

UseTemporary,

CreateMissingDirectories);

OutputStream = std::move(OutStream);

std::move(OutputStream);

IsInclusionDirective);

IsInclusionDirective)

;

StringRef Source)

;

DependencyCollectors.push_back(std::move(Listener));

Defines the Diagnostic-related interfaces.

llvm::MachO::Target Target

Defines the SourceManager interface.

Tracks various options which control how API notes are found and handled.

ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

Stores options for the analyzer from the command line.

Abstract interface for a consumer of code-completion information.

Options controlling the behavior of code completion.

CodeGenOptions - Track various options which control how the code is optimized and passed to the back...

CompilerInstance - Helper class for managing a single instance of the Clang compiler.

void setFileManager(FileManager *Value)

Replace the current file manager and virtual file system.

void setSourceManager(SourceManager *Value)

setSourceManager - Replace the current source manager.

void createPCHExternalASTSource(StringRef Path, DisableValidationForModuleKind DisableValidation, bool AllowPCHWithCompilerErrors, void *DeserializationListener, bool OwnDeserializationListener)

Create an external AST source to read a PCH file and attach it to the AST context.

DiagnosticConsumer & getDiagnosticClient() const

~CompilerInstance() override

void createPreprocessor(TranslationUnitKind TUKind)

Create the preprocessor, using the invocation, file, and source managers, and replace any existing on...

AnalyzerOptions & getAnalyzerOpts()

bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override

Check global module index for missing imports.

void createSourceManager(FileManager &FileMgr)

Create the source manager and replace any existing one with it.

FileManager * createFileManager(IntrusiveRefCntPtr< llvm::vfs::FileSystem > VFS=nullptr)

Create the file manager and replace any existing one with it.

const HeaderSearchOptions & getHeaderSearchOpts() const

DependencyOutputOptions & getDependencyOutputOpts()

bool hasFileManager() const

const DependencyOutputOptions & getDependencyOutputOpts() const

std::shared_ptr< Preprocessor > getPreprocessorPtr()

TargetInfo * getAuxTarget() const

const PCHContainerReader & getPCHContainerReader() const

Return the appropriate PCHContainerReader depending on the current CodeGenOptions.

DiagnosticsEngine & getDiagnostics() const

Get the current diagnostics engine.

GlobalModuleIndex * loadGlobalModuleIndex(SourceLocation TriggerLoc) override

Load, create, or return global module.

raw_ostream & getVerboseOutputStream()

Get the current stream for verbose output.

llvm::TimerGroup & getTimerGroup() const

std::unique_ptr< raw_pwrite_stream > createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="", bool RemoveFileOnSignal=true, bool CreateMissingDirectories=false, bool ForceUseTemporary=false)

Create the default output file (from the invocation's options) and add it to the list of tracked outp...

void setExternalSemaSource(IntrusiveRefCntPtr< ExternalSemaSource > ESS)

void createDiagnostics(llvm::vfs::FileSystem &VFS, DiagnosticConsumer *Client=nullptr, bool ShouldOwnClient=true)

Create the diagnostics engine using the invocation's diagnostic options and replace any existing one ...

const DiagnosticOptions & getDiagnosticOpts() const

std::string getSpecificModuleCachePath()

ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) override

Attempt to load the given module.

void setInvocation(std::shared_ptr< CompilerInvocation > Value)

setInvocation - Replace the current invocation.

std::shared_ptr< FailedModulesSet > getFailedModulesSetPtr() const

const CodeGenOptions & getCodeGenOpts() const

FileSystemOptions & getFileSystemOpts()

llvm::Timer & getFrontendTimer() const

const TargetOptions & getTargetOpts() const

bool InitializeSourceManager(const FrontendInputFile &Input)

InitializeSourceManager - Initialize the source manager to set InputFile as the main file.

void setOutputStream(std::unique_ptr< llvm::raw_pwrite_stream > OutStream)

FileManager & getFileManager() const

Return the current file manager to the caller.

void setBuildGlobalModuleIndex(bool Build)

Set the flag indicating whether we should (re)build the global module index.

IntrusiveRefCntPtr< DiagnosticsEngine > getDiagnosticsPtr() const

std::unique_ptr< Sema > takeSema()

const PreprocessorOptions & getPreprocessorOpts() const

void printDiagnosticStats()

At the end of a compilation, print the number of warnings/errors.

void resetAndLeakSourceManager()

void setASTConsumer(std::unique_ptr< ASTConsumer > Value)

setASTConsumer - Replace the current AST consumer; the compiler instance takes ownership of Value.

PreprocessorOutputOptions & getPreprocessorOutputOpts()

IntrusiveRefCntPtr< FileManager > getFileManagerPtr() const

IntrusiveRefCntPtr< ASTContext > getASTContextPtr() const

const PreprocessorOutputOptions & getPreprocessorOutputOpts() const

IntrusiveRefCntPtr< ASTReader > getASTReader() const

void setTarget(TargetInfo *Value)

Replace the current Target.

void setModuleDepCollector(std::shared_ptr< ModuleDependencyCollector > Collector)

std::shared_ptr< LangOptions > getLangOptsPtr() const

InMemoryModuleCache & getModuleCache() const

void addDependencyCollector(std::shared_ptr< DependencyCollector > Listener)

void createASTContext()

Create the AST context.

std::unique_ptr< raw_pwrite_stream > createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, bool UseTemporary, bool CreateMissingDirectories=false)

Create a new output file, optionally deriving the output path name, and add it to the list of tracked...

bool hasASTContext() const

void createModuleFromSource(SourceLocation ImportLoc, StringRef ModuleName, StringRef Source) override

Attempt to create the given module from the specified source buffer.

void resetAndLeakFileManager()

std::shared_ptr< HeaderSearchOptions > getHeaderSearchOptsPtr() const

void setASTContext(ASTContext *Value)

setASTContext - Replace the current AST context.

Preprocessor & getPreprocessor() const

Return the current preprocessor.

ASTContext & getASTContext() const

void setFailedModulesSet(std::shared_ptr< FailedModulesSet > FMS)

void LoadRequestedPlugins()

Load the list of plugins requested in the FrontendOptions.

TargetOptions & getTargetOpts()

IntrusiveRefCntPtr< TargetInfo > getTargetPtr() const

void setASTReader(IntrusiveRefCntPtr< ASTReader > Reader)

std::unique_ptr< llvm::raw_pwrite_stream > takeOutputStream()

bool hasInvocation() const

FrontendOptions & getFrontendOpts()

const FrontendOptions & getFrontendOpts() const

std::shared_ptr< ModuleDependencyCollector > getModuleDepCollector() const

std::shared_ptr< CompilerInvocation > getInvocationPtr()

bool hasDiagnostics() const

bool hadModuleLoaderFatalFailure() const

void setSema(Sema *S)

Replace the current Sema; the compiler instance takes ownership of S.

HeaderSearchOptions & getHeaderSearchOpts()

void createFrontendTimer()

Create the frontend timer and replace any existing one with it.

void setDiagnostics(DiagnosticsEngine *Value)

setDiagnostics - Replace the current diagnostics engine.

bool hasCodeCompletionConsumer() const

void resetAndLeakASTContext()

const LangOptions & getLangOpts() const

bool hasFailedModulesSet() const

CompilerInvocation & getInvocation()

const PCHContainerWriter & getPCHContainerWriter() const

Return the appropriate PCHContainerWriter depending on the current CodeGenOptions.

void setVerboseOutputStream(raw_ostream &Value)

Replace the current stream for verbose output.

void resetAndLeakPreprocessor()

std::unique_ptr< ASTConsumer > takeASTConsumer()

takeASTConsumer - Remove the current AST consumer and give ownership to the caller.

PreprocessorOptions & getPreprocessorOpts()

ASTConsumer & getASTConsumer() const

TargetInfo & getTarget() const

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

const FileSystemOptions & getFileSystemOpts() const

void createCodeCompletionConsumer()

Create a code completion consumer using the invocation; note that this will cause the source manager ...

void setCodeCompletionConsumer(CodeCompleteConsumer *Value)

setCodeCompletionConsumer - Replace the current code completion consumer; the compiler instance takes...

bool ExecuteAction(FrontendAction &Act)

ExecuteAction - Execute the provided action against the compiler's CompilerInvocation object.

std::shared_ptr< PCHContainerOperations > getPCHContainerOperations() const

void clearOutputFiles(bool EraseFiles)

clearOutputFiles - Clear the output file list.

DiagnosticOptions & getDiagnosticOpts()

LangOptions & getLangOpts()

const APINotesOptions & getAPINotesOpts() const

CodeGenOptions & getCodeGenOpts()

SourceManager & getSourceManager() const

Return the current source manager.

IntrusiveRefCntPtr< SourceManager > getSourceManagerPtr() const

CodeCompleteConsumer & getCodeCompletionConsumer() const

bool shouldBuildGlobalModuleIndex() const

Indicates whether we should (re)build the global module index.

bool hasSourceManager() const

bool hasASTConsumer() const

APINotesOptions & getAPINotesOpts()

std::unique_ptr< raw_pwrite_stream > createNullOutputFile()

void setAuxTarget(TargetInfo *Value)

Replace the current AuxTarget.

void makeModuleVisible(Module *Mod, Module::NameVisibilityKind Visibility, SourceLocation ImportLoc) override

Make the given module visible.

void createFailedModulesSet()

bool loadModuleFile(StringRef FileName, serialization::ModuleFile *&LoadedModuleFile)

bool hasPreprocessor() const

void setPreprocessor(std::shared_ptr< Preprocessor > Value)

Replace the current preprocessor.

void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)

Create the Sema object to be used for parsing.

Helper class for holding the data necessary to invoke the compiler.

DependencyOutputOptions - Options for controlling the compiler dependency file generation.

Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...

Options for controlling the compiler diagnostics engine.

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

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

Keeps track of options that affect how file operations are performed.

Abstract base class for actions which can be performed by the frontend.

An input file for the front end.

FrontendOptions - Options for controlling the behavior of the frontend.

A global index for a set of module files, providing information about the identifiers within those mo...

In-memory cache for modules.

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

Describes the result of attempting to load a module.

Abstract interface for a module loader.

Describes a module or submodule.

NameVisibilityKind

Describes the visibility of the various names within a particular module.

This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...

This abstract interface provides operations for creating containers for serialized ASTs (precompiled ...

PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...

PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g....

Engages in a tight little dance with the lexer to efficiently preprocess tokens.

Sema - This implements semantic analysis and AST building for C.

Encodes a location in the source.

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

Exposes information about the current target.

Options for controlling the target.

Information about a module that has been loaded by the ASTReader.

Defines the clang::TargetInfo interface.

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

@ Module

Module linkage, which indicates that the entity can be referred to from other translation units withi...

TranslationUnitKind

Describes the kind of translation unit being processed.

DisableValidationForModuleKind

Whether to disable the normal validation performed on precompiled headers and module files when they ...

Visibility

Describes the different kinds of visibility that a declaration may have.

Diagnostic wrappers for TextAPI types for error reporting.

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