Add support for specifying library link order

5 files changed, 149 insertions, 33 deletions

diff --git a/build/cxx/rule b/build/cxx/rule
index d139cc7..da46eb6 100644
--- a/build/cxx/rule
+++ b/build/cxx/rule
@@ -38,8 +38,6 @@ namespace build
     class link: public rule
     {
     public:
-      enum class type {exe, liba, libso};
-
       virtual void*
       match (action, target&, const std::string& hint) const;
 
@@ -48,6 +46,16 @@ namespace build
 
       static target_state
       perform_update (action, target&);
+
+    private:
+      enum class type {e, a, so};
+      enum class order {a, so, a_so, so_a};
+
+      static type
+      link_type (target&);
+
+      static order
+      link_order (target&);
     };
   }
 }
diff --git a/build/cxx/rule.cxx b/build/cxx/rule.cxx
index 2d64701..ec2a0b9 100644
--- a/build/cxx/rule.cxx
+++ b/build/cxx/rule.cxx
@@ -14,6 +14,7 @@
 #include <ext/stdio_filebuf.h>
 
 #include <build/scope>
+#include <build/variable>
 #include <build/algorithm>
 #include <build/process>
 #include <build/timestamp>
@@ -24,6 +25,8 @@
 
 #include <build/cxx/target>
 
+#include <build/config/utility>
+
 using namespace std;
 
 namespace build
@@ -420,6 +423,67 @@ namespace build
 
     // link
     //
+    inline link::type link::
+    link_type (target& t)
+    {
+      return t.is_a<exe> () ? type::e : (t.is_a<liba> () ? type::a : type::so);
+    }
+
+    static const list_value default_exe_order (names {name ("shared"),
+                                                      name ("static")});
+    static const list_value default_liba_order ("static");
+    static const list_value default_libso_order ("shared");
+
+    link::order link::
+    link_order (target& t)
+    {
+      const char* var;
+      const char* cvar;
+      const list_value* plv;
+
+      //@@ This should be in the bin module, not cxx! @@ remove config include.
+      //   Maybe this should be triggered via the variable access? The same
+      //   for bin.lib? After all, it can be queried in the buildfile.
+      //
+      switch (link_type (t))
+      {
+      case type::e:
+        var = "bin.exe.lib";
+        cvar = "config.bin.exe.lib";
+        plv = &default_exe_order;
+        break;
+      case type::a:
+        var = "bin.liba.lib";
+        cvar = "config.bin.liba.lib";
+        plv = &default_liba_order;
+        break;
+      case type::so:
+        var = "bin.libso.lib";
+        cvar = "config.bin.libso.lib";
+        plv = &default_libso_order;
+        break;
+      }
+
+      if (auto tv = t[var])
+        plv = &tv.as<const list_value&> ();
+      else
+      {
+        scope& root (*t.root_scope ());
+        auto rv (root.vars.assign (var));
+        rv = config::required (root, cvar, *plv).first;
+        plv = &rv.as<const list_value&> ();
+      }
+
+      //@@ Need to validate the value. Would be more efficient
+      //   to do it once on assignment than every time on query.
+      //   Custom var type?
+      //
+      const list_value& lv (*plv);
+      return lv[0].value == "shared"
+        ? lv.size () > 1 && lv[1].value == "static" ? order::so_a : order::so
+        : lv.size () > 1 && lv[1].value == "shared" ? order::a_so : order::a;
+    }
+
     void* link::
     match (action a, target& t, const string& hint) const
     {
@@ -499,31 +563,19 @@ namespace build
 
       path_target& t (static_cast<path_target&> (xt));
 
-      type tt (t.is_a<exe> ()
-               ? type::exe
-               : (t.is_a<liba> () ? type::liba : type::libso));
-
-      bool so (tt == type::libso); // Obj-so.
-
-      // Decide which lib{} member to use for this target.
-      //
-      bool lso; // Lib-so.
-      switch (tt)
-      {
-      case type::exe:   lso = true; break;
-      case type::liba:  lso = false;  break;
-      case type::libso: lso = true; break;
-      }
+      type lt (link_type (t));
+      bool so (lt == type::so);
+      optional<order> lo; // Link-order.
 
       // Derive file name from target name.
       //
       if (t.path ().empty ())
       {
-        switch (tt)
+        switch (lt)
         {
-        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;
+        case type::e:  t.path (t.derived_path (           )); break;
+        case type::a:  t.path (t.derived_path ("a",  "lib")); break;
+        case type::so: t.path (t.derived_path ("so", "lib")); break;
         }
       }
 
@@ -577,13 +629,32 @@ namespace build
           }
           else if (lib* l = pt->is_a<lib> ())
           {
-            // Make sure the library build that we need is available.
+            // Determine the library type to link.
             //
+            bool lso (true);
             const string& at ((*l)["bin.lib"].as<const string&> ());
 
-            if (lso ? at == "static" : at == "shared")
-              fail << (lso ? "shared" : "static") << " build of " << *l
-                   << " is not available";
+            if (!lo)
+              lo = link_order (t);
+
+            switch (*lo)
+            {
+            case order::a:
+            case order::a_so:
+              lso = false; // Fall through.
+            case order::so:
+            case order::so_a:
+              {
+                if (lso ? at == "static" : at == "shared")
+                {
+                  if (*lo == order::a_so || *lo == order::so_a)
+                    lso = !lso;
+                  else
+                    fail << (lso ? "shared" : "static") << " build of " << *l
+                         << " is not available";
+                }
+              }
+            }
 
             pt = lso ? static_cast<target*> (l->so) : l->a;
 
@@ -769,11 +840,8 @@ namespace build
     {
       path_target& t (static_cast<path_target&> (xt));
 
-      type tt (t.is_a<exe> ()
-               ? type::exe
-               : (t.is_a<liba> () ? type::liba : type::libso));
-
-      bool so (tt == type::libso);
+      type lt (link_type (t));
+      bool so (lt == type::so);
 
       if (!execute_prerequisites (a, t, t.mtime ()))
         return target_state::unchanged;
@@ -788,7 +856,7 @@ namespace build
       vector<const char*> args;
       string storage1;
 
-      if (tt == type::liba)
+      if (lt == type::a)
       {
         //@@ ranlib
         //
@@ -832,7 +900,7 @@ namespace build
         args.push_back (relo.back ().string ().c_str ());
       }
 
-      if (tt != type::liba)
+      if (lt != type::a)
         append_options (args, t, "cxx.libs");
 
       args.push_back (nullptr);
diff --git a/build/utility b/build/utility
index 01ecd95..064a95f 100644
--- a/build/utility
+++ b/build/utility
@@ -38,6 +38,35 @@ namespace build
     bool operator() (const P& x, const P& y) const {return *x < *y;}
   };
 
+  // Simple optional class template while waiting for std::optional.
+  //
+  template <typename T>
+  class optional
+  {
+  public:
+    typedef T value_type;
+
+    optional (): null_ (true) {}
+    optional (const T& v): value_ (v), null_ (false) {}
+    optional& operator= (const T& v) {value_ = v; null_ = false; return *this;}
+
+    T&       value () {return value_;}
+    const T& value () const {return value_;}
+
+    T*       operator-> () {return &value_;}
+    const T* operator-> () const {return &value_;}
+
+    T&       operator* () {return value_;}
+    const T& operator* () const {return value_;}
+
+    explicit operator bool () const {return !null_;}
+
+  private:
+    T value_;
+    bool null_;
+  };
+
+
   // Support for reverse iteration using range-based for-loop:
   //
   // for (... : reverse_iterate (x)) ...
diff --git a/build/variable b/build/variable
index 05ca671..59db060 100644
--- a/build/variable
+++ b/build/variable
@@ -67,6 +67,7 @@ namespace build
   struct list_value: value, names
   {
   public:
+    list_value () = default;
     list_value (names d): names (std::move (d)) {}
     list_value (std::string d) {emplace_back (std::move (d));}
     list_value (dir_path d) {emplace_back (std::move (d));}
@@ -115,6 +116,9 @@ namespace build
     operator= (const value_proxy&) const;
 
     const value_proxy&
+    operator= (list_value) const;
+
+    const value_proxy&
     operator= (std::string) const;
 
     const value_proxy&
diff --git a/build/variable.ixx b/build/variable.ixx
index 52272cc..54d7104 100644
--- a/build/variable.ixx
+++ b/build/variable.ixx
@@ -26,6 +26,13 @@ namespace build
   }
 
   inline const value_proxy& value_proxy::
+  operator= (list_value v) const
+  {
+    p->reset (new list_value (std::move (v)));
+    return *this;
+  }
+
+  inline const value_proxy& value_proxy::
   operator= (std::string v) const
   {
     // In most cases this is used to initialize a new variable, so
@@ -70,7 +77,7 @@ namespace build
   operator+= (const list_value& v) const
   {
     if (*p == nullptr)
-      *this = value_ptr (new list_value (v));
+      *this = v;
     else
     {
       list_value& lv (as<list_value&> ());