Split build system into library and driver

1 files changed, 1533 insertions, 0 deletions

diff --git a/libbuild2/variable.cxx b/libbuild2/variable.cxx
new file mode 100644
index 0000000..beb169e
--- /dev/null
+++ b/libbuild2/variable.cxx
@@ -0,0 +1,1533 @@
+// file      : libbuild2/variable.cxx -*- C++ -*-
+// copyright : Copyright (c) 2014-2019 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+#include <libbuild2/variable.hxx>
+
+#include <cstring> // memcmp()
+
+#include <libbutl/filesystem.mxx> // path_match()
+
+#include <libbuild2/context.hxx>
+#include <libbuild2/diagnostics.hxx>
+
+using namespace std;
+
+namespace build2
+{
+  // variable_visibility
+  //
+  ostream&
+  operator<< (ostream& o, variable_visibility v)
+  {
+    const char* s (nullptr);
+
+    switch (v)
+    {
+    case variable_visibility::normal:  s = "normal";       break;
+    case variable_visibility::project: s = "project";      break;
+    case variable_visibility::scope:   s = "scope";        break;
+    case variable_visibility::target:  s = "target";       break;
+    case variable_visibility::prereq:  s = "prerequisite"; break;
+    }
+
+    return o << s;
+  }
+
+  // value
+  //
+  void value::
+  reset ()
+  {
+    if (type == nullptr)
+      as<names> ().~names ();
+    else if (type->dtor != nullptr)
+      type->dtor (*this);
+
+    null = true;
+  }
+
+  value::
+  value (value&& v)
+      : type (v.type), null (v.null), extra (v.extra)
+  {
+    if (!null)
+    {
+      if (type == nullptr)
+        new (&data_) names (move (v).as<names> ());
+      else if (type->copy_ctor != nullptr)
+        type->copy_ctor (*this, v, true);
+      else
+        data_ = v.data_; // Copy as POD.
+    }
+  }
+
+  value::
+  value (const value& v)
+      : type (v.type), null (v.null), extra (v.extra)
+  {
+    if (!null)
+    {
+      if (type == nullptr)
+        new (&data_) names (v.as<names> ());
+      else if (type->copy_ctor != nullptr)
+        type->copy_ctor (*this, v, false);
+      else
+        data_ = v.data_; // Copy as POD.
+    }
+  }
+
+  value& value::
+  operator= (value&& v)
+  {
+    if (this != &v)
+    {
+      // Prepare the receiving value.
+      //
+      if (type != v.type)
+      {
+        *this = nullptr;
+        type = v.type;
+      }
+
+      // Now our types are the same. If the receiving value is NULL, then call
+      // copy_ctor() instead of copy_assign().
+      //
+      if (v)
+      {
+        if (type == nullptr)
+        {
+          if (null)
+            new (&data_) names (move (v).as<names> ());
+          else
+            as<names> () = move (v).as<names> ();
+        }
+        else if (auto f = null ? type->copy_ctor : type->copy_assign)
+          f (*this, v, true);
+        else
+          data_ = v.data_; // Assign as POD.
+
+        null = v.null;
+      }
+      else
+        *this = nullptr;
+    }
+
+    return *this;
+  }
+
+  value& value::
+  operator= (const value& v)
+  {
+    if (this != &v)
+    {
+      // Prepare the receiving value.
+      //
+      if (type != v.type)
+      {
+        *this = nullptr;
+        type = v.type;
+      }
+
+      // Now our types are the same. If the receiving value is NULL, then call
+      // copy_ctor() instead of copy_assign().
+      //
+      if (v)
+      {
+        if (type == nullptr)
+        {
+          if (null)
+            new (&data_) names (v.as<names> ());
+          else
+            as<names> () = v.as<names> ();
+        }
+        else if (auto f = null ? type->copy_ctor : type->copy_assign)
+          f (*this, v, false);
+        else
+          data_ = v.data_; // Assign as POD.
+
+        null = v.null;
+      }
+      else
+        *this = nullptr;
+    }
+
+    return *this;
+  }
+
+  void value::
+  assign (names&& ns, const variable* var)
+  {
+    assert (type == nullptr || type->assign != nullptr);
+
+    if (type == nullptr)
+    {
+      if (null)
+        new (&data_) names (move (ns));
+      else
+        as<names> () = move (ns);
+    }
+    else
+      type->assign (*this, move (ns), var);
+
+    null = false;
+  }
+
+  void value::
+  append (names&& ns, const variable* var)
+  {
+    if (type == nullptr)
+    {
+      if (null)
+        new (&data_) names (move (ns));
+      else
+      {
+        names& p (as<names> ());
+
+        if (p.empty ())
+          p = move (ns);
+        else if (!ns.empty ())
+        {
+          p.insert (p.end (),
+                    make_move_iterator (ns.begin ()),
+                    make_move_iterator (ns.end ()));
+        }
+      }
+    }
+    else
+    {
+      if (type->append == nullptr)
+      {
+        diag_record dr (fail);
+
+        dr << "cannot append to " << type->name << " value";
+
+        if (var != nullptr)
+          dr << " in variable " << var->name;
+      }
+
+      type->append (*this, move (ns), var);
+    }
+
+    null = false;
+  }
+
+  void value::
+  prepend (names&& ns, const variable* var)
+  {
+    if (type == nullptr)
+    {
+      if (null)
+        new (&data_) names (move (ns));
+      else
+      {
+        names& p (as<names> ());
+
+        if (p.empty ())
+          p = move (ns);
+        else if (!ns.empty ())
+        {
+          ns.insert (ns.end (),
+                     make_move_iterator (p.begin ()),
+                     make_move_iterator (p.end ()));
+          p = move (ns);
+        }
+      }
+    }
+    else
+    {
+      if (type->prepend == nullptr)
+      {
+        diag_record dr (fail);
+
+        dr << "cannot prepend to " << type->name << " value";
+
+        if (var != nullptr)
+          dr << " in variable " << var->name;
+      }
+
+      type->prepend (*this, move (ns), var);
+    }
+
+    null = false;
+  }
+
+  bool
+  operator== (const value& x, const value& y)
+  {
+    bool xn (x.null);
+    bool yn (y.null);
+
+    assert (x.type == y.type ||
+            (xn && x.type == nullptr) ||
+            (yn && y.type == nullptr));
+
+    if (xn || yn)
+      return xn == yn;
+
+    if (x.type == nullptr)
+      return x.as<names> () == y.as<names> ();
+
+    if (x.type->compare == nullptr)
+      return memcmp (&x.data_, &y.data_, x.type->size) == 0;
+
+    return x.type->compare (x, y) == 0;
+  }
+
+  bool
+  operator< (const value& x, const value& y)
+  {
+    bool xn (x.null);
+    bool yn (y.null);
+
+    assert (x.type == y.type ||
+            (xn && x.type == nullptr) ||
+            (yn && y.type == nullptr));
+
+    // NULL value is always less than non-NULL.
+    //
+    if (xn || yn)
+      return xn > yn; // !xn < !yn
+
+    if (x.type == nullptr)
+      return x.as<names> () < y.as<names> ();
+
+    if (x.type->compare == nullptr)
+      return memcmp (&x.data_, &y.data_, x.type->size) < 0;
+
+    return x.type->compare (x, y) < 0;
+  }
+
+  bool
+  operator> (const value& x, const value& y)
+  {
+    bool xn (x.null);
+    bool yn (y.null);
+
+    assert (x.type == y.type ||
+            (xn && x.type == nullptr) ||
+            (yn && y.type == nullptr));
+
+    // NULL value is always less than non-NULL.
+    //
+    if (xn || yn)
+      return xn < yn; // !xn > !yn
+
+    if (x.type == nullptr)
+      return x.as<names> () > y.as<names> ();
+
+    if (x.type->compare == nullptr)
+      return memcmp (&x.data_, &y.data_, x.type->size) > 0;
+
+    return x.type->compare (x, y) > 0;
+  }
+
+  void
+  typify (value& v, const value_type& t, const variable* var, memory_order mo)
+  {
+    if (v.type == nullptr)
+    {
+      if (v)
+      {
+        // Note: the order in which we do things here is important.
+        //
+        names ns (move (v).as<names> ());
+        v = nullptr;
+
+        // Use value_type::assign directly to delay v.type change.
+        //
+        t.assign (v, move (ns), var);
+        v.null = false;
+      }
+      else
+        v.type = &t;
+
+      v.type.store (&t, mo);
+    }
+    else if (v.type != &t)
+    {
+      diag_record dr (fail);
+
+      dr << "type mismatch";
+
+      if (var != nullptr)
+        dr << " in variable " << var->name;
+
+      dr << info << "value type is " << v.type->name;
+      dr << info << (var != nullptr && &t == var->type ? "variable" : "new")
+         << " type is " << t.name;
+    }
+  }
+
+  void
+  typify_atomic (value& v, const value_type& t, const variable* var)
+  {
+    // Typification is kind of like caching so we reuse that mutex shard.
+    //
+    shared_mutex& m (
+      variable_cache_mutex_shard[
+        hash<value*> () (&v) % variable_cache_mutex_shard_size]);
+
+    // Note: v.type is rechecked by typify() under lock.
+    //
+    ulock l (m);
+    typify (v, t, var, memory_order_release);
+  }
+
+  void
+  untypify (value& v)
+  {
+    if (v.type == nullptr)
+      return;
+
+    if (v.null)
+    {
+      v.type = nullptr;
+      return;
+    }
+
+    names ns;
+    names_view nv (v.type->reverse (v, ns));
+
+    if (nv.empty () || nv.data () == ns.data ())
+    {
+      // If the data is in storage, then we are all set.
+      //
+      ns.resize (nv.size ()); // Just to be sure.
+    }
+    else
+    {
+      // If the data is somewhere in the value itself, then steal it.
+      //
+      auto b (const_cast<name*> (nv.data ()));
+      ns.assign (make_move_iterator (b),
+                 make_move_iterator (b + nv.size ()));
+    }
+
+    v = nullptr;                   // Free old data.
+    v.type = nullptr;              // Change type.
+    v.assign (move (ns), nullptr); // Assign new data.
+  }
+
+  // Throw invalid_argument for an invalid simple value.
+  //
+  [[noreturn]] static void
+  throw_invalid_argument (const name& n, const name* r, const char* type)
+  {
+    string m;
+    string t (type);
+
+    if (r != nullptr)
+      m = "pair in " + t + " value";
+    else
+    {
+      m = "invalid " + t + " value: ";
+
+      if (n.simple ())
+        m += "'" + n.value + "'";
+      else if (n.directory ())
+        m += "'" + n.dir.representation () + "'";
+      else
+        m += "complex name";
+    }
+
+    throw invalid_argument (m);
+  }
+
+  // names
+  //
+  const names& value_traits<names>::empty_instance = empty_names;
+
+  // bool value
+  //
+  bool value_traits<bool>::
+  convert (name&& n, name* r)
+  {
+    if (r == nullptr && n.simple ())
+    {
+      const string& s (n.value);
+
+      if (s == "true")
+        return true;
+
+      if (s == "false")
+        return false;
+
+      // Fall through.
+    }
+
+    throw_invalid_argument (n, r, "bool");
+  }
+
+  const char* const value_traits<bool>::type_name = "bool";
+
+  const value_type value_traits<bool>::value_type
+  {
+    type_name,
+    sizeof (bool),
+    nullptr,                      // No base.
+    nullptr,                      // No element.
+    nullptr,                      // No dtor (POD).
+    nullptr,                      // No copy_ctor (POD).
+    nullptr,                      // No copy_assign (POD).
+    &simple_assign<bool>,
+    &simple_append<bool>,
+    &simple_append<bool>,         // Prepend same as append.
+    &simple_reverse<bool>,
+    nullptr,              // No cast (cast data_ directly).
+    nullptr,              // No compare (compare as POD).
+    nullptr               // Never empty.
+  };
+
+  // uint64_t value
+  //
+  uint64_t value_traits<uint64_t>::
+  convert (name&& n, name* r)
+  {
+    if (r == nullptr && n.simple ())
+    {
+      try
+      {
+        // May throw invalid_argument or out_of_range.
+        //
+        return stoull (n.value);
+      }
+      catch (const std::exception&)
+      {
+        // Fall through.
+      }
+    }
+
+    throw_invalid_argument (n, r, "uint64");
+  }
+
+  const char* const value_traits<uint64_t>::type_name = "uint64";
+
+  const value_type value_traits<uint64_t>::value_type
+  {
+    type_name,
+    sizeof (uint64_t),
+    nullptr,                          // No base.
+    nullptr,                          // No element.
+    nullptr,                          // No dtor (POD).
+    nullptr,                          // No copy_ctor (POD).
+    nullptr,                          // No copy_assign (POD).
+    &simple_assign<uint64_t>,
+    &simple_append<uint64_t>,
+    &simple_append<uint64_t>,         // Prepend same as append.
+    &simple_reverse<uint64_t>,
+    nullptr,                          // No cast (cast data_ directly).
+    nullptr,                          // No compare (compare as POD).
+    nullptr                           // Never empty.
+  };
+
+  // string value
+  //
+  string value_traits<string>::
+  convert (name&& n, name* r)
+  {
+    // The goal is to reverse the name into its original representation. The
+    // code is a bit convoluted because we try to avoid extra allocations for
+    // the common cases (unqualified, unpaired simple name or directory).
+    //
+
+    // We can only convert project-qualified simple and directory names.
+    //
+    if (!(n.simple (true) || n.directory (true)) ||
+        !(r == nullptr || r->simple (true) || r->directory (true)))
+      throw_invalid_argument (n, r, "string");
+
+    string s;
+
+    if (n.directory (true))
+      // Note that here we cannot assume what's in dir is really a
+      // path (think s/foo/bar/) so we have to reverse it exactly.
+      //
+      s = move (n.dir).representation (); // Move out of path.
+    else
+      s.swap (n.value);
+
+    // Convert project qualification to its string representation.
+    //
+    if (n.qualified ())
+    {
+      string p (move (*n.proj).string ());
+      p += '%';
+      p += s;
+      p.swap (s);
+    }
+
+    // The same for the RHS of a pair, if we have one.
+    //
+    if (r != nullptr)
+    {
+      s += '@';
+
+      if (r->qualified ())
+      {
+        s += r->proj->string ();
+        s += '%';
+      }
+
+      if (r->directory (true))
+        s += move (r->dir).representation ();
+      else
+        s += r->value;
+    }
+
+    return s;
+  }
+
+  const string& value_traits<string>::empty_instance = empty_string;
+
+  const char* const value_traits<string>::type_name = "string";
+
+  const value_type value_traits<string>::value_type
+  {
+    type_name,
+    sizeof (string),
+    nullptr,                      // No base.
+    nullptr,                      // No element.
+    &default_dtor<string>,
+    &default_copy_ctor<string>,
+    &default_copy_assign<string>,
+    &simple_assign<string>,
+    &simple_append<string>,
+    &simple_prepend<string>,
+    &simple_reverse<string>,
+    nullptr,                      // No cast (cast data_ directly).
+    &simple_compare<string>,
+    &default_empty<string>
+  };
+
+  // path value
+  //
+  path value_traits<path>::
+  convert (name&& n, name* r)
+  {
+    if (r == nullptr)
+    {
+      // A directory path is a path.
+      //
+      if (n.directory ())
+        return move (n.dir);
+
+      if (n.simple ())
+      {
+        try
+        {
+          return path (move (n.value));
+        }
+        catch (invalid_path& e)
+        {
+          n.value = move (e.path); // Restore the name object for diagnostics.
+          // Fall through.
+        }
+      }
+
+      // Reassemble split dir/value.
+      //
+      if (n.untyped () && n.unqualified ())
+      {
+        try
+        {
+          return n.dir / n.value;
+        }
+        catch (const invalid_path&)
+        {
+          // Fall through.
+        }
+      }
+
+      // Fall through.
+    }
+
+    throw_invalid_argument (n, r, "path");
+  }
+
+  const path& value_traits<path>::empty_instance = empty_path;
+
+  const char* const value_traits<path>::type_name = "path";
+
+  const value_type value_traits<path>::value_type
+  {
+    type_name,
+    sizeof (path),
+    nullptr,                    // No base.
+    nullptr,                    // No element.
+    &default_dtor<path>,
+    &default_copy_ctor<path>,
+    &default_copy_assign<path>,
+    &simple_assign<path>,
+    &simple_append<path>,
+    &simple_prepend<path>,
+    &simple_reverse<path>,
+    nullptr,                    // No cast (cast data_ directly).
+    &simple_compare<path>,
+    &default_empty<path>
+  };
+
+  // dir_path value
+  //
+  dir_path value_traits<dir_path>::
+  convert (name&& n, name* r)
+  {
+    if (r == nullptr)
+    {
+      if (n.directory ())
+        return move (n.dir);
+
+      if (n.simple ())
+      {
+        try
+        {
+          return dir_path (move (n.value));
+        }
+        catch (invalid_path& e)
+        {
+          n.value = move (e.path); // Restore the name object for diagnostics.
+          // Fall through.
+        }
+      }
+
+      // Reassemble split dir/value.
+      //
+      if (n.untyped () && n.unqualified ())
+      {
+        try
+        {
+          n.dir /= n.value;
+          return move (n.dir);
+        }
+        catch (const invalid_path&)
+        {
+          // Fall through.
+        }
+      }
+
+      // Fall through.
+    }
+
+    throw_invalid_argument (n, r, "dir_path");
+  }
+
+  const dir_path& value_traits<dir_path>::empty_instance = empty_dir_path;
+
+  const char* const value_traits<dir_path>::type_name = "dir_path";
+
+  const value_type value_traits<dir_path>::value_type
+  {
+    type_name,
+    sizeof (dir_path),
+    &value_traits<path>::value_type, // Base (assuming direct cast works for
+                                     // both).
+    nullptr,                         // No element.
+    &default_dtor<dir_path>,
+    &default_copy_ctor<dir_path>,
+    &default_copy_assign<dir_path>,
+    &simple_assign<dir_path>,
+    &simple_append<dir_path>,
+    &simple_prepend<dir_path>,
+    &simple_reverse<dir_path>,
+    nullptr,                        // No cast (cast data_ directly).
+    &simple_compare<dir_path>,
+    &default_empty<dir_path>
+  };
+
+  // abs_dir_path value
+  //
+  abs_dir_path value_traits<abs_dir_path>::
+  convert (name&& n, name* r)
+  {
+    if (r == nullptr && (n.simple () || n.directory ()))
+    {
+      try
+      {
+        dir_path d (n.simple () ? dir_path (move (n.value)) : move (n.dir));
+
+        if (!d.empty ())
+        {
+          if (d.relative ())
+            d.complete ();
+
+          d.normalize (true); // Actualize.
+        }
+
+        return abs_dir_path (move (d));
+      }
+      catch (const invalid_path&) {} // Fall through.
+    }
+
+    throw_invalid_argument (n, r, "abs_dir_path");
+  }
+
+  const char* const value_traits<abs_dir_path>::type_name = "abs_dir_path";
+
+  const value_type value_traits<abs_dir_path>::value_type
+  {
+    type_name,
+    sizeof (abs_dir_path),
+    &value_traits<dir_path>::value_type, // Base (assuming direct cast works
+                                         // for both).
+    nullptr,                             // No element.
+    &default_dtor<abs_dir_path>,
+    &default_copy_ctor<abs_dir_path>,
+    &default_copy_assign<abs_dir_path>,
+    &simple_assign<abs_dir_path>,
+    &simple_append<abs_dir_path>,
+    nullptr,                             // No prepend.
+    &simple_reverse<abs_dir_path>,
+    nullptr,                             // No cast (cast data_ directly).
+    &simple_compare<abs_dir_path>,
+    &default_empty<abs_dir_path>
+  };
+
+  // name value
+  //
+  name value_traits<name>::
+  convert (name&& n, name* r)
+  {
+    if (r == nullptr)
+      return move (n);
+
+    throw_invalid_argument (n, r, "name");
+  }
+
+  static names_view
+  name_reverse (const value& v, names&)
+  {
+    const name& n (v.as<name> ());
+    return n.empty () ? names_view (nullptr, 0) : names_view (&n, 1);
+  }
+
+  const char* const value_traits<name>::type_name = "name";
+
+  const value_type value_traits<name>::value_type
+  {
+    type_name,
+    sizeof (name),
+    nullptr,                    // No base.
+    nullptr,                    // No element.
+    &default_dtor<name>,
+    &default_copy_ctor<name>,
+    &default_copy_assign<name>,
+    &simple_assign<name>,
+    nullptr,                    // Append not supported.
+    nullptr,                    // Prepend not supported.
+    &name_reverse,
+    nullptr,                    // No cast (cast data_ directly).
+    &simple_compare<name>,
+    &default_empty<name>
+  };
+
+  // name_pair
+  //
+  name_pair value_traits<name_pair>::
+  convert (name&& n, name* r)
+  {
+    n.pair = '\0'; // Keep "unpaired" in case r is empty.
+    return name_pair (move (n), r != nullptr ? move (*r) : name ());
+  }
+
+  void
+  name_pair_assign (value& v, names&& ns, const variable* var)
+  {
+    using traits = value_traits<name_pair>;
+
+    size_t n (ns.size ());
+
+    if (n <= 2)
+    {
+      try
+      {
+        traits::assign (
+          v,
+          (n == 0
+           ? name_pair ()
+           : traits::convert (move (ns[0]), n == 2 ? &ns[1] : nullptr)));
+        return;
+      }
+      catch (const invalid_argument&) {} // Fall through.
+    }
+
+    diag_record dr (fail);
+    dr << "invalid name_pair value '" << ns << "'";
+
+    if (var != nullptr)
+      dr << " in variable " << var->name;
+  }
+
+  static names_view
+  name_pair_reverse (const value& v, names& ns)
+  {
+    const name_pair& p (v.as<name_pair> ());
+    const name& f (p.first);
+    const name& s (p.second);
+
+    if (f.empty () && s.empty ())
+      return names_view (nullptr, 0);
+
+    if (f.empty ())
+      return names_view (&s, 1);
+
+    if (s.empty ())
+      return names_view (&f, 1);
+
+    ns.push_back (f);
+    ns.back ().pair = '@';
+    ns.push_back (s);
+    return ns;
+  }
+
+  const char* const value_traits<name_pair>::type_name = "name_pair";
+
+  const value_type value_traits<name_pair>::value_type
+  {
+    type_name,
+    sizeof (name_pair),
+    nullptr,                         // No base.
+    nullptr,                         // No element.
+    &default_dtor<name_pair>,
+    &default_copy_ctor<name_pair>,
+    &default_copy_assign<name_pair>,
+    &name_pair_assign,
+    nullptr,                         // Append not supported.
+    nullptr,                         // Prepend not supported.
+    &name_pair_reverse,
+    nullptr,                         // No cast (cast data_ directly).
+    &simple_compare<name_pair>,
+    &default_empty<name_pair>
+  };
+
+  // process_path value
+  //
+  process_path value_traits<process_path>::
+  convert (name&& n, name* r)
+  {
+    if (                   n.untyped () &&  n.unqualified () &&  !n.empty () &&
+        (r == nullptr || (r->untyped () && r->unqualified () && !r->empty ())))
+    {
+      path rp (move (n.dir));
+      if (rp.empty ())
+        rp = path (move (n.value));
+      else
+        rp /= n.value;
+
+      path ep;
+      if (r != nullptr)
+      {
+        ep = move (r->dir);
+        if (ep.empty ())
+          ep = path (move (r->value));
+        else
+          ep /= r->value;
+      }
+
+      process_path pp (nullptr, move (rp), move (ep));
+      pp.initial = pp.recall.string ().c_str ();
+      return pp;
+    }
+
+    throw_invalid_argument (n, r, "process_path");
+  }
+
+  void
+  process_path_assign (value& v, names&& ns, const variable* var)
+  {
+    using traits = value_traits<process_path>;
+
+    size_t n (ns.size ());
+
+    if (n <= 2)
+    {
+      try
+      {
+        traits::assign (
+          v,
+          (n == 0
+           ? process_path ()
+           : traits::convert (move (ns[0]), n == 2 ? &ns[1] : nullptr)));
+        return;
+      }
+      catch (const invalid_argument&) {} // Fall through.
+    }
+
+    diag_record dr (fail);
+    dr << "invalid process_path value '" << ns << "'";
+
+    if (var != nullptr)
+      dr << " in variable " << var->name;
+  }
+
+  void
+  process_path_copy_ctor (value& l, const value& r, bool m)
+  {
+    const auto& rhs (r.as<process_path> ());
+
+    if (m)
+      new (&l.data_) process_path (move (const_cast<process_path&> (rhs)));
+    else
+    {
+      auto& lhs (
+        *new (&l.data_) process_path (
+          nullptr, path (rhs.recall), path (rhs.effect)));
+      lhs.initial = lhs.recall.string ().c_str ();
+    }
+  }
+
+  void
+  process_path_copy_assign (value& l, const value& r, bool m)
+  {
+    auto& lhs (l.as<process_path> ());
+    const auto& rhs (r.as<process_path> ());
+
+    if (m)
+      lhs = move (const_cast<process_path&> (rhs));
+    else
+    {
+      lhs.recall = rhs.recall;
+      lhs.effect = rhs.effect;
+      lhs.initial = lhs.recall.string ().c_str ();
+    }
+  }
+
+  static names_view
+  process_path_reverse (const value& v, names& s)
+  {
+    const process_path& x (v.as<process_path> ());
+
+    if (!x.empty ())
+    {
+      s.reserve (x.effect.empty () ? 1 : 2);
+
+      s.push_back (name (x.recall.directory (),
+                         string (),
+                         x.recall.leaf ().string ()));
+
+      if (!x.effect.empty ())
+      {
+        s.back ().pair = '@';
+        s.push_back (name (x.effect.directory (),
+                           string (),
+                           x.effect.leaf ().string ()));
+      }
+    }
+
+    return s;
+  }
+
+  const char* const value_traits<process_path>::type_name = "process_path";
+
+  const value_type value_traits<process_path>::value_type
+  {
+    type_name,
+    sizeof (process_path),
+    nullptr,                         // No base.
+    nullptr,                         // No element.
+    &default_dtor<process_path>,
+    &process_path_copy_ctor,
+    &process_path_copy_assign,
+    &process_path_assign,
+    nullptr,                         // Append not supported.
+    nullptr,                         // Prepend not supported.
+    &process_path_reverse,
+    nullptr,                         // No cast (cast data_ directly).
+    &simple_compare<process_path>,
+    &default_empty<process_path>
+  };
+
+  // target_triplet value
+  //
+  target_triplet value_traits<target_triplet>::
+  convert (name&& n, name* r)
+  {
+    if (r == nullptr)
+    {
+      if (n.simple ())
+      {
+        try
+        {
+          return n.empty () ? target_triplet () : target_triplet (n.value);
+        }
+        catch (const invalid_argument& e)
+        {
+          throw invalid_argument (
+            string ("invalid target_triplet value: ") + e.what ());
+        }
+      }
+
+      // Fall through.
+    }
+
+    throw_invalid_argument (n, r, "target_triplet");
+  }
+
+  const char* const value_traits<target_triplet>::type_name = "target_triplet";
+
+  const value_type value_traits<target_triplet>::value_type
+  {
+    type_name,
+    sizeof (target_triplet),
+    nullptr,                         // No base.
+    nullptr,                         // No element.
+    &default_dtor<target_triplet>,
+    &default_copy_ctor<target_triplet>,
+    &default_copy_assign<target_triplet>,
+    &simple_assign<target_triplet>,
+    nullptr,                         // Append not supported.
+    nullptr,                         // Prepend not supported.
+    &simple_reverse<target_triplet>,
+    nullptr,                         // No cast (cast data_ directly).
+    &simple_compare<target_triplet>,
+    &default_empty<target_triplet>
+  };
+
+  // project_name value
+  //
+  project_name value_traits<project_name>::
+  convert (name&& n, name* r)
+  {
+    if (r == nullptr)
+    {
+      if (n.simple ())
+      {
+        try
+        {
+          return n.empty () ? project_name () : project_name (move (n.value));
+        }
+        catch (const invalid_argument& e)
+        {
+          throw invalid_argument (
+            string ("invalid project_name value: ") + e.what ());
+        }
+      }
+
+      // Fall through.
+    }
+
+    throw_invalid_argument (n, r, "project_name");
+  }
+
+  const project_name&
+  value_traits<project_name>::empty_instance = empty_project_name;
+
+  const char* const value_traits<project_name>::type_name = "project_name";
+
+  const value_type value_traits<project_name>::value_type
+  {
+    type_name,
+    sizeof (project_name),
+    nullptr,                         // No base.
+    nullptr,                         // No element.
+    &default_dtor<project_name>,
+    &default_copy_ctor<project_name>,
+    &default_copy_assign<project_name>,
+    &simple_assign<project_name>,
+    nullptr,                         // Append not supported.
+    nullptr,                         // Prepend not supported.
+    &simple_reverse<project_name>,
+    nullptr,                         // No cast (cast data_ directly).
+    &simple_compare<project_name>,
+    &default_empty<project_name>
+  };
+
+  // variable_pool
+  //
+  void variable_pool::
+  update (variable& var,
+          const build2::value_type* t,
+          const variable_visibility* v,
+          const bool* o) const
+  {
+    // Check overridability (all overrides, if any, should already have
+    // been entered (see context.cxx:reset()).
+    //
+    if (var.overrides != nullptr && (o == nullptr || !*o))
+      fail << "variable " << var.name << " cannot be overridden";
+
+    bool ut (t != nullptr && var.type != t);
+    bool uv (v != nullptr && var.visibility != *v);
+
+    // Variable should not be updated post-aliasing.
+    //
+    assert (var.aliases == &var || (!ut && !uv));
+
+    // Update type?
+    //
+    if (ut)
+    {
+      assert (var.type == nullptr);
+      var.type = t;
+    }
+
+    // Change visibility? While this might at first seem like a bad idea,
+    // it can happen that the variable lookup happens before any values
+    // were set, in which case the variable will be entered with the
+    // default visibility.
+    //
+    if (uv)
+    {
+      assert (var.visibility == variable_visibility::normal); // Default.
+      var.visibility = *v;
+    }
+  }
+
+  static bool
+  match_pattern (const string& n, const string& p, const string& s, bool multi)
+  {
+    size_t nn (n.size ()), pn (p.size ()), sn (s.size ());
+
+    if (nn < pn + sn + 1)
+      return false;
+
+    if (pn != 0)
+    {
+      if (n.compare (0, pn, p) != 0)
+        return false;
+    }
+
+    if (sn != 0)
+    {
+      if (n.compare (nn - sn, sn, s) != 0)
+        return false;
+    }
+
+    // Make sure the stem is a single name unless instructed otherwise.
+    //
+    return multi || string::traits_type::find (n.c_str () + pn,
+                                               nn - pn - sn,
+                                               '.') == nullptr;
+  }
+
+  static inline void
+  merge_pattern (const variable_pool::pattern& p,
+                 const build2::value_type*& t,
+                 const variable_visibility*& v,
+                 const bool*& o)
+  {
+    if (p.type)
+    {
+      if (t == nullptr)
+        t = *p.type;
+      else if (p.match)
+        assert (t == *p.type);
+    }
+
+    if (p.visibility)
+    {
+      if (v == nullptr)
+        v = &*p.visibility;
+      else if (p.match)
+        assert (*v == *p.visibility);
+    }
+
+    if (p.overridable)
+    {
+      if (o == nullptr)
+        o = &*p.overridable;
+      else if (p.match)
+      {
+        // Allow the pattern to restrict but not relax.
+        //
+        if (*o)
+          o = &*p.overridable;
+        else
+          assert (*o == *p.overridable);
+      }
+    }
+  }
+
+  variable& variable_pool::
+  insert (string n,
+          const build2::value_type* t,
+          const variable_visibility* v,
+          const bool* o,
+          bool pat)
+  {
+    assert (!global_ || phase == run_phase::load);
+
+    // Apply pattern.
+    //
+    if (pat)
+    {
+      if (n.find ('.') != string::npos)
+      {
+        // Reverse means from the "largest" (most specific).
+        //
+        for (const pattern& p: reverse_iterate (patterns_))
+        {
+          if (match_pattern (n, p.prefix, p.suffix, p.multi))
+          {
+            merge_pattern (p, t, v, o);
+            break;
+          }
+        }
+      }
+    }
+
+    auto p (
+      insert (
+        variable {
+          move (n),
+          nullptr,
+          t,
+          nullptr,
+          v != nullptr ? *v : variable_visibility::normal}));
+
+    variable& r (p.first->second);
+
+    if (p.second)
+      r.aliases = &r;
+    else // Note: overridden variable will always exist.
+    {
+      if (t != nullptr || v != nullptr || o != nullptr)
+        update (r, t, v, o); // Not changing the key.
+      else if (r.overrides != nullptr)
+        fail << "variable " << r.name << " cannot be overridden";
+    }
+
+    return r;
+  }
+
+  const variable& variable_pool::
+  insert_alias (const variable& var, string n)
+  {
+    assert (var.aliases != nullptr && var.overrides == nullptr);
+
+    variable& a (insert (move (n),
+                         var.type,
+                         &var.visibility,
+                         nullptr /* override */,
+                         false   /* pattern  */));
+
+    if (a.aliases == &a) // Not aliased yet.
+    {
+      a.aliases = var.aliases;
+      const_cast<variable&> (var).aliases = &a;
+    }
+    else
+      assert (a.alias (var)); // Make sure it is already an alias of var.
+
+    return a;
+  }
+
+  void variable_pool::
+  insert_pattern (const string& p,
+                  optional<const value_type*> t,
+                  optional<bool> o,
+                  optional<variable_visibility> v,
+                  bool retro,
+                  bool match)
+  {
+    assert (!global_ || phase == run_phase::load);
+
+    size_t pn (p.size ());
+
+    size_t w (p.find ('*'));
+    assert (w != string::npos);
+
+    bool multi (w + 1 != pn && p[w + 1] == '*');
+
+    // Extract prefix and suffix.
+    //
+    string pfx, sfx;
+
+    if (w != 0)
+    {
+      assert (p[w - 1] == '.' && w != 1);
+      pfx.assign (p, 0, w);
+    }
+
+    w += multi ? 2 : 1; // First suffix character.
+    size_t sn (pn - w); // Suffix length.
+
+    if (sn != 0)
+    {
+      assert (p[w] == '.' && sn != 1);
+      sfx.assign (p, w, sn);
+    }
+
+    auto i (
+      patterns_.insert (
+        pattern {move (pfx), move (sfx), multi, match, t, v, o}));
+
+    // Apply retrospectively to existing variables.
+    //
+    if (retro)
+    {
+      for (auto& p: map_)
+      {
+        variable& var (p.second);
+
+        if (match_pattern (var.name, i->prefix, i->suffix, i->multi))
+        {
+          // Make sure that none of the existing more specific patterns
+          // match.
+          //
+          auto j (i), e (patterns_.end ());
+          for (++j; j != e; ++j)
+          {
+            if (match_pattern (var.name, j->prefix, j->suffix, j->multi))
+              break;
+          }
+
+          if (j == e)
+            update (var,
+                    t ?  *t : nullptr,
+                    v ? &*v : nullptr,
+                    o ? &*o : nullptr); // Not changing the key.
+        }
+      }
+    }
+  }
+
+  variable_pool variable_pool::instance (true);
+  const variable_pool& variable_pool::cinstance = variable_pool::instance;
+  const variable_pool& var_pool = variable_pool::cinstance;
+
+  // variable_map
+  //
+  auto variable_map::
+  find (const variable& var, bool typed) const ->
+    pair<const value_data*, const variable&>
+  {
+    const variable* v (&var);
+    const value_data* r (nullptr);
+    do
+    {
+      // @@ Should we verify that there are no distinct values for aliases?
+      //    This can happen if the values were entered before the variables
+      //    were aliased. Possible but probably highly unlikely.
+      //
+      auto i (m_.find (*v));
+      if (i != m_.end ())
+      {
+        r = &i->second;
+        break;
+      }
+
+      v = v->aliases;
+
+    } while (v != &var && v != nullptr);
+
+    // Check if this is the first access after being assigned a type.
+    //
+    if (r != nullptr && typed && v->type != nullptr)
+      typify (*r, *v);
+
+    return pair<const value_data*, const variable&> (
+      r, r != nullptr ? *v : var);
+  }
+
+  auto variable_map::
+  find_to_modify (const variable& var, bool typed) ->
+    pair<value_data*, const variable&>
+  {
+    auto p (find (var, typed));
+    auto* r (const_cast<value_data*> (p.first));
+
+    if (r != nullptr)
+      r->version++;
+
+    return pair<value_data*, const variable&> (r, p.second);
+  }
+
+  pair<reference_wrapper<value>, bool> variable_map::
+  insert (const variable& var, bool typed)
+  {
+    assert (!global_ || phase == run_phase::load);
+
+    auto p (m_.emplace (var, value_data (typed ? var.type : nullptr)));
+    value_data& r (p.first->second);
+
+    if (!p.second)
+    {
+      // Check if this is the first access after being assigned a type.
+      //
+      // Note: we still need atomic in case this is not a global state.
+      //
+      if (typed && var.type != nullptr)
+        typify (r, var);
+    }
+
+    r.version++;
+
+    return make_pair (reference_wrapper<value> (r), p.second);
+  }
+
+  // variable_type_map
+  //
+  lookup variable_type_map::
+  find (const target_type& type,
+        const string& name,
+        const variable& var) const
+  {
+    // Search across target type hierarchy.
+    //
+    for (auto tt (&type); tt != nullptr; tt = tt->base)
+    {
+      auto i (map_.find (*tt));
+
+      if (i == end ())
+        continue;
+
+      // Try to match the pattern, starting from the longest values
+      // so that the more "specific" patterns (i.e., those that cover
+      // fewer characters with the wildcard) take precedence. See
+      // tests/variable/type-pattern.
+      //
+      const variable_pattern_map& m (i->second);
+
+      for (auto j (m.rbegin ()); j != m.rend (); ++j)
+      {
+        const string& pat (j->first);
+
+        //@@ TODO: should we detect ambiguity? 'foo-*' '*-foo' and 'foo-foo'?
+        //   Right now the last defined will be used.
+        //
+        if (pat != "*")
+        {
+          if (name.size () < pat.size () - 1 || // One for '*' or '?'.
+              !butl::path_match (pat, name))
+            continue;
+        }
+
+        // Ok, this pattern matches. But is there a variable?
+        //
+        // Since we store append/prepend values untyped, instruct find() not
+        // to automatically type it. And if it is assignment, then typify it
+        // ourselves.
+        //
+        const variable_map& vm (j->second);
+        {
+          auto p (vm.find (var, false));
+          if (const variable_map::value_data* v = p.first)
+          {
+            // Check if this is the first access after being assigned a type.
+            //
+            if (v->extra == 0 && var.type != nullptr)
+              vm.typify (*v, var);
+
+            return lookup (*v, p.second, vm);
+          }
+        }
+      }
+    }
+
+    return lookup ();
+  }
+
+  size_t variable_cache_mutex_shard_size;
+  unique_ptr<shared_mutex[]> variable_cache_mutex_shard;
+
+  template struct LIBBUILD2_DEFEXPORT value_traits<strings>;
+  template struct LIBBUILD2_DEFEXPORT value_traits<vector<name>>;
+  template struct LIBBUILD2_DEFEXPORT value_traits<paths>;
+  template struct LIBBUILD2_DEFEXPORT value_traits<dir_paths>;
+  template struct LIBBUILD2_DEFEXPORT value_traits<uint64s>;
+
+  template struct LIBBUILD2_DEFEXPORT value_traits<std::map<string, string>>;
+
+  template struct LIBBUILD2_DEFEXPORT
+  value_traits<std::map<project_name, dir_path>>;
+}