clang  8.0.0svn
StandaloneExecution.h
Go to the documentation of this file.
1 //===--- StandaloneExecution.h - Standalone execution. -*- C++ ----------*-===//
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 // This file defines standalone execution of clang tools.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_TOOLING_STANDALONEEXECUTION_H
15 #define LLVM_CLANG_TOOLING_STANDALONEEXECUTION_H
16 
19 
20 namespace clang {
21 namespace tooling {
22 
23 /// A standalone executor that runs FrontendActions on a given set of
24 /// TUs in sequence.
25 ///
26 /// By default, this executor uses the following arguments adjusters (as defined
27 /// in `clang/Tooling/ArgumentsAdjusters.h`):
28 /// - `getClangStripOutputAdjuster()`
29 /// - `getClangSyntaxOnlyAdjuster()`
30 /// - `getClangStripDependencyFileAdjuster()`
32 public:
33  static const char *ExecutorName;
34 
35  /// Init with \p CompilationDatabase and the paths of all files to be
36  /// proccessed.
38  const CompilationDatabase &Compilations,
39  llvm::ArrayRef<std::string> SourcePaths,
41  llvm::vfs::getRealFileSystem(),
42  std::shared_ptr<PCHContainerOperations> PCHContainerOps =
43  std::make_shared<PCHContainerOperations>());
44 
45  /// Init with \p CommonOptionsParser. This is expected to be used by
46  /// `createExecutorFromCommandLineArgs` based on commandline options.
47  ///
48  /// The executor takes ownership of \p Options.
50  CommonOptionsParser Options,
51  std::shared_ptr<PCHContainerOperations> PCHContainerOps =
52  std::make_shared<PCHContainerOperations>());
53 
54  StringRef getExecutorName() const override { return ExecutorName; }
55 
56  bool isSingleProcess() const override { return true; }
57 
59 
62  std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
63  Actions) override;
64 
65  /// Set a \c DiagnosticConsumer to use during parsing.
67  Tool.setDiagnosticConsumer(DiagConsumer);
68  }
69 
70  ExecutionContext *getExecutionContext() override { return &Context; };
71 
72  ToolResults *getToolResults() override { return &Results; }
73 
75  return Tool.getSourcePaths();
76  }
77 
78  void mapVirtualFile(StringRef FilePath, StringRef Content) override {
79  Tool.mapVirtualFile(FilePath, Content);
80  }
81 
82  /// Returns the file manager used in the tool.
83  ///
84  /// The file manager is shared between all translation units.
85  FileManager &getFiles() { return Tool.getFiles(); }
86 
87 private:
88  // Used to store the parser when the executor is initialized with parser.
90  // FIXME: The standalone executor is currently just a wrapper of `ClangTool`.
91  // Merge `ClangTool` implementation into the this.
92  ClangTool Tool;
93  ExecutionContext Context;
94  InMemoryToolResults Results;
95  ArgumentsAdjuster ArgsAdjuster;
96 };
97 
98 } // end namespace tooling
99 } // end namespace clang
100 
101 #endif // LLVM_CLANG_TOOLING_STANDALONEEXECUTION_H
virtual llvm::Error execute(llvm::ArrayRef< std::pair< std::unique_ptr< FrontendActionFactory >, ArgumentsAdjuster >> Actions)=0
Executes each action with a corresponding arguments adjuster.
void setDiagnosticConsumer(DiagnosticConsumer *DiagConsumer)
Set a DiagnosticConsumer to use during parsing.
Definition: Tooling.h:328
ExecutionContext * getExecutionContext() override
Returns a reference to the execution context.
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:117
llvm::Error execute(llvm::ArrayRef< std::pair< std::unique_ptr< FrontendActionFactory >, ArgumentsAdjuster >> Actions) override
Executes each action with a corresponding arguments adjuster.
Utility to run a FrontendAction over a set of files.
Definition: Tooling.h:306
FileManager & getFiles()
Returns the file manager used in the tool.
Abstract interface, implemented by clients of the front-end, which formats and prints fully processed...
Definition: Diagnostic.h:1487
The context of an execution, including the information about compilation and results.
Definition: Execution.h:78
bool isSingleProcess() const override
Should return true iff executor runs all actions in a single process.
Interface for executing clang frontend actions.
Definition: Execution.h:112
FileManager & getFiles()
Returns the file manager used in the tool.
Definition: Tooling.h:367
std::function< CommandLineArguments(const CommandLineArguments &, StringRef Filename)> ArgumentsAdjuster
A prototype of a command line adjuster.
llvm::ArrayRef< std::string > getSourcePaths() const
Stores the key-value results in memory.
Definition: Execution.h:60
A standalone executor that runs FrontendActions on a given set of TUs in sequence.
Interface for compilation databases.
A parser for options common to all command-line Clang tools.
void setDiagnosticConsumer(DiagnosticConsumer *DiagConsumer)
Set a DiagnosticConsumer to use during parsing.
StringRef getExecutorName() const override
Returns the name of a specific executor.
void mapVirtualFile(StringRef FilePath, StringRef Content)
Map a virtual file to be used while running the tool.
Definition: Tooling.cpp:389
Dataflow Directional Tag Classes.
An abstraction for the result of a tool execution.
Definition: Execution.h:47
llvm::ArrayRef< std::string > getSourcePaths() const
Definition: Tooling.h:369
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.
void mapVirtualFile(StringRef FilePath, StringRef Content) override
Map a virtual file to be used while running the tool.
ToolResults * getToolResults() override
Returns a reference to the result container.