Have SubTool automatically pass calls to the parent tool

[builder.git] / source / tool.h

diff --git a/source/tool.h b/source/tool.h
index 6aee38b2ee6a59b62206c0f8617dd7e5df6cf590..41b8c5f24dd92387ae4bf454653c3984d34694b5 100644 (file)
--- a/source/tool.h
+++ b/source/tool.h
@@ -4,6 +4,7 @@
 #include <list>
 #include <string>
 #include <msp/fs/path.h>
+#include "buildinfo.h"
 
 class Architecture;
 class Builder;
@@ -20,6 +21,13 @@ Examples include compilers and linkers.
 class Tool
 {
 public:
+       enum ProcessingUnit
+       {
+               ONE_FILE,
+               DIRECTORY,
+               COMPONENT
+       };
+
        typedef std::list<Msp::FS::Path> SearchPath;
        typedef std::list<std::string> SuffixList;
 
@@ -27,10 +35,15 @@ protected:
        Builder &builder;
        const Architecture *architecture;
        std::string tag;
+       std::string command;
        FileTarget *executable;
        SuffixList input_suffixes;
        SuffixList aux_suffixes;
+       ProcessingUnit processing_unit;
        SearchPath system_path;
+       BuildInfo build_info;
+       bool prepared;
+       std::list<std::string> problems;
 
        Tool(Builder &, const std::string &);
        Tool(Builder &, const Architecture &, const std::string &);
@@ -39,9 +52,19 @@ public:
 
        const std::string &get_tag() const { return tag; }
 
+       /** Returns the architecture this tool build 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. */
-       // XXX The executable target should be retrieved when first needed
+       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.
@@ -55,27 +78,46 @@ public:
        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 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 too.  This is
+       /** 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()) const;
+       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::list<Target *> &, const std::string & = std::string()) const = 0;
+       virtual Target *create_target(const std::list<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 { return std::string(); }
 
+       void prepare();
+
+protected:
+       virtual void do_prepare() { }
+
+public:
+       const std::list<std::string> &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;
@@ -92,6 +134,16 @@ protected:
        Tool &parent;
 
        SubTool(Tool &);
+
+public:
+       virtual Target *create_source(const Component &, const Msp::FS::Path &) const;
+       virtual Target *create_source(const Msp::FS::Path &) const;
+       virtual Target *create_target(const std::list<Target *> &, const std::string & = std::string());
+       virtual Target *create_install(Target &) const;
+       virtual std::string create_build_signature(const BuildInfo &) const;
 };
 
+
+void operator>>(const Msp::LexicalConverter &, Tool::ProcessingUnit &);
+
 #endif