+++ /dev/null
-#ifndef TOOL_H_
-#define TOOL_H_
-
-#include <functional>
-#include <string>
-#include <vector>
-#include <msp/fs/path.h>
-#include "buildinfo.h"
-#include "internaltask.h"
-#include "virtualfilesystem.h"
-
-class Architecture;
-class Builder;
-class BuildInfo;
-class Component;
-class FileTarget;
-class Target;
-
-class ToolData
-{
-public:
- VirtualFileSystem::SearchPath system_path;
- BuildInfo build_info;
- Msp::Variant extra_data;
- std::vector<std::string> problems;
-};
-
-/**
-Base class for tools. Tools are used to turn targets into other targets.
-Examples include compilers and linkers.
-*/
-class Tool: protected ToolData
-{
-public:
- enum ProcessingUnit
- {
- ONE_FILE,
- DIRECTORY,
- COMPONENT
- };
-
-protected:
- Builder &builder;
- const Architecture *architecture = 0;
- std::string tag;
- std::string command;
- FileTarget *executable = 0;
- std::vector<std::string> input_suffixes;
- std::vector<std::string> aux_suffixes;
- ProcessingUnit processing_unit = ONE_FILE;
- std::function<Task *(const Target &)> run_func;
- bool prepared = false;
-
- Tool(Builder &b, const std::string &t): Tool(b, 0, t) { }
- Tool(Builder &b, const Architecture *a, const std::string &t): builder(b), architecture(a), tag(t) { }
-
-public:
- virtual ~Tool() { }
-
- Builder &get_builder() const { return builder; }
-
- const std::string &get_tag() const { return tag; }
-
- /** Returns the architecture this tool builds for. May return null if the
- tool is architecture-agnostic. */
- const Architecture *get_architecture() const { return architecture; }
-
- virtual const Tool *get_base_tool() const { return this; }
-
-protected:
- void set_run(std::function<Task *(const Target &)>);
-
- template<typename T>
- void set_run(Task *(*)(const T &));
-
- template<typename T>
- void set_run_internal(bool (*)(const T &));
-
-public:
- /** 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; }
-
- /// Returns a list of suffixes that can be processed with this tool.
- const std::vector<std::string> &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<std::string> &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; }
-
- const Msp::Variant &get_extra_data() const { return extra_data; }
-
- /// 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; }
-
- /// 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<Target *> &, 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(Tool * = 0);
-
-protected:
- virtual void do_prepare(ToolData &) const { }
-
-public:
- const std::vector<std::string> &get_problems() const { return problems; }
-
- /** Invokes the tool to build a target. This should not be called directly;
- use Target::build() instead. */
- Task *run(const Target &t) const { return run_func(t); }
-};
-
-
-template<typename T>
-void Tool::set_run(Task *(*f)(const T &))
-{
- set_run([f](const Target &t){ return f(dynamic_cast<const T &>(t)); });
-}
-
-template<typename T>
-void Tool::set_run_internal(bool (*f)(const T &))
-{
- set_run([f](const Target &t){
- const T &ct = dynamic_cast<const T &>(t);
- return new InternalTask([f, &ct]{ return f(ct); });
- });
-}
-
-
-void operator>>(const Msp::LexicalConverter &, Tool::ProcessingUnit &);
-
-#endif
projects / builder.git / blobdiff