From f995ffbf47c1f613b6131da1e5e6cb9aafca3367 Mon Sep 17 00:00:00 2001
From: Kohei Takahashi <flast@flast.jp>
Date: Sat, 11 Apr 2015 04:34:52 +0900
Subject: [PATCH 1/2] C++11 variadic templates based function_eval.

---
 .../phoenix/core/detail/function_eval.hpp     | 75 ++++++++++++++++++-
 1 file changed, 73 insertions(+), 2 deletions(-)

diff --git a/include/boost/phoenix/core/detail/function_eval.hpp b/include/boost/phoenix/core/detail/function_eval.hpp
index a964419..3c2a717 100644
--- a/include/boost/phoenix/core/detail/function_eval.hpp
+++ b/include/boost/phoenix/core/detail/function_eval.hpp
@@ -1,5 +1,6 @@
 /*=============================================================================
     Copyright (c) 2001-2007 Joel de Guzman
+    Copyright (c) 2015 Kohei Takahashi
 
     Distributed under the Boost Software License, Version 1.0. (See accompanying
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -16,6 +17,13 @@
 #include <boost/phoenix/core/detail/phx2_result.hpp>
 #include <boost/utility/result_of.hpp>
 
+#ifndef BOOST_PHOENIX_NO_VARIADIC_FUNCTION_EVAL
+#   include <boost/mpl/if.hpp>
+#   include <boost/type_traits/is_reference.hpp>
+#endif
+
+// XXX: Currently, we should use preprocessed files since
+// core/expression.hpp does not support c++11 variadic templates yet.
 #include <boost/phoenix/core/detail/cpp03/function_eval_expr.hpp>
 
 namespace boost { namespace phoenix {
@@ -26,7 +34,7 @@ namespace boost { namespace phoenix {
         {
             return x;
         }
-        
+
         template <typename T>
         T const& help_rvalue_deduction(T const& x)
         {
@@ -38,6 +46,7 @@ namespace boost { namespace phoenix {
             template <typename Sig>
             struct result;
 
+#ifdef BOOST_PHOENIX_NO_VARIADIC_FUNCTION_EVAL
             template <typename This, typename F, typename Context>
             struct result<This(F, Context)>
             {
@@ -65,8 +74,70 @@ namespace boost { namespace phoenix {
             }
 
         #include <boost/phoenix/core/detail/cpp03/function_eval.hpp>
+#else
+            template <typename, typename, typename...> struct result_impl;
+
+            template <typename F, typename... A, typename Head, typename... Tail>
+            struct result_impl<F, void(A...), Head, Tail...>
+                : result_impl<F, void(A..., Head), Tail...>
+            {
+            };
+
+            template <typename F, typename... A, typename Context>
+            struct result_impl<F, void(A...), Context>
+            {
+                typedef typename
+                    remove_reference<
+                        typename boost::result_of<evaluator(F, Context)>::type
+                    >::type
+                    fn;
+
+
+                typedef typename
+                    boost::result_of<
+                        fn(
+                            typename boost::add_reference<
+                                typename boost::add_const<
+                                    typename boost::result_of<boost::phoenix::evaluator(A, Context)>::type
+                                >::type
+                            >::type...
+                        )
+                    >::type
+                    type;
+
+                static type call(F f, A... a, Context ctx)
+                {
+                    return boost::phoenix::eval(f, ctx)(help_rvalue_deduction(boost::phoenix::eval(a, ctx))...);
+                }
+            };
+
+            template <typename This, typename F, typename... A>
+            struct result<This(F, A...)>
+                : result_impl<F, void(), A...>
+            {
+            };
+
+            template <typename F, typename... A>
+            typename result<
+                function_eval(
+                    F const &
+                  , typename mpl::if_<is_reference<A>, A, A const &>::type...
+                )
+            >::type
+            // 'A &... a, Context const &ctx' doesn't work as intended: type deduction always fail.
+            operator()(F && f, A &&... a) const
+            {
+                return
+                    result<
+                        function_eval(
+                            typename mpl::if_<is_reference<F>, F, F const &>::type
+                          , typename mpl::if_<is_reference<A>, A, A const &>::type...
+                        )
+                    >::call(f, a...);
+            }
+#endif
         };
-        
+
     }
 
     template <typename Dummy>

From daa27b0990e4f3b2d2429a9661408e60ee95a596 Mon Sep 17 00:00:00 2001
From: Kohei Takahashi <flast@flast.jp>
Date: Tue, 23 Feb 2016 23:21:02 +0900
Subject: [PATCH 2/2] Update limits

---
 include/boost/phoenix/core/limits.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/boost/phoenix/core/limits.hpp b/include/boost/phoenix/core/limits.hpp
index 5f760f3..6de301d 100644
--- a/include/boost/phoenix/core/limits.hpp
+++ b/include/boost/phoenix/core/limits.hpp
@@ -38,9 +38,11 @@
 # define BOOST_PHOENIX_NO_VARIADIC_ACTOR
 # define BOOST_PHOENIX_NO_VARIADIC_CALL
 # define BOOST_PHOENIX_NO_VARIADIC_FUNCTION_EQUAL
+# define BOOST_PHOENIX_NO_VARIADIC_FUNCTION_EVAL
 #endif
 #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
 # define BOOST_PHOENIX_NO_VARIADIC_ACTOR
+# define BOOST_PHOENIX_NO_VARIADIC_FUNCTION_EVAL
 #endif
 
 #if !defined(BOOST_PHOENIX_ARG_LIMIT)