clang 8.0.0

StandaloneExecution.cpp
Go to the documentation of this file.
1 //===- lib/Tooling/Execution.cpp - Standalone clang action execution. -----===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "clang/Tooling/StandaloneExecution.h"
11 #include "clang/Tooling/ToolExecutorPluginRegistry.h"
12
13 namespace clang {
14 namespace tooling {
15
16 static llvm::Error make_string_error(const llvm::Twine &Message) {
17 return llvm::make_error<llvm::StringError>(Message,
18 llvm::inconvertibleErrorCode());
19 }
20
21 const char *StandaloneToolExecutor::ExecutorName = "StandaloneToolExecutor";
22
23 static ArgumentsAdjuster getDefaultArgumentsAdjusters() {
24 return combineAdjusters(
25 getClangStripOutputAdjuster(),
26 combineAdjusters(getClangSyntaxOnlyAdjuster(),
27 getClangStripDependencyFileAdjuster()));
28 }
29
30 StandaloneToolExecutor::StandaloneToolExecutor(
31 const CompilationDatabase &Compilations,
32 llvm::ArrayRef<std::string> SourcePaths,
33 IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS,
34 std::shared_ptr<PCHContainerOperations> PCHContainerOps)
35 : Tool(Compilations, SourcePaths, std::move(PCHContainerOps),
36 std::move(BaseFS)),
37 Context(&Results), ArgsAdjuster(getDefaultArgumentsAdjusters()) {
38 // Use self-defined default argument adjusters instead of the default
39 // adjusters that come with the old `ClangTool`.
40 Tool.clearArgumentsAdjusters();
41 }
42
43 StandaloneToolExecutor::StandaloneToolExecutor(
44 CommonOptionsParser Options,
45 std::shared_ptr<PCHContainerOperations> PCHContainerOps)
46 : OptionsParser(std::move(Options)),
47 Tool(OptionsParser->getCompilations(), OptionsParser->getSourcePathList(),
48 std::move(PCHContainerOps)),
49 Context(&Results), ArgsAdjuster(getDefaultArgumentsAdjusters()) {
50 Tool.clearArgumentsAdjusters();
51 }
52
53 llvm::Error StandaloneToolExecutor::execute(
54 llvm::ArrayRef<
55 std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
56 Actions) {
57 if (Actions.empty())
58 return make_string_error("No action to execute.");
59
60 if (Actions.size() != 1)
61 return make_string_error(
62 "Only support executing exactly 1 action at this point.");
63
64 auto &Action = Actions.front();
65 Tool.appendArgumentsAdjuster(Action.second);
66 Tool.appendArgumentsAdjuster(ArgsAdjuster);
67 if (Tool.run(Action.first.get()))
68 return make_string_error("Failed to run action.");
69
70 return llvm::Error::success();
71 }
72
73 class StandaloneToolExecutorPlugin : public ToolExecutorPlugin {
74 public:
75 llvm::Expected<std::unique_ptr<ToolExecutor>>
76 create(CommonOptionsParser &OptionsParser) override {
77 if (OptionsParser.getSourcePathList().empty())
78 return make_string_error(
79 "[StandaloneToolExecutorPlugin] No positional argument found.");
80 return llvm::make_unique<StandaloneToolExecutor>(std::move(OptionsParser));
81 }
82 };
83
84 static ToolExecutorPluginRegistry::Add<StandaloneToolExecutorPlugin>
85 X("standalone", "Runs FrontendActions on a set of files provided "
86 "via positional arguments.");
87
88 // This anchor is used to force the linker to link in the generated object file
89 // and thus register the plugin.
90 volatile int StandaloneToolExecutorAnchorSource = 0;
91
92 } // end namespace tooling
93 } // end namespace clang
clang::tooling::StandaloneToolExecutorPlugin
Definition: StandaloneExecution.cpp:73
clang::tooling::make_string_error
static llvm::Error make_string_error(const llvm::Twine &Message)
Definition: StandaloneExecution.cpp:16
clang::tooling::StandaloneToolExecutorPlugin::create
llvm::Expected< std::unique_ptr< ToolExecutor > > create(CommonOptionsParser &OptionsParser) override
Create an ToolExecutor.
Definition: StandaloneExecution.cpp:76
clang::tooling::StandaloneToolExecutor::execute
llvm::Error execute(llvm::ArrayRef< std::pair< std::unique_ptr< FrontendActionFactory >, ArgumentsAdjuster >> Actions) override
Executes each action with a corresponding arguments adjuster.
Definition: StandaloneExecution.cpp:53
clang::tooling::StandaloneToolExecutorAnchorSource
volatile int StandaloneToolExecutorAnchorSource
Definition: StandaloneExecution.cpp:90
clang::tooling::getClangStripDependencyFileAdjuster
ArgumentsAdjuster getClangStripDependencyFileAdjuster()
Gets an argument adjuster which removes dependency-file related command line arguments.
Definition: ArgumentsAdjusters.cpp:57
clang::tooling::combineAdjusters
ArgumentsAdjuster combineAdjusters(ArgumentsAdjuster First, ArgumentsAdjuster Second)
Gets an argument adjuster which adjusts the arguments in sequence with the First adjuster and then wi...
Definition: ArgumentsAdjusters.cpp:100
std
Definition: Format.h:2072
clang::tooling::ClangTool::clearArgumentsAdjusters
void clearArgumentsAdjusters()
Clear the command line arguments adjuster chain.
Definition: Tooling.cpp:401
ToolExecutorPluginRegistry.h
StandaloneExecution.h
llvm::Expected
Definition: LLVM.h:39
clang::tooling::StandaloneToolExecutor::ExecutorName
static const char * ExecutorName
Definition: StandaloneExecution.h:33
llvm::ArrayRef< std::string >
clang::tooling::getClangStripOutputAdjuster
ArgumentsAdjuster getClangStripOutputAdjuster()
Gets an argument adjuster which removes output-related command line arguments.
Definition: ArgumentsAdjusters.cpp:39
clang::tooling::ArgumentsAdjuster
std::function< CommandLineArguments(const CommandLineArguments &, StringRef Filename)> ArgumentsAdjuster
A prototype of a command line adjuster.
Definition: ArgumentsAdjusters.h:37
clang::DiagnosticLevelMask::Error
clang::tooling::CompilationDatabase
Interface for compilation databases.
Definition: CompilationDatabase.h:81
llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem >
clang::tooling::CommonOptionsParser
A parser for options common to all command-line Clang tools.
Definition: CommonOptionsParser.h:66
clang::tooling::ClangTool::run
int run(ToolAction *Action)
Runs an action over all files specified in the command line.
Definition: Tooling.cpp:417
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:22
clang::tooling::ToolExecutorPlugin
Interface for factories that create specific executors.
Definition: Execution.h:159
clang::tooling::getClangSyntaxOnlyAdjuster
ArgumentsAdjuster getClangSyntaxOnlyAdjuster()
Gets an argument adjuster that converts input command line arguments to the "syntax check only" varia...
Definition: ArgumentsAdjusters.cpp:24
clang::tooling::X
static ToolExecutorPluginRegistry::Add< AllTUsToolExecutorPlugin > X("all-TUs", "Runs FrontendActions on all TUs in the compilation database. " "Tool results are stored in memory.")
clang::tooling::ClangTool::appendArgumentsAdjuster
void appendArgumentsAdjuster(ArgumentsAdjuster Adjuster)
Append a command line arguments adjuster to the adjuster chain.
Definition: Tooling.cpp:397
clang::tooling::CommonOptionsParser::getSourcePathList
const std::vector< std::string > & getSourcePathList() const
Returns a list of source file paths to process.
Definition: CommonOptionsParser.h:108
clang::tooling::StandaloneToolExecutor::StandaloneToolExecutor
StandaloneToolExecutor(const CompilationDatabase &Compilations, llvm::ArrayRef< std::string > SourcePaths, IntrusiveRefCntPtr< llvm::vfs::FileSystem > BaseFS=llvm::vfs::getRealFileSystem(), std::shared_ptr< PCHContainerOperations > PCHContainerOps=std::make_shared< PCHContainerOperations >())
Init with CompilationDatabase and the paths of all files to be proccessed.
Definition: StandaloneExecution.cpp:30
clang::tooling::getDefaultArgumentsAdjusters
static ArgumentsAdjuster getDefaultArgumentsAdjusters()
Definition: StandaloneExecution.cpp:23