Implement lib/liba/libso{} target group, shared/static library build

26 files changed, 1162 insertions, 524 deletions

diff --git a/build/algorithm b/build/algorithm
index 81ad8d8..7d82285 100644
--- a/build/algorithm
+++ b/build/algorithm
@@ -54,8 +54,13 @@ namespace build
   void
   inject_parent_fsdir (action, target&);
 
+  // Executor function type.
+  //
+  using executor_function = target_state (action, target&);
+
   // Execute the action on target, assuming a rule has been matched
-  // and the recipe for this action has been set.
+  // and the recipe for this action has been set. This is the default
+  // executor implementation.
   //
   target_state
   execute (action, target&);
@@ -68,17 +73,20 @@ namespace build
   // with postponed execution the same as ignored. Note that this
   // function can be used as a recipe.
   //
+  template <executor_function* E = execute>
   target_state
   execute_prerequisites (action, target&);
 
   // As above but iterates over the prerequisites in reverse.
   //
+  template <executor_function* E = execute>
   target_state
   reverse_execute_prerequisites (action, target&);
 
   // A version of the above that also determines whether the action
   // needs to be executed on the target based on the passed timestamp.
   //
+  template <executor_function* E = execute>
   bool
   execute_prerequisites (action, target&, const timestamp&);
 
@@ -89,15 +97,28 @@ namespace build
   // there are multiple prerequisites of this type, then the last
   // one returned.
   //
-  template <typename T>
+  template <typename T, executor_function* E = execute>
   T*
-  execute_prerequisites (action, target&, const timestamp&);
+  execute_find_prerequisites (action, target&, const timestamp&);
+
+  // Return noop_recipe instead of using this function directly.
+  //
+  target_state
+  noop_action (action, target&);
+
+  // Default action implementation which forwards to the prerequsites.
+  // Use default_recipe for the standard executor.
+  //
+  template <executor_function* E = execute>
+  target_state
+  default_action (action, target&);
 
   // Standard perform(clean) action implementation for the file target
   // or derived.
   //
+  template <executor_function* E = execute>
   target_state
-  perform_clean_file (action, target&);
+  perform_clean (action, target&);
 }
 
 #include <build/algorithm.ixx>
diff --git a/build/algorithm.cxx b/build/algorithm.cxx
index 82286f5..9f428b3 100644
--- a/build/algorithm.cxx
+++ b/build/algorithm.cxx
@@ -250,118 +250,9 @@ namespace build
   }
 
   target_state
-  execute_prerequisites (action a, target& t)
+  noop_action (action, target&)
   {
-    target_state ts (target_state::unchanged);
-
-    if (t.group != nullptr)
-      ts = execute_prerequisites (a, *t.group);
-
-    for (target* pt: t.prerequisites)
-    {
-      if (pt == nullptr) // Skip ignored.
-        continue;
-
-      if (execute (a, *pt) == target_state::changed)
-        ts = target_state::changed;
-    }
-
-    return ts;
-  }
-
-  target_state
-  reverse_execute_prerequisites (action a, target& t)
-  {
-    target_state ts (target_state::unchanged);
-
-    for (target* pt: reverse_iterate (t.prerequisites))
-    {
-      if (pt == nullptr) // Skip ignored.
-        continue;
-
-      if (execute (a, *pt) == target_state::changed)
-        ts = target_state::changed;
-    }
-
-    if (t.group != nullptr)
-    {
-      if (reverse_execute_prerequisites (a, *t.group) == target_state::changed)
-        ts = target_state::changed;
-    }
-
-    return ts;
-  }
-
-  bool
-  execute_prerequisites (action a, target& t, const timestamp& mt)
-  {
-    bool e (mt == timestamp_nonexistent);
-
-    if (t.group != nullptr)
-    {
-      if (execute_prerequisites (a, *t.group, mt))
-        e = true;
-    }
-
-    for (target* pt: t.prerequisites)
-    {
-      if (pt == nullptr) // Skip ignored.
-        continue;
-
-      target_state ts (execute (a, *pt));
-
-      if (!e)
-      {
-        // If this is an mtime-based target, then compare timestamps.
-        //
-        if (auto mpt = dynamic_cast<const mtime_target*> (pt))
-        {
-          timestamp mp (mpt->mtime ());
-
-          // What do we do if timestamps are equal? This can happen, for
-          // example, on filesystems that don't have subsecond resolution.
-          // There is not much we can do here except detect the case where
-          // the prerequisite was changed in this run which means the
-          // action must be executed on the target as well.
-          //
-          if (mt < mp || (mt == mp && ts == target_state::changed))
-            e = true;
-        }
-        else
-        {
-          // Otherwise we assume the prerequisite is newer if it was changed.
-          //
-          if (ts == target_state::changed)
-            e = true;
-        }
-      }
-    }
-
-    return e;
-  }
-
-  target_state
-  perform_clean_file (action a, target& t)
-  {
-    // The reverse order of update: first delete the file, then clean
-    // prerequisites.
-    //
-    file& ft (dynamic_cast<file&> (t));
-
-    bool r (rmfile (ft.path (), ft));
-
-    // Update timestamp in case there are operations after us that
-    // could use the information.
-    //
-    ft.mtime (timestamp_nonexistent);
-
-    // Clean prerequisites.
-    //
-    target_state ts (target_state::unchanged);
-
-    if (!t.prerequisites.empty ())
-      ts = reverse_execute_prerequisites (a, t);
-
-    return r ? target_state::changed : ts;
+    assert (false); // We shouldn't be called, see target::recipe().
+    return target_state::unchanged;
   }
 }
diff --git a/build/algorithm.ixx b/build/algorithm.ixx
index 5d87338..76f9a0f 100644
--- a/build/algorithm.ixx
+++ b/build/algorithm.ixx
@@ -53,16 +53,16 @@ namespace build
     }
   }
 
-  template <typename T>
+  template <typename T, executor_function* E>
   T*
-  execute_prerequisites (action, target&, const timestamp&, bool&);
+  execute_find_prerequisites (action, target&, const timestamp&, bool&);
 
-  template <typename T>
+  template <typename T, executor_function* E>
   inline T*
-  execute_prerequisites (action a, target& t, const timestamp& mt)
+  execute_find_prerequisites (action a, target& t, const timestamp& mt)
   {
     bool e (mt == timestamp_nonexistent);
-    T* r (execute_prerequisites<T> (a, t, mt, e));
+    T* r (execute_find_prerequisites<T, E> (a, t, mt, e));
     assert (r != nullptr);
     return e ? r : nullptr;
   }
diff --git a/build/algorithm.txx b/build/algorithm.txx
index 2592b5e..4f5f9f3 100644
--- a/build/algorithm.txx
+++ b/build/algorithm.txx
@@ -2,11 +2,110 @@
 // copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
 // license   : MIT; see accompanying LICENSE file
 
+#include <build/context>
+#include <build/utility> // reverse_iterate
+
 namespace build
 {
-  template <typename T>
+  template <executor_function* E>
+  target_state
+  execute_prerequisites (action a, target& t)
+  {
+    target_state ts (target_state::unchanged);
+
+    if (t.group != nullptr)
+      ts = execute_prerequisites<E> (a, *t.group);
+
+    for (target* pt: t.prerequisites)
+    {
+      if (pt == nullptr) // Skip ignored.
+        continue;
+
+      if (E (a, *pt) == target_state::changed)
+        ts = target_state::changed;
+    }
+
+    return ts;
+  }
+
+  template <executor_function* E>
+  target_state
+  reverse_execute_prerequisites (action a, target& t)
+  {
+    target_state ts (target_state::unchanged);
+
+    for (target* pt: reverse_iterate (t.prerequisites))
+    {
+      if (pt == nullptr) // Skip ignored.
+        continue;
+
+      if (E (a, *pt) == target_state::changed)
+        ts = target_state::changed;
+    }
+
+    if (t.group != nullptr)
+    {
+      if (reverse_execute_prerequisites<E> (a, *t.group) ==
+            target_state::changed)
+        ts = target_state::changed;
+    }
+
+    return ts;
+  }
+
+  template <executor_function* E>
+  bool
+  execute_prerequisites (action a, target& t, const timestamp& mt)
+  {
+    bool e (mt == timestamp_nonexistent);
+
+    if (t.group != nullptr)
+    {
+      if (execute_prerequisites<E> (a, *t.group, mt))
+        e = true;
+    }
+
+    for (target* pt: t.prerequisites)
+    {
+      if (pt == nullptr) // Skip ignored.
+        continue;
+
+      target_state ts (E (a, *pt));
+
+      if (!e)
+      {
+        // If this is an mtime-based target, then compare timestamps.
+        //
+        if (auto mpt = dynamic_cast<const mtime_target*> (pt))
+        {
+          timestamp mp (mpt->mtime ());
+
+          // What do we do if timestamps are equal? This can happen, for
+          // example, on filesystems that don't have subsecond resolution.
+          // There is not much we can do here except detect the case where
+          // the prerequisite was changed in this run which means the
+          // action must be executed on the target as well.
+          //
+          if (mt < mp || (mt == mp && ts == target_state::changed))
+            e = true;
+        }
+        else
+        {
+          // Otherwise we assume the prerequisite is newer if it was changed.
+          //
+          if (ts == target_state::changed)
+            e = true;
+        }
+      }
+    }
+
+    return e;
+  }
+
+  template <typename T, executor_function* E>
   T*
-  execute_prerequisites (action a, target& t, const timestamp& mt, bool& e)
+  execute_find_prerequisites (
+    action a, target& t, const timestamp& mt, bool& e)
   {
     //@@ Can factor the bulk of it into a non-template code. Can
     // either do a function template that will do dynamic_cast check
@@ -15,14 +114,14 @@ namespace build
     T* r (nullptr);
 
     if (t.group != nullptr)
-      r = execute_prerequisites<T> (a, *t.group, mt, e);
+      r = execute_find_prerequisites<T, E> (a, *t.group, mt, e);
 
     for (target* pt: t.prerequisites)
     {
       if (pt == nullptr) // Skip ignored.
         continue;
 
-      target_state ts (execute (a, *pt));
+      target_state ts (E (a, *pt));
 
       if (!e)
       {
@@ -56,4 +155,36 @@ namespace build
 
     return r;
   }
+
+  template <executor_function* E = execute>
+  target_state
+  default_action (action a, target& t)
+  {
+    return current_mode == execution_mode::first
+      ? execute_prerequisites<E> (a, t)
+      : reverse_execute_prerequisites<E> (a, t);
+  }
+
+  template <executor_function* E>
+  target_state
+  perform_clean (action a, target& t)
+  {
+    // The reverse order of update: first delete the file, then clean
+    // prerequisites.
+    //
+    file& ft (dynamic_cast<file&> (t));
+
+    bool r (rmfile (ft.path (), ft));
+
+    // Update timestamp in case there are operations after us that
+    // could use the information.
+    //
+    ft.mtime (timestamp_nonexistent);
+
+    // Clean prerequisites.
+    //
+    target_state ts (reverse_execute_prerequisites<E> (a, t));
+
+    return r ? target_state::changed : ts;
+  }
 }
diff --git a/build/b.cxx b/build/b.cxx
index 01ca248..eac0768 100644
--- a/build/b.cxx
+++ b/build/b.cxx
@@ -77,14 +77,15 @@ namespace build
   }
 }
 
-#include <build/native>
+#include <build/config/module>
+
+#include <build/bin/target>
+#include <build/bin/rule>
 
 #include <build/cxx/target>
 #include <build/cxx/rule>
 #include <build/cxx/module>
 
-#include <build/config/module>
-
 using namespace build;
 
 int
@@ -139,11 +140,13 @@ main (int argc, char* argv[])
     target_types.insert (dir::static_type);
     target_types.insert (fsdir::static_type);
 
-    target_types.insert (obja::static_type);
-    target_types.insert (objso::static_type);
-    target_types.insert (obj::static_type);
-    target_types.insert (exe::static_type);
-    target_types.insert (lib::static_type);
+    target_types.insert (bin::obja::static_type);
+    target_types.insert (bin::objso::static_type);
+    target_types.insert (bin::obj::static_type);
+    target_types.insert (bin::exe::static_type);
+    target_types.insert (bin::liba::static_type);
+    target_types.insert (bin::libso::static_type);
+    target_types.insert (bin::lib::static_type);
 
     target_types.insert (cxx::h::static_type);
     target_types.insert (cxx::c::static_type);
@@ -155,27 +158,45 @@ main (int argc, char* argv[])
 
     // Register rules.
     //
-    cxx::link cxx_link;
-    rules[default_id][typeid (exe)].emplace ("cxx.gnu.link", cxx_link);
-    rules[update_id][typeid (exe)].emplace ("cxx.gnu.link", cxx_link);
-    rules[clean_id][typeid (exe)].emplace ("cxx.gnu.link", cxx_link);
+    bin::obj_rule obj_rule;
+    bin::lib_rule lib_rule;
+    {
+      using namespace bin;
+
+      rules[default_id][typeid (obj)].emplace ("bin.obj", obj_rule);
+      rules[update_id][typeid (obj)].emplace ("bin.obj", obj_rule);
+      rules[clean_id][typeid (obj)].emplace ("bin.obj", obj_rule);
 
-    rules[default_id][typeid (lib)].emplace ("cxx.gnu.link", cxx_link);
-    rules[update_id][typeid (lib)].emplace ("cxx.gnu.link", cxx_link);
-    rules[clean_id][typeid (lib)].emplace ("cxx.gnu.link", cxx_link);
+      rules[default_id][typeid (lib)].emplace ("bin.lib", lib_rule);
+      rules[update_id][typeid (lib)].emplace ("bin.lib", lib_rule);
+      rules[clean_id][typeid (lib)].emplace ("bin.lib", lib_rule);
+    }
 
     cxx::compile cxx_compile;
-    rules[default_id][typeid (obja)].emplace ("cxx.gnu.compile", cxx_compile);
-    rules[update_id][typeid (obja)].emplace ("cxx.gnu.compile", cxx_compile);
-    rules[clean_id][typeid (obja)].emplace ("cxx.gnu.compile", cxx_compile);
+    cxx::link cxx_link;
+    {
+      using namespace bin;
+
+      rules[default_id][typeid (obja)].emplace ("cxx.gnu.compile", cxx_compile);
+      rules[update_id][typeid (obja)].emplace ("cxx.gnu.compile", cxx_compile);
+      rules[clean_id][typeid (obja)].emplace ("cxx.gnu.compile", cxx_compile);
 
-    rules[default_id][typeid (objso)].emplace ("cxx.gnu.compile", cxx_compile);
-    rules[update_id][typeid (objso)].emplace ("cxx.gnu.compile", cxx_compile);
-    rules[clean_id][typeid (objso)].emplace ("cxx.gnu.compile", cxx_compile);
+      rules[default_id][typeid (objso)].emplace ("cxx.gnu.compile", cxx_compile);
+      rules[update_id][typeid (objso)].emplace ("cxx.gnu.compile", cxx_compile);
+      rules[clean_id][typeid (objso)].emplace ("cxx.gnu.compile", cxx_compile);
 
-    rules[default_id][typeid (obj)].emplace ("cxx.gnu.compile", cxx_compile);
-    rules[update_id][typeid (obj)].emplace ("cxx.gnu.compile", cxx_compile);
-    rules[clean_id][typeid (obj)].emplace ("cxx.gnu.compile", cxx_compile);
+      rules[default_id][typeid (exe)].emplace ("cxx.gnu.link", cxx_link);
+      rules[update_id][typeid (exe)].emplace ("cxx.gnu.link", cxx_link);
+      rules[clean_id][typeid (exe)].emplace ("cxx.gnu.link", cxx_link);
+
+      rules[default_id][typeid (liba)].emplace ("cxx.gnu.link", cxx_link);
+      rules[update_id][typeid (liba)].emplace ("cxx.gnu.link", cxx_link);
+      rules[clean_id][typeid (liba)].emplace ("cxx.gnu.link", cxx_link);
+
+      rules[default_id][typeid (libso)].emplace ("cxx.gnu.link", cxx_link);
+      rules[update_id][typeid (libso)].emplace ("cxx.gnu.link", cxx_link);
+      rules[clean_id][typeid (libso)].emplace ("cxx.gnu.link", cxx_link);
+    }
 
     dir_rule dir_r;
     rules[default_id][typeid (dir)].emplace ("dir", dir_r);
diff --git a/build/bin/rule b/build/bin/rule
new file mode 100644
index 0000000..007f6f7
--- /dev/null
+++ b/build/bin/rule
@@ -0,0 +1,39 @@
+// file      : build/bin/rule -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
+// license   : MIT; see accompanying LICENSE file
+
+#ifndef BUILD_BIN_RULE
+#define BUILD_BIN_RULE
+
+#include <build/rule>
+
+namespace build
+{
+  namespace bin
+  {
+    class obj_rule: public rule
+    {
+    public:
+      virtual void*
+      match (action, target&, const std::string& hint) const;
+
+      virtual recipe
+      apply (action, target&, void*) const;
+    };
+
+    class lib_rule: public rule
+    {
+    public:
+      virtual void*
+      match (action, target&, const std::string& hint) const;
+
+      virtual recipe
+      apply (action, target&, void*) const;
+
+      static target_state
+      perform (action, target&);
+    };
+  }
+}
+
+#endif // BUILD_BIN_RULE
diff --git a/build/bin/rule.cxx b/build/bin/rule.cxx
new file mode 100644
index 0000000..1b887bf
--- /dev/null
+++ b/build/bin/rule.cxx
@@ -0,0 +1,126 @@
+// file      : build/bin/rule.cxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
+// license   : MIT; see accompanying LICENSE file
+
+#include <build/bin/rule>
+
+#include <build/scope>
+#include <build/target>
+#include <build/algorithm>
+#include <build/diagnostics>
+
+#include <build/config/utility>
+
+#include <build/bin/target>
+
+using namespace std;
+
+namespace build
+{
+  namespace bin
+  {
+    // obj
+    //
+    void* obj_rule::
+    match (action a, target& t, const std::string&) const
+    {
+      fail << diag_doing (a, t) << " target group" <<
+        info << "explicitly select either obja{} or objso{} member";
+    }
+
+    recipe obj_rule::
+    apply (action, target&, void*) const {return empty_recipe;}
+
+    // lib
+    //
+    // The whole logic is pretty much as if we had our two group
+    // members as prerequisites.
+    //
+    void* lib_rule::
+    match (action, target& t, const std::string&) const
+    {
+      return &t;
+    }
+
+    recipe lib_rule::
+    apply (action a, target& xt, void*) const
+    {
+      lib& t (static_cast<lib&> (xt));
+
+      // Configure.
+      //
+      // The logic is as follows: if this library somehow knowns what
+      // it wants to be (i.e., the bin.lib is defined), then don't
+      // bother configuring the project-wide value.
+      //
+      const string* type (nullptr);
+
+      if (auto v = t["bin.lib"])
+        type = &v.as<const string&> ();
+      else
+      {
+        scope& root (*t.root_scope ());
+        type = &config::required (root, "config.bin.lib", "shared").first;
+        root.assign ("bin.lib") = *type;
+      }
+
+      bool ar (*type == "static" || *type == "both");
+      bool so (*type == "shared" || *type == "both");
+
+      if (!ar && !so)
+        fail << "unknown library type: " << *type <<
+          info << "'static', 'shared', or 'both' expected";
+
+      if (ar)
+      {
+        if (t.a == nullptr)
+          t.a = &static_cast<liba&> (search (prerequisite_key {
+                &liba::static_type, &t.dir, &t.name, &t.ext, nullptr}));
+
+        build::match (a, *t.a);
+      }
+
+      if (so)
+      {
+        if (t.so == nullptr)
+          t.so = &static_cast<libso&> (search (prerequisite_key {
+                &libso::static_type, &t.dir, &t.name, &t.ext, nullptr}));
+
+        build::match (a, *t.so);
+      }
+
+      return &perform;
+    }
+
+    target_state lib_rule::
+    perform (action a, target& xt)
+    {
+      lib& t (static_cast<lib&> (xt));
+
+      //@@ Not cool we have to do this again. Looks like we need
+      //   some kind of a cache vs resolved pointer, like in
+      //   prerequisite vs prerequisite_target.
+      //
+      //
+      const string& type (t["bin.lib"].as<const string&> ());
+      bool ar (type == "static" || type == "both");
+      bool so (type == "shared" || type == "both");
+
+      target* m1 (ar ? t.a : nullptr);
+      target* m2 (so ? t.so : nullptr);
+
+      if (current_mode == execution_mode::last)
+        swap (m1, m2);
+
+      target_state ts (target_state::unchanged);
+
+      if (m1 != nullptr && execute (a, *m1) == target_state::changed)
+        ts = target_state::changed;
+
+      if (m2 != nullptr && execute (a, *m2) == target_state::changed)
+        ts = target_state::changed;
+
+      return ts;
+    }
+  }
+}
diff --git a/build/bin/target b/build/bin/target
new file mode 100644
index 0000000..b26a890
--- /dev/null
+++ b/build/bin/target
@@ -0,0 +1,96 @@
+// file      : build/bin/target -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
+// license   : MIT; see accompanying LICENSE file
+
+#ifndef BUILD_BIN_TARGET
+#define BUILD_BIN_TARGET
+
+#include <build/target>
+
+namespace build
+{
+  namespace bin
+  {
+    // The obj{} target group.
+    //
+    class obja: public file
+    {
+    public:
+      using file::file;
+
+    public:
+      virtual const target_type& type () const {return static_type;}
+      static const target_type static_type;
+    };
+
+    class objso: public file
+    {
+    public:
+      using file::file;
+
+    public:
+      virtual const target_type& type () const {return static_type;}
+      static const target_type static_type;
+    };
+
+    class obj: public target
+    {
+    public:
+      using target::target;
+
+      obja* a {nullptr};
+      objso* so {nullptr};
+
+    public:
+      virtual const target_type& type () const {return static_type;}
+      static const target_type static_type;
+    };
+
+    class exe: public file
+    {
+    public:
+      using file::file;
+
+    public:
+      virtual const target_type& type () const {return static_type;}
+      static const target_type static_type;
+    };
+
+    // The lib{} target group.
+    //
+    class liba: public file
+    {
+    public:
+      using file::file;
+
+    public:
+      virtual const target_type& type () const {return static_type;}
+      static const target_type static_type;
+    };
+
+    class libso: public file
+    {
+    public:
+      using file::file;
+
+    public:
+      virtual const target_type& type () const {return static_type;}
+      static const target_type static_type;
+    };
+
+    class lib: public target
+    {
+    public:
+      using target::target;
+
+      liba* a {nullptr};
+      libso* so {nullptr};
+
+    public:
+      virtual const target_type& type () const {return static_type;}
+      static const target_type static_type;
+    };
+  }
+}
+
+#endif // BUILD_BIN_TARGET
diff --git a/build/bin/target.cxx b/build/bin/target.cxx
new file mode 100644
index 0000000..1849533
--- /dev/null
+++ b/build/bin/target.cxx
@@ -0,0 +1,156 @@
+// file      : build/bin/target.cxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
+// license   : MIT; see accompanying LICENSE file
+
+#include <build/bin/target>
+
+using namespace std;
+
+namespace build
+{
+  namespace bin
+  {
+    static target*
+    obja_factory (dir_path d, std::string n, const std::string* e)
+    {
+      obj* o (targets.find<obj> (d, n));
+      obja* a (new obja (std::move (d), std::move (n), e));
+
+      if ((a->group = o))
+        o->a = a;
+
+      return a;
+    }
+
+    const target_type obja::static_type
+    {
+      typeid (obja),
+      "obja",
+      &file::static_type,
+      &obja_factory,
+      file::static_type.search
+    };
+
+    static target*
+    objso_factory (dir_path d, std::string n, const std::string* e)
+    {
+      obj* o (targets.find<obj> (d, n));
+      objso* so (new objso (std::move (d), std::move (n), e));
+
+      if ((so->group = o))
+        o->so = so;
+
+      return so;
+    }
+
+    const target_type objso::static_type
+    {
+      typeid (objso),
+      "objso",
+      &file::static_type,
+      &objso_factory,
+      file::static_type.search
+    };
+
+    static target*
+    obj_factory (dir_path d, string n, const string* e)
+    {
+      obja* a (targets.find<obja> (d, n));
+      objso* so (targets.find<objso> (d, n));
+      obj* o (new obj (move (d), move (n), e));
+
+      if ((o->a = a))
+        a->group = o;
+
+      if ((o->so = so))
+        so->group = o;
+
+      return o;
+    }
+
+    const target_type obj::static_type
+    {
+      typeid (obj),
+      "obj",
+      &target::static_type,
+      &obj_factory,
+      target::static_type.search
+    };
+
+    const target_type exe::static_type
+    {
+      typeid (exe),
+      "exe",
+      &file::static_type,
+      &target_factory<exe>,
+      file::static_type.search
+    };
+
+    static target*
+    liba_factory (dir_path d, std::string n, const std::string* e)
+    {
+      lib* l (targets.find<lib> (d, n));
+      liba* a (new liba (std::move (d), std::move (n), e));
+
+      if ((a->group = l))
+        l->a = a;
+
+      return a;
+    }
+
+    const target_type liba::static_type
+    {
+      typeid (liba),
+      "liba",
+      &file::static_type,
+      &liba_factory,
+      file::static_type.search
+    };
+
+    static target*
+    libso_factory (dir_path d, std::string n, const std::string* e)
+    {
+      lib* l (targets.find<lib> (d, n));
+      libso* so (new libso (std::move (d), std::move (n), e));
+
+      if ((so->group = l))
+        l->so = so;
+
+      return so;
+    }
+
+    const target_type libso::static_type
+    {
+      typeid (libso),
+      "libso",
+      &file::static_type,
+      &libso_factory,
+      file::static_type.search
+    };
+
+    static target*
+    lib_factory (dir_path d, string n, const string* e)
+    {
+      liba* a (targets.find<liba> (d, n));
+      libso* so (targets.find<libso> (d, n));
+      lib* l (new lib (move (d), move (n), e));
+
+      if ((l->a = a))
+        a->group = l;
+
+      if ((l->so = so))
+        so->group = l;
+
+      return l;
+    }
+
+    const target_type lib::static_type
+    {
+      typeid (lib),
+      "lib",
+      &target::static_type,
+      &lib_factory,
+      target::static_type.search
+    };
+  }
+}
diff --git a/build/buildfile b/build/buildfile
index b3dfb4a..dd6fcaa 100644
--- a/build/buildfile
+++ b/build/buildfile
@@ -1,10 +1,11 @@
+config = config/{operation module utility}
+bin = bin/{target rule}
 cxx = cxx/{target rule module}
-config = config/{operation module}
 
 exe{b b-prev}: cxx{b algorithm name operation spec scope variable target \
-  prerequisite rule file module native context search diagnostics token \
-  lexer parser process timestamp path path-io utility filesystem dump \
-  options $config $cxx}
+  prerequisite rule file module context search diagnostics token lexer \
+  parser process timestamp path path-io utility filesystem dump options \
+  $config $bin $cxx}
 
 .: exe{b b-prev}
 
diff --git a/build/config/utility b/build/config/utility
new file mode 100644
index 0000000..2973516
--- /dev/null
+++ b/build/config/utility
@@ -0,0 +1,45 @@
+// file      : build/config/utility -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
+// license   : MIT; see accompanying LICENSE file
+
+#ifndef BUILD_CONFIG_UTILITY
+#define BUILD_CONFIG_UTILITY
+
+#include <string>
+#include <utility> // pair
+
+namespace build
+{
+  class scope;
+  class list_value;
+
+  namespace config
+  {
+    // Set, if necessary, a required config.* variable.
+    //
+    // Return the reference to the value as well as the indication of
+    // whether the variable has actually been set.
+    //
+    template <typename T>
+    std::pair<const T&, bool>
+    required (scope& root, const char* name, const T& default_value);
+
+    std::pair<const std::string&, bool>
+    required (scope& root, const char* name, const char* default_value);
+
+    // Set, if necessary, an optional config.* variable. In particular,
+    // an unspecified variable is set to NULL which is used to to
+    // distinguish between the "configured as unspecified" and "not
+    // yet configured" cases.
+    //
+    // Return the pointer to the value, which can be NULL.
+    //
+    template <typename T>
+    const T*
+    optional (scope& root, const char* name);
+  }
+}
+
+#include <build/config/utility.txx>
+
+#endif // BUILD_CONFIG_UTILITY
diff --git a/build/config/utility.cxx b/build/config/utility.cxx
new file mode 100644
index 0000000..8b26239
--- /dev/null
+++ b/build/config/utility.cxx
@@ -0,0 +1,41 @@
+// file      : build/config/utility.cxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
+// license   : MIT; see accompanying LICENSE file
+
+#include <build/config/utility>
+
+using namespace std;
+
+namespace build
+{
+  namespace config
+  {
+    // The same as the template except it is a bit more efficient
+    // when it comes to not creating the default value string
+    // unnecessarily.
+    //
+    pair<const string&, bool>
+    required (scope& root, const char* name, const char* def_value)
+    {
+      string r;
+      const variable& var (variable_pool.find (name));
+
+      if (auto v = root[var])
+      {
+        const string& s (v.as<const string&> ());
+
+        if (!v.belongs (*global_scope)) // A value from (some) config.build.
+          return pair<const string&, bool> (s, false);
+
+        r = s;
+      }
+      else
+        r = def_value;
+
+      auto v (root.assign (var));
+      v = move (r);
+
+      return pair<const string&, bool> (v.as<const string&> (), true);
+    }
+  }
+}
diff --git a/build/config/utility.txx b/build/config/utility.txx
new file mode 100644
index 0000000..e37c2b5
--- /dev/null
+++ b/build/config/utility.txx
@@ -0,0 +1,61 @@
+// file      : build/config/utility.txx -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
+// license   : MIT; see accompanying LICENSE file
+
+#include <utility> // move()
+
+#include <build/scope>
+#include <build/variable>
+
+namespace build
+{
+  namespace config
+  {
+    template <typename T>
+    std::pair<const T&, bool>
+    required (scope& root, const char* name, const T& def_value)
+    {
+      T r;
+      const variable& var (variable_pool.find (name));
+
+      if (auto v = root[var])
+      {
+        const T& s (v.as<const T&> ());
+
+        if (!v.belongs (*global_scope)) // A value from (some) config.build.
+          return std::pair<const T&, bool> (s, false);
+
+        r = s;
+      }
+      else
+        r = def_value;
+
+      auto v (root.assign (var));
+      v = std::move (r);
+
+      return std::pair<const T&, bool> (v.as<const T&> (), true);
+    }
+
+    template <typename T>
+    const T*
+    optional (scope& root, const char* name)
+    {
+      const T* r (nullptr);
+      const variable& var (variable_pool.find (name));
+
+      auto v (root[var]);
+
+      if (v.defined ())
+      {
+        if (v.belongs (*global_scope))
+          root.assign (var) = v;
+
+        r =  v.null () ? nullptr : &v.as<const T&> ();
+      }
+      else
+        root.assign (var) = nullptr;
+
+      return r;
+    }
+  }
+}
diff --git a/build/cxx/module.cxx b/build/cxx/module.cxx
index 3e0101f..45f8271 100644
--- a/build/cxx/module.cxx
+++ b/build/cxx/module.cxx
@@ -12,6 +12,8 @@
 #include <build/process>
 #include <build/diagnostics>
 
+#include <build/config/utility>
+
 using namespace std;
 
 namespace build
@@ -41,130 +43,68 @@ namespace build
 
       // config.cxx
       //
-      for (bool f (true); f; f = false)
       {
-        auto val (root["config.cxx"]);
-
-        string v;
+        auto r (config::required (root, "config.cxx", "g++"));
 
-        if (val)
+        // If we actually set a new value, test it by trying to execute.
+        //
+        if (r.second)
         {
-          if (!val.belongs (*global_scope))
-            break; // A value from (some) config.build.
-
-          v = val.as<const string&> ();
-        }
-        else
-          v = "g++"; // Default.
+          const string& cxx (r.first);
+          const char* args[] = {cxx.c_str (), "-dumpversion", nullptr};
 
-        // Test it by trying to execute.
-        //
-        const char* args[] = {v.c_str (), "-dumpversion", nullptr};
+          if (verb)
+            print_process (args);
+          else
+            text << "test " << cxx;
 
-        if (verb)
-          print_process (args);
-        else
-          text << "test " << v;
+          string ver;
+          try
+          {
+            process pr (args, false, false, true);
 
-        string ver;
-        try
-        {
-          process pr (args, false, false, true);
+            __gnu_cxx::stdio_filebuf<char> fb (pr.in_ofd, ios_base::in);
+            istream is (&fb);
 
-          __gnu_cxx::stdio_filebuf<char> fb (pr.in_ofd, ios_base::in);
-          istream is (&fb);
+            bool r (getline (is, ver));
 
-          bool r (getline (is, ver));
+            if (!pr.wait ())
+              throw failed ();
 
-          if (!pr.wait ())
-            throw failed ();
+            if (!r)
+              fail << "unexpected output from " << cxx;
+          }
+          catch (const process_error& e)
+          {
+            error << "unable to execute " << cxx << ": " << e.what ();
 
-          if (!r)
-            fail << "unexpected output from " << v;
-        }
-        catch (const process_error& e)
-        {
-          error << "unable to execute " << v << ": " << e.what ();
+            if (e.child ())
+              exit (1);
 
-          if (e.child ())
-            exit (1);
+            throw failed ();
+          }
 
-          throw failed ();
+          //text << "toolchain version " << ver;
         }
-
-        //text << "toolchain version " << ver;
-
-        // Set on the project root.
-        //
-        root.assign ("config.cxx") = move (v);
       }
 
       // config.cxx.{p,c,l}options
       // config.cxx.libs
       //
-      // These are optional so all we need to do is "import" them
-      // into the root scope if they were specified on the command
-      // line and set them to NULL if unspecified (the last part
-      // is important to distinguish between the "configured as
-      // unspecified" and "not configured" cases).
-      //
-      // We also merge them into the corresponding cxx.* variables.
+      // These are optional. We also merge them into the corresponding
+      // cxx.* variables.
       //
-      {
-        auto v (root["config.cxx.poptions"]);
+      if (auto* v = config::optional<list_value> (root, "config.cxx.poptions"))
+        root.append ("cxx.poptions") += *v;
 
-        if (v.defined ())
-        {
-          if (v.belongs (*global_scope))
-            root.assign ("config.cxx.poptions") = v;
+      if (auto* v = config::optional<list_value> (root, "config.cxx.coptions"))
+        root.append ("cxx.coptions") += *v;
 
-          root.append ("cxx.poptions") += v;
-        }
-        else
-          root.assign ("config.cxx.poptions") = nullptr;
-      }
+      if (auto* v = config::optional<list_value> (root, "config.cxx.loptions"))
+        root.append ("cxx.loptions") += *v;
 
-      {
-        auto v (root["config.cxx.coptions"]);
-
-        if (v.defined ())
-        {
-          if (v.belongs (*global_scope))
-            root.assign ("config.cxx.coptions") = v;
-
-          root.append ("cxx.coptions") += v;
-        }
-        else
-          root.assign ("config.cxx.coptions") = nullptr;
-      }
-
-      {
-        auto v (root["config.cxx.loptions"]);
-
-        if (v.defined ())
-        {
-          if (v.belongs (*global_scope))
-            root.assign ("config.cxx.loptions") = v;
-
-          root.append ("cxx.loptions") += v;
-        }
-        else
-          root.assign ("config.cxx.loptions") = nullptr;
-      }
-
-      {
-        auto v (root["config.cxx.libs"]);
-
-        if (v.defined ())
-        {
-          if (v.belongs (*global_scope))
-            root.assign ("config.cxx.libs") = v;
-
-          root.append ("cxx.libs") += v;
-        }
-        else
-          root.assign ("config.cxx.libs") = nullptr;
-      }
+      if (auto* v = config::optional<list_value> (root, "config.cxx.libs"))
+        root.append ("cxx.libs") += *v;
     }
   }
 }
diff --git a/build/cxx/rule b/build/cxx/rule
index 24879d4..d139cc7 100644
--- a/build/cxx/rule
+++ b/build/cxx/rule
@@ -6,9 +6,6 @@
 #define BUILD_CXX_RULE
 
 #include <build/rule>
-#include <build/native>
-
-#include <build/cxx/target>
 
 namespace build
 {
@@ -16,6 +13,8 @@ namespace build
 
   namespace cxx
   {
+    class cxx;
+
     // @@ Can't we do match(obj&) and then registration code extracts
     // that. And no virtuals?
     //
@@ -39,6 +38,8 @@ namespace build
     class link: public rule
     {
     public:
+      enum class type {exe, liba, libso};
+
       virtual void*
       match (action, target&, const std::string& hint) const;
 
diff --git a/build/cxx/rule.cxx b/build/cxx/rule.cxx
index 65616f8..9d25143 100644
--- a/build/cxx/rule.cxx
+++ b/build/cxx/rule.cxx
@@ -20,12 +20,18 @@
 #include <build/diagnostics>
 #include <build/context>
 
+#include <build/bin/target>
+
+#include <build/cxx/target>
+
 using namespace std;
 
 namespace build
 {
   namespace cxx
   {
+    using namespace bin;
+
     // T is either target or scope.
     //
     template <typename T>
@@ -73,27 +79,16 @@ namespace build
       // - if path already assigned, verify extension?
       //
 
-      if (t.is_a<obj> ())
-        fail << diag_doing (a, t) << " target group" <<
-          info << "explicitly select either obja{} or objso{} member";
-
-      // See if we have a C++ source file.
+      // See if we have a C++ source file. Iterate in reverse so that
+      // a source file specified for an obj member overrides the one
+      // specified for the group.
       //
-      for (prerequisite_target& pe: t.prerequisites)
+      for (prerequisite_target& pe: reverse_iterate (group_prerequisites (t)))
       {
         if (pe.prereq->type.id == typeid (cxx))
           return &pe;
       }
 
-      if (t.group != nullptr)
-      {
-        for (prerequisite_target& pe: t.group->prerequisites)
-        {
-          if (pe.prereq->type.id == typeid (cxx))
-            return &pe;
-        }
-      }
-
       level3 ([&]{trace << "no c++ source file for target " << t;});
       return nullptr;
     }
@@ -146,7 +141,7 @@ namespace build
       switch (a)
       {
       case perform_update_id: return &perform_update;
-      case perform_clean_id: return &perform_clean_file;
+      case perform_clean_id: return &perform_clean;
       default: return default_recipe; // Forward to prerequisites.
       }
     }
@@ -273,9 +268,13 @@ namespace build
             path f (next (l, pos));
             f.normalize ();
 
-            assert (f.absolute ()); // Logic below depends on this.
+            if (!f.absolute ())
+            {
+              level5 ([&]{trace << "skipping generated/non-existent " << f;});
+              continue;
+            }
 
-            level5 ([&]{trace << "prerequisite path: " << f;});
+            level5 ([&]{trace << "injecting " << f;});
 
             // Split the name into its directory part, the name part, and
             // extension. Here we can assume the name part is a valid
@@ -343,7 +342,7 @@ namespace build
     perform_update (action a, target& xt)
     {
       path_target& t (static_cast<path_target&> (xt));
-      cxx* s (execute_prerequisites<cxx> (a, t, t.mtime ()));
+      cxx* s (execute_find_prerequisites<cxx> (a, t, t.mtime ()));
 
       if (s == nullptr)
         return target_state::unchanged;
@@ -431,13 +430,13 @@ namespace build
       //   (i.e., a utility library).
       //
 
-      bool so (t.is_a<lib> ());
+      bool so (t.is_a<libso> ());
 
       // Scan prerequisites and see if we can work with what we've got.
       //
       bool seen_cxx (false), seen_c (false), seen_obj (false);
 
-      for (prerequisite& p: t.prerequisites)
+      for (prerequisite& p: group_prerequisites (t))
       {
         if (p.type.id == typeid (cxx)) // @@ Should use is_a (add to p.type).
         {
@@ -478,6 +477,20 @@ namespace build
       return seen_cxx || seen_c || seen_obj ? &t : nullptr;
     }
 
+    static inline target_state
+    select_a (action a, target& t)
+    {
+      obj* o (t.is_a<obj> ());
+      return execute (a, o != nullptr ? *o->a : t);
+    }
+
+    static inline target_state
+    select_so (action a, target& t)
+    {
+      obj* o (t.is_a<obj> ());
+      return execute (a, o != nullptr ? *o->so : t);
+    }
+
     recipe link::
     apply (action a, target& xt, void*) const
     {
@@ -485,16 +498,22 @@ namespace build
 
       path_target& t (static_cast<path_target&> (xt));
 
-      bool so (t.is_a<lib> ());
+      type tt (t.is_a<exe> ()
+               ? type::exe
+               : (t.is_a<liba> () ? type::liba : type::libso));
+
+      bool so (tt == type::libso);
 
       // Derive file name from target name.
       //
       if (t.path ().empty ())
       {
-        if (so)
-          t.path (t.derived_path ("so", "lib"));
-        else
-          t.path (t.derived_path ()); // exe
+        switch (tt)
+        {
+        case type::exe:   t.path (t.derived_path (           )); break;
+        case type::liba:  t.path (t.derived_path ("a",  "lib")); break;
+        case type::libso: t.path (t.derived_path ("so", "lib")); break;
+        }
       }
 
       // We may need the project roots for rule chaining (see below).
@@ -506,8 +525,9 @@ namespace build
       // Process prerequisites: do rule chaining for C and C++ source
       // files as well as search and match.
       //
-      for (prerequisite_target& pe: t.prerequisites)
+      for (prerequisite_target& pe: group_prerequisites (t))
       {
+        bool group (!pe.belongs (t)); // Target group's prerequisite.
         prerequisite& p (pe);
 
         if (!p.is_a<c> () && !p.is_a<cxx> ())
@@ -525,21 +545,37 @@ namespace build
           // If this is the obj{} target group, then pick the appropriate
           // member and make sure it is searched and matched.
           //
+          target* pt;
+
           if (obj* o = pe.target->is_a<obj> ())
           {
-            pe.target = so ? static_cast<target*> (o->so) : o->a;
+            pt = so ? static_cast<target*> (o->so) : o->a;
 
-            if (pe.target == nullptr)
+            if (pt == nullptr)
             {
               const target_type& type (
                 so ? objso::static_type : obja::static_type);
 
-              pe.target = &search (
+              pt = &search (
                 prerequisite_key {&type, &p.dir, &p.name, &p.ext, &p.scope});
             }
+
+            // This is a bit tricky: if this is a group's prerequisite,
+            // then we have to keep pe.target pointing to the obj{} group
+            // since there could be another match that uses a different
+            // member of this prerequisite. In this case we specify the
+            // "executor" (see below) which will pick the right member
+            // for one of common algorithms. However, if this is our own
+            // prerequisite, then we are free to hard-wire the member
+            // we need directly in pe.target.
+            //
+            if (!group)
+              pe.target = pt;
           }
+          else
+            pt = pe.target;
 
-          build::match (a, *pe.target);
+          build::match (a, *pt);
           continue;
         }
 
@@ -557,7 +593,9 @@ namespace build
 
         prerequisite& cp (p);
         const target_type& o_type (
-          so ? objso::static_type : obja::static_type);
+          group
+          ? obj::static_type
+          : (so ? objso::static_type : obja::static_type));
 
         // Come up with the obj*{} prerequisite. The c(xx){} prerequisite
         // directory can be relative (to the scope) or absolute. If it is
@@ -590,7 +628,7 @@ namespace build
 
         // Resolve this prerequisite to target.
         //
-        target& ot (search (op));
+        target* ot (&search (op));
 
         // If we are cleaning, check that this target is in the same or
         // a subdirectory of ours.
@@ -601,7 +639,7 @@ namespace build
         // update will come and finish the rewrite process (it will even
         // reuse op that we have created but then ignored). So all is good.
         //
-        if (a.operation () == clean_id && !ot.dir.sub (t.dir))
+        if (a.operation () == clean_id && !ot->dir.sub (t.dir))
         {
           // If we shouldn't clean obj{}, then it is fair to assume
           // we shouldn't clean cxx{} either (generated source will
@@ -612,6 +650,26 @@ namespace build
           continue;
         }
 
+        pe.target = ot;
+
+        // If we have created the obj{} target group, pick one of its
+        // members; the rest would be primarily concerned with it.
+        //
+        if (group)
+        {
+          obj& o (static_cast<obj&> (*ot));
+          ot = so ? static_cast<target*> (o.so) : o.a;
+
+          if (ot == nullptr)
+          {
+            const target_type& type (
+              so ? objso::static_type : obja::static_type);
+
+            ot = &search (
+              prerequisite_key {&type, &o.dir, &o.name, &o.ext, nullptr});
+          }
+        }
+
         // If this target already exists, then it needs to be "compatible"
         // with what we are doing here.
         //
@@ -625,7 +683,7 @@ namespace build
         // speculatively doesn't really hurt.
         //
         prerequisite* cp1 (nullptr);
-        for (prerequisite& p: ot.prerequisites)
+        for (prerequisite& p: reverse_iterate (group_prerequisites (*ot)))
         {
           // Ignore some known target types (fsdir, headers).
           //
@@ -643,19 +701,19 @@ namespace build
           }
 
           fail << "synthesized target for prerequisite " << cp
-               << " would be incompatible with existing target " << ot <<
+               << " would be incompatible with existing target " << *ot <<
             info << "unknown existing prerequsite type " << p <<
             info << "specify corresponding obj{} target explicitly";
         }
 
         if (cp1 != nullptr)
         {
-          build::match (a, ot); // Now cp1 should be resolved.
-          search (cp);          // Our own prerequisite, so this is ok.
+          build::match (a, *ot); // Now cp1 should be resolved.
+          search (cp);           // Our own prerequisite, so this is ok.
 
           if (cp.target != cp1->target)
             fail << "synthesized target for prerequisite " << cp
-                 << " would be incompatible with existing target " << ot <<
+                 << " would be incompatible with existing target " << *ot <<
               info << "existing prerequsite " << *cp1 << " does not "
                  << "match " << cp <<
               info << "specify corresponding " << o_type.name << "{} "
@@ -663,40 +721,55 @@ namespace build
         }
         else
         {
-          ot.prerequisites.emplace_back (cp);
-          build::match (a, ot);
+          // Note: add the source to the group, not member.
+          //
+          pe.target->prerequisites.emplace_back (cp);
+          build::match (a, *ot);
         }
 
         // Change the exe{} target's prerequsite ref from cxx{} to obj*{}.
         //
         pe.prereq = &op;
-        pe.target = &ot;
       }
 
       // Inject dependency on the output directory.
       //
       inject_parent_fsdir (a, t);
 
-      switch (a)
+      if (so)
       {
-      case perform_update_id: return &perform_update;
-      case perform_clean_id: return &perform_clean_file;
-      default: return default_recipe; // Forward to prerequisites.
+        switch (a)
+        {
+        case perform_update_id: return &perform_update;
+        case perform_clean_id: return &perform_clean<select_so>;
+        default: return default_action<select_so>; // Forward to prerequisites.
+        }
+      }
+      else
+      {
+        switch (a)
+        {
+        case perform_update_id: return &perform_update;
+        case perform_clean_id: return &perform_clean<select_a>;
+        default: return default_action<select_a>; // Forward to prerequisites.
+        }
       }
     }
 
     target_state link::
     perform_update (action a, target& xt)
     {
-      // @@ Q:
-      //
-      // - what are we doing with libraries?
-      //
       path_target& t (static_cast<path_target&> (xt));
 
-      bool so (t.is_a<lib> ());
+      type tt (t.is_a<exe> ()
+               ? type::exe
+               : (t.is_a<liba> () ? type::liba : type::libso));
+
+      bool so (tt == type::libso);
 
-      if (!execute_prerequisites (a, t, t.mtime ()))
+      if (so
+          ? !execute_prerequisites<select_so> (a, t, t.mtime ())
+          : !execute_prerequisites<select_a> (a, t, t.mtime ()))
         return target_state::unchanged;
 
       // Translate paths to relative (to working directory) ones. This
@@ -706,24 +779,35 @@ namespace build
       vector<path> relo;
 
       scope& rs (*t.root_scope ()); // Shouldn't have matched if nullptr.
-      const string& cxx (rs["config.cxx"].as<const string&> ());
+      vector<const char*> args;
+      string storage1;
 
-      vector<const char*> args {cxx.c_str ()};
+      if (tt == type::liba)
+      {
+        //@@ ranlib
+        //
+        args.push_back ("ar");
+        args.push_back ("-rc");
+        args.push_back (relt.string ().c_str ());
+      }
+      else
+      {
+        args.push_back (rs["config.cxx"].as<const string&> ().c_str ());
 
-      append_options (args, t, "cxx.coptions");
+        append_options (args, t, "cxx.coptions");
 
-      string std; // Storage.
-      append_std (args, t, std);
+        append_std (args, t, storage1);
 
-      if (so)
-        args.push_back ("-shared");
+        if (so)
+          args.push_back ("-shared");
 
-      args.push_back ("-o");
-      args.push_back (relt.string ().c_str ());
+        args.push_back ("-o");
+        args.push_back (relt.string ().c_str ());
 
-      append_options (args, t, "cxx.loptions");
+        append_options (args, t, "cxx.loptions");
+      }
 
-      for (target* pt: t.prerequisites)
+      for (target* pt: group_prerequisites (t))
       {
         if (pt == nullptr)
           continue; // Skipped.
@@ -743,7 +827,8 @@ namespace build
         args.push_back (relo.back ().string ().c_str ());
       }
 
-      append_options (args, t, "cxx.libs");
+      if (tt != type::liba)
+        append_options (args, t, "cxx.libs");
 
       args.push_back (nullptr);
 
diff --git a/build/file.cxx b/build/file.cxx
index 72b8d37..c130663 100644
--- a/build/file.cxx
+++ b/build/file.cxx
@@ -11,6 +11,8 @@
 #include <build/filesystem>
 #include <build/diagnostics>
 
+#include <build/config/utility>
+
 using namespace std;
 
 namespace build
@@ -257,20 +259,14 @@ namespace build
 
     // Figure out this project's out_root.
     //
-    const variable& var (variable_pool.find ("config." + n.value));
-    auto val (iroot[var]);
+    string var ("config." + n.value);
+    const dir_path& out_root (
+      config::required (iroot, var.c_str (), dir_path ()).first);
 
-    if (val)
-    {
-      if (val.belongs (*global_scope))
-        iroot.assign (var) = val; // Copy into root scope.
-    }
-    else
+    if (out_root.empty ())
       fail (l) << "unable to find out_root for imported " << n <<
         info << "consider explicitly configuring its out_root via the "
-               << var.name << " command line variable";
-
-    const dir_path& out_root (val.as<const dir_path&> ());
+               << var << " command line variable";
 
     // Bootstrap the imported root scope. This is pretty similar to
     // what we do in main() except that here we don't try to guess
diff --git a/build/native b/build/native
deleted file mode 100644
index 3c1e6f2..0000000
--- a/build/native
+++ /dev/null
@@ -1,70 +0,0 @@
-// file      : build/native -*- C++ -*-
-// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
-// license   : MIT; see accompanying LICENSE file
-
-#ifndef BUILD_NATIVE
-#define BUILD_NATIVE
-
-#include <build/target>
-
-namespace build
-{
-  // The obj{} target group members.
-  //
-  class obja: public file
-  {
-  public:
-    using file::file;
-
-  public:
-    virtual const target_type& type () const {return static_type;}
-    static const target_type static_type;
-  };
-
-  class objso: public file
-  {
-  public:
-    using file::file;
-
-  public:
-    virtual const target_type& type () const {return static_type;}
-    static const target_type static_type;
-  };
-
-  // Target group.
-  //
-  class obj: public target
-  {
-  public:
-    using target::target;
-
-    obja* a {nullptr};
-    objso* so {nullptr};
-
-  public:
-    virtual const target_type& type () const {return static_type;}
-    static const target_type static_type;
-  };
-
-  class exe: public file
-  {
-  public:
-    using file::file;
-
-  public:
-    virtual const target_type& type () const {return static_type;}
-    static const target_type static_type;
-  };
-
-  class lib: public file
-  {
-  public:
-    using file::file;
-
-  public:
-    virtual const target_type& type () const {return static_type;}
-    static const target_type static_type;
-  };
-}
-
-#endif // BUILD_NATIVE
diff --git a/build/native.cxx b/build/native.cxx
deleted file mode 100644
index 42b6cf3..0000000
--- a/build/native.cxx
+++ /dev/null
@@ -1,72 +0,0 @@
-// file      : build/native.cxx -*- C++ -*-
-// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
-// license   : MIT; see accompanying LICENSE file
-
-#include <build/native>
-
-using namespace std;
-
-namespace build
-{
-  const target_type obja::static_type
-  {
-    typeid (obja),
-    "obja",
-    &file::static_type,
-    &member_target_factory<obja, obj>,
-    file::static_type.search
-  };
-
-  const target_type objso::static_type
-  {
-    typeid (objso),
-    "objso",
-    &file::static_type,
-    &member_target_factory<objso, obj>,
-    file::static_type.search
-  };
-
-  static target*
-  obj_factory (dir_path d, string n, const string* e)
-  {
-    target* a (targets.find (obja::static_type, d, n));
-    target* so (targets.find (objso::static_type, d, n));
-
-    obj* t (new obj (move (d), move (n), e));
-
-    if ((t->a = static_cast<obja*> (a)))
-      a->group = t;
-
-    if ((t->so = static_cast<objso*> (so)))
-      so->group = t;
-
-    return t;
-  }
-
-  const target_type obj::static_type
-  {
-    typeid (obj),
-    "obj",
-    &target::static_type,
-    &obj_factory,
-    target::static_type.search
-  };
-
-  const target_type exe::static_type
-  {
-    typeid (exe),
-    "exe",
-    &file::static_type,
-    &target_factory<exe>,
-    file::static_type.search
-  };
-
-  const target_type lib::static_type
-  {
-    typeid (lib),
-    "lib",
-    &file::static_type,
-    &target_factory<lib>,
-    file::static_type.search
-  };
-}
diff --git a/build/prerequisite b/build/prerequisite
index b845f03..8a601fb 100644
--- a/build/prerequisite
+++ b/build/prerequisite
@@ -32,7 +32,7 @@ namespace build
     typedef build::scope scope_type;
 
     target_key tk;
-    mutable scope_type* scope;
+    mutable scope_type* scope; // Can be NULL if tk.dir is absolute.
   };
 
   inline bool
diff --git a/build/rule.cxx b/build/rule.cxx
index 03dd056..e912b2e 100644
--- a/build/rule.cxx
+++ b/build/rule.cxx
@@ -92,7 +92,7 @@ namespace build
 
     return a == perform_update_id
       ? &perform_update
-      : t.prerequisites.empty () ? noop_recipe : default_recipe;
+      : t.has_prerequisites () ? default_recipe : noop_recipe;
   }
 
   target_state path_rule::
@@ -211,7 +211,7 @@ namespace build
     // First update prerequisites (e.g. create parent directories)
     // then create this directory.
     //
-    if (!t.prerequisites.empty ())
+    if (t.has_prerequisites ())
       ts = execute_prerequisites (a, t);
 
     const path& d (t.dir); // Everything is in t.dir.
@@ -253,7 +253,7 @@ namespace build
 
     target_state ts (target_state::unchanged);
 
-    if (!t.prerequisites.empty ())
+    if (t.has_prerequisites ())
       ts = reverse_execute_prerequisites (a, t);
 
     // If we couldn't remove the directory, return postponed meaning
diff --git a/build/search.cxx b/build/search.cxx
index 7fa9720..b1d5ec6 100644
--- a/build/search.cxx
+++ b/build/search.cxx
@@ -100,7 +100,9 @@ namespace build
       level4 ([&]{trace << (r.second ? "new" : "existing") << " target "
                         << t << " for prerequsite " << pk;});
 
-      t.path (move (f));
+      if (t.path ().empty ())
+        t.path (move (f));
+
       t.mtime (mt);
       return &t;
     }
diff --git a/build/target b/build/target
index 49c135f..cca8f8d 100644
--- a/build/target
+++ b/build/target
@@ -14,6 +14,7 @@
 #include <ostream>
 #include <cassert>
 #include <utility>    // move()
+#include <iterator>
 
 #include <build/path>
 #include <build/map-key>       // map_iterator_adapter
@@ -69,7 +70,7 @@ namespace build
   extern const recipe default_recipe;
 
   target_state
-  noop_recipe_function (action, target&);
+  noop_action (action, target&); // Defined in <algorithm>
 
   // Prerequisite target. It consist of a reference to the prerequisite
   // plus a pointer to target to which it resolves in this context.
@@ -101,6 +102,16 @@ namespace build
 
     prerequisite_target (prerequisite& p, target_type& t)
         : prereq (&p), target (&t) {}
+
+    // Return true if this object belongs to the target's prerequisite
+    // list. Note that this test only works if you use references to
+    // the container elements and the container hasn't been resized
+    // since such a reference was obtained. Normally this function is
+    // used when iterating over combined prerequisites range (see
+    // group_prerequisites below).
+    //
+    bool
+    belongs (const target_type&) const;
   };
 
   // Target.
@@ -126,7 +137,9 @@ namespace build
                              // if any. Note that we assume that the group
                              // and all its members are in the same scope
                              // (see, for example, variable lookup).
-  public:
+                             // We also currently assume that there are
+                             // no multi-level groups.
+   public:
     // Most qualified scope that contains this target.
     //
     scope&
@@ -145,6 +158,16 @@ namespace build
     typedef std::vector<prerequisite_target> prerequisites_type;
     prerequisites_type prerequisites;
 
+    // Check if there are any prerequisites, taking into account
+    // group prerequisites.
+    //
+    bool
+    has_prerequisites () const
+    {
+      return !prerequisites.empty () ||
+        (group != nullptr && !group->prerequisites.empty ());
+    }
+
     // Target-specific variables.
     //
   public:
@@ -226,7 +249,7 @@ namespace build
       // the recipe.
       //
       recipe_function** f (recipe_.target<recipe_function*> ());
-      state = (f == nullptr || *f != &noop_recipe_function)
+      state = (f == nullptr || *f != &noop_action)
         ? target_state::unknown
         : target_state::unchanged;
 
@@ -255,6 +278,119 @@ namespace build
   std::ostream&
   operator<< (std::ostream&, const target&);
 
+  // A "range" that presents the prerequisites of a group and one of
+  // its members as one continuous sequence, or, in other words, as
+  // if they were in a single container. The group's prerequisites
+  // come first followed by the member's. If you need to see them
+  // in the other direction, iterate in reverse, for example:
+  //
+  // for (prerequisite_target& pe: group_prerequisites (t))
+  //
+  // for (prerequisite_target& pe: reverse_iterate (group_prerequisites (t))
+  //
+  // Note that in this case the individual elements of each list will
+  // also be traversed in reverse, but that's what you usually want,
+  // anyway.
+  //
+  class group_prerequisites
+  {
+  public:
+    typedef target::prerequisites_type prerequisites_type;
+
+    explicit
+    group_prerequisites (target& t): t_ (t) {}
+
+    struct iterator
+    {
+      typedef prerequisites_type::iterator base_iterator;
+
+      typedef base_iterator::value_type value_type;
+      typedef base_iterator::pointer pointer;
+      typedef base_iterator::reference reference;
+      typedef base_iterator::difference_type difference_type;
+      typedef std::bidirectional_iterator_tag iterator_category;
+
+      iterator () {}
+      iterator (target* t, prerequisites_type* c, base_iterator i)
+          : t_ (t), c_ (c), i_ (i) {}
+
+      iterator&
+      operator++ ()
+      {
+        if (++i_ == c_->end () && c_ != &t_->prerequisites)
+        {
+          c_ = &t_->prerequisites;
+          i_ = c_->begin ();
+        }
+        return *this;
+      }
+
+      iterator
+      operator++ (int) {iterator r (*this); return ++r;}
+
+      iterator&
+      operator-- ()
+      {
+        if (i_ == c_->begin () && c_ == &t_->prerequisites)
+        {
+          c_ = &t_->group->prerequisites;
+          i_ = c_->end ();
+        }
+
+        --i_;
+        return *this;
+      }
+
+      iterator
+      operator-- (int) {iterator r (*this); return --r;}
+
+      friend bool
+      operator== (const iterator& x, const iterator& y)
+      {
+        return x.t_ == y.t_ && x.c_ == y.c_ && x.i_ == y.i_;
+      }
+
+      reference operator* () const {return *i_;}
+      pointer operator-> () const {return i_.operator -> ();}
+
+      friend bool
+      operator!= (const iterator& x, const iterator& y) {return !(x == y);}
+
+    private:
+      target* t_ {nullptr};
+      prerequisites_type* c_ {nullptr};
+      prerequisites_type::iterator i_;
+    };
+
+    typedef std::reverse_iterator<iterator> reverse_iterator;
+
+    iterator
+    begin () const
+    {
+      auto& c ((t_.group != nullptr && !t_.group->prerequisites.empty ()
+                ? *t_.group : t_).prerequisites);
+      return iterator (&t_, &c, c.begin ());
+    }
+
+    iterator
+    end () const
+    {
+      auto& c (t_.prerequisites);
+      return iterator (&t_, &c, c.end ());
+    }
+
+    reverse_iterator
+    rbegin () const {return reverse_iterator (end ());}
+
+    reverse_iterator
+    rend () const {return reverse_iterator (begin ());}
+
+  private:
+    target& t_;
+  };
+
+  //
+  //
   struct target_set
   {
     typedef std::map<target_key, std::unique_ptr<target>> map;
@@ -277,14 +413,13 @@ namespace build
     // 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
+    template <typename T>
+    T*
+    find (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;
+      auto i (map_.find (target_key {&T::static_type, &dir, &name, &e}));
+      return i != map_.end () ? static_cast<T*> (i->second.get ()) : nullptr;
     }
 
     iterator begin () const {return map_.begin ();}
@@ -340,20 +475,6 @@ 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
@@ -465,4 +586,6 @@ namespace build
   };
 }
 
+#include <build/target.ixx>
+
 #endif // BUILD_TARGET
diff --git a/build/target.cxx b/build/target.cxx
index 4f06596..5e421c3 100644
--- a/build/target.cxx
+++ b/build/target.cxx
@@ -6,8 +6,7 @@
 
 #include <build/scope>
 #include <build/search>
-#include <build/context>
-#include <build/algorithm>   // execute_prerequisites()
+#include <build/algorithm>
 #include <build/diagnostics>
 
 using namespace std;
@@ -16,24 +15,9 @@ namespace build
 {
   // recipe
   //
-  target_state
-  noop_recipe_function (action, target&)
-  {
-    assert (false); // We shouldn't be called, see target::recipe().
-    return target_state::unchanged;
-  }
-
-  static target_state
-  default_recipe_function (action a, target& t)
-  {
-    return current_mode == execution_mode::first
-      ? execute_prerequisites (a, t)
-      : reverse_execute_prerequisites (a, t);
-  }
-
   const recipe empty_recipe;
-  const recipe noop_recipe (&noop_recipe_function);
-  const recipe default_recipe (&default_recipe_function);
+  const recipe noop_recipe (&noop_action);
+  const recipe default_recipe (&default_action);
 
   // target
   //
diff --git a/build/target.ixx b/build/target.ixx
new file mode 100644
index 0000000..02bdc69
--- /dev/null
+++ b/build/target.ixx
@@ -0,0 +1,13 @@
+// file      : build/target.ixx -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
+// license   : MIT; see accompanying LICENSE file
+
+namespace build
+{
+  inline bool prerequisite_target::
+  belongs (const target_type& t) const
+  {
+    const auto& p (t.prerequisites);
+    return !(p.empty () || this < &p.front () || this > &p.back ());
+  }
+}
diff --git a/build/utility b/build/utility
index 6584c0a..01ecd95 100644
--- a/build/utility
+++ b/build/utility
@@ -50,12 +50,12 @@ namespace build
   public:
     reverse_range (T& x): x_ (x) {}
 
-    auto begin () const -> decltype (this->x_.rbegin ())
+    auto begin () -> decltype (this->x_.rbegin ())
     {
       return x_.rbegin ();
     }
 
-    auto end () const -> decltype (this->x_.rend ())
+    auto end () -> decltype (this->x_.rend ())
     {
       return x_.rend ();
     }
@@ -68,6 +68,13 @@ namespace build
     return reverse_range<T> (x);
   }
 
+  template <typename T>
+  inline reverse_range<const T>
+  reverse_iterate (const T& x)
+  {
+    return reverse_range<const T> (x);
+  }
+
   // Call a function if there is an exception.
   //