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

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

clang: lib/Tooling/Tooling.cpp Source File

;

tooling;

(BinaryName, llvm::sys::getDefaultTargetTriple(),

*Diagnostics,

, std::move(VFS));

CompilerDriver->

(

);

CompilerDriver;

OffloadCompilation =

;

(

&Job : Jobs)

(StringRef(Job.getExecutable()) ==

)

OffloadCompilation =

;

(Jobs.

() > 1) {

(

*A : Actions){

(isa<driver::BindArchAction>(A))

A = *A->input_begin();

(isa<driver::OffloadAction>(A)) {

assert(Actions.size() > 1);

isa<driver::CompileJobAction>(Actions.front()) ||

(isa<driver::BindArchAction>(Actions.front()) &&

isa<driver::CompileJobAction>(*Actions.front()->input_begin())));

OffloadCompilation =

;

OffloadCompilation;

llvm::opt::ArgStringList *

StringRef(

.getCreator().getName()) ==

;

isSrcFile(II.getType());

(IsCC1Command(Job) && llvm::all_of(Job.getInputInfos(), IsSrcFile))

CC1Jobs.push_back(&Job);

(IsCC1Command(Job))

CC1Jobs.push_back(&Job);

(CC1Jobs.empty() ||

llvm::raw_svector_ostream error_stream(error_msg);

Jobs.

(error_stream,

,

);

Diagnostics->

(diag::err_fe_expected_compiler_job)

<< error_stream.str();

&CC1Jobs[0]->getArguments();

*

BinaryName) {

assert(!CC1Args.empty() &&

);

Twine &Code,

Twine &

,

std::shared_ptr<PCHContainerOperations> PCHContainerOps) {

std::vector<std::string>(),

,

, std::move(PCHContainerOps));

std::vector<std::string>

std::vector<std::string> &ExtraArgs,

std::vector<std::string> Args;

Args.push_back(ToolName.str());

Args.push_back(

);

Args.insert(Args.end(), ExtraArgs.begin(), ExtraArgs.end());

std::unique_ptr<FrontendAction>

,

Twine &Code,

std::vector<std::string> &Args,

Twine &

,

Twine &ToolName,

std::shared_ptr<PCHContainerOperations> PCHContainerOps) {

StringRef FileNameRef =

.toNullTerminatedStringRef(FileNameStorage);

std::move(

), Files.get(), std::move(PCHContainerOps));

Invocation.

();

std::unique_ptr<FrontendAction>

,

Twine &Code,

std::vector<std::string> &Args,

Twine &

,

Twine &ToolName,

std::shared_ptr<PCHContainerOperations> PCHContainerOps,

llvm::vfs::OverlayFileSystem(llvm::vfs::getRealFileSystem()));

llvm::vfs::InMemoryFileSystem);

OverlayFileSystem->pushOverlay(InMemoryFileSystem);

InMemoryFileSystem->addFile(

, 0,

llvm::MemoryBuffer::getMemBuffer(

Code.toNullTerminatedStringRef(CodeStorage)));

(

&FilenameWithContent : VirtualMappedFiles) {

InMemoryFileSystem->addFile(

FilenameWithContent.first, 0,

llvm::MemoryBuffer::getMemBuffer(FilenameWithContent.second));

StringRef RelativePath(

);

RelativePath.consume_front(

);

(

EC = FS.makeAbsolute(AbsolutePath))

llvm::errorCodeToError(EC);

llvm::sys::path::native(AbsolutePath);

std::string(AbsolutePath);

StringRef InvokedAs) {

(CommandLine.empty() || InvokedAs.empty())

StringRef TargetOPT =

Table.getOption(driver::options::OPT_target).getPrefixedName();

StringRef TargetOPTLegacy =

Table.getOption(driver::options::OPT_target_legacy_spelling)

StringRef DriverModeOPT =

Table.getOption(driver::options::OPT_driver_mode).getPrefixedName();

ShouldAddTarget = TargetMode.TargetIsValid;

ShouldAddMode = TargetMode.DriverMode !=

;

(

= ++CommandLine.begin();

!= CommandLine.end();

StringRef TokenRef(*

);

ShouldAddTarget = ShouldAddTarget && !TokenRef.starts_with(TargetOPT) &&

TokenRef != TargetOPTLegacy;

ShouldAddMode = ShouldAddMode && !TokenRef.starts_with(DriverModeOPT);

CommandLine.insert(++CommandLine.begin(), TargetMode.DriverMode);

(ShouldAddTarget) {

CommandLine.insert(++CommandLine.begin(),

(TargetOPT + TargetMode.TargetPrefix).str());

llvm::StringRef WorkingDir,

llvm::cl::TokenizerCallback Tokenizer,

llvm::vfs::FileSystem &FS) {

SeenRSPFile =

;

Argv.reserve(CommandLine.size());

(

&Arg : CommandLine) {

Argv.push_back(Arg.c_str());

SeenRSPFile |= Arg.front() ==

;

llvm::BumpPtrAllocator Alloc;

llvm::cl::ExpansionContext ECtx(Alloc, Tokenizer);

ECtx.setVFS(&FS).setCurrentDir(WorkingDir).expandResponseFiles(Argv);

std::vector<std::string> ExpandedArgv(Argv.begin(), Argv.end());

CommandLine = std::move(ExpandedArgv);

std::unique_ptr<FrontendAction> Action;

SingleFrontendActionFactory(std::unique_ptr<FrontendAction> Action)

: Action(

::move(Action)) {}

std::unique_ptr<FrontendAction>

()

{

std::move(Action);

std::vector<std::string> CommandLine,

*Action,

*Files, std::shared_ptr<PCHContainerOperations> PCHContainerOps)

: CommandLine(

::move(CommandLine)), Action(Action), OwnsAction(

),

Files(Files), PCHContainerOps(

::move(PCHContainerOps)) {}

std::vector<std::string> CommandLine,

std::unique_ptr<FrontendAction> FAction,

*Files,

std::shared_ptr<PCHContainerOperations> PCHContainerOps)

: CommandLine(

::move(CommandLine)),

Action(new SingleFrontendActionFactory(

::move(FAction))),

OwnsAction(

), Files(Files),

PCHContainerOps(

::move(PCHContainerOps)) {}

llvm::opt::ArgStringList Argv;

(

std::string &Str : CommandLine)

Argv.push_back(Str.c_str());

*

BinaryName = Argv[0];

DiagOpts = &*ParsedDiagOpts;

DiagConsumer ? DiagConsumer : &DiagnosticPrinter,

);

Diagnostics->setSourceManager(&SrcMgr);

(CommandLine.size() >= 2 && CommandLine[1] ==

) {

std::unique_ptr<CompilerInvocation> Invocation(

(Diagnostics->hasErrorOccurred())

std::move(PCHContainerOps), DiagConsumer);

std::unique_ptr<driver::Driver> Driver(

Driver->setCheckInputsExist(

);

std::unique_ptr<driver::Compilation> Compilation(

&*Diagnostics, Compilation.get());

std::unique_ptr<CompilerInvocation> Invocation(

runInvocation(BinaryName, Compilation.get(), std::move(Invocation),

std::move(PCHContainerOps));

ToolInvocation::runInvocation(

std::shared_ptr<CompilerInvocation> Invocation,

std::shared_ptr<PCHContainerOperations> PCHContainerOps) {

(Invocation->getHeaderSearchOpts().Verbose) {

llvm::errs() <<

;

Compilation->

().

(llvm::errs(),

,

);

llvm::errs() <<

;

std::move(PCHContainerOps), DiagConsumer);

std::shared_ptr<CompilerInvocation> Invocation,

*Files,

std::shared_ptr<PCHContainerOperations> PCHContainerOps,

std::unique_ptr<FrontendAction> ScopedToolAction(

());

std::shared_ptr<PCHContainerOperations> PCHContainerOps,

: Compilations(Compilations), SourcePaths(SourcePaths),

PCHContainerOps(

::move(PCHContainerOps)),

OverlayFileSystem(new

::vfs::OverlayFileSystem(

::move(BaseFS))),

InMemoryFileSystem(new

::vfs::InMemoryFileSystem),

OverlayFileSystem->pushOverlay(InMemoryFileSystem);

Files->setVirtualFileSystem(OverlayFileSystem);

MappedFileContents.push_back(std::make_pair(FilePath, Content));

ArgsAdjuster =

(std::move(ArgsAdjuster), std::move(Adjuster));

ArgsAdjuster =

;

(StringRef Arg : Args)

(Arg.starts_with(

))

.c_str())(Args,

);

StaticSymbol;

(SeenWorkingDirectories.insert(

).second)

(

&MappedFile : MappedFileContents)

(llvm::sys::path::is_absolute(MappedFile.first))

InMemoryFileSystem->addFile(

llvm::MemoryBuffer::getMemBuffer(MappedFile.second));

ProcessingFailed =

;

FileSkipped =

;

std::vector<std::string> AbsolutePaths;

AbsolutePaths.reserve(SourcePaths.size());

(

&SourcePath : SourcePaths) {

llvm::errs() <<

<< SourcePath

<<

<< llvm::toString(AbsPath.takeError()) <<

;

AbsolutePaths.push_back(std::move(*AbsPath));

std::string InitialWorkingDir;

(

CWD = OverlayFileSystem->getCurrentWorkingDirectory()) {

InitialWorkingDir = std::move(*CWD);

llvm::errs() <<

<< CWD.getError().message() <<

;

NumOfTotalFiles = AbsolutePaths.size();

ProcessedFileCounter = 0;

(llvm::StringRef

: AbsolutePaths) {

std::vector<CompileCommand> CompileCommandsForFile =

(CompileCommandsForFile.empty()) {

llvm::errs() <<

<<

<<

;

(OverlayFileSystem->setCurrentWorkingDirectory(

llvm::report_fatal_error(

+

(

&MappedFile : MappedFileContents)

(!llvm::sys::path::is_absolute(MappedFile.first))

InMemoryFileSystem->addFile(

llvm::MemoryBuffer::getMemBuffer(MappedFile.second));

assert(!CommandLine.empty());

(NumOfTotalFiles > 1)

llvm::errs() <<

+ std::to_string(++ProcessedFileCounter) +

+

std::to_string(NumOfTotalFiles) +

+

Invocation(std::move(CommandLine), Action, Files.get(),

(!Invocation.

()) {

(PrintErrorMessage)

llvm::errs() <<

<<

<<

;

ProcessingFailed =

;

(!InitialWorkingDir.empty()) {

OverlayFileSystem->setCurrentWorkingDirectory(InitialWorkingDir))

llvm::errs() <<

<< EC.message() <<

;

ProcessingFailed ? 1 : (FileSkipped ? 2 : 0);

std::vector<std::unique_ptr<ASTUnit>> &ASTs;

ASTBuilderAction(std::vector<std::unique_ptr<ASTUnit>> &ASTs) : ASTs(ASTs) {}

runInvocation(std::shared_ptr<CompilerInvocation> Invocation,

std::shared_ptr<PCHContainerOperations> PCHContainerOps,

std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation(

Invocation, std::move(PCHContainerOps),

&Invocation->getDiagnosticOpts(),

ASTs.push_back(std::move(AST));

ASTBuilderAction Action(ASTs);

(&Action);

this->PrintErrorMessage = PrintErrorMessage;

std::unique_ptr<ASTUnit>

std::shared_ptr<PCHContainerOperations> PCHContainerOps) {

, std::move(PCHContainerOps));

StringRef Code,

std::vector<std::string> &Args, StringRef

,

StringRef ToolName, std::shared_ptr<PCHContainerOperations> PCHContainerOps,

std::vector<std::unique_ptr<ASTUnit>> ASTs;

ASTBuilderAction Action(ASTs);

llvm::vfs::OverlayFileSystem(std::move(BaseFS)));

llvm::vfs::InMemoryFileSystem);

OverlayFileSystem->pushOverlay(InMemoryFileSystem);

&Action, Files.get(), std::move(PCHContainerOps));

InMemoryFileSystem->addFile(

, 0,

llvm::MemoryBuffer::getMemBufferCopy(Code));

(

&FilenameWithContent : VirtualMappedFiles) {

InMemoryFileSystem->addFile(

FilenameWithContent.first, 0,

llvm::MemoryBuffer::getMemBuffer(FilenameWithContent.second));

(!Invocation.

())

assert(ASTs.size() == 1);

std::move(ASTs[0]);

Defines the Diagnostic-related interfaces.

Defines the Diagnostic IDs-related interfaces.

Defines the clang::FileManager interface and associated types.

Defines the clang::FileSystemOptions interface.

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

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 createSourceManager(FileManager &FileMgr)

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

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

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

setInvocation - Replace the current invocation.

bool hasDiagnostics() const

bool ExecuteAction(FrontendAction &Act)

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

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

static std::string GetResourcesPath(const char *Argv0, void *MainAddr)

Get the directory where the compiler headers reside, relative to the compiler binary (found by the pa...

static bool CreateFromArgs(CompilerInvocation &Res, ArrayRef< const char * > CommandLineArgs, DiagnosticsEngine &Diags, const char *Argv0=nullptr)

Create a compiler invocation from a list of input options.

FrontendOptions & getFrontendOpts()

CodeGenOptions & getCodeGenOpts()

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.

DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)

Issue the message to the client.

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

void clearStatCache()

Removes the FileSystemStatCache object from the manager.

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

FileSystemOptions & getFileSystemOpts()

Returns the current file system options.

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

std::string WorkingDir

If set, paths are resolved as if the working directory was set to the value of WorkingDir.

unsigned DisableFree

Disable memory freeing on exit.

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

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

Command - An executable path/name and argument vector to execute.

Compilation - A set of tasks to perform for a single driver invocation.

ActionList & getActions()

Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...

void setTitle(std::string Value)

InputInfo - Wrapper for information about an input source.

JobList - A sequence of jobs to perform.

void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote, CrashReportInfo *CrashInfo=nullptr) const

const llvm::opt::OptTable & getDriverOptTable()

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

std::unique_ptr< DiagnosticOptions > CreateAndPopulateDiagOpts(ArrayRef< const char * > Argv)

@ Success

Template argument deduction was successful.

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