diff options
Diffstat (limited to 'build/target')
| -rw-r--r-- | build/target | 144 |
1 files changed, 84 insertions, 60 deletions
diff --git a/build/target b/build/target index 00be7b5..3033e4e 100644 --- a/build/target +++ b/build/target @@ -11,7 +11,6 @@ #include <memory> // unique_ptr #include <cstddef> // size_t #include <functional> // function, reference_wrapper -#include <typeindex> #include <ostream> #include <cassert> #include <utility> // move() @@ -22,11 +21,13 @@ #include <build/name> #include <build/variable> #include <build/operation> +#include <build/target-key> #include <build/prerequisite> #include <build/utility> // compare_*, extension_pool namespace build { + class scope; class target; // Target state. @@ -70,36 +71,59 @@ namespace build target_state noop_recipe_function (action, target&); - // Target type. + // Prerequisite target. It consist of a reference to the prerequisite + // plus a pointer to target to which it resolves in this context. // - struct target_type + struct prerequisite_target { - std::type_index id; - const char* name; - const target_type* base; - target* (*const factory) (dir_path, std::string, const std::string*); - target* (*const search) (prerequisite&); - }; + typedef build::target target_type; - inline std::ostream& - operator<< (std::ostream& os, const target_type& tt) - { - return os << tt.name; - } + prerequisite* prereq; // Must not be NULL but can be reset. + + operator prerequisite& () const {return *prereq;} + + // Target to which this prerequisite resolves in this context. + // Note that unlike prerequisite::target, this can be a group + // member target. Depending on the stage, NULL means either + // the target is not yet resolved or it should be skipped. + // + // Note also that it is possible the target can vary from + // action to action, just like recipes. We don't need to keep + // track of the action here since the target will be updates + // if the recipe is updated, as part of rule::apply(). + // + target_type* target {nullptr}; + + operator target_type* () const {return target;} + + explicit + prerequisite_target (prerequisite& p): prereq (&p) {} + prerequisite_target (prerequisite& p, target_type& t) + : prereq (&p), target (&t) {} + }; + + // + // class target { public: virtual ~target () = default; + target (const target&) = delete; + target& operator= (const target&) = delete; + target (dir_path d, std::string n, const std::string* e) : dir (std::move (d)), name (std::move (n)), ext (e) {} - const dir_path dir; // Absolute and normalized. + const dir_path dir; // Absolute and normalized. const std::string name; - const std::string* ext; // Extension, NULL means unspecified, - // empty means no extension. + const std::string* ext; // Extension, NULL means unspecified, + // empty means no extension. + + target* group {nullptr}; // Target group to which this target + // belongs, if any. public: // Most qualified scope that contains this target. // @@ -116,10 +140,7 @@ namespace build // Prerequisites. // public: - typedef - std::vector<std::reference_wrapper<prerequisite>> - prerequisites_type; - + typedef std::vector<prerequisite_target> prerequisites_type; prerequisites_type prerequisites; // Target-specific variables. @@ -209,11 +230,17 @@ namespace build dependents = 0; } - private: - target (const target&) = delete; - target& operator= (const target&) = delete; - + // Target type info. + // public: + template <typename T> + T* + is_a () {return dynamic_cast<T*> (this);} + + template <typename T> + const T* + is_a () const {return dynamic_cast<const T*> (this);} + virtual const target_type& type () const = 0; static const target_type static_type; @@ -225,39 +252,6 @@ namespace build std::ostream& operator<< (std::ostream&, const target&); - // Light-weight (by being shallow-pointing) target key. - // - struct target_key - { - mutable const target_type* type; - mutable const dir_path* dir; - mutable const std::string* name; - mutable const std::string* const* ext; - - friend bool - operator< (const target_key& x, const target_key& y) - { - const std::type_index& xt (x.type->id); - const std::type_index& yt (y.type->id); - - //@@ TODO: use compare() to compare once. - - // Unspecified and specified extension are assumed equal. The - // extension strings are from the pool, so we can just compare - // pointers. - // - return - (xt < yt) || - (xt == yt && *x.name < *y.name) || - (xt == yt && *x.name == *y.name && *x.dir < *y.dir) || - (xt == yt && *x.name == *y.name && *x.dir == *y.dir && - *x.ext != nullptr && *y.ext != nullptr && **x.ext < **y.ext); - } - }; - - std::ostream& - operator<< (std::ostream&, const target_key&); - struct target_set { typedef std::map<target_key, std::unique_ptr<target>> map; @@ -277,6 +271,19 @@ namespace build return find (target_key {&type, &dir, &name, &e}, trace); } + // As above but ignore the extension and return the target or + // nullptr instead of the iterator. + // + target* + find (const target_type& type, + const dir_path& dir, + const std::string& name) const + { + const std::string* e (nullptr); + auto i (map_.find (target_key {&type, &dir, &name, &e})); + return i != map_.end () ? i->second.get () : nullptr; + } + iterator begin () const {return map_.begin ();} iterator end () const {return map_.end ();} @@ -330,6 +337,20 @@ namespace build return new T (std::move (d), std::move (n), e); } + // Default implementation for a target that is a member of a + // target group. Besides creating the target as above this + // version also tries to "link up" with the group. + // + template <typename T, typename G> + target* + member_target_factory (dir_path d, std::string n, const std::string* e) + { + target* g (targets.find (G::static_type, d, n)); + target* t (new T (std::move (d), std::move (n), e)); + t->group = g; + return t; + } + // Modification time-based target. // class mtime_target: public target @@ -377,11 +398,14 @@ namespace build // Return a path derived from target's dir, name, and, if specified, // ext. If ext is not specified, then use default_ext. If name_prefix - // if not NULL, add it before the name part. + // if not NULL, add it before the name part and after the directory. + // Similarly, if name_suffix if not NULL, add it after the name part + // and before the extension. // path_type derived_path (const char* default_ext = nullptr, - const char* name_prefix = nullptr); + const char* name_prefix = nullptr, + const char* name_suffix = nullptr); protected: virtual timestamp |