passenger 6.0.7 → 6.0.8

data/src/cxx_supportlib/vendor-modified/boost/parameter/preprocessor.hpp

@@ -1,1077 +1,217 @@
-// Copyright Daniel Wallin 2006. Use, modification and distribution is
-// subject to 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)
+// Copyright Daniel Wallin 2006.
+// Copyright Cromwell D. Enage 2017.
+// 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)
 
 #ifndef BOOST_PARAMETER_PREPROCESSOR_060206_HPP
-# define BOOST_PARAMETER_PREPROCESSOR_060206_HPP
+#define BOOST_PARAMETER_PREPROCESSOR_060206_HPP
 
-# include <boost/parameter/parameters.hpp>
-# include <boost/parameter/binding.hpp>
-# include <boost/parameter/match.hpp>
+#include <boost/parameter/aux_/preprocessor/impl/forwarding_overloads.hpp>
+#include <boost/parameter/aux_/preprocessor/impl/specification.hpp>
+#include <boost/preprocessor/cat.hpp>
 
-# include <boost/parameter/aux_/parenthesized_type.hpp>
-# include <boost/parameter/aux_/cast.hpp>
-# include <boost/parameter/aux_/preprocessor/flatten.hpp>
-
-# include <boost/preprocessor/repetition/repeat_from_to.hpp>
-# include <boost/preprocessor/comparison/equal.hpp>
-# include <boost/preprocessor/control/if.hpp>
-# include <boost/preprocessor/control/iif.hpp>
-# include <boost/preprocessor/control/expr_if.hpp>
-# include <boost/preprocessor/repetition/enum_params.hpp>
-# include <boost/preprocessor/repetition/enum_binary_params.hpp>
-# include <boost/preprocessor/repetition/enum_trailing.hpp>
-# include <boost/preprocessor/seq/first_n.hpp>
-# include <boost/preprocessor/seq/for_each_product.hpp>
-# include <boost/preprocessor/seq/for_each_i.hpp> 
-# include <boost/preprocessor/tuple/elem.hpp> 
-# include <boost/preprocessor/tuple/eat.hpp>
-# include <boost/preprocessor/seq/fold_left.hpp>
-# include <boost/preprocessor/seq/push_back.hpp>
-# include <boost/preprocessor/seq/size.hpp>
-# include <boost/preprocessor/seq/enum.hpp>
-# include <boost/preprocessor/seq/push_back.hpp>
-
-# include <boost/preprocessor/detail/is_nullary.hpp>
-
-# include <boost/mpl/always.hpp>
-# include <boost/mpl/apply_wrap.hpp>
-
-namespace boost { namespace parameter { namespace aux {
-
-#  if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
-
-// Given Match, which is "void x" where x is an argument matching
-// criterion, extract a corresponding MPL predicate.
-template <class Match>
-struct unwrap_predicate;
-
-// Match anything
-template <>
-struct unwrap_predicate<void*>
-{
-    typedef mpl::always<mpl::true_> type;
-};
-
-#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
-
-typedef void* voidstar;
-
-// A matching predicate is explicitly specified
-template <class Predicate>
-struct unwrap_predicate<voidstar (Predicate)>
-{
-    typedef Predicate type;
-};
-
-#else
-
-// A matching predicate is explicitly specified
-template <class Predicate>
-struct unwrap_predicate<void *(Predicate)>
-{
-    typedef Predicate type;
-};
-
-#endif 
-
-
-// A type to which the argument is supposed to be convertible is
-// specified
-template <class Target>
-struct unwrap_predicate<void (Target)>
-{
-    typedef is_convertible<mpl::_, Target> type;
-};
-
-// Recast the ParameterSpec's nested match metafunction as a free metafunction
-template <
-    class Parameters
-  , BOOST_PP_ENUM_BINARY_PARAMS(
-        BOOST_PARAMETER_MAX_ARITY, class A, = boost::parameter::void_ BOOST_PP_INTERCEPT
-    )
->
-struct match
-  : Parameters::template match<
-        BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, A)
-    >
-{};
-# endif 
-
-# undef false_
-
-template <
-    class Parameters
-  , BOOST_PP_ENUM_BINARY_PARAMS(
-        BOOST_PARAMETER_MAX_ARITY, class A, = boost::parameter::void_ BOOST_PP_INTERCEPT
-    )
->
-struct argument_pack
-{
-    typedef typename make_arg_list<
-        typename BOOST_PARAMETER_build_arg_list(
-            BOOST_PARAMETER_MAX_ARITY, make_items, typename Parameters::parameter_spec, A
-        )::type
-      , typename Parameters::deduced_list
-      , tag_keyword_arg
-      , mpl::false_
-    >::type result;
-    typedef typename mpl::first<result>::type type;
-};
-
-// Works around VC6 problem where it won't accept rvalues.
-template <class T>
-T& as_lvalue(T& value, long)
-{
-    return value;
-}
-
-template <class T>
-T const& as_lvalue(T const& value, int)
-{
-    return value;
-}
-
-
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-
-template <class Predicate, class T, class Args>
-struct apply_predicate
-{
-    BOOST_MPL_ASSERT((
-        mpl::and_<mpl::false_,T>
-    ));
-
-    typedef typename mpl::if_<
-        typename mpl::apply2<Predicate,T,Args>::type
-      , char
-      , int
-    >::type type;
-};
-
-template <class P>
-struct funptr_predicate
-{
-    static P p;
-
-    template <class T, class Args, class P0>
-    static typename apply_predicate<P0,T,Args>::type
-    check_predicate(type<T>, Args*, void**(*)(P0));
-
-    template <class T, class Args, class P0>
-    static typename mpl::if_<
-        is_convertible<T,P0>
-      , char
-      , int
-     >::type check_predicate(type<T>, Args*, void*(*)(P0));
-
-    template <class T, class Args>
-    struct apply
-    {
-        BOOST_STATIC_CONSTANT(bool, result = 
-            sizeof(check_predicate(boost::type<T>(), (Args*)0, &p)) == 1
-        );
-
-        typedef mpl::bool_<apply<T,Args>::result> type;
-    };
-};
-
-template <>
-struct funptr_predicate<void**>
-  : mpl::always<mpl::true_>
-{};
-
-# endif
-
-}}} // namespace boost::parameter::aux
-
-# if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-// From Paul Mensonides
-#  define BOOST_PARAMETER_IS_NULLARY(x) \
-    BOOST_PP_SPLIT(1, BOOST_PARAMETER_IS_NULLARY_C x BOOST_PP_COMMA() 0) \
-    /**/
-#  define BOOST_PARAMETER_IS_NULLARY_C() \
-    ~, 1 BOOST_PP_RPAREN() \
-    BOOST_PP_TUPLE_EAT(2) BOOST_PP_LPAREN() ~ \
-    /**/
-# else
-#  define BOOST_PARAMETER_IS_NULLARY(x) BOOST_PP_IS_NULLARY(x)
-# endif
-
-# define BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_static ()
-# define BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \
-    BOOST_PARAMETER_IS_NULLARY( \
-        BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_CHECK_STATIC_,name) \
-    )
-
-# if !defined(BOOST_MSVC)
-#  define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_static
-#  define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC(name) \
-    BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_, name)
-# else
-// Workaround for MSVC preprocessor.
-//
-// When stripping static from "static f", msvc will produce
-// " f". The leading whitespace doesn't go away when pasting
-// the token with something else, so this thing is a hack to
-// strip the whitespace.
-#  define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_static (
-#  define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_AUX(name) \
-    BOOST_PP_CAT(BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_, name))
-#  define BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC(name) \
-    BOOST_PP_SEQ_HEAD( \
-        BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC_AUX(name) \
-    )
-# endif
-
-# define BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \
-    BOOST_PP_EXPR_IF( \
-        BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \
-      , static \
-    )
-
-# define BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name) \
-    BOOST_PP_IF( \
-        BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(name) \
-      , BOOST_PARAMETER_MEMBER_FUNCTION_STRIP_STATIC \
-      , name BOOST_PP_TUPLE_EAT(1) \
-    )(name)
-
-// Calculates [begin, end) arity range.
-
-# define BOOST_PARAMETER_ARITY_RANGE_M_optional(state) state
-# define BOOST_PARAMETER_ARITY_RANGE_M_deduced_optional(state) state
-# define BOOST_PARAMETER_ARITY_RANGE_M_required(state) BOOST_PP_INC(state)
-# define BOOST_PARAMETER_ARITY_RANGE_M_deduced_required(state) BOOST_PP_INC(state)
-
-# define BOOST_PARAMETER_ARITY_RANGE_M(s, state, x) \
-    BOOST_PP_CAT( \
-        BOOST_PARAMETER_ARITY_RANGE_M_ \
-      , BOOST_PARAMETER_FN_ARG_QUALIFIER(x) \
-    )(state)
+// Helper macro for BOOST_PARAMETER_CONSTRUCTOR.
+#define BOOST_PARAMETER_CONSTRUCTOR_AUX(class_, base, tag_namespace, args)   \
+    BOOST_PARAMETER_SPECIFICATION(tag_namespace, ctor, args, 0)              \
+        BOOST_PP_CAT(constructor_parameters, __LINE__);                      \
+    BOOST_PARAMETER_CONSTRUCTOR_OVERLOADS(class_, base, args)
 /**/
 
-# define BOOST_PARAMETER_ARITY_RANGE(args) \
-    ( \
-        BOOST_PP_SEQ_FOLD_LEFT(BOOST_PARAMETER_ARITY_RANGE_M, 0, args) \
-      , BOOST_PP_INC(BOOST_PP_SEQ_SIZE(args)) \
-    )
-/**/
+#include <boost/parameter/aux_/preprocessor/impl/function_name.hpp>
 
-// Accessor macros for the argument specs tuple.
-# define BOOST_PARAMETER_FN_ARG_QUALIFIER(x) \
-    BOOST_PP_TUPLE_ELEM(4,0,x)
-/**/
-
-# define BOOST_PARAMETER_FN_ARG_NAME(x) \
-    BOOST_PP_TUPLE_ELEM(4,1,x)
-/**/
-
-# define BOOST_PARAMETER_FN_ARG_PRED(x) \
-    BOOST_PP_TUPLE_ELEM(4,2,x)
-/**/
-
-# define BOOST_PARAMETER_FN_ARG_DEFAULT(x) \
-    BOOST_PP_TUPLE_ELEM(4,3,x)
+// Defines the implementation function header.
+#define BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name, is_const)                   \
+    template <typename Args>                                                 \
+    typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name, is_const)<           \
+        Args                                                                 \
+    >::type BOOST_PARAMETER_FUNCTION_IMPL_NAME(name, is_const)(              \
+        Args const& args                                                     \
+    )
 /**/
 
-# define BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_out(x)
-# define BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_in_out(x)
+#include <boost/parameter/aux_/preprocessor/impl/parenthesized_return_type.hpp>
+#include <boost/parameter/config.hpp>
 
-// Returns 1 if x is either "out(k)" or "in_out(k)".
-# define BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER(x) \
-    BOOST_PP_IS_EMPTY( \
-        BOOST_PP_CAT(BOOST_PARAMETETER_FUNCTION_EAT_KEYWORD_QUALIFIER_, x) \
-    ) \
+// Expands to the result metafunction and the parameters specialization.
+#if defined(BOOST_PARAMETER_CAN_USE_MP11)
+#define BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_ns, args, is_const)  \
+    template <typename Args>                                                 \
+    using BOOST_PARAMETER_FUNCTION_RESULT_NAME(name, is_const)               \
+    = typename BOOST_PARAMETER_PARENTHESIZED_RETURN_TYPE(result);            \
+    BOOST_PARAMETER_SPECIFICATION(tag_ns, name, args, is_const)              \
+        BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME(name, is_const);
 /**/
-
-# define BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_out(x) x
-# define BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_in_out(x) x
-# define BOOST_PARAMETER_FUNCTION_KEYWORD_GET(x) \
-    BOOST_PP_CAT(BOOST_PARAMETETER_FUNCTION_GET_KEYWORD_QUALIFIER_, x)
+#else
+#define BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_ns, args, is_const)  \
+    template <typename Args>                                                 \
+    struct BOOST_PARAMETER_FUNCTION_RESULT_NAME(name, is_const)              \
+      : BOOST_PARAMETER_PARENTHESIZED_RETURN_TYPE(result)                    \
+    {                                                                        \
+    };                                                                       \
+    BOOST_PARAMETER_SPECIFICATION(tag_ns, name, args, is_const)              \
+        BOOST_PARAMETER_FUNCTION_SPECIFICATION_NAME(name, is_const);
 /**/
+#endif  // BOOST_PARAMETER_CAN_USE_MP11
 
-// Returns the keyword of x, where x is either a keyword qualifier
-// or a keyword.
-//
-//   k => k
-//   out(k) => k
-//   in_out(k) => k
-//
-# define BOOST_PARAMETER_FUNCTION_KEYWORD(x) \
-    BOOST_PP_IF( \
-        BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER(x) \
-      , BOOST_PARAMETER_FUNCTION_KEYWORD_GET \
-      , x BOOST_PP_TUPLE_EAT(1) \
-    )(x)
+// Helper macro for BOOST_PARAMETER_BASIC_FUNCTION.
+#define BOOST_PARAMETER_BASIC_FUNCTION_AUX(result, name, tag_ns, args)       \
+    BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_ns, args, 0)             \
+    BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name, 0);                             \
+    BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS(name, name, args, 0, 0)       \
+    BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name, 0)
 /**/
 
-# define BOOST_PARAMETER_FN_ARG_KEYWORD(x) \
-    BOOST_PARAMETER_FUNCTION_KEYWORD( \
-        BOOST_PARAMETER_FN_ARG_NAME(x) \
-    )
+#include <boost/preprocessor/control/expr_if.hpp>
 
-// Builds forwarding functions.
-
-# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z(z, n) \
-    template<BOOST_PP_ENUM_PARAMS_Z(z, n, class ParameterArgumentType)>
+// Helper macro for BOOST_PARAMETER_BASIC_MEMBER_FUNCTION,
+// BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION,
+// BOOST_PARAMETER_BASIC_FUNCTION_CALL_OPERATOR, and
+// BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR.
+#define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX(r, n, i, tag_ns, args, c)  \
+    BOOST_PARAMETER_FUNCTION_HEAD(r, i, tag_ns, args, c)                     \
+    BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS(n, i, args, 1, c)             \
+    BOOST_PARAMETER_FUNCTION_IMPL_HEAD(i, c) BOOST_PP_EXPR_IF(c, const)
 /**/
 
-# if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
-#  define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n) \
-    , typename boost::parameter::aux::match< \
-          parameters, BOOST_PP_ENUM_PARAMS(n, ParameterArgumentType) \
-      >::type = parameters()
-# else
-#  define BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z(z, name, parameters, n)
-# endif
-/**/
+#include <boost/parameter/aux_/preprocessor/impl/flatten.hpp>
 
-# define BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(base) \
-    BOOST_PP_CAT( \
-        boost_param_parameters_ \
-      , BOOST_PP_CAT(__LINE__, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) \
+// Expands to a Boost.Parameter-enabled constructor header.  All arguments are
+// accessible via args and keywords only.
+#define BOOST_PARAMETER_CONSTRUCTOR(class_, base, tag_namespace, args)       \
+    BOOST_PARAMETER_CONSTRUCTOR_AUX(                                         \
+        class_, base, tag_namespace                                          \
+      , BOOST_PARAMETER_AUX_PP_FLATTEN(2, 2, 3, args)                        \
     )
-
-// Produce a name for a result type metafunction for the function
-// named base
-# define BOOST_PARAMETER_FUNCTION_RESULT_NAME(base) \
-    BOOST_PP_CAT( \
-        boost_param_result_ \
-      , BOOST_PP_CAT(__LINE__,BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)) \
-    )
-
-// Can't do boost_param_impl_ ## basee because base might start with an underscore
-// daniel: what? how is that relevant? the reason for using CAT() is to make sure
-// base is expanded. i'm not sure we need to here, but it's more stable to do it.
-# define BOOST_PARAMETER_IMPL(base) \
-    BOOST_PP_CAT(boost_param_impl,BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base))
-
-# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00(z, n, r, data, elem) \
-    BOOST_PP_IF( \
-        n \
-      , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z, BOOST_PP_TUPLE_EAT(2) \
-    )(z,n) \
-    BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(7,3,data)) \
-    inline \
-    BOOST_PP_EXPR_IF(n, typename) \
-        BOOST_PARAMETER_FUNCTION_RESULT_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))<   \
-        BOOST_PP_EXPR_IF(n, typename) \
-        boost::parameter::aux::argument_pack< \
-            BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data)) \
-            BOOST_PP_COMMA_IF(n) \
-            BOOST_PP_IF( \
-                n, BOOST_PP_SEQ_ENUM, BOOST_PP_TUPLE_EAT(1) \
-            )(elem) \
-        >::type \
-    >::type \
-    BOOST_PARAMETER_MEMBER_FUNCTION_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))( \
-        BOOST_PP_IF( \
-            n \
-          , BOOST_PP_SEQ_FOR_EACH_I_R \
-          , BOOST_PP_TUPLE_EAT(4) \
-        )( \
-            r \
-          , BOOST_PARAMETER_FUNCTION_ARGUMENT \
-          , ~ \
-          , elem \
-        ) \
-        BOOST_PP_IF(n, BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z, BOOST_PP_TUPLE_EAT(4))( \
-            z \
-          , BOOST_PP_TUPLE_ELEM(7,3,data) \
-          , BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data)) \
-          , n \
-        ) \
-    ) BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(7,4,data), const) \
-    { \
-        return BOOST_PARAMETER_IMPL(BOOST_PP_TUPLE_ELEM(7,3,data))( \
-            BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(BOOST_PP_TUPLE_ELEM(7,3,data))()( \
-                BOOST_PP_ENUM_PARAMS_Z(z, n, a) \
-            ) \
-        ); \
-    }
 /**/
 
-# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION0(r, data, elem) \
-    BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00( \
-        BOOST_PP_TUPLE_ELEM(7,0,data) \
-      , BOOST_PP_TUPLE_ELEM(7,1,data) \
-      , r \
-      , data \
-      , elem \
+// Expands to a Boost.Parameter-enabled function header.  All arguments are
+// accessible via args and keywords only.
+#define BOOST_PARAMETER_BASIC_FUNCTION(result, name, tag_namespace, args)    \
+    BOOST_PARAMETER_BASIC_FUNCTION_AUX(                                      \
+        result, name, tag_namespace                                          \
+      , BOOST_PARAMETER_AUX_PP_FLATTEN(2, 2, 3, args)                        \
     )
 /**/
 
-# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_0(z, n, data) \
-    BOOST_PARAMETER_FUNCTION_FWD_FUNCTION00( \
-        z, n, BOOST_PP_DEDUCE_R() \
-      , (z, n, BOOST_PP_TUPLE_REM(5) data) \
-      , ~ \
+// Expands to a Boost.Parameter-enabled member function header.  All arguments
+// are accessible via args and keywords only.
+#define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION(result, name, tag_ns, args)    \
+    BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX(                               \
+        result, name, name, tag_ns                                           \
+      , BOOST_PARAMETER_AUX_PP_FLATTEN(2, 2, 3, args), 0                     \
     )
 /**/
 
-# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_N(z, n, data) \
-    BOOST_PP_SEQ_FOR_EACH( \
-        BOOST_PARAMETER_FUNCTION_FWD_FUNCTION0 \
-      , (z, n, BOOST_PP_TUPLE_REM(5) data) \
-      , BOOST_PP_SEQ_FOR_EACH_PRODUCT( \
-            BOOST_PARAMETER_FUNCTION_FWD_PRODUCT \
-          , BOOST_PP_SEQ_FIRST_N( \
-                n, BOOST_PP_TUPLE_ELEM(5,3,data) \
-            ) \
-        ) \
+// Expands to a Boost.Parameter-enabled const-qualified member function
+// header.  All arguments are accessible via args and keywords only.
+#define BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION(r, name, tag_ns, args)   \
+    BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX(                               \
+        r, name, name, tag_ns                                                \
+      , BOOST_PARAMETER_AUX_PP_FLATTEN(2, 2, 3, args), 1                     \
     )
 /**/
 
-# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTION(z, n, data) \
-    BOOST_PP_IF( \
-        n \
-      , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_N \
-      , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_ARITY_0 \
-    )(z,n,data) \
-/**/
-
-# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS0( \
-    result,name,args,const_,combinations,range \
-) \
-    BOOST_PP_REPEAT_FROM_TO( \
-        BOOST_PP_TUPLE_ELEM(2,0,range), BOOST_PP_TUPLE_ELEM(2,1,range) \
-      , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION \
-      , (result,name,const_,combinations,BOOST_PP_TUPLE_ELEM(2,1,range)) \
+// Expands to a Boost.Parameter-enabled function call operator header.  All
+// arguments are accessible via args and keywords only.
+#define BOOST_PARAMETER_BASIC_FUNCTION_CALL_OPERATOR(result, tag_ns, args)   \
+    BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX(                               \
+        result, operator(), operator, tag_ns                                 \
+      , BOOST_PARAMETER_AUX_PP_FLATTEN(2, 2, 3, args), 0                     \
     )
 /**/
 
-# define BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS(result,name,args, const_, combinations) \
-    BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS0( \
-        result, name, args, const_, combinations, BOOST_PARAMETER_ARITY_RANGE(args) \
+// Expands to a Boost.Parameter-enabled const-qualified function call
+// operator header.  All arguments are accessible via args and keywords only.
+#define BOOST_PARAMETER_BASIC_CONST_FUNCTION_CALL_OPERATOR(r, tag_ns, args)  \
+    BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX(                               \
+        r, operator(), operator, tag_ns                                      \
+      , BOOST_PARAMETER_AUX_PP_FLATTEN(2, 2, 3, args), 1                     \
     )
 /**/
 
-// Builds boost::parameter::parameters<> specialization
-#  define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_optional(tag) \
-    optional<tag
-
-#  define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_required(tag) \
-    required<tag
-
-#  define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_deduced_optional(tag) \
-    optional<boost::parameter::deduced<tag>
-
-#  define BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_deduced_required(tag) \
-    required<boost::parameter::deduced<tag>
+#include <boost/parameter/aux_/preprocessor/impl/function_dispatch_layer.hpp>
 
-# if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-
-#  define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \
-    BOOST_PP_COMMA_IF(i) \
-    boost::parameter::BOOST_PP_CAT( \
-        BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \
-      , BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \
-    )( \
-        tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \
-            BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \
-        ) \
-    ) \
-      , typename boost::parameter::aux::unwrap_predicate< \
-            void BOOST_PARAMETER_FN_ARG_PRED(elem) \
-        >::type \
-    >
-# elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-#  define BOOST_PARAMETER_FUNCTION_PARAMETERS_M(r,tag_namespace,i,elem) \
-    BOOST_PP_COMMA_IF(i) \
-    boost::parameter::BOOST_PP_CAT( \
-        BOOST_PARAMETER_FUNCTION_PARAMETERS_QUALIFIER_ \
-      , BOOST_PARAMETER_FN_ARG_QUALIFIER(elem) \
-    )( \
-        tag_namespace::BOOST_PARAMETER_FUNCTION_KEYWORD( \
-            BOOST_PARAMETER_FN_ARG_KEYWORD(elem) \
-        ) \
-    ) \
-      , boost::mpl::always<boost::mpl::true_> \
-    >
-# endif
-
-# define BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, base, args)             \
-    template <class BoostParameterDummy>                                            \
-    struct BOOST_PP_CAT(                                                            \
-            BOOST_PP_CAT(boost_param_params_, __LINE__)                             \
-          , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base)                              \
-    ) : boost::parameter::parameters<                                               \
-            BOOST_PP_SEQ_FOR_EACH_I(                                                \
-                BOOST_PARAMETER_FUNCTION_PARAMETERS_M, tag_namespace, args          \
-            )                                                                       \
-        >                                                                           \
-    {};                                                                             \
-                                                                                    \
-    typedef BOOST_PP_CAT( \
-            BOOST_PP_CAT(boost_param_params_, __LINE__) \
-          , BOOST_PARAMETER_MEMBER_FUNCTION_NAME(base) \
-    )<int>
-
-// Defines result type metafunction
-# define BOOST_PARAMETER_FUNCTION_RESULT_ARG(z, _, i, x) \
-    BOOST_PP_COMMA_IF(i) class BOOST_PP_TUPLE_ELEM(3,1,x)
-/**/
-
-# define BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args)                                   \
-    template <class Args>                                                                       \
-    struct BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)                                           \
-    {                                                                                           \
-        typedef typename BOOST_PARAMETER_PARENTHESIZED_TYPE(result) type;                       \
-    };
-
-// Defines implementation function
-# define BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name)           \
-    template <class Args>                                   \
-    typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<    \
-       Args                                                 \
-    >::type BOOST_PARAMETER_IMPL(name)(Args const& args)
-
-# define BOOST_PARAMETER_FUNCTION_IMPL_FWD(name) \
-    BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name);
-/**/
-
-# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(state, arg) \
-    ( \
-        BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 0, state)) \
-      , BOOST_PP_SEQ_PUSH_BACK(BOOST_PP_TUPLE_ELEM(4, 1, state), arg) \
-      , BOOST_PP_TUPLE_ELEM(4, 2, state) \
-      , BOOST_PP_TUPLE_ELEM(4, 3, state) \
-    )
-
-# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_deduced_required(state, arg) \
-    BOOST_PARAMETER_FUNCTION_SPLIT_ARG_required(state, arg)
-
-# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_optional(state, arg) \
-    ( \
-        BOOST_PP_TUPLE_ELEM(4, 0, state) \
-      , BOOST_PP_TUPLE_ELEM(4, 1, state) \
-      , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 2, state)) \
-      , BOOST_PP_SEQ_PUSH_BACK(BOOST_PP_TUPLE_ELEM(4, 3, state), arg) \
-    )
-
-# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG_deduced_optional(state, arg) \
-    BOOST_PARAMETER_FUNCTION_SPLIT_ARG_optional(state, arg)
-
-# define BOOST_PARAMETER_FUNCTION_SPLIT_ARG(s, state, arg) \
-    BOOST_PP_CAT( \
-        BOOST_PARAMETER_FUNCTION_SPLIT_ARG_ \
-      , BOOST_PARAMETER_FN_ARG_QUALIFIER(arg) \
-    )(state, arg)
-
-// Returns (required_count, required, optional_count, optionals) tuple
-# define BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args) \
-    BOOST_PP_SEQ_FOLD_LEFT( \
-        BOOST_PARAMETER_FUNCTION_SPLIT_ARG \
-      , (0,BOOST_PP_SEQ_NIL, 0,BOOST_PP_SEQ_NIL) \
-      , args \
-    )
-
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME(keyword) \
-    BOOST_PP_CAT(BOOST_PP_CAT(keyword,_),type)
-
-// Helpers used as parameters to BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS.
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG(r, _, arg) \
-    , class BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME( \
-              BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \
-      )
-
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG(r, _, arg) \
-    , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG_NAME( \
-              BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \
-      )& BOOST_PARAMETER_FN_ARG_KEYWORD(arg)
-
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER(r, _, arg) \
-    , BOOST_PARAMETER_FN_ARG_KEYWORD(arg)
-
-// Produces a name for the dispatch functions.
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name) \
-    BOOST_PP_CAT( \
-        boost_param_default_ \
-      , BOOST_PP_CAT(__LINE__, BOOST_PARAMETER_MEMBER_FUNCTION_NAME(name)) \
-    )
-
-// Helper macro used below to produce lists based on the keyword argument
-// names. macro is applied to every element. n is the number of
-// optional arguments that should be included.
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS(macro, n, split_args) \
-    BOOST_PP_SEQ_FOR_EACH( \
-        macro \
-      , ~ \
-      , BOOST_PP_TUPLE_ELEM(4,1,split_args) \
-    ) \
-    BOOST_PP_SEQ_FOR_EACH( \
-        macro \
-      , ~ \
-      , BOOST_PP_SEQ_FIRST_N( \
-          BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), n) \
-        , BOOST_PP_TUPLE_ELEM(4,3,split_args) \
-        ) \
-    )
-
-// Generates a keyword | default expression.
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT(arg, tag_namespace) \
-    boost::parameter::keyword< \
-        tag_namespace::BOOST_PARAMETER_FN_ARG_KEYWORD(arg) \
-    >::instance | boost::parameter::aux::use_default_tag()
-
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_GET_ARG(arg, tag_ns) \
-    BOOST_PARAMETER_FUNCTION_CAST( \
-        args[ \
-            BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT( \
-                arg, tag_ns \
-            ) \
-        ] \
-      , BOOST_PARAMETER_FN_ARG_PRED(arg) \
-      , Args \
-    )
-
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY(name, n, split_args, tag_namespace) \
-    { \
-        return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \
-            (ResultType(*)())0 \
-          , args \
-          , 0L \
-            BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
-                BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER \
-              , n \
-              , split_args \
-            ) \
-          , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_GET_ARG( \
-                BOOST_PP_SEQ_ELEM( \
-                    BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), n) \
-                  , BOOST_PP_TUPLE_ELEM(4,3,split_args) \
-                ) \
-              , tag_namespace \
-            ) \
-        ); \
-    }
-
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_ACTUAL_DEFAULT(arg) \
-    BOOST_PARAMETER_FUNCTION_CAST( \
-        boost::parameter::aux::as_lvalue(BOOST_PARAMETER_FN_ARG_DEFAULT(arg), 0L) \
-      , BOOST_PARAMETER_FN_ARG_PRED(arg) \
-      , Args \
-    )
-
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY(name, n, split_args, tag_ns, const_) \
-    template < \
-        class ResultType \
-      , class Args \
-        BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
-            BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \
-          , BOOST_PP_INC(n) \
-          , split_args \
-        ) \
-    > \
-    BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \
-    ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \
-        ResultType(*)() \
-      , Args const& args \
-      , long \
-        BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
-            BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \
-          , BOOST_PP_INC(n) \
-          , split_args \
-        ) \
-      , boost::parameter::aux::use_default_tag \
-    ) BOOST_PP_EXPR_IF(const_, const) \
-    { \
-        return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \
-            (ResultType(*)())0 \
-          , args \
-          , 0L \
-            BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
-                BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_PARAMETER \
-              , BOOST_PP_INC(n) \
-              , split_args \
-            ) \
-          , BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_ACTUAL_DEFAULT( \
-                BOOST_PP_SEQ_ELEM( \
-                    BOOST_PP_SUB(BOOST_PP_TUPLE_ELEM(4,2,split_args), BOOST_PP_INC(n)) \
-                  , BOOST_PP_TUPLE_ELEM(4,3,split_args) \
-                ) \
-            ) \
-        ); \
-    }
-
-// Produces a forwarding layer in the default evaluation machine.
-//
-// data is a tuple:
-//
-//   (name, split_args)
-//
-// Where name is the base name of the function, and split_args is a tuple:
-//
-//   (required_count, required_args, optional_count, required_args)
-//
-
-
-// defines the actual function body for BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION below.
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION0(z, n, data) \
-    template < \
-        class ResultType \
-      , class Args \
-        BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
-            BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \
-          , n \
-          , BOOST_PP_TUPLE_ELEM(5,1,data) \
-        ) \
-    > \
-    BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(BOOST_PP_TUPLE_ELEM(5,0,data)) \
-    ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(BOOST_PP_TUPLE_ELEM(5,0,data))( \
-        ResultType(*)() \
-      , Args const& args \
-      , int \
-        BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
-            BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \
-          , n \
-          , BOOST_PP_TUPLE_ELEM(5,1,data) \
-        ) \
-    ) BOOST_PP_EXPR_IF(BOOST_PP_TUPLE_ELEM(5,2,data), const) \
-    BOOST_PP_IF( \
-        n \
-      , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_BODY \
-      , ; BOOST_PP_TUPLE_EAT(4) \
-    )( \
-        BOOST_PP_TUPLE_ELEM(5,0,data) \
-      , n \
-      , BOOST_PP_TUPLE_ELEM(5,1,data) \
-      , BOOST_PP_TUPLE_ELEM(5,3,data) \
-    )
-
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION(z, n, data) \
-    BOOST_PP_IF( \
-        BOOST_PP_AND( \
-            BOOST_PP_NOT(n) \
-          , BOOST_PP_TUPLE_ELEM(5,4,data) \
-        ) \
-      , BOOST_PP_TUPLE_EAT(3) \
-      , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION0 \
-    )(z, n, data) \
-    BOOST_PP_IF( \
-        BOOST_PP_EQUAL(n, BOOST_PP_TUPLE_ELEM(4,2,BOOST_PP_TUPLE_ELEM(5,1,data))) \
-      , BOOST_PP_TUPLE_EAT(5) \
-      , BOOST_PARAMETER_FUNCTION_DEFAULT_EVAL_DEFAULT_BODY \
-    )( \
-        BOOST_PP_TUPLE_ELEM(5,0,data) \
-      , n \
-      , BOOST_PP_TUPLE_ELEM(5,1,data) \
-      , BOOST_PP_TUPLE_ELEM(5,3,data) \
-      , BOOST_PP_TUPLE_ELEM(5,2,data) \
-    )
-
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_GET_ARG(r, tag_ns, arg) \
-    , BOOST_PARAMETER_FUNCTION_CAST( \
-          args[ \
-              boost::parameter::keyword<tag_ns::BOOST_PARAMETER_FN_ARG_KEYWORD(arg)>::instance \
-          ] \
-        , BOOST_PARAMETER_FN_ARG_PRED(arg) \
-        , Args \
-      )
-
-// Generates the function template that recives a ArgumentPack, and then
-// goes on to call the layers of overloads generated by 
-// BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER.
-# define BOOST_PARAMETER_FUNCTION_INITIAL_DISPATCH_FUNCTION(name, split_args, const_, tag_ns) \
-    template <class Args> \
-    typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<Args>::type \
-    BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \
-    BOOST_PARAMETER_IMPL(name)(Args const& args) BOOST_PP_EXPR_IF(const_, const) \
-    { \
-        return BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \
-            (typename BOOST_PARAMETER_FUNCTION_RESULT_NAME(name)<Args>::type(*)())0 \
-          , args \
-          , 0L \
- \
-            BOOST_PP_SEQ_FOR_EACH( \
-                BOOST_PARAMETER_FUNCTION_DEFAULT_GET_ARG \
-              , tag_ns \
-              , BOOST_PP_TUPLE_ELEM(4,1,split_args) \
-            ) \
- \
-        ); \
-    }
-
-// Helper for BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER below.
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER_AUX( \
-    name, split_args, skip_fwd_decl, const_, tag_namespace \
-  ) \
-    BOOST_PP_REPEAT_FROM_TO( \
-        0 \
-      , BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 2, split_args)) \
-      , BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION \
-      , (name, split_args, const_, tag_namespace, skip_fwd_decl) \
-    ) \
- \
-    BOOST_PARAMETER_FUNCTION_INITIAL_DISPATCH_FUNCTION(name, split_args, const_, tag_namespace) \
-\
-    template < \
-        class ResultType \
-      , class Args \
-        BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
-            BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_TEMPLATE_ARG \
-          , 0 \
-          , split_args \
-        ) \
-    > \
-    BOOST_PARAMETER_MEMBER_FUNCTION_STATIC(name) \
-    ResultType BOOST_PARAMETER_FUNCTION_DEFAULT_NAME(name)( \
-        ResultType(*)() \
-      , Args const& \
-      , int \
-        BOOST_PARAMETER_FUNCTION_DEFAULT_ARGUMENTS( \
-            BOOST_PARAMETER_FUNCTION_DEFAULT_FUNCTION_ARG \
-          , 0 \
-          , split_args \
-        ) \
-    ) BOOST_PP_EXPR_IF(const_, const)
-
-// Generates a bunch of forwarding functions that each extract
-// one more argument.
-# define BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, skip_fwd_decl, const_, tag_ns) \
-    BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER_AUX( \
-        name, BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args), skip_fwd_decl, const_, tag_ns \
-    )
-/**/
-
-// Defines the result metafunction and the parameters specialization.
-# define BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args)   \
-      BOOST_PARAMETER_FUNCTION_RESULT_(result, name, args)                   \
-                                                                            \
-          BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, name, args)    \
-          BOOST_PARAMETER_FUNCTION_PARAMETERS_NAME(name);                   \
-
-// Helper for BOOST_PARAMETER_FUNCTION below.
-# define BOOST_PARAMETER_FUNCTION_AUX(result, name, tag_namespace, args)    \
-    BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args)         \
-    BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name); \
-\
-    BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS(                                  \
-        result, name, args, 0                                                \
-      , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args)                      \
-    )                                                                        \
-                                                                             \
-    BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, 0, 0, tag_namespace)
-
-// Defines a Boost.Parameter enabled function with the new syntax.
-# define BOOST_PARAMETER_FUNCTION(result, name, tag_namespace, args)    \
-    BOOST_PARAMETER_FUNCTION_AUX(                                       \
-        result, name, tag_namespace                                      \
-      , BOOST_PARAMETER_FLATTEN(3, 2, 3, args)                           \
-    )                                                                    \
-/**/
-
-// Defines a Boost.Parameter enabled function.
-# define BOOST_PARAMETER_BASIC_FUNCTION_AUX(result, name, tag_namespace, args)    \
-    BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args)        \
-                                                                            \
-    BOOST_PARAMETER_FUNCTION_IMPL_FWD(name)                                 \
-                                                                            \
-    BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS(                                 \
-        result, name, args, 0                                               \
-      , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args)                     \
-    )                                                                       \
-                                                                            \
-    BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name)
-
-# define BOOST_PARAMETER_BASIC_FUNCTION(result, name, tag_namespace, args)  \
-    BOOST_PARAMETER_BASIC_FUNCTION_AUX(                                     \
-        result, name, tag_namespace                                     \
-      , BOOST_PARAMETER_FLATTEN(2, 2, 3, args)                          \
-    )                                                                   \
-/**/
-
-// Defines a Boost.Parameter enabled member function.
-# define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX(result, name, tag_namespace, args, const_) \
-    BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args)                    \
-                                                                                        \
-    BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS(                                             \
-        result, name, args, const_                                                      \
-      , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args)                                 \
-    )                                                                                   \
-                                                                                        \
-    BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name) BOOST_PP_EXPR_IF(const_, const)            \
-/**/
-
-# define BOOST_PARAMETER_BASIC_MEMBER_FUNCTION(result, name, tag_namespace, args) \
-    BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \
-        result, name, tag_namespace \
-      , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \
-      , 0 \
+// Helper macro for BOOST_PARAMETER_FUNCTION.
+#define BOOST_PARAMETER_FUNCTION_AUX(result, name, tag_ns, args)             \
+    BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_ns, args, 0)             \
+    BOOST_PARAMETER_FUNCTION_IMPL_HEAD(name, 0);                             \
+    BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS(name, name, args, 0, 0)       \
+    BOOST_PARAMETER_FUNCTION_DISPATCH_LAYER(                                 \
+        1, (name, BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args), 0, 0, tag_ns)   \
     )
 /**/
 
-# define BOOST_PARAMETER_BASIC_CONST_MEMBER_FUNCTION(result, name, tag_namespace, args) \
-    BOOST_PARAMETER_BASIC_MEMBER_FUNCTION_AUX( \
-        result, name, tag_namespace \
-      , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \
-      , 1 \
-    )
-/**/
-
-
-
-# define BOOST_PARAMETER_MEMBER_FUNCTION_AUX(result, name, tag_namespace, const_, args)    \
-    BOOST_PARAMETER_FUNCTION_HEAD(result, name, tag_namespace, args)         \
-\
-    BOOST_PARAMETER_FUNCTION_FWD_FUNCTIONS(                                  \
-        result, name, args, const_                                           \
-      , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args)                      \
-    )                                                                        \
-                                                                             \
-    BOOST_PARAMETER_FUNCTION_DEFAULT_LAYER(name, args, 1, const_, tag_namespace)
-
-// Defines a Boost.Parameter enabled function with the new syntax.
-# define BOOST_PARAMETER_MEMBER_FUNCTION(result, name, tag_namespace, args)    \
-    BOOST_PARAMETER_MEMBER_FUNCTION_AUX(                                       \
-        result, name, tag_namespace, 0                                     \
-      , BOOST_PARAMETER_FLATTEN(3, 2, 3, args)                           \
-    )                                                                    \
-/**/
-
-# define BOOST_PARAMETER_CONST_MEMBER_FUNCTION(result, name, tag_namespace, args)    \
-    BOOST_PARAMETER_MEMBER_FUNCTION_AUX(                                       \
-        result, name, tag_namespace, 1                                     \
-      , BOOST_PARAMETER_FLATTEN(3, 2, 3, args)                           \
-    )                                                                    \
-/**/
-
-// Defines a Boost.Parameter enabled constructor.
-
-# define BOOST_PARAMETER_FUNCTION_ARGUMENT(r, _, i, elem) \
-    BOOST_PP_COMMA_IF(i) elem& BOOST_PP_CAT(a, i)
-/**/
-
-# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00(z, n, r, data, elem) \
-    BOOST_PP_IF( \
-        n \
-      , BOOST_PARAMETER_FUNCTION_FWD_FUNCTION_TEMPLATE_Z, BOOST_PP_TUPLE_EAT(2) \
-    )(z, n) \
-    BOOST_PP_EXPR_IF(BOOST_PP_EQUAL(n,1), explicit) \
-    BOOST_PP_TUPLE_ELEM(6,2,data)( \
-        BOOST_PP_IF( \
-            n \
-          , BOOST_PP_SEQ_FOR_EACH_I_R \
-          , BOOST_PP_TUPLE_EAT(4) \
-        )( \
-            r \
-          , BOOST_PARAMETER_FUNCTION_ARGUMENT \
-          , ~ \
-          , elem \
-        ) \
-        BOOST_PP_IF(n, BOOST_PARAMETER_FUNCTION_FWD_MATCH_Z, BOOST_PP_TUPLE_EAT(4))( \
-            z \
-          , BOOST_PP_TUPLE_ELEM(6,3,data) \
-          , BOOST_PP_CAT(constructor_parameters, __LINE__) \
-          , n \
-        ) \
-    ) \
-      : BOOST_PARAMETER_PARENTHESIZED_TYPE(BOOST_PP_TUPLE_ELEM(6,3,data)) ( \
-            BOOST_PP_CAT(constructor_parameters, __LINE__)()( \
-                BOOST_PP_ENUM_PARAMS_Z(z, n, a) \
-            ) \
-        ) \
-    {}
-/**/
-
-# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR0(r, data, elem) \
-    BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00( \
-        BOOST_PP_TUPLE_ELEM(6,0,data) \
-      , BOOST_PP_TUPLE_ELEM(6,1,data) \
-      , r \
-      , data \
-      , elem \
+// Expands to a Boost.Parameter-enabled function header.  All arguments are
+// accessible via args and keywords, as well as by name.
+#define BOOST_PARAMETER_FUNCTION(result, name, tag_namespace, args)          \
+    BOOST_PARAMETER_FUNCTION_AUX(                                            \
+        result, name, tag_namespace                                          \
+      , BOOST_PARAMETER_AUX_PP_FLATTEN(3, 2, 3, args)                        \
     )
 /**/
 
-# define BOOST_PARAMETER_FUNCTION_FWD_PRODUCT(r, product) \
-    (product)
-/**/
+#include <boost/preprocessor/control/if.hpp>
 
-# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_0(z, n, data) \
-    BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR00( \
-        z, n, BOOST_PP_DEDUCE_R() \
-      , (z, n, BOOST_PP_TUPLE_REM(4) data) \
-      , ~ \
+// Helper macro for BOOST_PARAMETER_MEMBER_FUNCTION
+// BOOST_PARAMETER_CONST_MEMBER_FUNCTION,
+// BOOST_PARAMETER_FUNCTION_CALL_OPERATOR, and
+// BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR.
+#define BOOST_PARAMETER_MEMBER_FUNCTION_AUX(r, name, impl, tag_ns, c, args)  \
+    BOOST_PARAMETER_FUNCTION_HEAD(r, impl, tag_ns, args, c)                  \
+    BOOST_PARAMETER_FUNCTION_FORWARD_OVERLOADS(name, impl, args, 1, c)       \
+    BOOST_PARAMETER_FUNCTION_DISPATCH_LAYER(                                 \
+        0, (                                                                 \
+            impl                                                             \
+          , BOOST_PARAMETER_FUNCTION_SPLIT_ARGS(args)                        \
+          , BOOST_PP_IF(                                                     \
+                BOOST_PARAMETER_MEMBER_FUNCTION_IS_STATIC(impl)              \
+              , 0                                                            \
+              , 1                                                            \
+            )                                                                \
+          , c                                                                \
+          , tag_ns                                                           \
+        )                                                                    \
     )
 /**/
 
-# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_N(z, n, data) \
-    BOOST_PP_SEQ_FOR_EACH( \
-        BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR0 \
-      , (z, n, BOOST_PP_TUPLE_REM(4) data) \
-      , BOOST_PP_SEQ_FOR_EACH_PRODUCT( \
-            BOOST_PARAMETER_FUNCTION_FWD_PRODUCT \
-          , BOOST_PP_SEQ_FIRST_N( \
-                n, BOOST_PP_TUPLE_ELEM(4,2,data) \
-            ) \
-        ) \
+// Expands to a Boost.Parameter-enabled member function header.  All
+// arguments are accessible via args and keywords, as well as by name.
+#define BOOST_PARAMETER_MEMBER_FUNCTION(result, name, tag_ns, args)          \
+    BOOST_PARAMETER_MEMBER_FUNCTION_AUX(                                     \
+        result, name, name, tag_ns, 0                                        \
+      , BOOST_PARAMETER_AUX_PP_FLATTEN(3, 2, 3, args)                        \
     )
 /**/
 
-# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR(z, n, data) \
-    BOOST_PP_IF( \
-        n \
-      , BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_N \
-      , BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR_ARITY_0 \
-    )(z,n,data) \
-/**/
-
-# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS0(class_,base,args,combinations,range) \
-    BOOST_PP_REPEAT_FROM_TO( \
-        BOOST_PP_TUPLE_ELEM(2,0,range), BOOST_PP_TUPLE_ELEM(2,1,range) \
-      , BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTOR \
-      , (class_,base,combinations,BOOST_PP_TUPLE_ELEM(2,1,range)) \
+// Expands to a Boost.Parameter-enabled const-qualified member function
+// header.  All arguments are accessible via args and keywords, as well as
+// by name.
+#define BOOST_PARAMETER_CONST_MEMBER_FUNCTION(result, name, tag_ns, args)    \
+    BOOST_PARAMETER_MEMBER_FUNCTION_AUX(                                     \
+        result, name, name, tag_ns, 1                                        \
+      , BOOST_PARAMETER_AUX_PP_FLATTEN(3, 2, 3, args)                        \
     )
 /**/
 
-# define BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS(class_,base,args,combinations) \
-    BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS0( \
-        class_, base, args, combinations, BOOST_PARAMETER_ARITY_RANGE(args) \
+// Expands to a Boost.Parameter-enabled function call operator header.  All
+// arguments are accessible via args and keywords, as well as by name.
+#define BOOST_PARAMETER_FUNCTION_CALL_OPERATOR(result, tag_ns, args)         \
+    BOOST_PARAMETER_MEMBER_FUNCTION_AUX(                                     \
+        result, operator(), operator, tag_ns, 0                              \
+      , BOOST_PARAMETER_AUX_PP_FLATTEN(3, 2, 3, args)                        \
     )
 /**/
 
-# define BOOST_PARAMETER_CONSTRUCTOR_AUX(class_, base, tag_namespace, args) \
-    BOOST_PARAMETER_FUNCTION_PARAMETERS(tag_namespace, ctor, args)          \
-        BOOST_PP_CAT(constructor_parameters, __LINE__); \
-\
-    BOOST_PARAMETER_FUNCTION_FWD_CONSTRUCTORS( \
-        class_, base, args \
-      , BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \
-    ) \
-/**/
-
-# define BOOST_PARAMETER_CONSTRUCTOR(class_, base, tag_namespace, args) \
-    BOOST_PARAMETER_CONSTRUCTOR_AUX( \
-        class_, base, tag_namespace \
-      , BOOST_PARAMETER_FLATTEN(2, 2, 3, args) \
+// Expands to a Boost.Parameter-enabled const-qualified function call operator
+// header.  All arguments are accessible via args and keywords, as well as
+// by name.
+#define BOOST_PARAMETER_CONST_FUNCTION_CALL_OPERATOR(result, tag_ns, args)   \
+    BOOST_PARAMETER_MEMBER_FUNCTION_AUX(                                     \
+        result, operator(), operator, tag_ns, 1                              \
+      , BOOST_PARAMETER_AUX_PP_FLATTEN(3, 2, 3, args)                        \
     )
 /**/
 
-# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-#  define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \
-    (BOOST_PP_IF( \
-        BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \
-            BOOST_PARAMETER_FN_ARG_NAME(elem) \
-        ) \
-      , (const ParameterArgumentType ## i)(ParameterArgumentType ## i) \
-      , (const ParameterArgumentType ## i) \
-    ))
-// No partial ordering. This feature doesn't work.
-# else
-#  define BOOST_PARAMETER_FUNCTION_FWD_COMBINATION(r, _, i, elem) \
-    (BOOST_PP_IF( \
-        BOOST_PARAMETER_FUNCTION_IS_KEYWORD_QUALIFIER( \
-            BOOST_PARAMETER_FN_ARG_NAME(elem) \
-        ) \
-      , (ParameterArgumentType ## i) \
-      , (const ParameterArgumentType ## i) \
-    ))
-# endif
-
-# define BOOST_PARAMETER_FUNCTION_FWD_COMBINATIONS(args) \
-    BOOST_PP_SEQ_FOR_EACH_I(BOOST_PARAMETER_FUNCTION_FWD_COMBINATION, ~, args)
-
-#endif // BOOST_PARAMETER_PREPROCESSOR_060206_HPP
+#endif  // include guard