From dd1b102282394698632367f514d7734fe23bf993 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 23 May 2002 22:42:09 +0000
Subject: [PATCH] result() fixes

[SVN r14031]
---
 include/boost/python/detail/result.hpp       |  24 ++-
 include/boost/python/preprocessed/result.hpp | 160 +++++++++----------
 test/result.cpp                              |  24 +--
 3 files changed, 103 insertions(+), 105 deletions(-)

diff --git a/include/boost/python/detail/result.hpp b/include/boost/python/detail/result.hpp
index d8bf1358..b00fd23f 100755
--- a/include/boost/python/detail/result.hpp
+++ b/include/boost/python/detail/result.hpp
@@ -31,23 +31,21 @@ namespace boost { namespace python { namespace detail {
 
 #  define BOOST_PYTHON_FIRST_ARGUMENT_PF(args, ignored)                                         \
 template <class R BOOST_PP_COMMA_IF(args) BOOST_MPL_TEMPLATE_PARAMETERS(0, args, class A)>      \
-boost::type<R>* result(BOOST_PYTHON_FN(*,0,args), long = 0) { return 0; }
+boost::type<R>* result(BOOST_PYTHON_FN(*,0,args), int = 0) { return 0; }
 
-#  define BOOST_PYTHON_FIRST_ARGUMENT_PMF(args, cv)                                     \
-template <class R, BOOST_MPL_TEMPLATE_PARAMETERS(0, args, class A)>                     \
-boost::type<R>* result(BOOST_PYTHON_FN(A0::*,1,args)cv(), long = 0) { return 0; }
+#  define BOOST_PYTHON_FIRST_ARGUMENT_PMF(args, cv)                                             \
+template <class R, BOOST_MPL_TEMPLATE_PARAMETERS(0, args, class A)>                             \
+boost::type<R>* result(BOOST_PYTHON_FN(A0::*,1,args)cv(), int = 0) { return 0; }
 
 BOOST_PYTHON_REPEAT_ARITY_2ND(BOOST_PYTHON_FIRST_ARGUMENT_PF, nil)
 BOOST_PYTHON_REPEAT_MF_CV_2ND(BOOST_PYTHON_FIRST_ARGUMENT_PMF)
 
 template <class R, class T>
-boost::type<R>* result(R (T::*), long = 0) { return 0; }
+boost::type<R>* result(R (T::*), int = 0) { return 0; }
 
-
-#  if defined(BOOST_MSVC) && BOOST_MSVC <= 1300  /* it almost works with VC6, but not VC7 */    \
-   || (defined(BOOST_MSVC) && _MSC_FULL_VER == 13012108)  /*  or the VC7.01 alpha */            \
-   || defined(__GNUC__) && __GNUC__ < 3                                                         \
-   || defined(__MWERKS__) && __MWERKS__ < 3000
+#  if (defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140)  \
+   || (defined(__GNUC__) && __GNUC__ < 3)                 \
+   || (defined(__MWERKS__) && __MWERKS__ < 0x3000)
 // This code actually works on all implementations, but why use it when we don't have to?
 template <class T>
 struct get_result_type
@@ -71,15 +69,15 @@ struct result_result
 
     typedef typename t1::type* type;
 };
+
 template <class X>
 typename result_result<X>::type
-result(X const&, int = 0) { return 0; }
+result(X const&, short) { return 0; }
 
 #  else // Simpler code for more-capable compilers
-
 template <class X>
 boost::type<typename X::result_type>*
-result(X const&, int = 0) { return 0; }
+result(X const&, short = 0) { return 0; }
 
 #  endif 
 
diff --git a/include/boost/python/preprocessed/result.hpp b/include/boost/python/preprocessed/result.hpp
index f9eb99c6..10180c99 100755
--- a/include/boost/python/preprocessed/result.hpp
+++ b/include/boost/python/preprocessed/result.hpp
@@ -7,403 +7,403 @@
 # define RESULT2_DWA2002521_HPP
 
 template<class R>
-boost::type<R>*result(R(*)(),long=0)
+boost::type<R>*result(R(*)(),int=0)
 {
     return 0;
 }
 template<class R,class A0>
-boost::type<R>*result(R(*)(A0),long=0)
+boost::type<R>*result(R(*)(A0),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1>
-boost::type<R>*result(R(*)(A0,A1),long=0)
+boost::type<R>*result(R(*)(A0,A1),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2>
-boost::type<R>*result(R(*)(A0,A1,A2),long=0)
+boost::type<R>*result(R(*)(A0,A1,A2),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3>
-boost::type<R>*result(R(*)(A0,A1,A2,A3),long=0)
+boost::type<R>*result(R(*)(A0,A1,A2,A3),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4>
-boost::type<R>*result(R(*)(A0,A1,A2,A3,A4),long=0)
+boost::type<R>*result(R(*)(A0,A1,A2,A3,A4),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5>
-boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5),long=0)
+boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6>
-boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6),long=0)
+boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
-boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7),long=0)
+boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
-boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8),long=0)
+boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
-boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9),long=0)
+boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10>
-boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10),long=0)
+boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11>
-boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11),long=0)
+boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12>
-boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12),long=0)
+boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13>
-boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13),long=0)
+boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13,class A14>
-boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14),long=0)
+boost::type<R>*result(R(*)(A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14),int=0)
 {
     return 0;
 }
  
 template<class R,class A0>
-boost::type<R>*result(R(A0::*)(),long=0)
+boost::type<R>*result(R(A0::*)(),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1>
-boost::type<R>*result(R(A0::*)(A1),long=0)
+boost::type<R>*result(R(A0::*)(A1),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2>
-boost::type<R>*result(R(A0::*)(A1,A2),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3>
-boost::type<R>*result(R(A0::*)(A1,A2,A3),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13,class A14>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14),int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13,class A14,class A15>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15),long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15),int=0)
 {
     return 0;
 }
 template<class R,class A0>
-boost::type<R>*result(R(A0::*)()const,long=0)
+boost::type<R>*result(R(A0::*)()const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1>
-boost::type<R>*result(R(A0::*)(A1)const,long=0)
+boost::type<R>*result(R(A0::*)(A1)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2>
-boost::type<R>*result(R(A0::*)(A1,A2)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3>
-boost::type<R>*result(R(A0::*)(A1,A2,A3)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13,class A14>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)const,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13,class A14,class A15>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)const,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)const,int=0)
 {
     return 0;
 }
 template<class R,class A0>
-boost::type<R>*result(R(A0::*)()volatile,long=0)
+boost::type<R>*result(R(A0::*)()volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1>
-boost::type<R>*result(R(A0::*)(A1)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2>
-boost::type<R>*result(R(A0::*)(A1,A2)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3>
-boost::type<R>*result(R(A0::*)(A1,A2,A3)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13,class A14>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13,class A14,class A15>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0>
-boost::type<R>*result(R(A0::*)()const volatile,long=0)
+boost::type<R>*result(R(A0::*)()const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1>
-boost::type<R>*result(R(A0::*)(A1)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2>
-boost::type<R>*result(R(A0::*)(A1,A2)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3>
-boost::type<R>*result(R(A0::*)(A1,A2,A3)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13,class A14>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14)const volatile,int=0)
 {
     return 0;
 }
 template<class R,class A0,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9,class A10,class A11,class A12,class A13,class A14,class A15>
-boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)const volatile,long=0)
+boost::type<R>*result(R(A0::*)(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15)const volatile,int=0)
 {
     return 0;
 }
diff --git a/test/result.cpp b/test/result.cpp
index caf0ec27..19b1cf41 100755
--- a/test/result.cpp
+++ b/test/result.cpp
@@ -61,51 +61,51 @@ int main()
     // Show that we can use the general version that works for
     // AdaptableFunctions
     expect_int(
-        result((int(*)())0,0L)
+        result((int(*)())0,0)
         );
 
     expect_int(
-        result((int(*)(char))0,0L)
+        result((int(*)(char))0,0)
         );
 
     expect_int(
-        result((int(X::*)())0,0L)
+        result((int(X::*)())0,0)
         );
 
     expect_int(
-        result((int(X::*)(char))0,0L)
+        result((int(X::*)(char))0,0)
         );
 
     expect_int(
-        result((int(X::*))0,0L)
+        result((int(X::*))0,0)
         );
     
     expect_int(
-        result(std::plus<int>(), 0L)
+        result(std::plus<int>(),0)
         );
 
     expect_string(
-        result((char*(*)())0,0L)
+        result((char*(*)())0,0)
         );
     
     expect_string(
-        result((char*(*)(char))0,0L)
+        result((char*(*)(char))0,0)
         );
     
     expect_string(
-        result((char*(X::*)())0,0L)
+        result((char*(X::*)())0,0)
         );
     
     expect_string(
-        result((char*(X::*)(char))0,0L)
+        result((char*(X::*)(char))0,0)
         );
     
     expect_string(
-        result((char*(X::*))0,0L)
+        result((char*(X::*))0,0)
         );
     
     expect_string(
-        result(std::plus<char*>(), 0L)
+        result(std::plus<char*>(),0)
         );
 
     return 0;