From a47fbc18f740b7667871619c8d0eed5229b42ee5 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 11 Apr 2002 18:58:10 +0000
Subject: [PATCH] Use PP lib for holders

[SVN r13447]
---
 include/boost/python/detail/preprocessor.hpp  |   8 +
 include/boost/python/detail/signature.hpp     | 217 -------------
 include/boost/python/object/class.hpp         |   2 +
 .../boost/python/object/pointer_holder.hpp    | 295 +++---------------
 include/boost/python/object/value_holder.hpp  | 293 +++--------------
 .../python/preprocessed/pointer_holder.hpp    | 105 +++++++
 .../pointer_holder_back_reference.hpp         | 115 +++++++
 .../python/preprocessed/value_holder.hpp      | 105 +++++++
 .../value_holder_back_reference.hpp           | 117 +++++++
 9 files changed, 523 insertions(+), 734 deletions(-)
 delete mode 100644 include/boost/python/detail/signature.hpp
 create mode 100644 include/boost/python/preprocessed/pointer_holder.hpp
 create mode 100644 include/boost/python/preprocessed/pointer_holder_back_reference.hpp
 create mode 100644 include/boost/python/preprocessed/value_holder.hpp
 create mode 100644 include/boost/python/preprocessed/value_holder_back_reference.hpp

diff --git a/include/boost/python/detail/preprocessor.hpp b/include/boost/python/detail/preprocessor.hpp
index 23278436..728c4699 100644
--- a/include/boost/python/detail/preprocessor.hpp
+++ b/include/boost/python/detail/preprocessor.hpp
@@ -8,10 +8,12 @@
 
 # include <boost/config.hpp>
 # include <boost/preprocessor/tuple/to_list.hpp>
+# include <boost/preprocessor/tuple/elem.hpp>
 # include <boost/preprocessor/list/for_each.hpp>
 # include <boost/preprocessor/repeat_from_to_2nd.hpp>
 # include <boost/preprocessor/inc.hpp>
 # include <boost/preprocessor/empty.hpp>
+# include <boost/preprocessor/enum.hpp>
 # include <boost/preprocessor/expr_if.hpp>
 
 namespace boost { namespace python { namespace detail { 
@@ -83,6 +85,12 @@ namespace boost { namespace python { namespace detail {
 # define BOOST_PYTHON_REPEAT_MF_ALL_CV_2ND(function) \
    BOOST_PP_LIST_FOR_EACH(BOOST_PYTHON_REPEAT_PMF_CV,function,BOOST_PYTHON_ALL_CV)
 
+#define BOOST_PYTHON_NUMBER_PAIR(Index, Pair)           \
+  BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,0,Pair),Index)     \
+  BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,1,Pair),Index)
+
+#define BOOST_PYTHON_ENUM_PARAMS2(N, Pair) BOOST_PP_ENUM(N, BOOST_PYTHON_NUMBER_PAIR, Pair)
+
 
 }}} // namespace boost::python::detail
 
diff --git a/include/boost/python/detail/signature.hpp b/include/boost/python/detail/signature.hpp
deleted file mode 100644
index db8b39a4..00000000
--- a/include/boost/python/detail/signature.hpp
+++ /dev/null
@@ -1,217 +0,0 @@
-//  (C) Copyright David Abrahams 2002. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  This work was funded in part by Lawrence Berkeley and Lawrence
-//  Livermore National Labs
-//
-//  This file generated for 5-argument member functions and 6-argument free
-//  functions by gen_signature.py
-
-#ifndef SIGNATURE_DWA2002128_HPP
-# define SIGNATURE_DWA2002128_HPP
-
-# include <boost/mpl/type_list.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-template <class R>
-mpl::type_list<R>
-signature(R (*)())
-{
-    return mpl::type_list<R>();
-}
-
-template <class R, class A0>
-mpl::type_list<R,A0>
-signature(R (*)(A0))
-{
-    return mpl::type_list<R,A0>();
-}
-
-template <class R, class A0, class A1>
-mpl::type_list<R,A0,A1>
-signature(R (*)(A0, A1))
-{
-    return mpl::type_list<R,A0,A1>();
-}
-
-template <class R, class A0, class A1, class A2>
-mpl::type_list<R,A0,A1,A2>
-signature(R (*)(A0, A1, A2))
-{
-    return mpl::type_list<R,A0,A1,A2>();
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-mpl::type_list<R,A0,A1,A2,A3>
-signature(R (*)(A0, A1, A2, A3))
-{
-    return mpl::type_list<R,A0,A1,A2,A3>();
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-mpl::type_list<R,A0,A1,A2,A3,A4>
-signature(R (*)(A0, A1, A2, A3, A4))
-{
-    return mpl::type_list<R,A0,A1,A2,A3,A4>();
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-mpl::type_list<R,A0,A1,A2,A3,A4,A5>
-signature(R (*)(A0, A1, A2, A3, A4, A5))
-{
-    return mpl::type_list<R,A0,A1,A2,A3,A4,A5>();
-}
-template <class R, class A0>
-mpl::type_list<R,A0&> signature(R (A0::*)())
-{
-    return mpl::type_list<R,A0&>();
-}
-
-template <class R, class A0, class A1>
-mpl::type_list<R,A0&,A1> signature(R (A0::*)(A1))
-{
-    return mpl::type_list<R,A0&,A1>();
-}
-
-template <class R, class A0, class A1, class A2>
-mpl::type_list<R,A0&,A1,A2> signature(R (A0::*)(A1, A2))
-{
-    return mpl::type_list<R,A0&,A1,A2>();
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-mpl::type_list<R,A0&,A1,A2,A3> signature(R (A0::*)(A1, A2, A3))
-{
-    return mpl::type_list<R,A0&,A1,A2,A3>();
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-mpl::type_list<R,A0&,A1,A2,A3,A4> signature(R (A0::*)(A1, A2, A3, A4))
-{
-    return mpl::type_list<R,A0&,A1,A2,A3,A4>();
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-mpl::type_list<R,A0&,A1,A2,A3,A4,A5> signature(R (A0::*)(A1, A2, A3, A4, A5))
-{
-    return mpl::type_list<R,A0&,A1,A2,A3,A4,A5>();
-}
-
-
-template <class R, class A0>
-mpl::type_list<R,A0 const&> signature(R (A0::*)() const)
-{
-    return mpl::type_list<R,A0 const&>();
-}
-
-template <class R, class A0, class A1>
-mpl::type_list<R,A0 const&,A1> signature(R (A0::*)(A1) const)
-{
-    return mpl::type_list<R,A0 const&,A1>();
-}
-
-template <class R, class A0, class A1, class A2>
-mpl::type_list<R,A0 const&,A1,A2> signature(R (A0::*)(A1, A2) const)
-{
-    return mpl::type_list<R,A0 const&,A1,A2>();
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-mpl::type_list<R,A0 const&,A1,A2,A3> signature(R (A0::*)(A1, A2, A3) const)
-{
-    return mpl::type_list<R,A0 const&,A1,A2,A3>();
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-mpl::type_list<R,A0 const&,A1,A2,A3,A4> signature(R (A0::*)(A1, A2, A3, A4) const)
-{
-    return mpl::type_list<R,A0 const&,A1,A2,A3,A4>();
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-mpl::type_list<R,A0 const&,A1,A2,A3,A4,A5> signature(R (A0::*)(A1, A2, A3, A4, A5) const)
-{
-    return mpl::type_list<R,A0 const&,A1,A2,A3,A4,A5>();
-}
-
-
-template <class R, class A0>
-mpl::type_list<R,A0 volatile&> signature(R (A0::*)() volatile)
-{
-    return mpl::type_list<R,A0 volatile&>();
-}
-
-template <class R, class A0, class A1>
-mpl::type_list<R,A0 volatile&,A1> signature(R (A0::*)(A1) volatile)
-{
-    return mpl::type_list<R,A0 volatile&,A1>();
-}
-
-template <class R, class A0, class A1, class A2>
-mpl::type_list<R,A0 volatile&,A1,A2> signature(R (A0::*)(A1, A2) volatile)
-{
-    return mpl::type_list<R,A0 volatile&,A1,A2>();
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-mpl::type_list<R,A0 volatile&,A1,A2,A3> signature(R (A0::*)(A1, A2, A3) volatile)
-{
-    return mpl::type_list<R,A0 volatile&,A1,A2,A3>();
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-mpl::type_list<R,A0 volatile&,A1,A2,A3,A4> signature(R (A0::*)(A1, A2, A3, A4) volatile)
-{
-    return mpl::type_list<R,A0 volatile&,A1,A2,A3,A4>();
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-mpl::type_list<R,A0 volatile&,A1,A2,A3,A4,A5> signature(R (A0::*)(A1, A2, A3, A4, A5) volatile)
-{
-    return mpl::type_list<R,A0 volatile&,A1,A2,A3,A4,A5>();
-}
-
-
-template <class R, class A0>
-mpl::type_list<R,A0 const volatile&> signature(R (A0::*)() const volatile)
-{
-    return mpl::type_list<R,A0 const volatile&>();
-}
-
-template <class R, class A0, class A1>
-mpl::type_list<R,A0 const volatile&,A1> signature(R (A0::*)(A1) const volatile)
-{
-    return mpl::type_list<R,A0 const volatile&,A1>();
-}
-
-template <class R, class A0, class A1, class A2>
-mpl::type_list<R,A0 const volatile&,A1,A2> signature(R (A0::*)(A1, A2) const volatile)
-{
-    return mpl::type_list<R,A0 const volatile&,A1,A2>();
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-mpl::type_list<R,A0 const volatile&,A1,A2,A3> signature(R (A0::*)(A1, A2, A3) const volatile)
-{
-    return mpl::type_list<R,A0 const volatile&,A1,A2,A3>();
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-mpl::type_list<R,A0 const volatile&,A1,A2,A3,A4> signature(R (A0::*)(A1, A2, A3, A4) const volatile)
-{
-    return mpl::type_list<R,A0 const volatile&,A1,A2,A3,A4>();
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-mpl::type_list<R,A0 const volatile&,A1,A2,A3,A4,A5> signature(R (A0::*)(A1, A2, A3, A4, A5) const volatile)
-{
-    return mpl::type_list<R,A0 const volatile&,A1,A2,A3,A4,A5>();
-}
-
-}}} // namespace boost::python::detail
-
-#endif // SIGNATURE_DWA2002128_HPP
-
diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp
index 5ca8c41e..10c54629 100644
--- a/include/boost/python/object/class.hpp
+++ b/include/boost/python/object/class.hpp
@@ -59,6 +59,8 @@ struct BOOST_PYTHON_DECL instance_holder : private noncopyable
  private:
     instance_holder* m_next;
 };
+// This macro is needed for implementation of derived holders
+# define BOOST_PYTHON_UNFORWARD(N,ignored) (typename unforward<A##N>::type)(a##N)
 
 // Each extension instance will be one of these
 struct instance
diff --git a/include/boost/python/object/pointer_holder.hpp b/include/boost/python/object/pointer_holder.hpp
index 3a8e2cec..31e8fead 100644
--- a/include/boost/python/object/pointer_holder.hpp
+++ b/include/boost/python/object/pointer_holder.hpp
@@ -15,6 +15,8 @@
 # include <boost/mpl/select_type.hpp>
 # include <boost/mpl/apply.hpp>
 # include <boost/python/detail/pointee.hpp>
+# include <boost/python/detail/preprocessor.hpp>
+# include <boost/preprocessor/enum_params.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -22,125 +24,27 @@ template <class Pointer, class Value>
 struct pointer_holder : instance_holder
 {
     pointer_holder(Pointer);
-    
+
     // Forward construction to the held object
-    pointer_holder(PyObject*)
-        : m_p(new Value) {}
+# ifndef BOOST_PYTHON_GENERATE_CODE
+#  include <boost/python/preprocessed/pointer_holder.hpp>
+# endif 
 
-    
-    template <class A1>
-    pointer_holder(PyObject*, A1 a1)
-        : m_p(new Value(
-            (typename unforward<A1>::type)(a1)
-                  ))
-    {}
-    
-    template <class A1, class A2>
-    pointer_holder(PyObject*, A1 a1, A2 a2)
-        : m_p(new Value(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            ))
-    {}
-    
-    template <class A1, class A2, class A3>
-    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3)
-        : m_p(new Value(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            ))
-    {}
-    
-    template <class A1, class A2, class A3, class A4>
-    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4)
-        : m_p(new Value(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            ))
-    {}
-    
-    template <class A1, class A2, class A3, class A4, class A5>
-    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-        : m_p(new Value(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            )) {}
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-        : m_p(new Value(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            )) {}
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-        : m_p(new Value(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            ))
-    {}
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-        : m_p(new Value(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            , (typename unforward<A8>::type)(a8)
-            ))
-    {}
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-        : m_p(new Value(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            , (typename unforward<A8>::type)(a8)
-            , (typename unforward<A9>::type)(a9)
-            ))
-    {}
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
-        : m_p(new Value(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            , (typename unforward<A8>::type)(a8)
-            , (typename unforward<A9>::type)(a9)
-            , (typename unforward<A10>::type)(a10)
-            ))
+
+# define BOOST_PYTHON_CONSTRUCT_POINTER_HOLDER(nargs, ignored)          \
+    BOOST_PP_EXPR_IF(nargs, template <)                                 \
+        BOOST_PP_ENUM_PARAMS(nargs, class A)                            \
+    BOOST_PP_EXPR_IF(nargs, >)                                          \
+    pointer_holder(PyObject*                                            \
+                   BOOST_PP_COMMA_IF(nargs)                             \
+                   BOOST_PYTHON_ENUM_PARAMS2(nargs, (A,a)))             \
+        : m_p(new Value(                                                \
+                  BOOST_PP_ENUM(nargs, BOOST_PYTHON_UNFORWARD, nil)     \
+            ))                                                          \
     {}
 
+    BOOST_PYTHON_REPEAT_ARITY_2ND(BOOST_PYTHON_CONSTRUCT_POINTER_HOLDER,nil)
+        
  private: // required holder implementation
     void* holds(converter::undecorated_type_id_t);
 
@@ -158,153 +62,26 @@ struct pointer_holder_back_reference : instance_holder
     pointer_holder_back_reference(Pointer);
     
     // Forward construction to the held object
-    pointer_holder_back_reference(PyObject* p)
-        : m_p(new held_type(p)) {
-        void const* x = &instance_finder<held_type>::registration; (void)x;
-    }
-
-    template <class A1>
-    pointer_holder_back_reference(PyObject* p, A1 a1)
-        : m_p(new held_type(p
-            , (typename unforward<A1>::type)(a1)
-                  ))
-    {
-        void const* x = &instance_finder<held_type>::registration; (void)x;
-    }
-
+# ifndef BOOST_PYTHON_GENERATE_CODE
+#  include <boost/python/preprocessed/pointer_holder_back_reference.hpp>
+# endif
     
-    template <class A1, class A2>
-    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2)
-        : m_p(new held_type(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            ))
-    {
-        void const* x = &instance_finder<held_type>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3>
-    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3)
-        : m_p(new held_type(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            ))
-    {
-        void const* x = &instance_finder<held_type>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4>
-    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4)
-        : m_p(new held_type(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            ))
-    {
-        void const* x = &instance_finder<held_type>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4, class A5>
-    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-        : m_p(new held_type(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            )) {
-        void const* x = &instance_finder<held_type>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-        : m_p(new held_type(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            )) {
-        void const* x = &instance_finder<held_type>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-        : m_p(new held_type(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            ))
-    {
-        void const* x = &instance_finder<held_type>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-        : m_p(new held_type(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            , (typename unforward<A8>::type)(a8)
-            ))
-    {
-        void const* x = &instance_finder<held_type>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-        : m_p(new held_type(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            , (typename unforward<A8>::type)(a8)
-            , (typename unforward<A9>::type)(a9)
-            ))
-    {
-        void const* x = &instance_finder<held_type>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
-        : m_p(new held_type(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            , (typename unforward<A8>::type)(a8)
-            , (typename unforward<A9>::type)(a9)
-            , (typename unforward<A10>::type)(a10)
-            ))
-    {
-        void const* x = &instance_finder<held_type>::registration; (void)x;
+# define BOOST_PYTHON_CONSTRUCT_POINTER_HOLDER_BACK_REFERENCE(nargs, ignored)   \
+    BOOST_PP_EXPR_IF(nargs, template <)                                         \
+        BOOST_PP_ENUM_PARAMS(nargs, class A)                                    \
+    BOOST_PP_EXPR_IF(nargs, >)                                                  \
+    pointer_holder_back_reference(PyObject* p                                   \
+                   BOOST_PP_COMMA_IF(nargs)                                     \
+                   BOOST_PYTHON_ENUM_PARAMS2(nargs, (A,a)))                     \
+        : m_p(new held_type(                                                    \
+                    p,                                                          \
+                    BOOST_PP_ENUM(nargs, BOOST_PYTHON_UNFORWARD, nil)           \
+            ))                                                                  \
+    {                                                                           \
+        void const* x = &instance_finder<held_type>::registration; (void)x;     \
     }
 
+    BOOST_PYTHON_REPEAT_ARITY_2ND(BOOST_PYTHON_CONSTRUCT_POINTER_HOLDER_BACK_REFERENCE,nil)
 
  private: // required holder implementation
     void* holds(converter::undecorated_type_id_t);
diff --git a/include/boost/python/object/value_holder.hpp b/include/boost/python/object/value_holder.hpp
index d98d1d10..49251921 100644
--- a/include/boost/python/object/value_holder.hpp
+++ b/include/boost/python/object/value_holder.hpp
@@ -12,6 +12,8 @@
 # include <boost/python/object/inheritance.hpp>
 # include <boost/python/object/find_instance.hpp>
 # include <boost/python/object/forward.hpp>
+# include <boost/python/detail/preprocessor.hpp>
+# include <boost/preprocessor/enum_params.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -19,122 +21,24 @@ template <class Held>
 struct value_holder : instance_holder
 {
     // Forward construction to the held object
-    value_holder(PyObject*)
-        : m_held() {}
-    
-    template <class A1>
-    value_holder(PyObject*, A1 a1)
-        : m_held(
-            (typename unforward<A1>::type)(a1)
-            )
-    {}
-    
-    template <class A1, class A2>
-    value_holder(PyObject*, A1 a1, A2 a2)
-        : m_held(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            )
-    {}
-    
-    template <class A1, class A2, class A3>
-    value_holder(PyObject*, A1 a1, A2 a2, A3 a3)
-        : m_held(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            )
-    {}
-    
-    template <class A1, class A2, class A3, class A4>
-    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4)
-        : m_held(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            )
-    {}
-    
-    template <class A1, class A2, class A3, class A4, class A5>
-    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-        : m_held(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            ) {}
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-        : m_held(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            ) {}
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-        : m_held(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            )
-    {}
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-        : m_held(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            , (typename unforward<A8>::type)(a8)
-            )
-    {}
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-        : m_held(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            , (typename unforward<A8>::type)(a8)
-            , (typename unforward<A9>::type)(a9)
-            )
-    {}
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
-        : m_held(
-            (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            , (typename unforward<A8>::type)(a8)
-            , (typename unforward<A9>::type)(a9)
-            , (typename unforward<A10>::type)(a10)
-            )
+# ifndef BOOST_PYTHON_GENERATE_CODE
+#  include <boost/python/preprocessed/value_holder.hpp>
+# endif 
+
+# define BOOST_PYTHON_CONSTRUCT_VALUE_HOLDER(nargs, ignored)  \
+    BOOST_PP_EXPR_IF(nargs, template <)                         \
+        BOOST_PP_ENUM_PARAMS(nargs, class A)                    \
+    BOOST_PP_EXPR_IF(nargs, >)                                  \
+    value_holder(PyObject*                                      \
+                   BOOST_PP_COMMA_IF(nargs)                     \
+                   BOOST_PYTHON_ENUM_PARAMS2(nargs, (A,a)))     \
+        : m_held(                                               \
+            BOOST_PP_ENUM(nargs, BOOST_PYTHON_UNFORWARD, nil)   \
+            )                                                   \
     {}
 
+    BOOST_PYTHON_REPEAT_ARITY_2ND(BOOST_PYTHON_CONSTRUCT_VALUE_HOLDER,nil)
+
  private: // required holder implementation
     void* holds(converter::undecorated_type_id_t);
 
@@ -146,154 +50,27 @@ template <class Held, class BackReferenceType>
 struct value_holder_back_reference : instance_holder
 {
     // Forward construction to the held object
-    value_holder_back_reference(PyObject* p)
-        : m_held() {
-        void const* x = &instance_finder<BackReferenceType>::registration; (void)x;
-    }
-
+# ifndef BOOST_PYTHON_GENERATE_CODE
+#  include <boost/python/preprocessed/value_holder_back_reference.hpp>
+# endif
     
-    template <class A1>
-    value_holder_back_reference(PyObject* p, A1 a1)
-        : m_held(p
-            , (typename unforward<A1>::type)(a1)
-            )
-    {
-        void const* x = &instance_finder<BackReferenceType>::registration; (void)x;
+# define BOOST_PYTHON_CONSTRUCT_VALUE_HOLDER_BACK_REFERENCE(nargs, ignored)             \
+    BOOST_PP_EXPR_IF(nargs, template <)                                                 \
+        BOOST_PP_ENUM_PARAMS(nargs, class A)                                            \
+    BOOST_PP_EXPR_IF(nargs, >)                                                          \
+    value_holder_back_reference(PyObject* p                                             \
+                   BOOST_PP_COMMA_IF(nargs)                                             \
+                   BOOST_PYTHON_ENUM_PARAMS2(nargs, (A,a)))                             \
+        : m_held(                                                                       \
+            p BOOST_PP_COMMA_IF(nargs)                                                  \
+            BOOST_PP_ENUM(nargs, BOOST_PYTHON_UNFORWARD, nil)                           \
+            )                                                                           \
+    {                                                                                   \
+        void const* x = &instance_finder<BackReferenceType>::registration; (void)x;     \
     }
 
+    BOOST_PYTHON_REPEAT_ARITY_2ND(BOOST_PYTHON_CONSTRUCT_VALUE_HOLDER_BACK_REFERENCE,nil)
     
-    template <class A1, class A2>
-    value_holder_back_reference(PyObject* p, A1 a1, A2 a2)
-        : m_held(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            )
-    {
-        void const* x = &instance_finder<BackReferenceType>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3>
-    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3)
-        : m_held(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            )
-    {
-        void const* x = &instance_finder<BackReferenceType>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4>
-    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4)
-        : m_held(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            )
-    {
-        void const* x = &instance_finder<BackReferenceType>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4, class A5>
-    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-        : m_held(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            ) {
-        void const* x = &instance_finder<BackReferenceType>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-        : m_held(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            ) {
-        void const* x = &instance_finder<BackReferenceType>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-        : m_held(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            )
-    {
-        void const* x = &instance_finder<BackReferenceType>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-        : m_held(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            , (typename unforward<A8>::type)(a8)
-            )
-    {
-        void const* x = &instance_finder<BackReferenceType>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-        : m_held(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            , (typename unforward<A8>::type)(a8)
-            , (typename unforward<A9>::type)(a9)
-            )
-    {
-        void const* x = &instance_finder<BackReferenceType>::registration; (void)x;
-    }
-
-    
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
-        : m_held(p
-            , (typename unforward<A1>::type)(a1)
-            , (typename unforward<A2>::type)(a2)
-            , (typename unforward<A3>::type)(a3)
-            , (typename unforward<A4>::type)(a4)
-            , (typename unforward<A5>::type)(a5)
-            , (typename unforward<A6>::type)(a6)
-            , (typename unforward<A7>::type)(a7)
-            , (typename unforward<A8>::type)(a8)
-            , (typename unforward<A9>::type)(a9)
-            , (typename unforward<A10>::type)(a10)
-            )
-    {
-        void const* x = &instance_finder<BackReferenceType>::registration; (void)x;
-    }
-
  private: // required holder implementation
     void* holds(converter::undecorated_type_id_t);
 
diff --git a/include/boost/python/preprocessed/pointer_holder.hpp b/include/boost/python/preprocessed/pointer_holder.hpp
new file mode 100644
index 00000000..0f2bf149
--- /dev/null
+++ b/include/boost/python/preprocessed/pointer_holder.hpp
@@ -0,0 +1,105 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef POINTER_HOLDER_DWA2002411_HPP
+# define POINTER_HOLDER_DWA2002411_HPP
+
+pointer_holder(PyObject*)
+    :m_p(new Value())
+{
+
+}
+template<class A0>pointer_holder(PyObject*,A0 a0)
+    :m_p(new Value(
+             (typename unforward<A0>::type)(a0)))
+{
+
+}
+template<class A0,class A1>pointer_holder(PyObject*,A0 a0,A1 a1)
+    :m_p(new Value(
+             (typename unforward<A0>::type)(a0),
+             (typename unforward<A1>::type)(a1)))
+{
+
+}
+template<class A0,class A1,class A2>pointer_holder(PyObject*,A0 a0,A1 a1,A2 a2)
+    :m_p(new Value(
+             (typename unforward<A0>::type)(a0),
+             (typename unforward<A1>::type)(a1),
+             (typename unforward<A2>::type)(a2)))
+{
+
+}
+template<class A0,class A1,class A2,class A3>pointer_holder(PyObject*,A0 a0,A1 a1,A2 a2,A3 a3)
+    :m_p(new Value(
+             (typename unforward<A0>::type)(a0),
+             (typename unforward<A1>::type)(a1),
+             (typename unforward<A2>::type)(a2),
+             (typename unforward<A3>::type)(a3)))
+{
+
+}
+template<class A0,class A1,class A2,class A3,class A4>pointer_holder(PyObject*,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4)
+    :m_p(new Value(
+             (typename unforward<A0>::type)(a0),
+             (typename unforward<A1>::type)(a1),
+             (typename unforward<A2>::type)(a2),
+             (typename unforward<A3>::type)(a3),
+             (typename unforward<A4>::type)(a4)))
+{
+
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5>pointer_holder(PyObject*,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
+    :m_p(new Value(
+             (typename unforward<A0>::type)(a0),
+             (typename unforward<A1>::type)(a1),
+             (typename unforward<A2>::type)(a2),
+             (typename unforward<A3>::type)(a3),
+             (typename unforward<A4>::type)(a4),
+             (typename unforward<A5>::type)(a5)))
+{
+
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5,class A6>pointer_holder(PyObject*,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
+    :m_p(new Value(
+             (typename unforward<A0>::type)(a0),
+             (typename unforward<A1>::type)(a1),
+             (typename unforward<A2>::type)(a2),
+             (typename unforward<A3>::type)(a3),
+             (typename unforward<A4>::type)(a4),
+             (typename unforward<A5>::type)(a5),
+             (typename unforward<A6>::type)(a6)))
+{
+
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>pointer_holder(PyObject*,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
+    :m_p(new Value(
+             (typename unforward<A0>::type)(a0),
+             (typename unforward<A1>::type)(a1),
+             (typename unforward<A2>::type)(a2),
+             (typename unforward<A3>::type)(a3),
+             (typename unforward<A4>::type)(a4),
+             (typename unforward<A5>::type)(a5),
+             (typename unforward<A6>::type)(a6),
+             (typename unforward<A7>::type)(a7)))
+{
+
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>pointer_holder(PyObject*,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
+    :m_p(new Value(
+             (typename unforward<A0>::type)(a0),
+             (typename unforward<A1>::type)(a1),
+             (typename unforward<A2>::type)(a2),
+             (typename unforward<A3>::type)(a3),
+             (typename unforward<A4>::type)(a4),
+             (typename unforward<A5>::type)(a5),
+             (typename unforward<A6>::type)(a6),
+             (typename unforward<A7>::type)(a7),
+             (typename unforward<A8>::type)(a8)))
+{
+
+}
+
+#endif // POINTER_HOLDER_DWA2002411_HPP
diff --git a/include/boost/python/preprocessed/pointer_holder_back_reference.hpp b/include/boost/python/preprocessed/pointer_holder_back_reference.hpp
new file mode 100644
index 00000000..b07242cc
--- /dev/null
+++ b/include/boost/python/preprocessed/pointer_holder_back_reference.hpp
@@ -0,0 +1,115 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef POINTER_HOLDER_BACK_REFERENCE_DWA2002411_HPP
+# define POINTER_HOLDER_BACK_REFERENCE_DWA2002411_HPP
+
+pointer_holder_back_reference(PyObject*p)
+    :m_p(new held_type(p,))
+{
+    void const*x=&instance_finder<held_type>::registration;
+    (void)x;
+}
+template<class A0>pointer_holder_back_reference(PyObject*p,A0 a0)
+    :m_p(new held_type(p,
+                       (typename unforward<A0>::type)(a0)))
+{
+    void const*x=&instance_finder<held_type>::registration;
+    (void)x;
+}
+template<class A0,class A1>pointer_holder_back_reference(PyObject*p,A0 a0,A1 a1)
+    :m_p(new held_type(p,
+                       (typename unforward<A0>::type)(a0),
+                       (typename unforward<A1>::type)(a1)))
+{
+    void const*x=&instance_finder<held_type>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2>pointer_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2)
+    :m_p(new held_type(p,
+                       (typename unforward<A0>::type)(a0),
+                       (typename unforward<A1>::type)(a1),
+                       (typename unforward<A2>::type)(a2)))
+{
+    void const*x=&instance_finder<held_type>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2,class A3>pointer_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2,A3 a3)
+    :m_p(new held_type(p,
+                       (typename unforward<A0>::type)(a0),
+                       (typename unforward<A1>::type)(a1),
+                       (typename unforward<A2>::type)(a2),
+                       (typename unforward<A3>::type)(a3)))
+{
+    void const*x=&instance_finder<held_type>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2,class A3,class A4>pointer_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4)
+    :m_p(new held_type(p,
+                       (typename unforward<A0>::type)(a0),
+                       (typename unforward<A1>::type)(a1),
+                       (typename unforward<A2>::type)(a2),
+                       (typename unforward<A3>::type)(a3),
+                       (typename unforward<A4>::type)(a4)))
+{
+    void const*x=&instance_finder<held_type>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5>pointer_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
+    :m_p(new held_type(p,
+                       (typename unforward<A0>::type)(a0),
+                       (typename unforward<A1>::type)(a1),
+                       (typename unforward<A2>::type)(a2),
+                       (typename unforward<A3>::type)(a3),
+                       (typename unforward<A4>::type)(a4),
+                       (typename unforward<A5>::type)(a5)))
+{
+    void const*x=&instance_finder<held_type>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5,class A6>pointer_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
+    :m_p(new held_type(p,
+                       (typename unforward<A0>::type)(a0),
+                       (typename unforward<A1>::type)(a1),
+                       (typename unforward<A2>::type)(a2),
+                       (typename unforward<A3>::type)(a3),
+                       (typename unforward<A4>::type)(a4),
+                       (typename unforward<A5>::type)(a5),
+                       (typename unforward<A6>::type)(a6)))
+{
+    void const*x=&instance_finder<held_type>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>pointer_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
+    :m_p(new held_type(p,
+                       (typename unforward<A0>::type)(a0),
+                       (typename unforward<A1>::type)(a1),
+                       (typename unforward<A2>::type)(a2),
+                       (typename unforward<A3>::type)(a3),
+                       (typename unforward<A4>::type)(a4),
+                       (typename unforward<A5>::type)(a5),
+                       (typename unforward<A6>::type)(a6),
+                       (typename unforward<A7>::type)(a7)))
+{
+    void const*x=&instance_finder<held_type>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>pointer_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
+    :m_p(new held_type(p,
+                       (typename unforward<A0>::type)(a0),
+                       (typename unforward<A1>::type)(a1),
+                       (typename unforward<A2>::type)(a2),
+                       (typename unforward<A3>::type)(a3),
+                       (typename unforward<A4>::type)(a4),
+                       (typename unforward<A5>::type)(a5),
+                       (typename unforward<A6>::type)(a6),
+                       (typename unforward<A7>::type)(a7),
+                       (typename unforward<A8>::type)(a8)))
+{
+    void const*x=&instance_finder<held_type>::registration;
+    (void)x;
+}
+
+#endif // POINTER_HOLDER_BACK_REFERENCE_DWA2002411_HPP
diff --git a/include/boost/python/preprocessed/value_holder.hpp b/include/boost/python/preprocessed/value_holder.hpp
new file mode 100644
index 00000000..88ba56dd
--- /dev/null
+++ b/include/boost/python/preprocessed/value_holder.hpp
@@ -0,0 +1,105 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef VALUE_HOLDER_DWA2002411_HPP
+# define VALUE_HOLDER_DWA2002411_HPP
+
+value_holder(PyObject*)
+    :m_held()
+{
+
+}
+template<class A0>value_holder(PyObject*,A0 a0)
+    :m_held(
+        (typename unforward<A0>::type)(a0))
+{
+
+}
+template<class A0,class A1>value_holder(PyObject*,A0 a0,A1 a1)
+    :m_held(
+        (typename unforward<A0>::type)(a0),
+        (typename unforward<A1>::type)(a1))
+{
+
+}
+template<class A0,class A1,class A2>value_holder(PyObject*,A0 a0,A1 a1,A2 a2)
+    :m_held(
+        (typename unforward<A0>::type)(a0),
+        (typename unforward<A1>::type)(a1),
+        (typename unforward<A2>::type)(a2))
+{
+
+}
+template<class A0,class A1,class A2,class A3>value_holder(PyObject*,A0 a0,A1 a1,A2 a2,A3 a3)
+    :m_held(
+        (typename unforward<A0>::type)(a0),
+        (typename unforward<A1>::type)(a1),
+        (typename unforward<A2>::type)(a2),
+        (typename unforward<A3>::type)(a3))
+{
+
+}
+template<class A0,class A1,class A2,class A3,class A4>value_holder(PyObject*,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4)
+    :m_held(
+        (typename unforward<A0>::type)(a0),
+        (typename unforward<A1>::type)(a1),
+        (typename unforward<A2>::type)(a2),
+        (typename unforward<A3>::type)(a3),
+        (typename unforward<A4>::type)(a4))
+{
+
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5>value_holder(PyObject*,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
+    :m_held(
+        (typename unforward<A0>::type)(a0),
+        (typename unforward<A1>::type)(a1),
+        (typename unforward<A2>::type)(a2),
+        (typename unforward<A3>::type)(a3),
+        (typename unforward<A4>::type)(a4),
+        (typename unforward<A5>::type)(a5))
+{
+
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5,class A6>value_holder(PyObject*,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
+    :m_held(
+        (typename unforward<A0>::type)(a0),
+        (typename unforward<A1>::type)(a1),
+        (typename unforward<A2>::type)(a2),
+        (typename unforward<A3>::type)(a3),
+        (typename unforward<A4>::type)(a4),
+        (typename unforward<A5>::type)(a5),
+        (typename unforward<A6>::type)(a6))
+{
+
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>value_holder(PyObject*,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
+    :m_held(
+        (typename unforward<A0>::type)(a0),
+        (typename unforward<A1>::type)(a1),
+        (typename unforward<A2>::type)(a2),
+        (typename unforward<A3>::type)(a3),
+        (typename unforward<A4>::type)(a4),
+        (typename unforward<A5>::type)(a5),
+        (typename unforward<A6>::type)(a6),
+        (typename unforward<A7>::type)(a7))
+{
+
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>value_holder(PyObject*,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
+    :m_held(
+        (typename unforward<A0>::type)(a0),
+        (typename unforward<A1>::type)(a1),
+        (typename unforward<A2>::type)(a2),
+        (typename unforward<A3>::type)(a3),
+        (typename unforward<A4>::type)(a4),
+        (typename unforward<A5>::type)(a5),
+        (typename unforward<A6>::type)(a6),
+        (typename unforward<A7>::type)(a7),
+        (typename unforward<A8>::type)(a8))
+{
+
+}       
+
+#endif // VALUE_HOLDER_DWA2002411_HPP
diff --git a/include/boost/python/preprocessed/value_holder_back_reference.hpp b/include/boost/python/preprocessed/value_holder_back_reference.hpp
new file mode 100644
index 00000000..c9d91434
--- /dev/null
+++ b/include/boost/python/preprocessed/value_holder_back_reference.hpp
@@ -0,0 +1,117 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef VALUE_HOLDER_BACK_REFERENCE_DWA2002411_HPP
+# define VALUE_HOLDER_BACK_REFERENCE_DWA2002411_HPP
+
+value_holder_back_reference(PyObject*p)
+    :m_held(p)
+{
+    void const*x=&instance_finder<BackReferenceType>::registration;
+    (void)x;
+}
+
+
+template<class A0>value_holder_back_reference(PyObject*p,A0 a0)
+    :m_held(p,
+            (typename unforward<A0>::type)(a0))
+{
+    void const*x=&instance_finder<BackReferenceType>::registration;
+    (void)x;
+}
+template<class A0,class A1>value_holder_back_reference(PyObject*p,A0 a0,A1 a1)
+    :m_held(p,
+            (typename unforward<A0>::type)(a0),
+            (typename unforward<A1>::type)(a1))
+{
+    void const*x=&instance_finder<BackReferenceType>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2>value_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2)
+    :m_held(p,
+            (typename unforward<A0>::type)(a0),
+            (typename unforward<A1>::type)(a1),
+            (typename unforward<A2>::type)(a2))
+{
+    void const*x=&instance_finder<BackReferenceType>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2,class A3>value_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2,A3 a3)
+    :m_held(p,
+            (typename unforward<A0>::type)(a0),
+            (typename unforward<A1>::type)(a1),
+            (typename unforward<A2>::type)(a2),
+            (typename unforward<A3>::type)(a3))
+{
+    void const*x=&instance_finder<BackReferenceType>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2,class A3,class A4>value_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4)
+    :m_held(p,
+            (typename unforward<A0>::type)(a0),
+            (typename unforward<A1>::type)(a1),
+            (typename unforward<A2>::type)(a2),
+            (typename unforward<A3>::type)(a3),
+            (typename unforward<A4>::type)(a4))
+{
+    void const*x=&instance_finder<BackReferenceType>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5>value_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
+    :m_held(p,
+            (typename unforward<A0>::type)(a0),
+            (typename unforward<A1>::type)(a1),
+            (typename unforward<A2>::type)(a2),
+            (typename unforward<A3>::type)(a3),
+            (typename unforward<A4>::type)(a4),
+            (typename unforward<A5>::type)(a5))
+{
+    void const*x=&instance_finder<BackReferenceType>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5,class A6>value_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
+    :m_held(p,
+            (typename unforward<A0>::type)(a0),
+            (typename unforward<A1>::type)(a1),
+            (typename unforward<A2>::type)(a2),
+            (typename unforward<A3>::type)(a3),
+            (typename unforward<A4>::type)(a4),
+            (typename unforward<A5>::type)(a5),
+            (typename unforward<A6>::type)(a6))
+{
+    void const*x=&instance_finder<BackReferenceType>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>value_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
+    :m_held(p,
+            (typename unforward<A0>::type)(a0),
+            (typename unforward<A1>::type)(a1),
+            (typename unforward<A2>::type)(a2),
+            (typename unforward<A3>::type)(a3),
+            (typename unforward<A4>::type)(a4),
+            (typename unforward<A5>::type)(a5),
+            (typename unforward<A6>::type)(a6),
+            (typename unforward<A7>::type)(a7))
+{
+    void const*x=&instance_finder<BackReferenceType>::registration;
+    (void)x;
+}
+template<class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>value_holder_back_reference(PyObject*p,A0 a0,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
+    :m_held(p,
+            (typename unforward<A0>::type)(a0),
+            (typename unforward<A1>::type)(a1),
+            (typename unforward<A2>::type)(a2),
+            (typename unforward<A3>::type)(a3),
+            (typename unforward<A4>::type)(a4),
+            (typename unforward<A5>::type)(a5),
+            (typename unforward<A6>::type)(a6),
+            (typename unforward<A7>::type)(a7),
+            (typename unforward<A8>::type)(a8))
+{
+    void const*x=&instance_finder<BackReferenceType>::registration;
+    (void)x;
+}
+
+#endif // VALUE_HOLDER_BACK_REFERENCE_DWA2002411_HPP