7 #include <msp/fs/path.h>
9 #include "internaltask.h"
10 #include "virtualfilesystem.h"
20 Base class for tools. Tools are used to turn targets into other targets.
21 Examples include compilers and linkers.
35 const Architecture *architecture = 0;
38 FileTarget *executable = 0;
39 std::vector<std::string> input_suffixes;
40 std::vector<std::string> aux_suffixes;
41 ProcessingUnit processing_unit = ONE_FILE;
42 VirtualFileSystem::SearchPath system_path;
44 std::function<Task *(const Target &)> run_func;
45 bool prepared = false;
46 std::vector<std::string> problems;
48 Tool(Builder &b, const std::string &t): Tool(b, 0, t) { }
49 Tool(Builder &b, const Architecture &a, const std::string &t): Tool(b, &a, t) { }
51 Tool(Builder &b, const Architecture *a, const std::string &t): builder(b), architecture(a), tag(t) { }
55 Builder &get_builder() const { return builder; }
57 const std::string &get_tag() const { return tag; }
59 /** Returns the architecture this tool builds for. May return null if the
60 tool is architecture-agnostic. */
61 const Architecture *get_architecture() const { return architecture; }
64 void set_run(std::function<Task *(const Target &)>);
67 void set_run(Task *(*)(const T &));
70 void set_run_internal(bool (*)(const T &));
73 /** Overrides the command used by the tool. The new command should accept
74 the same command line arguments. Only works on tools that use an external
75 command. If cross is true and the architecture is not native, a cross
76 prefix is added to the command. May have no effect after prepare() has been
78 void set_command(const std::string &cmd, bool cross = false);
80 /** Returns a target for the tool's own executable. If the tool does not
81 use an external program, returns null. The tool must be prepared first. */
82 FileTarget *get_executable() const { return executable; }
84 /// Returns a list of suffixes that can be processed with this tool.
85 const std::vector<std::string> &get_input_suffixes() const { return input_suffixes; }
87 /** Returns a list of suffixes that are associated with this tool, but can't
88 be processed directly. For example C and C++ headers. */
89 const std::vector<std::string> &get_auxiliary_suffixes() const { return aux_suffixes; }
91 /** Indicates whether the tool can accept a suffix. If aux is true,
92 auxiliary suffixes are considered as well */
93 bool accepts_suffix(const std::string &, bool aux = false) const;
95 /** Returns the grouping unit this tool prefers to process. */
96 ProcessingUnit get_processing_unit() const { return processing_unit; }
98 /// Returns the systemwide search path for source files.
99 const VirtualFileSystem::SearchPath &get_system_path() const { return system_path; }
101 /** Returns tool-specific build info. This can be used by other tools down
103 const BuildInfo &get_build_info() const { return build_info; }
105 /// Creates a source file appropriate for this tool.
106 virtual Target *create_source(const Component &, const Msp::FS::Path &) const { return 0; }
108 /** Creates a package-less source file appropriate for this tool. This is
109 called during dependency discovery when no package has created a target for
111 virtual Target *create_source(const Msp::FS::Path &) const { return 0; }
113 /// Convenience function to create a target from a single source.
114 Target *create_target(Target &, const std::string & = std::string());
116 /** Creates a target from sources. The exact types of accepted sources
117 depends on the tool. The optional second argument can be used to select an
118 alternative target type for tools that can create multiple kinds of targets. */
119 virtual Target *create_target(const std::vector<Target *> &, const std::string & = std::string()) = 0;
121 /** Creates an install target for a target created by this tool. Can return
122 null if the tool does not want to handle installing in a special way. */
123 virtual Target *create_install(Target &) const { return 0; }
125 virtual std::string create_build_signature(const BuildInfo &) const;
130 virtual void do_prepare() { }
133 const std::vector<std::string> &get_problems() const { return problems; }
135 /** Invokes the tool to build a target. This should not be called directly;
136 use Target::build() instead. */
137 Task *run(const Target &t) const { return run_func(t); }
141 Intermediate base class for tool facets. For example, a linker may need to
142 use different commands depending on whether C++ source files are present or
143 not, but their presence can't be directly determined from the object files.
145 class SubTool: public Tool
150 SubTool(Tool &t): Tool(t), parent(t) { }
153 Target *create_source(const Component &, const Msp::FS::Path &) const override;
154 Target *create_source(const Msp::FS::Path &) const override;
155 Target *create_target(const std::vector<Target *> &, const std::string & = std::string()) override;
156 Target *create_install(Target &) const override;
157 std::string create_build_signature(const BuildInfo &) const override;
162 void Tool::set_run(Task *(*f)(const T &))
164 set_run([f](const Target &t){ return f(dynamic_cast<const T &>(t)); });
168 void Tool::set_run_internal(bool (*f)(const T &))
170 set_run([f](const Target &t){
171 const T &ct = dynamic_cast<const T &>(t);
172 return new InternalTask([f, &ct]{ return f(ct); });
177 void operator>>(const Msp::LexicalConverter &, Tool::ProcessingUnit &);