From ffa0839de796fbefc48bacc4777648ff19b3fee6 Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Fri, 8 Sep 2017 16:16:11 +0200
Subject: Add ability to pass scope to buildfile functions, add
 $install.resolve()

---
 build2/function.hxx | 232 ++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 209 insertions(+), 23 deletions(-)

(limited to 'build2/function.hxx')

diff --git a/build2/function.hxx b/build2/function.hxx
index 0e592b1..96bf401 100644
--- a/build2/function.hxx
+++ b/build2/function.hxx
@@ -5,9 +5,9 @@
 #ifndef BUILD2_FUNCTION_HXX
 #define BUILD2_FUNCTION_HXX
 
+#include <map>
 #include <utility>       // index_sequence
 #include <type_traits>   // aligned_storage
-#include <unordered_map>
 
 #include <build2/types.hxx>
 #include <build2/utility.hxx>
@@ -45,6 +45,9 @@ namespace build2
   // expected to issue diagnostics and throw failed. Note that the arguments
   // are conceptually "moved" and can be reused by the implementation.
   //
+  // A function can also optionally receive the current scope by having the
+  // first argument of the const scope& type.
+  //
   // Normally functions come in families that share a common qualification
   // (e.g., string. or path.). The function_family class is a "registrar"
   // that simplifies handling of function families. For example:
@@ -64,7 +67,9 @@ namespace build2
   //
   struct function_overload;
 
-  using function_impl = value (vector_view<value>, const function_overload&);
+  using function_impl = value (const scope&,
+                               vector_view<value>,
+                               const function_overload&);
 
   struct function_overload
   {
@@ -134,7 +139,7 @@ namespace build2
   class function_map
   {
   public:
-    using map_type = std::unordered_multimap<string, function_overload>;
+    using map_type = std::multimap<string, function_overload>;
     using iterator = map_type::iterator;
     using const_iterator = map_type::const_iterator;
 
@@ -145,9 +150,12 @@ namespace build2
     erase (iterator i) {map_.erase (i);}
 
     value
-    call (const string& name, vector_view<value> args, const location& l) const
+    call (const scope& base,
+          const string& name,
+          vector_view<value> args,
+          const location& l) const
     {
-      return call (name, args, l, true).first;
+      return call (base, name, args, l, true).first;
     }
 
     // As above but do not fail if no match was found (but still do if the
@@ -156,11 +164,12 @@ namespace build2
     // functions.
     //
     pair<value, bool>
-    try_call (const string& name,
+    try_call (const scope& base,
+              const string& name,
               vector_view<value> args,
               const location& l) const
     {
-      return call (name, args, l, false);
+      return call (base, name, args, l, false);
     }
 
     iterator
@@ -175,9 +184,20 @@ namespace build2
     const_iterator
     end () const {return map_.end ();}
 
+    // Return true if the function with this name is already defined. If the
+    // name ends with '.', then instead check if any function with this prefix
+    // (which we call a family) is already defined.
+    //
+    bool
+    defined (const string&) const;
+
   private:
     pair<value, bool>
-    call (const string&, vector_view<value>, const location&, bool fail) const;
+    call (const scope&,
+          const string&,
+          vector_view<value>,
+          const location&,
+          bool fail) const;
 
     map_type map_;
   };
@@ -195,7 +215,7 @@ namespace build2
     // exceptions), you would normally call the default implementation.
     //
     static value
-    default_thunk (vector_view<value>, const function_overload&);
+    default_thunk (const scope&, vector_view<value>, const function_overload&);
 
     // A function family uses a common qualification (though you can pass
     // empty string to supress it). For an unqualified name (doesn't not
@@ -212,6 +232,13 @@ namespace build2
     entry
     operator[] (string name) const;
 
+    static bool
+    defined (string qual)
+    {
+      qual += '.';
+      return functions.defined (qual);
+    }
+
   private:
     const string qual_;
     function_impl* thunk_;
@@ -392,12 +419,12 @@ namespace build2
     //
     struct data
     {
-      value (*const thunk) (vector_view<value>, const void*);
+      value (*const thunk) (const scope&, vector_view<value>, const void*);
       R (*const impl) (A...);
     };
 
     static value
-    thunk (vector_view<value> args, const void* d)
+    thunk (const scope&, vector_view<value> args, const void* d)
     {
       return thunk (move (args),
                     static_cast<const data*> (d)->impl,
@@ -417,6 +444,39 @@ namespace build2
     }
   };
 
+  // Specialization for functions that expect the current scope as a first
+  // argument.
+  //
+  template <typename R, typename... A>
+  struct function_cast<R, const scope&, A...>
+  {
+    struct data
+    {
+      value (*const thunk) (const scope&, vector_view<value>, const void*);
+      R (*const impl) (const scope&, A...);
+    };
+
+    static value
+    thunk (const scope& base, vector_view<value> args, const void* d)
+    {
+      return thunk (base, move (args),
+                    static_cast<const data*> (d)->impl,
+                    std::index_sequence_for<A...> ());
+    }
+
+    template <size_t... i>
+    static value
+    thunk (const scope& base, vector_view<value> args,
+           R (*impl) (const scope&, A...),
+           std::index_sequence<i...>)
+    {
+      return value (
+        impl (base,
+              function_arg<A>::cast (
+                i < args.size () ? &args[i] : nullptr)...));
+    }
+  };
+
   // Specialization for void return type. In this case we return NULL value.
   //
   template <typename... A>
@@ -424,12 +484,12 @@ namespace build2
   {
     struct data
     {
-      value (*const thunk) (vector_view<value>, const void*);
+      value (*const thunk) (const scope&, vector_view<value>, const void*);
       void (*const impl) (A...);
     };
 
     static value
-    thunk (vector_view<value> args, const void* d)
+    thunk (const scope&, vector_view<value> args, const void* d)
     {
       thunk (move (args),
              static_cast<const data*> (d)->impl,
@@ -447,6 +507,35 @@ namespace build2
     }
   };
 
+  template <typename... A>
+  struct function_cast<void, const scope&, A...>
+  {
+    struct data
+    {
+      value (*const thunk) (const scope&, vector_view<value>, const void*);
+      void (*const impl) (const scope&, A...);
+    };
+
+    static value
+    thunk (const scope& base, vector_view<value> args, const void* d)
+    {
+      thunk (base, move (args),
+             static_cast<const data*> (d)->impl,
+             std::index_sequence_for<A...> ());
+      return value (nullptr);
+    }
+
+    template <size_t... i>
+    static void
+    thunk (const scope& base, vector_view<value> args,
+           void (*impl) (const scope&, A...),
+           std::index_sequence<i...>)
+    {
+      impl (base,
+            function_arg<A>::cast (i < args.size () ? &args[i] : nullptr)...);
+    }
+  };
+
   // Customization for coerced lambdas (see below).
   //
 #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 6
@@ -455,12 +544,12 @@ namespace build2
   {
     struct data
     {
-      value (*const thunk) (vector_view<value>, const void*);
+      value (*const thunk) (const scope&, vector_view<value>, const void*);
       R (L::*const impl) (A...) const;
     };
 
     static value
-    thunk (vector_view<value> args, const void* d)
+    thunk (const scope&, vector_view<value> args, const void* d)
     {
       return thunk (move (args),
                     static_cast<const data*> (d)->impl,
@@ -482,17 +571,49 @@ namespace build2
     }
   };
 
+  template <typename L, typename R, typename... A>
+  struct function_cast_lamb<L, R, const scope&, A...>
+  {
+    struct data
+    {
+      value (*const thunk) (const scope&, vector_view<value>, const void*);
+      R (L::*const impl) (const scope&, A...) const;
+    };
+
+    static value
+    thunk (const scope& base, vector_view<value> args, const void* d)
+    {
+      return thunk (base, move (args),
+                    static_cast<const data*> (d)->impl,
+                    std::index_sequence_for<A...> ());
+    }
+
+    template <size_t... i>
+    static value
+    thunk (const scope& base, vector_view<value> args,
+           R (L::*impl) (const scope&, A...) const,
+           std::index_sequence<i...>)
+    {
+      const L* l (nullptr); // Undefined behavior.
+
+      return value (
+        (l->*impl) (base,
+                    function_arg<A>::cast (
+                      i < args.size () ? &args[i] : nullptr)...));
+    }
+  };
+
   template <typename L, typename... A>
   struct function_cast_lamb<L, void, A...>
   {
     struct data
     {
-      value (*const thunk) (vector_view<value>, const void*);
+      value (*const thunk) (const scope&, vector_view<value>, const void*);
       void (L::*const impl) (A...) const;
     };
 
     static value
-    thunk (vector_view<value> args, const void* d)
+    thunk (const scope&, vector_view<value> args, const void* d)
     {
       thunk (move (args),
              static_cast<const data*> (d)->impl,
@@ -512,6 +633,37 @@ namespace build2
           i < args.size () ? &args[i] : nullptr)...);
     }
   };
+
+  template <typename L, typename... A>
+  struct function_cast_lamb<L, void, const scope&, A...>
+  {
+    struct data
+    {
+      value (*const thunk) (const scope&, vector_view<value>, const void*);
+      void (L::*const impl) (const scope&, A...) const;
+    };
+
+    static value
+    thunk (const scope& base, vector_view<value> args, const void* d)
+    {
+      thunk (base, move (args),
+             static_cast<const data*> (d)->impl,
+             std::index_sequence_for<A...> ());
+      return value (nullptr);
+    }
+
+    template <size_t... i>
+    static void
+    thunk (const scope& base, vector_view<value> args,
+           void (L::*impl) (const scope&, A...) const,
+           std::index_sequence<i...>)
+    {
+      const L* l (nullptr);
+      (l->*impl) (base,
+                  function_arg<A>::cast (
+                    i < args.size () ? &args[i] : nullptr)...);
+    }
+  };
 #endif
 
   // Customization for member functions.
@@ -521,12 +673,12 @@ namespace build2
   {
     struct data
     {
-      value (*const thunk) (vector_view<value>, const void*);
+      value (*const thunk) (const scope&, vector_view<value>, const void*);
       R (T::*const impl) () const;
     };
 
     static value
-    thunk (vector_view<value> args, const void* d)
+    thunk (const scope&, vector_view<value> args, const void* d)
     {
       auto mf (static_cast<const data*> (d)->impl);
       return value ((function_arg<T>::cast (&args[0]).*mf) ());
@@ -538,12 +690,12 @@ namespace build2
   {
     struct data
     {
-      value (*const thunk) (vector_view<value>, const void*);
+      value (*const thunk) (const scope&, vector_view<value>, const void*);
       void (T::*const impl) () const;
     };
 
     static value
-    thunk (vector_view<value> args, const void* d)
+    thunk (const scope&, vector_view<value> args, const void* d)
     {
       auto mf (static_cast<const data*> (d)->impl);
       (function_arg<T>::cast (args[0]).*mf) ();
@@ -558,12 +710,12 @@ namespace build2
   {
     struct data
     {
-      value (*const thunk) (vector_view<value>, const void*);
+      value (*const thunk) (const scope&, vector_view<value>, const void*);
       R T::*const impl;
     };
 
     static value
-    thunk (vector_view<value> args, const void* d)
+    thunk (const scope&, vector_view<value> args, const void* d)
     {
       auto dm (static_cast<const data*> (d)->impl);
       return value (move (function_arg<T>::cast (&args[0]).*dm));
@@ -593,6 +745,23 @@ namespace build2
                 typename cast::data {&cast::thunk, impl}));
     }
 
+    template <typename R, typename... A>
+    void
+    operator= (R (*impl) (const scope&, A...)) &&
+    {
+      using args = function_args<A...>;
+      using cast = function_cast<R, const scope&, A...>;
+
+      insert (move (name),
+              function_overload (
+                nullptr,
+                args::min,
+                args::max,
+                function_overload::types (args::types, args::max),
+                thunk,
+                typename cast::data {&cast::thunk, impl}));
+    }
+
     // Support for assigning a (capture-less) lambda.
     //
     // GCC up until version 6 has a bug (#62052) that is triggered by calling
@@ -625,6 +794,23 @@ namespace build2
                 thunk,
                 typename cast::data {&cast::thunk, op}));
     }
+
+    template <typename L, typename R, typename... A>
+    void
+    coerce_lambda (R (L::*op) (const scope&, A...) const) &&
+    {
+      using args = function_args<A...>;
+      using cast = function_cast_lamb<L, R, const scope&, A...>;
+
+      insert (move (name),
+              function_overload (
+                nullptr,
+                args::min,
+                args::max,
+                function_overload::types (args::types, args::max),
+                thunk,
+                typename cast::data {&cast::thunk, op}));
+    }
 #else
     template <typename L>
     void
-- 
cgit v1.1