#include <string>
#include <msp/fs/path.h>
+class Architecture;
class Builder;
+class BuildInfo;
class Component;
+class FileTarget;
class Target;
class Task;
+/**
+Base class for tools. Tools are used to turn targets into other targets.
+Examples include compilers and linkers.
+*/
class Tool
{
public:
protected:
Builder &builder;
+ const Architecture *architecture;
std::string tag;
+ FileTarget *executable;
SuffixList input_suffixes;
SuffixList aux_suffixes;
SearchPath system_path;
Tool(Builder &, const std::string &);
+ Tool(Builder &, const Architecture &, const std::string &);
public:
virtual ~Tool() { }
const std::string &get_tag() const { return tag; }
+
+ /** Returns a target for the tool's own executable. If the tool does not
+ use an external program, returns null. */
+ // XXX The executable target should be retrieved when first needed
+ FileTarget *get_executable() const { return executable; }
+
+ /// Returns a list of suffixes that can be processed with this tool.
const SuffixList &get_input_suffixes() const { return input_suffixes; }
+
+ /** Returns a list of suffixes that are associated with this tool, but can't
+ be processed directly. For example C and C++ headers. */
const SuffixList &get_auxiliary_suffixes() const { return aux_suffixes; }
- bool accepts_suffix(const std::string &, bool = false) const;
+
+ /** Indicates whether the tool can accept a suffix. If aux is true,
+ auxiliary suffixes are considered as well */
+ bool accepts_suffix(const std::string &, bool aux = false) const;
+
+ /// Returns the systemwide search path for source files.
const SearchPath &get_system_path() const { return system_path; }
+ /// Creates a source file appropriate for this tool.
virtual Target *create_source(const Component &, const Msp::FS::Path &) const { return 0; }
+
+ /** Creates a package-less source file appropriate for this too. This is
+ called during dependency discovery when no package has created a target for
+ the file. */
+ virtual Target *create_source(const Msp::FS::Path &) const { return 0; }
+
+ /// Convenience function to create a target from a single source.
Target *create_target(Target &, const std::string & = std::string()) const;
+
+ /** Creates a target from sources. The exact types of accepted sources
+ depends on the tool. The optional second argument can be used to select an
+ alternative target type for tools that can create multiple kinds of targets. */
virtual Target *create_target(const std::list<Target *> &, const std::string & = std::string()) const = 0;
+
+ virtual std::string create_build_signature(const BuildInfo &) const { return std::string(); }
+
+ /** Invokes the tool to build a target. This should not be called directly;
+ use Target::build() instead. */
virtual Task *run(const Target &) const = 0;
};
+/**
+Intermediate base class for tool facets. For example, a linker may need to
+use different commands depending on whether C++ source files are present or
+not, but their presence can't be directly determined from the object files.
+*/
+class SubTool: public Tool
+{
+protected:
+ Tool &parent;
+
+ SubTool(Tool &);
+};
+
#endif