Create branches/filesystem-v3 for v2 removal

[SVN r77385]

doc/projects.html

@@ -396,33 +396,27 @@
       </blockquote>
     </dd>
 
-    <dt><b><a href="http://pyrap.googlecode.com/">Pyrap</a></b></dt>
-    <dd>
-      <p><a href="diepen@astron.nl"
-        >Ger van Diepen</a> writes:</p>
-
-      <blockquote>
-        <p>Pyrap is the python interface to the Radio-Astronomical Package
-        casacore (<a href="http://casacore.googlecode.com/"
-        >casacore.googlecode.com</a>). Astronomers love pyrap because
-        it makes it easily possible to get their data (observed with
-        radio-astronomical telescopes like LOFAR, ASKAP, and eVLA) in numpy
-        arrays and do basic data inspection and manipulation using the many
-        python packages that are available.</p>
-
-        <p>Boost.Python made it quite easily possible to create converters for
-        the various data types, also for numpy arrays and individual elements
-        of a numpy array. It's nice they work fully recursively. Mapping C++
-        functions to Python was straightforward.</p>
-      </blockquote>
-    </dd>
-
-    <dt><b><a href="http://www.rdkit.org/"
-           >RDKit: Cheminformatics and Machine Learning Software</a></b></dt>
+    <dt><b><a href="http://www.rationaldiscovery.com">Rational Discovery
+    LLC</a></b></dt>
 
     <dd>
-      A collection of cheminformatics and machine-learning software
-      written in C++ and Python.
+      Rational Discovery provides computational modeling, combinatorial
+      library design and custom software development services to the
+      pharmaceutical, biotech and chemical industries. We do a substantial
+      amount of internal research to develop new approaches for applying
+      machine-learning techniques to solve chemical problems. Because we're a
+      small organization and chemistry is a large and complex field, it is
+      essential that we be able to quickly and easily prototype and test new
+      algorithms.
+
+      <p>For our internal software, we implement core data structures in C
+      and expose them to Python using Boost.Python. Algorithm development is
+      done in Python and then translated to C if required (often it's not).
+      This hybrid development approach not only greatly increases our
+      productivity, but it also allows "non-developers" (people without C
+      experience) to take part in method development. Learning C is a
+      daunting task, but "Python fits your brain." (Thanks to Bruce Eckel for
+      the quote.)</p>
     </dd>
   </dl>
 

doc/tutorial/doc/html/python/functions.html

@@ -372,8 +372,8 @@ Namespaces are one honking great idea -- let's do more of those!
         or writing thin wrappers:
       </p>
 <pre class="programlisting"><span class="comment">// write "thin wrappers"</span>
-<span class="keyword">int</span> <span class="identifier">f1</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span> <span class="special">}</span>
-<span class="keyword">int</span> <span class="identifier">f2</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">);</span> <span class="special">}</span>
+<span class="keyword">int</span> <span class="identifier">f1</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span> <span class="special">}</span>
+<span class="keyword">int</span> <span class="identifier">f2</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">);</span> <span class="special">}</span>
 
 <span class="comment">/*...*/</span>
 

doc/tutorial/doc/tutorial.qbk

@@ -901,8 +901,8 @@ wrapping as outlined in the [link python.overloading previous section], or
 writing thin wrappers:
 
     // write "thin wrappers"
-    int f1(int x) { return f(x); }
-    int f2(int x, double y) { return f(x,y); }
+    int f1(int x) { f(x); }
+    int f2(int x, double y) { f(x,y); }
 
     /*...*/
 

example/Jamroot

@@ -11,10 +11,7 @@ use-project boost
 # boost_python library from the project whose global ID is
 # /boost/python.
 project
-  : requirements <library>/boost/python//boost_python 
-                 <implicit-dependency>/boost//headers 
-  : usage-requirements <implicit-dependency>/boost//headers 
-  ;
+  : requirements <library>/boost/python//boost_python ;
 
 # Declare the three extension modules.  You can specify multiple
 # source files after the colon separated by spaces.

example/boost-build.jam

@@ -2,6 +2,6 @@
 # Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-# Edit this path to point at the tools/build/src subdirectory of your
+# Edit this path to point at the tools/build/v2 subdirectory of your
 # Boost installation.  Absolute paths work, too.
-boost-build ../../../tools/build/src ;
+boost-build ../../../tools/build/v2 ;

example/quickstart/Jamroot

@@ -12,8 +12,6 @@ use-project boost
 # /boost/python.
 project boost-python-quickstart
   : requirements <library>/boost/python//boost_python 
-    		 <implicit-dependency>/boost//headers 
-  : usage-requirements <implicit-dependency>/boost//headers 	 
     ;
 
 # Make the definition of the python-extension rule available
@@ -31,7 +29,7 @@ import testing ;
 testing.make-test run-pyd : extending test_extending.py : : test_ext ;
 
 # Declare a test of the embedding application
-testing.run embedding embedding.cpp
+testing.run embedding 
   :              # any ordinary arguments
   : script.py    # any arguments that should be treated as relative paths
   :              # requirements

example/quickstart/boost-build.jam

@@ -2,6 +2,6 @@
 # Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-# Edit this path to point at the tools/build/src subdirectory of your
+# Edit this path to point at the tools/build/v2 subdirectory of your
 # Boost installation.  Absolute paths work, too.
-boost-build ../../../../tools/build/src ;
+boost-build ../../../../tools/build/v2 ;

example/tutorial/Jamroot

@@ -20,10 +20,7 @@ use-project boost
 # boost_python library from the project whose global ID is
 # /boost/python.
 project
-  : requirements <library>/boost/python//boost_python 
-                 <implicit-dependency>/boost//headers 
-  : usage-requirements <implicit-dependency>/boost//headers 
-  ;
+  : requirements <library>/boost/python//boost_python ;
 
 # Declare the three extension modules.  You can specify multiple
 # source files after the colon separated by spaces.

include/boost/python/args.hpp

@@ -102,6 +102,7 @@ namespace detail
       return this->operator,(python::arg(name));
   }
 
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template<typename T>
   struct is_keywords
   {
@@ -125,6 +126,31 @@ namespace detail
       typedef mpl::bool_<value> type;
       BOOST_PYTHON_MPL_LAMBDA_SUPPORT(1,is_reference_to_keywords,(T))
   };
+# else 
+  typedef char (&yes_keywords_t)[1];
+  typedef char (&no_keywords_t)[2];
+      
+  no_keywords_t is_keywords_test(...);
+
+  template<std::size_t nkeywords>
+  yes_keywords_t is_keywords_test(void (*)(keywords<nkeywords>&));
+
+  template<std::size_t nkeywords>
+  yes_keywords_t is_keywords_test(void (*)(keywords<nkeywords> const&));
+
+  template<typename T>
+  class is_reference_to_keywords
+  {
+   public:
+      BOOST_STATIC_CONSTANT(
+          bool, value = (
+              sizeof(detail::is_keywords_test( (void (*)(T))0 ))
+              == sizeof(detail::yes_keywords_t)));
+
+      typedef mpl::bool_<value> type;
+      BOOST_PYTHON_MPL_LAMBDA_SUPPORT(1,is_reference_to_keywords,(T))
+  };
+# endif 
 }
 
 inline detail::keywords<1> args(char const* name)

include/boost/python/back_reference.hpp

@@ -29,6 +29,7 @@ struct back_reference
     T m_value;
 };
 
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template<typename T>
 class is_back_reference
 {
@@ -43,6 +44,36 @@ class is_back_reference<back_reference<T> >
     BOOST_STATIC_CONSTANT(bool, value = true);
 };
 
+# else // no partial specialization
+
+}} // namespace boost::python
+
+#include <boost/type.hpp>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  typedef char (&yes_back_reference_t)[1];
+  typedef char (&no_back_reference_t)[2];
+      
+  no_back_reference_t is_back_reference_test(...);
+
+  template<typename T>
+  yes_back_reference_t is_back_reference_test(boost::type< back_reference<T> >);
+}
+
+template<typename T>
+class is_back_reference
+{
+ public:
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            sizeof(detail::is_back_reference_test(boost::type<T>()))
+            == sizeof(detail::yes_back_reference_t)));
+};
+
+# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 //
 // implementations

include/boost/python/bases.hpp

@@ -24,6 +24,7 @@ namespace boost { namespace python {
 
   namespace detail
   {
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
     template <class T> struct specifies_bases
         : mpl::false_
     {
@@ -34,6 +35,23 @@ namespace boost { namespace python {
         : mpl::true_
     {
     };
+# else
+    template < BOOST_PP_ENUM_PARAMS(BOOST_PYTHON_MAX_BASES, class Base) >
+    static char is_bases_helper(bases< BOOST_PYTHON_BASE_PARAMS > const&);
+    
+    static char (& is_bases_helper(...) )[256];
+
+    template <class T>
+    struct specifies_bases
+    {
+     private:
+        static typename add_reference<T>::type make();
+        BOOST_STATIC_CONSTANT(bool, non_ref = !is_reference<T>::value);
+     public:
+        BOOST_STATIC_CONSTANT(bool, value = non_ref & (sizeof(is_bases_helper(make())) == 1));
+        typedef mpl::bool_<value> type;
+    };
+# endif
     template <class T, class Prev = bases<> >
     struct select_bases
         : mpl::if_<

include/boost/python/class.hpp

@@ -45,7 +45,8 @@
 # if BOOST_WORKAROUND(__MWERKS__, <= 0x3004)                        \
     /* pro9 reintroduced the bug */                                 \
     || (BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
-        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
+        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))   \
+    || BOOST_WORKAROUND(__GNUC__, < 3)
 
 #  define BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING 1
 
@@ -301,6 +302,7 @@ class class_ : public objects::class_base
     }
 
     // Property creation
+# if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
     template <class Get>
     self& add_property(char const* name, Get fget, char const* docstr = 0)
     {
@@ -315,6 +317,47 @@ class class_ : public objects::class_base
             name, this->make_getter(fget), this->make_setter(fset), docstr);
         return *this;
     }
+# else
+ private:
+    template <class Get>
+    self& add_property_impl(char const* name, Get fget, char const* docstr, int)
+    {
+        base::add_property(name, this->make_getter(fget), docstr);
+        return *this;
+    }
+
+    template <class Get, class Set>
+    self& add_property_impl(char const* name, Get fget, Set fset, ...)
+    {
+        base::add_property(
+            name, this->make_getter(fget), this->make_setter(fset), 0);
+        return *this;
+    }
+
+ public:    
+    template <class Get>
+    self& add_property(char const* name, Get fget)
+    {
+        base::add_property(name, this->make_getter(fget), 0);
+        return *this;
+    }
+
+    template <class Get, class DocStrOrSet>
+    self& add_property(char const* name, Get fget, DocStrOrSet docstr_or_set)
+    {
+        this->add_property_impl(name, this->make_getter(fget), docstr_or_set, 0);
+        return *this;
+    }
+
+    template <class Get, class Set>
+    self&
+    add_property(char const* name, Get fget, Set fset, char const* docstr)
+    {
+        base::add_property(
+            name, this->make_getter(fget), this->make_setter(fset), docstr);
+        return *this;
+    }
+# endif
         
     template <class Get>
     self& add_static_property(char const* name, Get fget)

include/boost/python/converter/arg_from_python.hpp

@@ -115,9 +115,9 @@ struct arg_rvalue_from_python
     arg_rvalue_from_python(PyObject*);
     bool convertible() const;
 
-# if _MSC_FULL_VER > 13102196
+# if BOOST_MSVC < 1301 || _MSC_FULL_VER > 13102196
     typename arg_rvalue_from_python<T>::
-# endif
+# endif 
     result_type operator()();
     
  private:

include/boost/python/converter/arg_to_python_base.hpp

@@ -13,9 +13,17 @@ struct registration;
 namespace detail
 {
   struct BOOST_PYTHON_DECL arg_to_python_base
+# if !defined(BOOST_MSVC) || BOOST_MSVC <= 1300 || _MSC_FULL_VER > 13102179
       : handle<>
+# endif 
   {
       arg_to_python_base(void const volatile* source, registration const&);
+# if defined(BOOST_MSVC) && BOOST_MSVC > 1300 && _MSC_FULL_VER <= 13102179
+      PyObject* get() const { return m_ptr.get(); }
+      PyObject* release() { return m_ptr.release(); }
+   private:
+      handle<> m_ptr;
+# endif 
   };
 }
 

include/boost/python/converter/object_manager.hpp

@@ -121,6 +121,7 @@ struct is_object_manager
 {
 };
 
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T>
 struct is_reference_to_object_manager
     : mpl::false_
@@ -150,6 +151,79 @@ struct is_reference_to_object_manager<T const volatile&>
     : is_object_manager<T>
 {
 };
+# else
+
+namespace detail
+{
+  typedef char (&yes_reference_to_object_manager)[1];
+  typedef char (&no_reference_to_object_manager)[2];
+
+  // A number of nastinesses go on here in order to work around MSVC6
+  // bugs.
+  template <class T>
+  struct is_object_manager_help
+  {
+      typedef typename mpl::if_<
+          is_object_manager<T>
+          , yes_reference_to_object_manager
+          , no_reference_to_object_manager
+          >::type type;
+
+      // If we just use the type instead of the result of calling this
+      // function, VC6 will ICE.
+      static type call();
+  };
+
+  // A set of overloads for each cv-qualification. The same argument
+  // is passed twice: the first one is used to unwind the cv*, and the
+  // second one is used to avoid relying on partial ordering for
+  // overload resolution.
+  template <class U>
+  typename is_object_manager_help<U>
+  is_object_manager_helper(U*, void*);
+  
+  template <class U>
+  typename is_object_manager_help<U>
+  is_object_manager_helper(U const*, void const*);
+  
+  template <class U>
+  typename is_object_manager_help<U>
+  is_object_manager_helper(U volatile*, void volatile*);
+  
+  template <class U>
+  typename is_object_manager_help<U>
+  is_object_manager_helper(U const volatile*, void const volatile*);
+  
+  template <class T>
+  struct is_reference_to_object_manager_nonref
+      : mpl::false_
+  {
+  };
+
+  template <class T>
+  struct is_reference_to_object_manager_ref
+  {
+      static T sample_object;
+      BOOST_STATIC_CONSTANT(
+        bool, value
+        = (sizeof(is_object_manager_helper(&sample_object, &sample_object).call())
+            == sizeof(detail::yes_reference_to_object_manager)
+          )
+        );
+      typedef mpl::bool_<value> type;
+  };
+}
+
+template <class T>
+struct is_reference_to_object_manager
+    : mpl::if_<
+        is_reference<T>
+        , detail::is_reference_to_object_manager_ref<T>
+        , detail::is_reference_to_object_manager_nonref<T>
+    >::type
+{
+};
+# endif 
 
 }}} // namespace boost::python::converter
 

include/boost/python/converter/registered.hpp

@@ -44,7 +44,8 @@ struct registered
 {
 };
 
-# if !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
+# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+    && !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
 // collapses a few more types to the same static instance.  MSVC7.1
 // fails to strip cv-qualification from array types in typeid.  For
 // some reason we can't use this collapse there or array converters

include/boost/python/converter/registered_pointee.hpp

@@ -14,6 +14,7 @@ namespace boost { namespace python { namespace converter {
 
 struct registration;
 
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T>
 struct registered_pointee
     : registered<
@@ -25,6 +26,37 @@ struct registered_pointee
     >
 {
 };
+# else
+namespace detail
+{
+  template <class T>
+  struct registered_pointee_base
+  {
+      static registration const& converters;
+  };
+}
+
+template <class T>
+struct registered_pointee
+    : detail::registered_pointee_base<
+        typename add_reference<
+           typename add_cv<T>::type
+        >::type
+    >
+{
+};
+
+//
+// implementations
+//
+namespace detail
+{
+  template <class T>
+  registration const& registered_pointee_base<T>::converters
+     = registry::lookup(pointer_type_id<T>());
+}
+
+# endif 
 }}} // namespace boost::python::converter
 
 #endif // REGISTERED_POINTEE_DWA2002710_HPP

include/boost/python/copy_const_reference.hpp

@@ -16,7 +16,7 @@ namespace detail
 {
   template <class R>
   struct copy_const_reference_expects_a_const_reference_return_type
-# if defined(__GNUC__) || defined(__EDG__)
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
   {}
 # endif
   ;

include/boost/python/copy_non_const_reference.hpp

@@ -16,7 +16,7 @@ namespace detail
 {
   template <class R>
   struct copy_non_const_reference_expects_a_non_const_reference_return_type
-# if defined(__GNUC__) || defined(__EDG__)
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
   {}
 # endif
   ;

include/boost/python/data_members.hpp

@@ -270,7 +270,7 @@ inline object make_getter(D& x)
     return detail::make_getter(x, policy, is_member_pointer<D>(), 0L);
 }
 
-#  if !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+#  if !BOOST_WORKAROUND(__EDG_VERSION__, <= 238) && !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
 template <class D>
 inline object make_getter(D const& d)
 {
@@ -305,7 +305,7 @@ inline object make_setter(D& x)
     return detail::make_setter(x, default_call_policies(), is_member_pointer<D>(), 0);
 }
 
-# if BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
+# if !(BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(__EDG_VERSION__, <= 238))
 template <class D>
 inline object make_setter(D const& x)
 {

include/boost/python/default_call_policies.hpp

@@ -23,7 +23,7 @@ namespace detail
 {
 // for "readable" error messages
   template <class T> struct specify_a_return_value_policy_to_wrap_functions_returning
-# if defined(__GNUC__) || defined(__EDG__)
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
   {}
 # endif 
   ;

include/boost/python/detail/borrowed_ptr.hpp

@@ -19,6 +19,7 @@ template<class T> class borrowed
     typedef T type;
 };
 
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template<typename T>
 struct is_borrowed_ptr
 {
@@ -67,6 +68,35 @@ struct is_borrowed_ptr<T*>
 };
 #  endif 
 
+# else // no partial specialization
+
+typedef char (&yes_borrowed_ptr_t)[1];
+typedef char (&no_borrowed_ptr_t)[2];
+
+no_borrowed_ptr_t is_borrowed_ptr_test(...);
+
+template <class T>
+typename mpl::if_c<
+    is_pointer<T>::value
+    , T
+    , int
+    >::type
+is_borrowed_ptr_test1(boost::type<T>);
+
+template<typename T>
+yes_borrowed_ptr_t is_borrowed_ptr_test(borrowed<T> const volatile*);
+
+template<typename T>
+class is_borrowed_ptr
+{
+ public:
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            sizeof(detail::is_borrowed_ptr_test(is_borrowed_ptr_test1(boost::type<T>())))
+            == sizeof(detail::yes_borrowed_ptr_t)));
+};
+
+# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 }
 

include/boost/python/detail/config.hpp

@@ -29,6 +29,9 @@
 # endif
 
 # if defined(BOOST_MSVC)
+#  if _MSC_VER < 1300
+#   define BOOST_MSVC6_OR_EARLIER 1
+#  endif
 
 #  pragma warning (disable : 4786) // disable truncated debug symbols
 #  pragma warning (disable : 4251) // disable exported dll function

include/boost/python/detail/construct.hpp

@@ -8,7 +8,13 @@
 namespace boost { namespace python { namespace detail { 
 
 template <class T, class Arg>
-void construct_pointee(void* storage, Arg& x, T const volatile*)
+void construct_pointee(void* storage, Arg& x
+# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+                       , T const volatile*
+# else 
+                       , T const*
+# endif 
+    )
 {
     new (storage) T(x);
 }

include/boost/python/detail/cv_category.hpp

@@ -12,7 +12,7 @@ template <bool is_const_, bool is_volatile_>
 struct cv_tag
 {
     BOOST_STATIC_CONSTANT(bool, is_const = is_const_);
-    BOOST_STATIC_CONSTANT(bool, is_volatile = is_volatile_);
+    BOOST_STATIC_CONSTANT(bool, is_volatile = is_const_);
 };
 
 typedef cv_tag<false,false> cv_unqualified;

include/boost/python/detail/destroy.hpp

@@ -7,12 +7,25 @@
 
 # include <boost/type_traits/is_array.hpp>
 # include <boost/detail/workaround.hpp>
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+#  include <boost/type_traits/is_enum.hpp>
+# endif 
 namespace boost { namespace python { namespace detail { 
 
-template <bool array> struct value_destroyer;
+template <
+    bool array
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+  , bool enum_  // vc7 has a problem destroying enums
+# endif 
+    > struct value_destroyer;
     
 template <>
-struct value_destroyer<false>
+struct value_destroyer<
+    false
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+  , false
+# endif 
+    >
 {
     template <class T>
     static void execute(T const volatile* p)
@@ -22,7 +35,12 @@ struct value_destroyer<false>
 };
 
 template <>
-struct value_destroyer<true>
+struct value_destroyer<
+    true
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+  , false
+# endif 
+    >
 {
     template <class A, class T>
     static void execute(A*, T const volatile* const first)
@@ -31,6 +49,9 @@ struct value_destroyer<true>
         {
             value_destroyer<
                 boost::is_array<T>::value
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+              , boost::is_enum<T>::value
+# endif 
             >::execute(p);
         }
     }
@@ -42,6 +63,25 @@ struct value_destroyer<true>
     }
 };
 
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+template <>
+struct value_destroyer<true,true>
+{
+    template <class T>
+    static void execute(T const volatile*)
+    {
+    }
+};
+
+template <>
+struct value_destroyer<false,true>
+{
+    template <class T>
+    static void execute(T const volatile*)
+    {
+    }
+};
+# endif 
 template <class T>
 inline void destroy_referent_impl(void* p, T& (*)())
 {
@@ -49,6 +89,9 @@ inline void destroy_referent_impl(void* p, T& (*)())
     // must come *before* T for metrowerks
     value_destroyer<
          (boost::is_array<T>::value)
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+       , (boost::is_enum<T>::value)
+# endif 
     >::execute((const volatile T*)p);
 }
 

include/boost/python/detail/enable_if.hpp

@@ -7,7 +7,40 @@
 # include <boost/python/detail/sfinae.hpp>
 # include <boost/detail/workaround.hpp>
 
-#if !defined(BOOST_NO_SFINAE)
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#  include <boost/mpl/if.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <class T> struct always_void { typedef void type; };
+
+template <class C, class T = int>
+struct enable_if_arg
+{
+    typedef typename mpl::if_<C,T,int&>::type type;
+};
+             
+template <class C, class T = int>
+struct disable_if_arg
+{
+    typedef typename mpl::if_<C,int&,T>::type type;
+};
+             
+template <class C, class T = typename always_void<C>::type>
+struct enable_if_ret
+{
+    typedef typename mpl::if_<C,T,int[2]>::type type;
+};
+             
+template <class C, class T = typename always_void<C>::type>
+struct disable_if_ret
+{
+    typedef typename mpl::if_<C,int[2],T>::type type;
+};
+             
+}}} // namespace boost::python::detail
+
+# elif !defined(BOOST_NO_SFINAE)
 #  include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace python { namespace detail { 

include/boost/python/detail/force_instantiate.hpp

@@ -10,9 +10,23 @@ namespace boost { namespace python { namespace detail {
 // Allows us to force the argument to be instantiated without
 // incurring unused variable warnings
 
+# if !defined(BOOST_MSVC) || BOOST_MSVC < 1300 || _MSC_FULL_VER > 13102196
+
 template <class T>
 inline void force_instantiate(T const&) {}
 
+# else
+
+#  pragma optimize("g", off)
+inline void force_instantiate_impl(...) {}
+#  pragma optimize("", on)
+template <class T>
+inline void force_instantiate(T const& x)
+{
+    detail::force_instantiate_impl(&x);
+}
+# endif
+
 }}} // namespace boost::python::detail
 
 #endif // FORCE_INSTANTIATE_DWA200265_HPP

include/boost/python/detail/if_else.hpp

@@ -25,11 +25,46 @@ struct if_selected
     };
 };
 
+# if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
+namespace msvc70_aux {
+
+template< bool > struct inherit_from
+{
+    template< typename T > struct result
+    {
+        typedef T type;
+    };
+};
+
+template<> struct inherit_from<true>
+{
+    template< typename T > struct result
+    {
+        struct type {};
+    };
+};
+
+template< typename T >
+struct never_true
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+} // namespace msvc70_aux
+
+#endif // # if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
+
 template <class T>
 struct elif_selected
 {
-# if !(defined(__MWERKS__) && __MWERKS__ <= 0x2407)
+# if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__MWERKS__) && __MWERKS__ <= 0x2407)
     template <class U> class then;
+# elif defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
+    template <class U>
+    struct then : msvc70_aux::inherit_from< msvc70_aux::never_true<U>::value >
+        ::template result< if_selected<T> >::type
+    {
+    };
 # else
     template <class U>
     struct then : if_selected<T>
@@ -38,7 +73,7 @@ struct elif_selected
 # endif 
 };
 
-# if !(defined(__MWERKS__) && __MWERKS__ <= 0x2407)
+# if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__MWERKS__) && __MWERKS__ <= 0x2407)
 template <class T>
 template <class U>
 class elif_selected<T>::then : public if_selected<T>

include/boost/python/detail/msvc_typeinfo.hpp

@@ -7,18 +7,15 @@
 
 #include <typeinfo>
 #include <boost/type.hpp>
+#include <boost/type_traits/config.hpp>
 
 //
-// Fix for icc's broken typeid() implementation which doesn't strip
+// Fix for MSVC's broken typeid() implementation which doesn't strip
 // decoration. This fix doesn't handle cv-qualified array types. It
 // could probably be done, but I haven't figured it out yet.
 //
 
-// Note: This file is badly named. It initially was MSVC specific, but was
-// extended to cover intel too. Now the old version of MSVC is no longer
-// supported, but the intel version is still supported.
-
-# if defined(BOOST_INTEL_CXX_VERSION) && BOOST_INTEL_CXX_VERSION <= 700
+# if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(BOOST_INTEL_CXX_VERSION) && BOOST_INTEL_CXX_VERSION <= 700
 
 namespace boost { namespace python { namespace detail { 
 
@@ -47,14 +44,8 @@ inline typeinfo typeid_ref(type<T>*, ...)
     return detail::typeid_ref_1((T(*)())0);
 }
 
-#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32))
-#   define BOOST_PYTT_DECL __cdecl
-#else
-#   define BOOST_PYTT_DECL /**/
-#endif
-
 template< typename T > T&(* is_ref_tester1(type<T>) )(type<T>) { return 0; }
-inline char BOOST_PYTT_DECL is_ref_tester1(...) { return 0; }
+inline char BOOST_TT_DECL is_ref_tester1(...) { return 0; }
 
 template <class T>
 inline typeinfo msvc_typeid(boost::type<T>*)
@@ -80,5 +71,5 @@ inline typeinfo assert_array_typeid_compiles()
 
 }}} // namespace boost::python::detail
 
-# endif // BOOST_INTEL_CXX_VERSION
+# endif // BOOST_MSVC
 #endif // MSVC_TYPEINFO_DWA200222_HPP

include/boost/python/detail/referent_storage.hpp

@@ -42,6 +42,7 @@ union aligned_storage
   // but sizeof() is broken in CodeWarriors <= 8.0
   template <class T> struct referent_size;
   
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   
   template <class T>
   struct referent_size<T&>
@@ -50,6 +51,15 @@ union aligned_storage
           std::size_t, value = sizeof(T));
   };
 
+# else
+
+  template <class T> struct referent_size
+  {
+      static T f();
+      BOOST_STATIC_CONSTANT(std::size_t, value = sizeof(f()));
+  };
+  
+# endif
 
 // A metafunction returning a POD type which can store U, where T ==
 // U&. If T is not a reference type, returns a POD which can store T.

include/boost/python/detail/result.hpp

@@ -43,7 +43,9 @@ namespace boost { namespace python { namespace detail {
 template <class R, class T>
 boost::type<R>* result(R (T::*), int = 0) { return 0; }
 
-#  if (defined(__MWERKS__) && __MWERKS__ < 0x3000)
+#  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

include/boost/python/detail/string_literal.hpp

@@ -14,6 +14,7 @@
 
 namespace boost { namespace python { namespace detail { 
 
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T>
 struct is_string_literal : mpl::false_
 {
@@ -44,6 +45,43 @@ struct is_string_literal<T[n]>
 {
 };
 #  endif 
+# else
+template <bool is_array = true>
+struct string_literal_helper
+{
+    typedef char (&yes_string_literal)[1];
+    typedef char (&no_string_literal)[2];
+
+    template <class T>
+    struct apply
+    {
+        typedef apply<T> self;
+        static T x;
+        static yes_string_literal check(char const*);
+        static no_string_literal check(char*);
+        static no_string_literal check(void const volatile*);
+        
+        BOOST_STATIC_CONSTANT(
+            bool, value = sizeof(self::check(x)) == sizeof(yes_string_literal));
+        typedef mpl::bool_<value> type;
+    };
+};
+
+template <>
+struct string_literal_helper<false>
+{
+    template <class T>
+    struct apply : mpl::false_
+    {
+    };
+};
+
+template <class T>
+struct is_string_literal
+    : string_literal_helper<is_array<T>::value>::apply<T>
+{
+};
+# endif
 
 }}} // namespace boost::python::detail
 

include/boost/python/detail/type_list.hpp

@@ -30,6 +30,10 @@
 #  include <boost/mpl/vector/vector10.hpp>
 # endif
 
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #  include <boost/python/detail/type_list_impl.hpp>
+# else
+#  include <boost/python/detail/type_list_impl_no_pts.hpp>
+# endif
 
 #endif // TYPE_LIST_DWA2002913_HPP

include/boost/python/detail/type_list_impl_no_pts.hpp

@@ -0,0 +1,107 @@
+#ifndef BOOST_PP_IS_ITERATING
+// Copyright David Abrahams 2002.
+// 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 TYPE_LIST_IMPL_NO_PTS_DWA2002913_HPP
+#  define TYPE_LIST_IMPL_NO_PTS_DWA2002913_HPP
+
+#  include <boost/python/detail/type_list.hpp>
+
+#  include <boost/preprocessor/enum_params.hpp>
+#  include <boost/preprocessor/enum_params_with_a_default.hpp>
+#  include <boost/preprocessor/cat.hpp>
+#  include <boost/preprocessor/repeat.hpp>
+#  include <boost/preprocessor/empty.hpp>
+#  include <boost/preprocessor/iterate.hpp>
+#  include <boost/mpl/void.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template< typename T >
+struct is_list_arg
+{
+    enum { value = true };
+};
+
+template<>
+struct is_list_arg<mpl::void_>
+{
+    enum { value = false };
+};
+
+template<int> struct type_list_impl_chooser;
+
+#  define BOOST_PYTHON_LIST_ACTUAL_PARAMS BOOST_PP_ENUM_PARAMS_Z(1,BOOST_PYTHON_LIST_SIZE,T)
+#  define BOOST_PYTHON_LIST_FORMAL_PARAMS BOOST_PP_ENUM_PARAMS_Z(1,BOOST_PYTHON_LIST_SIZE,class T)
+
+#  define BOOST_PP_ITERATION_PARAMS_1                                                           \
+        (3, (0, BOOST_PYTHON_LIST_SIZE, <boost/python/detail/type_list_impl_no_pts.hpp>))
+#  include BOOST_PP_ITERATE()
+
+#  define BOOST_PYTHON_PLUS() +
+#  define BOOST_PYTHON_IS_LIST_ARG(z, n, data)          \
+    BOOST_PP_IF(n, BOOST_PYTHON_PLUS, BOOST_PP_EMPTY)() \
+    is_list_arg< BOOST_PP_CAT(T,n) >::value
+    
+template<
+    BOOST_PYTHON_LIST_FORMAL_PARAMS
+    >
+struct type_list_count_args
+{
+    enum { value =
+           BOOST_PP_REPEAT_1(BOOST_PYTHON_LIST_SIZE, BOOST_PYTHON_IS_LIST_ARG, _)
+    };
+};
+
+template<
+    BOOST_PYTHON_LIST_FORMAL_PARAMS
+    >
+struct type_list_impl
+{
+    typedef type_list_count_args< BOOST_PYTHON_LIST_ACTUAL_PARAMS > arg_num_;
+    typedef typename detail::type_list_impl_chooser< arg_num_::value >
+    ::template result_< BOOST_PYTHON_LIST_ACTUAL_PARAMS >::type type;
+};
+
+template<
+    BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PYTHON_LIST_SIZE, class T, mpl::void_)
+    >
+struct type_list
+    : detail::type_list_impl< BOOST_PYTHON_LIST_ACTUAL_PARAMS >::type
+{
+    typedef typename detail::type_list_impl<
+        BOOST_PYTHON_LIST_ACTUAL_PARAMS
+        >::type type;
+};
+
+#  undef BOOST_PYTHON_IS_LIST_ARG
+#  undef BOOST_PYTHON_PLUS
+#  undef BOOST_PYTHON_LIST_FORMAL_PARAMS
+#  undef BOOST_PYTHON_LIST_ACTUAL_PARAMS
+
+}}} // namespace boost::python::detail
+
+# endif // TYPE_LIST_IMPL_NO_PTS_DWA2002913_HPP
+
+#else // BOOST_PP_IS_ITERATING
+
+# define N BOOST_PP_ITERATION()
+
+template<>
+struct type_list_impl_chooser<N>
+{
+    template<
+        BOOST_PYTHON_LIST_FORMAL_PARAMS
+        >
+    struct result_
+    {
+        typedef typename BOOST_PP_CAT(mpl::vector,N)<
+            BOOST_PP_ENUM_PARAMS(N, T)
+            >::type type;
+    };
+};
+
+# undef N
+
+#endif // BOOST_PP_IS_ITERATING 

include/boost/python/detail/value_is_xxx.hpp

@@ -9,6 +9,35 @@
 # include <boost/mpl/bool.hpp>
 # include <boost/preprocessor/enum_params.hpp>
 
+# if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+# include <boost/type_traits/is_reference.hpp>
+# include <boost/type_traits/add_reference.hpp>
+
+#  define BOOST_PYTHON_VALUE_IS_XXX_DEF(name, qualified_name, nargs)    \
+template <class X_>                                                     \
+struct value_is_##name                                                  \
+{                                                                       \
+    typedef char yes;                                                   \
+    typedef char (&no)[2];                                              \
+                                                                        \
+    static typename add_reference<X_>::type dummy;                      \
+                                                                        \
+    template < BOOST_PP_ENUM_PARAMS_Z(1, nargs, class U) >              \
+    static yes test(                                                    \
+       qualified_name< BOOST_PP_ENUM_PARAMS_Z(1, nargs, U) > const&, int \
+    );                                                                  \
+                                                                        \
+    template <class U>                                                  \
+    static no test(U&, ...);                                            \
+                                                                        \
+    BOOST_STATIC_CONSTANT(                                              \
+        bool, value                                                     \
+        = (sizeof(test(dummy, 0)) == sizeof(yes)));                     \
+                                                                        \
+    typedef mpl::bool_<value> type;                                    \
+};
+
+# else
 
 #  include <boost/type_traits/remove_reference.hpp>
 #  include <boost/type_traits/remove_cv.hpp>
@@ -28,5 +57,6 @@ struct value_is_##name                                                  \
                                                                         \
 };                                                              
 
+# endif
 
 #endif // VALUE_IS_XXX_DWA2003224_HPP

include/boost/python/exception_translator.hpp

@@ -8,7 +8,6 @@
 # include <boost/python/detail/prefix.hpp>
 
 # include <boost/bind.hpp>
-# include <boost/bind/placeholders.hpp>
 # include <boost/type.hpp>
 # include <boost/python/detail/translate_exception.hpp>
 # include <boost/python/detail/exception_handler.hpp>

include/boost/python/extract.hpp

@@ -19,9 +19,11 @@
 # include <boost/python/detail/copy_ctor_mutates_rhs.hpp>
 # include <boost/python/detail/void_ptr.hpp>
 # include <boost/python/detail/void_return.hpp>
+# include <boost/utility.hpp>
 # include <boost/call_traits.hpp>
 
-#if BOOST_WORKAROUND(BOOST_INTEL_WIN, <= 900)
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(BOOST_INTEL_WIN, <= 900)
+// workaround for VC++ 6.x or 7.0
 # define BOOST_EXTRACT_WORKAROUND ()
 #else
 # define BOOST_EXTRACT_WORKAROUND

include/boost/python/handle.hpp

@@ -87,6 +87,8 @@ class handle
         return *this;
     }
 
+#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)
+
     template<typename Y>
     handle& operator=(handle<Y> const & r) // never throws
     {
@@ -95,6 +97,8 @@ class handle
         return *this;
     }
 
+#endif
+
     template <typename Y>
     handle(handle<Y> const& r)
         : m_p(python::xincref(python::upcast<T>(r.get())))
@@ -155,6 +159,7 @@ typedef handle<PyTypeObject> type_handle;
 //
 // Compile-time introspection
 //
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template<typename T>
 class is_handle
 {
@@ -168,6 +173,28 @@ class is_handle<handle<T> >
  public:
     BOOST_STATIC_CONSTANT(bool, value = true);
 };
+# else
+namespace detail
+{
+  typedef char (&yes_handle_t)[1];
+  typedef char (&no_handle_t)[2];
+      
+  no_handle_t is_handle_test(...);
+
+  template<typename T>
+  yes_handle_t is_handle_test(boost::type< handle<T> >);
+}
+
+template<typename T>
+class is_handle
+{
+ public:
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            sizeof(detail::is_handle_test(boost::type<T>()))
+            == sizeof(detail::yes_handle_t)));
+};
+# endif
 
 //
 // implementations

include/boost/python/init.hpp

@@ -76,6 +76,27 @@ namespace detail
   //
   //      This metaprogram checks if T is an optional
   //
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+    template <class T>
+    struct is_optional {
+
+    private:
+
+        template <BOOST_PYTHON_OVERLOAD_TYPES>
+        static boost::type_traits::yes_type f(optional<BOOST_PYTHON_OVERLOAD_ARGS>);
+        static boost::type_traits::no_type f(...);
+        static T t();
+
+    public:
+
+        BOOST_STATIC_CONSTANT(
+            bool, value =
+                sizeof(f(t())) == sizeof(::boost::type_traits::yes_type));
+        typedef mpl::bool_<value> type;
+    };
+
+#else
 
     template <class T>
     struct is_optional
@@ -87,6 +108,7 @@ namespace detail
       : mpl::true_
     {};
   
+#endif
 
   template <int NDefaults>
   struct define_class_init_helper;

include/boost/python/instance_holder.hpp

@@ -7,7 +7,7 @@
 
 # include <boost/python/detail/prefix.hpp>
 
-# include <boost/noncopyable.hpp>
+# include <boost/utility.hpp>
 # include <boost/python/type_id.hpp>
 # include <cstddef>
 

include/boost/python/make_constructor.hpp

@@ -104,6 +104,14 @@ namespace detail
       
       // If the BasePolicy_ supplied a result converter it would be
       // ignored; issue an error if it's not the default.
+#if defined _MSC_VER && _MSC_VER < 1300
+      typedef is_same<
+              typename BasePolicy_::result_converter
+            , default_result_converter
+          > same_result_converter;
+      //see above for explanation
+      BOOST_STATIC_ASSERT(same_result_converter::value) ;
+#else
       BOOST_MPL_ASSERT_MSG(
          (is_same<
               typename BasePolicy_::result_converter
@@ -112,6 +120,7 @@ namespace detail
         , MAKE_CONSTRUCTOR_SUPPLIES_ITS_OWN_RESULT_CONVERTER_THAT_WOULD_OVERRIDE_YOURS
         , (typename BasePolicy_::result_converter)
       );
+#endif
       typedef constructor_result_converter result_converter;
       typedef offset_args<typename BasePolicy_::argument_package, mpl::int_<1> > argument_package;
   };

include/boost/python/manage_new_object.hpp

@@ -17,7 +17,7 @@ namespace detail
 {
   template <class R>
   struct manage_new_object_requires_a_pointer_return_type
-# if defined(__GNUC__) || defined(__EDG__)
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
   {}
 # endif
   ;

include/boost/python/object/class.hpp

@@ -6,6 +6,7 @@
 # define CLASS_DWA20011214_HPP
 
 # include <boost/python/detail/prefix.hpp>
+# include <boost/utility.hpp>
 # include <boost/python/object_core.hpp>
 # include <boost/python/type_id.hpp>
 # include <cstddef>

include/boost/python/object/class_metadata.hpp

@@ -53,7 +53,11 @@ struct register_base_of
     template <class Base>
     inline void operator()(Base*) const
     {
+# if !BOOST_WORKAROUND(BOOST_MSVC, == 1200)
         BOOST_MPL_ASSERT_NOT((is_same<Base,Derived>));
+# else
+        BOOST_STATIC_ASSERT(!(is_same<Base,Derived>::value));
+# endif 
         
         // Register the Base class
         register_dynamic_id<Base>();

include/boost/python/object/forward.hpp

@@ -12,7 +12,13 @@
 # include <boost/ref.hpp>
 # include <boost/python/detail/value_arg.hpp>
 # include <boost/python/detail/copy_ctor_mutates_rhs.hpp>
-# include <boost/mpl/or.hpp>
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#  include <boost/type_traits/is_enum.hpp>
+#  include <boost/mpl/and.hpp>
+#  include <boost/mpl/not.hpp>
+# else
+#  include <boost/mpl/or.hpp>
+# endif 
 
 namespace boost { namespace python { namespace objects { 
 
@@ -36,13 +42,24 @@ struct reference_to_value
 template <class T>
 struct forward
     : mpl::if_<
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+          // vc6 chokes on unforwarding enums nested in classes
+          mpl::and_<
+              is_scalar<T>
+            , mpl::not_< 
+                  is_enum<T>
+              >
+          >
+# else 
           mpl::or_<python::detail::copy_ctor_mutates_rhs<T>, is_scalar<T> >
+# endif 
         , T
         , reference_to_value<T>
       >
 {
 };
 
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template<typename T>
 struct unforward
 {
@@ -69,6 +86,88 @@ struct unforward_cref<reference_to_value<T> >
 {
 };
 
+# else // no partial specialization
+
+namespace detail
+{
+  typedef char (&yes_reference_to_value_t)[1];
+  typedef char (&no_reference_to_value_t)[2];
+      
+  no_reference_to_value_t is_reference_to_value_test(...);
+
+  template<typename T>
+  yes_reference_to_value_t is_reference_to_value_test(boost::type< reference_to_value<T> >);
+
+  template<bool wrapped>
+  struct unforwarder
+  {
+      template <class T>
+      struct apply
+      {
+          typedef typename unwrap_reference<T>::type& type;
+      };
+  };
+
+  template<>
+  struct unforwarder<true>
+  {
+      template <class T>
+      struct apply
+      {
+          typedef typename T::reference type;
+      };
+  };
+
+  template<bool wrapped = false>
+  struct cref_unforwarder
+  {
+      template <class T>
+      struct apply
+        : python::detail::value_arg<
+              typename unwrap_reference<T>::type
+          >
+      {          
+      };
+  };
+      
+  template<>
+  struct cref_unforwarder<true>
+  {
+      template <class T>
+      struct apply
+        : python::detail::value_arg<
+              typename T::reference
+          >
+      {
+      };
+  };
+
+  template<typename T>
+  struct is_reference_to_value
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, value = (
+              sizeof(is_reference_to_value_test(boost::type<T>()))
+              == sizeof(yes_reference_to_value_t)));
+      typedef mpl::bool_<value> type;
+  };
+}
+
+template <typename T>
+struct unforward
+    : public detail::unforwarder<
+        detail::is_reference_to_value<T>::value
+      >::template apply<T>
+{};
+
+template <typename T>
+struct unforward_cref
+    : public detail::cref_unforwarder<
+        detail::is_reference_to_value<T>::value
+      >::template apply<T>
+{};
+
+# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 template <class T>
 typename reference_to_value<T>::reference

include/boost/python/object/iterator.hpp

@@ -71,7 +71,35 @@ struct iterator_range
 # endif 
     };
     
+# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    // for compilers which can't deduce the value_type of pointers, we
+    // have a special implementation of next.  This takes advantage of
+    // the fact that T* results are treated like T& results by
+    // Boost.Python's function wrappers.
+    struct next_ptr
+    {
+        typedef Iterator result_type;
+        
+        result_type
+        operator()(iterator_range<NextPolicies,Iterator>& self)
+        {
+            if (self.m_start == self.m_finish)
+                stop_iteration_error();
+            return self.m_start++;
+        }
+    };
+    
+    typedef mpl::if_<
+        is_same<
+            boost::detail::please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee<Iterator>
+          , typename traits_t::value_type
+        >
+      , next_ptr
+      , next
+    >::type next_fn;
+# else
     typedef next next_fn;
+# endif
     
     object m_sequence; // Keeps the sequence alive while iterating.
     Iterator m_start;

include/boost/python/object/pointer_holder.hpp

@@ -46,7 +46,11 @@ template <class T> class wrapper;
 
 namespace boost { namespace python { namespace objects {
 
-#define BOOST_PYTHON_UNFORWARD_LOCAL(z, n, _) BOOST_PP_COMMA_IF(n) objects::do_unforward(a##n,0)
+#  if BOOST_WORKAROUND(__GNUC__, == 2)
+#   define BOOST_PYTHON_UNFORWARD_LOCAL(z, n, _) BOOST_PP_COMMA_IF(n) (typename unforward<A##n>::type)objects::do_unforward(a##n,0)
+#  else
+#   define BOOST_PYTHON_UNFORWARD_LOCAL(z, n, _) BOOST_PP_COMMA_IF(n) objects::do_unforward(a##n,0)
+#  endif 
 
 template <class Pointer, class Value>
 struct pointer_holder : instance_holder

include/boost/python/object/value_holder.hpp

@@ -33,7 +33,11 @@
 
 namespace boost { namespace python { namespace objects { 
 
-#define BOOST_PYTHON_UNFORWARD_LOCAL(z, n, _) BOOST_PP_COMMA_IF(n) objects::do_unforward(a##n,0)
+#  if BOOST_WORKAROUND(__GNUC__, == 2)
+#   define BOOST_PYTHON_UNFORWARD_LOCAL(z, n, _) BOOST_PP_COMMA_IF(n) (typename unforward<A##n>::type)objects::do_unforward(a##n,0)
+#  else
+#   define BOOST_PYTHON_UNFORWARD_LOCAL(z, n, _) BOOST_PP_COMMA_IF(n) objects::do_unforward(a##n,0)
+#  endif 
 
 template <class Value>
 struct value_holder : instance_holder

include/boost/python/object_core.hpp

@@ -36,6 +36,12 @@
 # include <boost/type_traits/is_convertible.hpp>
 # include <boost/type_traits/remove_reference.hpp>
 
+# if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#  include <boost/type_traits/add_pointer.hpp>
+# endif
+
+# include <boost/mpl/if.hpp>
+
 namespace boost { namespace python { 
 
 namespace detail
@@ -92,7 +98,11 @@ namespace api
   class object_operators : public def_visitor<U>
   {
    protected:
+# if !defined(BOOST_MSVC) || BOOST_MSVC >= 1300
       typedef object const& object_cref;
+# else 
+      typedef object object_cref;
+# endif
    public:
       // function call
       //
@@ -129,11 +139,25 @@ namespace api
     
       template <class T>
       const_object_item
-      operator[](T const& key) const;
+      operator[](T const& key) const
+# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+          ;
+# else 
+      {
+          return (*this)[object(key)];
+      }
+# endif 
     
       template <class T>
       object_item
-      operator[](T const& key);
+      operator[](T const& key)
+# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+          ;
+# else 
+      {
+          return (*this)[object(key)];
+      }
+# endif
 
       // slicing
       //
@@ -151,11 +175,29 @@ namespace api
 
       template <class T, class V>
       const_object_slice
-      slice(T const& start, V const& end) const;
+      slice(T const& start, V const& end) const
+# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+          ;
+# else
+      {
+          return this->slice(
+               slice_bound<T>::type(start)
+              ,  slice_bound<V>::type(end));
+      }
+# endif
     
       template <class T, class V>
       object_slice
-      slice(T const& start, V const& end);
+      slice(T const& start, V const& end)
+# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+          ;
+# else
+      {
+          return this->slice(
+              slice_bound<T>::type(start)
+              , slice_bound<V>::type(end));
+      }
+# endif
       
    private: // def visitation for adding callable objects as class methods
       
@@ -206,6 +248,26 @@ namespace api
       PyObject* m_ptr;
   };
 
+# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  template <class T, class U>
+  struct is_derived_impl
+  {
+      static T x;
+      template <class X>
+      static X* to_pointer(X const&);
+      
+      static char test(U const*);
+      typedef char (&no)[2];
+      static no test(...);
+
+      BOOST_STATIC_CONSTANT(bool, value = sizeof(test(to_pointer(x))) == 1);
+  };
+  
+  template <class T, class U>
+  struct is_derived
+    : mpl::bool_<is_derived_impl<T,U>::value>
+  {};
+# else
   template <class T, class U>
   struct is_derived
     : is_convertible<
@@ -213,13 +275,28 @@ namespace api
         , U const*
       >
   {};
+# endif 
 
   template <class T>
   typename objects::unforward_cref<T>::type do_unforward_cref(T const& x)
   {
+# if BOOST_WORKAROUND(__GNUC__, == 2)
+      typedef typename objects::unforward_cref<T>::type ret;
+      return ret(x);
+# else
       return x;
+# endif 
   }
 
+# if BOOST_WORKAROUND(__GNUC__, == 2)
+  // GCC 2.x has non-const string literals; this hacks around that problem.
+  template <unsigned N>
+  char const (& do_unforward_cref(char const(&x)[N]) )[N]
+  {
+      return x;
+  }
+# endif
+  
   class object;
   
   template <class T>
@@ -246,7 +323,14 @@ namespace api
       
       // explicit conversion from any C++ object to Python
       template <class T>
-      explicit object(T const& x)
+      explicit object(
+          T const& x
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+          // use some SFINAE to un-confuse MSVC about its
+          // copy-initialization ambiguity claim.
+        , typename mpl::if_<is_proxy<T>,int&,int>::type* = 0
+# endif 
+      )
         : object_base(object_base_initializer(x))
       {
       }
@@ -264,14 +348,31 @@ namespace api
   // Macros for forwarding constructors in classes derived from
   // object. Derived classes will usually want these as an
   // implementation detail
-# define BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(derived, base)               \
-    inline explicit derived(::boost::python::detail::borrowed_reference p)     \
-        : base(p) {}                                                           \
-    inline explicit derived(::boost::python::detail::new_reference p)          \
-        : base(p) {}                                                           \
-    inline explicit derived(::boost::python::detail::new_non_null_reference p) \
+# define BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS_(derived, base)       \
+    inline explicit derived(python::detail::borrowed_reference p)       \
+        : base(p) {}                                                    \
+    inline explicit derived(python::detail::new_reference p)            \
+        : base(p) {}                                                    \
+    inline explicit derived(python::detail::new_non_null_reference p)   \
         : base(p) {}
 
+# if !defined(BOOST_MSVC) || BOOST_MSVC >= 1300
+#  define BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS_
+# else
+  // MSVC6 has a bug which causes an explicit template constructor to
+  // be preferred over an appropriate implicit conversion operator
+  // declared on the argument type. Normally, that would cause a
+  // runtime failure when using extract<T> to extract a type with a
+  // templated constructor. This additional constructor will turn that
+  // runtime failure into an ambiguity error at compile-time due to
+  // the lack of partial ordering, or at least a link-time error if no
+  // generalized template constructor is declared.
+#  define BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(derived, base)       \
+    BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS_(derived, base)            \
+    template <class T>                                                  \
+    explicit derived(extract<T> const&);
+# endif
+
   //
   // object_initializer -- get the handle to construct the object with,
   // based on whether T is a proxy or derived from object