X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Ftool.h;h=6fa4fb5c127090bf81a0ded5574c14bd2aa0bc69;hb=451ef4f33b5a57dcb56bd7cb671bed359ac86247;hp=7371103213b91f56483f630da8cada940d3fda66;hpb=3e8f3a5e852e9dd5b78ec3d89c722ef1bae6bef5;p=builder.git diff --git a/source/tool.h b/source/tool.h index 7371103..6fa4fb5 100644 --- a/source/tool.h +++ b/source/tool.h @@ -1,11 +1,15 @@ #ifndef TOOL_H_ #define TOOL_H_ -#include #include +#include #include +#include "buildinfo.h" +#include "virtualfilesystem.h" +class Architecture; class Builder; +class BuildInfo; class Component; class FileTarget; class Target; @@ -18,33 +22,104 @@ Examples include compilers and linkers. class Tool { public: - typedef std::list SearchPath; - typedef std::list SuffixList; + enum ProcessingUnit + { + ONE_FILE, + DIRECTORY, + COMPONENT + }; protected: Builder &builder; + const Architecture *architecture = 0; std::string tag; - FileTarget *executable; - SuffixList input_suffixes; - SuffixList aux_suffixes; - SearchPath system_path; + std::string command; + FileTarget *executable = 0; + std::vector input_suffixes; + std::vector aux_suffixes; + ProcessingUnit processing_unit = ONE_FILE; + VirtualFileSystem::SearchPath system_path; + BuildInfo build_info; + bool prepared = false; + std::vector problems; - Tool(Builder &, const std::string &); + Tool(Builder &b, const std::string &t): Tool(b, 0, t) { } + Tool(Builder &b, const Architecture &a, const std::string &t): Tool(b, &a, t) { } +private: + Tool(Builder &b, const Architecture *a, const std::string &t): builder(b), architecture(a), tag(t) { } public: virtual ~Tool() { } const std::string &get_tag() const { return tag; } - // XXX The executable target should be retrieved when first needed + + /** Returns the architecture this tool builds for. May return null if the + tool is architecture-agnostic. */ + const Architecture *get_architecture() const { return architecture; } + + /** Overrides the command used by the tool. The new command should accept + the same command line arguments. Only works on tools that use an external + command. If cross is true and the architecture is not native, a cross + prefix is added to the command. May have no effect after prepare() has been + called. */ + void set_command(const std::string &cmd, bool cross = false); + + /** Returns a target for the tool's own executable. If the tool does not + use an external program, returns null. The tool must be prepared first. */ FileTarget *get_executable() const { return executable; } - const SuffixList &get_input_suffixes() const { return input_suffixes; } - const SuffixList &get_auxiliary_suffixes() const { return aux_suffixes; } - bool accepts_suffix(const std::string &, bool = false) const; - const SearchPath &get_system_path() const { return system_path; } + /// Returns a list of suffixes that can be processed with this tool. + const std::vector &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 std::vector &get_auxiliary_suffixes() const { return aux_suffixes; } + + /** 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 grouping unit this tool prefers to process. */ + ProcessingUnit get_processing_unit() const { return processing_unit; } + + /// Returns the systemwide search path for source files. + const VirtualFileSystem::SearchPath &get_system_path() const { return system_path; } + + /** Returns tool-specific build info. This can be used by other tools down + the chain. */ + const BuildInfo &get_build_info() const { return build_info; } + + /// 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 tool. 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; } - Target *create_target(Target &, const std::string & = std::string()) const; - virtual Target *create_target(const std::list &, const std::string & = std::string()) const = 0; + + /// Convenience function to create a target from a single source. + Target *create_target(Target &, const std::string & = std::string()); + + /** 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::vector &, const std::string & = std::string()) = 0; + + /** Creates an install target for a target created by this tool. Can return + null if the tool does not want to handle installing in a special way. */ + virtual Target *create_install(Target &) const { return 0; } + + virtual std::string create_build_signature(const BuildInfo &) const; + + void prepare(); + +protected: + virtual void do_prepare() { } + +public: + const std::vector &get_problems() const { return problems; } + + /** Invokes the tool to build a target. This should not be called directly; + use Target::build() instead. */ virtual Task *run(const Target &) const = 0; }; @@ -58,7 +133,17 @@ class SubTool: public Tool protected: Tool &parent; - SubTool(Tool &); + SubTool(Tool &t): Tool(t), parent(t) { } + +public: + Target *create_source(const Component &, const Msp::FS::Path &) const override; + Target *create_source(const Msp::FS::Path &) const override; + Target *create_target(const std::vector &, const std::string & = std::string()) override; + Target *create_install(Target &) const override; + std::string create_build_signature(const BuildInfo &) const override; }; + +void operator>>(const Msp::LexicalConverter &, Tool::ProcessingUnit &); + #endif