From 977d07a3ae47ef204665d1eda2d642e5064724f3 Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Mon, 24 Jun 2019 12:01:19 +0200
Subject: Split build system into library and driver

---
 libbuild2/variable.txx | 670 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 670 insertions(+)
 create mode 100644 libbuild2/variable.txx

(limited to 'libbuild2/variable.txx')

diff --git a/libbuild2/variable.txx b/libbuild2/variable.txx
new file mode 100644
index 0000000..9b7490a
--- /dev/null
+++ b/libbuild2/variable.txx
@@ -0,0 +1,670 @@
+// file      : libbuild2/variable.txx -*- C++ -*-
+// copyright : Copyright (c) 2014-2019 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+#include <libbuild2/diagnostics.hxx>
+
+namespace build2
+{
+  template <typename T>
+  bool lookup::
+  belongs (const T& x, bool t) const
+  {
+    if (vars == &x.vars)
+      return true;
+
+    if (t)
+    {
+      for (const auto& p1: x.target_vars) // variable_type_map
+      {
+        for (const auto& p2: p1.second) // variable_pattern_map
+        {
+          if (vars == &p2.second)
+            return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  // This one will be SFINAE'd out unless T is a simple value.
+  //
+  template <typename T>
+  auto
+  convert (names&& ns) ->
+    decltype (value_traits<T>::convert (move (ns[0]), nullptr))
+  {
+    size_t n (ns.size ());
+
+    if (n == 0)
+    {
+      if (value_traits<T>::empty_value)
+        return T ();
+    }
+    else if (n == 1)
+    {
+      return convert<T> (move (ns[0]));
+    }
+    else if (n == 2 && ns[0].pair != '\0')
+    {
+      return convert<T> (move (ns[0]), move (ns[1]));
+    }
+
+    throw invalid_argument (
+      string ("invalid ") + value_traits<T>::type_name +
+      (n == 0 ? " value: empty" : " value: multiple names"));
+  }
+
+  template <typename T>
+  T
+  convert (value&& v)
+  {
+    if (v.type == nullptr)
+      return convert<T> (move (v).as<names> ());
+    else if (v.type == &value_traits<T>::value_type)
+      return move (v).as<T> ();
+
+    throw invalid_argument (
+      string ("invalid ") + value_traits<T>::value_type.name +
+      " value: conversion from " + v.type->name);
+  }
+
+  template <typename T>
+  void
+  default_dtor (value& v)
+  {
+    v.as<T> ().~T ();
+  }
+
+  template <typename T>
+  void
+  default_copy_ctor (value& l, const value& r, bool m)
+  {
+    if (m)
+      new (&l.data_) T (move (const_cast<value&> (r).as<T> ()));
+    else
+      new (&l.data_) T (r.as<T> ());
+  }
+
+  template <typename T>
+  void
+  default_copy_assign (value& l, const value& r, bool m)
+  {
+    if (m)
+      l.as<T> () = move (const_cast<value&> (r).as<T> ());
+    else
+      l.as<T> () = r.as<T> ();
+  }
+
+  template <typename T>
+  bool
+  default_empty (const value& v)
+  {
+    return value_traits<T>::empty (v.as<T> ());
+  }
+
+  template <typename T>
+  void
+  simple_assign (value& v, names&& ns, const variable* var)
+  {
+    size_t n (ns.size ());
+
+    if (value_traits<T>::empty_value ? n <= 1 : n == 1)
+    {
+      try
+      {
+        value_traits<T>::assign (
+          v,
+          (n == 0
+           ? T ()
+           : value_traits<T>::convert (move (ns.front ()), nullptr)));
+
+        return;
+      }
+      catch (const invalid_argument&) {} // Fall through.
+    }
+
+    diag_record dr (fail);
+
+    dr << "invalid " << value_traits<T>::value_type.name
+       << " value '" << ns << "'";
+
+    if (var != nullptr)
+      dr << " in variable " << var->name;
+  }
+
+  template <typename T>
+  void
+  simple_append (value& v, names&& ns, const variable* var)
+  {
+    size_t n (ns.size ());
+
+    if (value_traits<T>::empty_value ? n <= 1 : n == 1)
+    {
+      try
+      {
+        value_traits<T>::append (
+          v,
+          (n == 0
+           ? T ()
+           : value_traits<T>::convert (move (ns.front ()), nullptr)));
+
+        return;
+      }
+      catch (const invalid_argument&) {} // Fall through.
+    }
+
+    diag_record dr (fail);
+
+    dr << "invalid " << value_traits<T>::value_type.name
+       << " value '" << ns << "'";
+
+    if (var != nullptr)
+      dr << " in variable " << var->name;
+  }
+
+  template <typename T>
+  void
+  simple_prepend (value& v, names&& ns, const variable* var)
+  {
+    size_t n (ns.size ());
+
+    if (value_traits<T>::empty_value ? n <= 1 : n == 1)
+    {
+      try
+      {
+        value_traits<T>::prepend (
+          v,
+          (n == 0
+           ? T ()
+           : value_traits<T>::convert (move (ns.front ()), nullptr)));
+
+        return;
+      }
+      catch (const invalid_argument&) {} // Fall through.
+    }
+
+    diag_record dr (fail);
+
+    dr << "invalid " << value_traits<T>::value_type.name
+       << " value '" << ns << "'";
+
+    if (var != nullptr)
+      dr << " in variable " << var->name;
+  }
+
+  template <typename T>
+  names_view
+  simple_reverse (const value& v, names& s)
+  {
+    const T& x (v.as<T> ());
+
+    // Represent an empty simple value as empty name sequence rather than
+    // a single empty name. This way, for example, during serialization we
+    // end up with a much saner looking:
+    //
+    // config.import.foo =
+    //
+    // Rather than:
+    //
+    // config.import.foo = {}
+    //
+    if (!value_traits<T>::empty (x))
+      s.emplace_back (value_traits<T>::reverse (x));
+
+    return s;
+  }
+
+  template <typename T>
+  int
+  simple_compare (const value& l, const value& r)
+  {
+    return value_traits<T>::compare (l.as<T> (), r.as<T> ());
+  }
+
+  // vector<T> value
+  //
+
+  template <typename T>
+  vector<T> value_traits<vector<T>>::
+  convert (names&& ns)
+  {
+    vector<T> v;
+
+    // Similar to vector_append() below except we throw instead of issuing
+    // diagnostics.
+    //
+    for (auto i (ns.begin ()); i != ns.end (); ++i)
+    {
+      name& n (*i);
+      name* r (nullptr);
+
+      if (n.pair)
+      {
+        r = &*++i;
+
+        if (n.pair != '@')
+          throw invalid_argument (
+            string ("invalid pair character: '") + n.pair + "'");
+      }
+
+      v.push_back (value_traits<T>::convert (move (n), r));
+    }
+
+    return v;
+  }
+
+  template <typename T>
+  void
+  vector_append (value& v, names&& ns, const variable* var)
+  {
+    vector<T>& p (v
+                  ? v.as<vector<T>> ()
+                  : *new (&v.data_) vector<T> ());
+
+    // Convert each element to T while merging pairs.
+    //
+    for (auto i (ns.begin ()); i != ns.end (); ++i)
+    {
+      name& n (*i);
+      name* r (nullptr);
+
+      if (n.pair)
+      {
+        r = &*++i;
+
+        if (n.pair != '@')
+        {
+          diag_record dr (fail);
+
+          dr << "unexpected pair style for "
+             << value_traits<T>::value_type.name << " value "
+             << "'" << n << "'" << n.pair << "'" << *r << "'";
+
+          if (var != nullptr)
+            dr << " in variable " << var->name;
+        }
+      }
+
+      try
+      {
+        p.push_back (value_traits<T>::convert (move (n), r));
+      }
+      catch (const invalid_argument&)
+      {
+        diag_record dr (fail);
+
+        dr << "invalid " << value_traits<T>::value_type.name;
+
+        if (n.pair)
+          dr << " element pair '" << n << "'@'" << *r << "'";
+        else
+          dr << " element '" << n << "'";
+
+        if (var != nullptr)
+          dr << " in variable " << var->name;
+      }
+    }
+  }
+
+  template <typename T>
+  void
+  vector_assign (value& v, names&& ns, const variable* var)
+  {
+    if (v)
+      v.as<vector<T>> ().clear ();
+
+    vector_append<T> (v, move (ns), var);
+  }
+
+  template <typename T>
+  void
+  vector_prepend (value& v, names&& ns, const variable* var)
+  {
+    // Reduce to append.
+    //
+    vector<T> t;
+    vector<T>* p;
+
+    if (v)
+    {
+      p = &v.as<vector<T>> ();
+      p->swap (t);
+    }
+    else
+      p = new (&v.data_) vector<T> ();
+
+    vector_append<T> (v, move (ns), var);
+
+    p->insert (p->end (),
+               make_move_iterator (t.begin ()),
+               make_move_iterator (t.end ()));
+  }
+
+  template <typename T>
+  static names_view
+  vector_reverse (const value& v, names& s)
+  {
+    auto& vv (v.as<vector<T>> ());
+    s.reserve (vv.size ());
+
+    for (const T& x: vv)
+      s.push_back (value_traits<T>::reverse (x));
+
+    return s;
+  }
+
+  template <typename T>
+  static int
+  vector_compare (const value& l, const value& r)
+  {
+    auto& lv (l.as<vector<T>> ());
+    auto& rv (r.as<vector<T>> ());
+
+    auto li (lv.begin ()), le (lv.end ());
+    auto ri (rv.begin ()), re (rv.end ());
+
+    for (; li != le && ri != re; ++li, ++ri)
+      if (int r = value_traits<T>::compare (*li, *ri))
+        return r;
+
+    if (li == le && ri != re) // l shorter than r.
+      return -1;
+
+    if (ri == re && li != le) // r shorter than l.
+      return 1;
+
+    return 0;
+  }
+
+  template <typename T>
+  value_traits<vector<T>>::value_type_ex::
+  value_type_ex (value_type&& v)
+    : value_type (move (v))
+  {
+    type_name  = value_traits<T>::type_name;
+    type_name += 's';
+    name = type_name.c_str ();
+  }
+
+  template <typename T>
+  const vector<T> value_traits<vector<T>>::empty_instance;
+
+  template <typename T>
+  const typename value_traits<vector<T>>::value_type_ex
+  value_traits<vector<T>>::value_type = build2::value_type // VC14 wants =.
+  {
+    nullptr,                          // Patched above.
+    sizeof (vector<T>),
+    nullptr,                          // No base.
+    &value_traits<T>::value_type,
+    &default_dtor<vector<T>>,
+    &default_copy_ctor<vector<T>>,
+    &default_copy_assign<vector<T>>,
+    &vector_assign<T>,
+    &vector_append<T>,
+    &vector_prepend<T>,
+    &vector_reverse<T>,
+    nullptr,                          // No cast (cast data_ directly).
+    &vector_compare<T>,
+    &default_empty<vector<T>>
+  };
+
+  // map<K, V> value
+  //
+  template <typename K, typename V>
+  void
+  map_append (value& v, names&& ns, const variable* var)
+  {
+    using std::map;
+
+    map<K, V>& p (v
+                  ? v.as<map<K, V>> ()
+                  : *new (&v.data_) map<K, V> ());
+
+    // Verify we have a sequence of pairs and convert each lhs/rhs to K/V.
+    //
+    for (auto i (ns.begin ()); i != ns.end (); ++i)
+    {
+      name& l (*i);
+
+      if (!l.pair)
+      {
+        diag_record dr (fail);
+
+        dr << value_traits<map<K, V>>::value_type.name << " key-value "
+           << "pair expected instead of '" << l << "'";
+
+        if (var != nullptr)
+          dr << " in variable " << var->name;
+      }
+
+      name& r (*++i); // Got to have the second half of the pair.
+
+      if (l.pair != '@')
+      {
+        diag_record dr (fail);
+
+        dr << "unexpected pair style for "
+           << value_traits<map<K, V>>::value_type.name << " key-value "
+           << "'" << l << "'" << l.pair << "'" << r << "'";
+
+        if (var != nullptr)
+          dr << " in variable " << var->name;
+      }
+
+      try
+      {
+        K k (value_traits<K>::convert (move (l), nullptr));
+
+        try
+        {
+          V v (value_traits<V>::convert (move (r), nullptr));
+
+          p.emplace (move (k), move (v));
+        }
+        catch (const invalid_argument&)
+        {
+          diag_record dr (fail);
+
+          dr << "invalid " << value_traits<V>::value_type.name
+             << " element value '" << r << "'";
+
+          if (var != nullptr)
+            dr << " in variable " << var->name;
+        }
+      }
+      catch (const invalid_argument&)
+      {
+        diag_record dr (fail);
+
+        dr << "invalid " << value_traits<K>::value_type.name
+           << " element key '" << l << "'";
+
+        if (var != nullptr)
+          dr << " in variable " << var->name;
+      }
+    }
+  }
+
+  template <typename K, typename V>
+  void
+  map_assign (value& v, names&& ns, const variable* var)
+  {
+    using std::map;
+
+    if (v)
+      v.as<map<K, V>> ().clear ();
+
+    map_append<K, V> (v, move (ns), var);
+  }
+
+  template <typename K, typename V>
+  static names_view
+  map_reverse (const value& v, names& s)
+  {
+    using std::map;
+
+    auto& vm (v.as<map<K, V>> ());
+    s.reserve (2 * vm.size ());
+
+    for (const auto& p: vm)
+    {
+      s.push_back (value_traits<K>::reverse (p.first));
+      s.back ().pair = '@';
+      s.push_back (value_traits<V>::reverse (p.second));
+    }
+
+    return s;
+  }
+
+  template <typename K, typename V>
+  static int
+  map_compare (const value& l, const value& r)
+  {
+    using std::map;
+
+    auto& lm (l.as<map<K, V>> ());
+    auto& rm (r.as<map<K, V>> ());
+
+    auto li (lm.begin ()), le (lm.end ());
+    auto ri (rm.begin ()), re (rm.end ());
+
+    for (; li != le && ri != re; ++li, ++ri)
+    {
+      int r;
+      if ((r = value_traits<K>::compare (li->first, ri->first)) != 0 ||
+          (r = value_traits<V>::compare (li->second, ri->second)) != 0)
+        return r;
+    }
+
+    if (li == le && ri != re) // l shorter than r.
+      return -1;
+
+    if (ri == re && li != le) // r shorter than l.
+      return 1;
+
+    return 0;
+  }
+
+  template <typename K, typename V>
+  value_traits<std::map<K, V>>::value_type_ex::
+  value_type_ex (value_type&& v)
+    : value_type (move (v))
+  {
+    type_name  = value_traits<K>::type_name;
+    type_name += '_';
+    type_name += value_traits<V>::type_name;
+    type_name += "_map";
+    name = type_name.c_str ();
+  }
+
+  template <typename K, typename V>
+  const std::map<K,V> value_traits<std::map<K, V>>::empty_instance;
+
+  template <typename K, typename V>
+  const typename value_traits<std::map<K, V>>::value_type_ex
+  value_traits<std::map<K, V>>::value_type = build2::value_type // VC14 wants =
+  {
+    nullptr,             // Patched above.
+    sizeof (map<K, V>),
+    nullptr,             // No base.
+    nullptr,             // No element.
+    &default_dtor<map<K, V>>,
+    &default_copy_ctor<map<K, V>>,
+    &default_copy_assign<map<K, V>>,
+    &map_assign<K, V>,
+    &map_append<K, V>,
+    &map_append<K, V>,   // Prepend is the same as append.
+    &map_reverse<K, V>,
+    nullptr,             // No cast (cast data_ directly).
+    &map_compare<K, V>,
+    &default_empty<map<K, V>>
+  };
+
+  // variable_cache
+  //
+  template <typename K>
+  pair<value&, ulock> variable_cache<K>::
+  insert (K k, const lookup& stem, size_t ver, const variable& var)
+  {
+    using value_data = variable_map::value_data;
+
+    const variable_map* svars (stem.vars); // NULL if undefined.
+    size_t sver (stem.defined ()
+                 ? static_cast<const value_data*> (stem.value)->version
+                 : 0);
+
+    shared_mutex& m (
+      variable_cache_mutex_shard[
+        hash<variable_cache*> () (this) % variable_cache_mutex_shard_size]);
+
+    slock sl (m);
+    ulock ul (m, defer_lock);
+
+    auto i (m_.find (k));
+
+    // Cache hit.
+    //
+    if (i != m_.end ()                 &&
+        i->second.version == ver       &&
+        i->second.stem_vars == svars   &&
+        i->second.stem_version == sver &&
+        (var.type == nullptr || i->second.value.type == var.type))
+      return pair<value&, ulock> (i->second.value, move (ul));
+
+    // Relock for exclusive access. Note that it is entirely possible
+    // that between unlock and lock someone else has updated the entry.
+    //
+    sl.unlock ();
+    ul.lock ();
+
+    // Note that the cache entries are never removed so we can reuse the
+    // iterator.
+    //
+    pair<typename map_type::iterator, bool> p (i, i == m_.end ());
+
+    if (p.second)
+      p = m_.emplace (move (k),
+                      entry_type {value_data (nullptr), ver, svars, sver});
+
+    entry_type& e (p.first->second);
+
+    if (p.second)
+    {
+      // Cache miss.
+      //
+      e.value.version++; // New value.
+    }
+    else if (e.version != ver     ||
+             e.stem_vars != svars ||
+             e.stem_version != sver)
+    {
+      // Cache invalidation.
+      //
+      assert (e.version <= ver);
+      e.version = ver;
+
+      if (e.stem_vars != svars)
+        e.stem_vars = svars;
+      else
+        assert (e.stem_version <= sver);
+
+      e.stem_version = sver;
+
+      e.value.version++; // Value changed.
+    }
+    else
+    {
+      // Cache hit.
+      //
+      if (var.type != nullptr && e.value.type != var.type)
+        typify (e.value, *var.type, &var);
+
+      ul.unlock ();
+    }
+
+    return pair<value&, ulock> (e.value, move (ul));
+  }
+}
-- 
cgit v1.1