Merge branch 'develop'

Fixes empty example

doc/projects.html

@@ -396,27 +396,33 @@
       </blockquote>
     </dd>
 
-    <dt><b><a href="http://www.rationaldiscovery.com">Rational Discovery
-    LLC</a></b></dt>
+    <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>
 
     <dd>
-      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>
+      A collection of cheminformatics and machine-learning software
+      written in C++ and Python.
     </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="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="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="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) { f(x); }
-    int f2(int x, double y) { f(x,y); }
+    int f1(int x) { return f(x); }
+    int f2(int x, double y) { return f(x,y); }
 
     /*...*/
 

example/Jamroot

@@ -11,7 +11,10 @@ use-project boost
 # boost_python library from the project whose global ID is
 # /boost/python.
 project
-  : requirements <library>/boost/python//boost_python ;
+  : requirements <library>/boost/python//boost_python 
+                 <implicit-dependency>/boost//headers 
+  : usage-requirements <implicit-dependency>/boost//headers 
+  ;
 
 # 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/v2 subdirectory of your
+# Edit this path to point at the tools/build/src subdirectory of your
 # Boost installation.  Absolute paths work, too.
-boost-build ../../../tools/build/v2 ;
+boost-build ../../../tools/build/src ;

example/quickstart/Jamroot

@@ -12,6 +12,8 @@ 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
@@ -29,7 +31,7 @@ import testing ;
 testing.make-test run-pyd : extending test_extending.py : : test_ext ;
 
 # Declare a test of the embedding application
-testing.run embedding 
+testing.run embedding embedding.cpp
   :              # 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/v2 subdirectory of your
+# Edit this path to point at the tools/build/src subdirectory of your
 # Boost installation.  Absolute paths work, too.
-boost-build ../../../../tools/build/v2 ;
+boost-build ../../../../tools/build/src ;

example/tutorial/Jamroot

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

include/boost/python/args.hpp

@@ -102,7 +102,6 @@ namespace detail
       return this->operator,(python::arg(name));
   }
 
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template<typename T>
   struct is_keywords
   {
@@ -126,31 +125,6 @@ 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,7 +29,6 @@ struct back_reference
     T m_value;
 };
 
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template<typename T>
 class is_back_reference
 {
@@ -44,36 +43,6 @@ 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,7 +24,6 @@ namespace boost { namespace python {
 
   namespace detail
   {
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
     template <class T> struct specifies_bases
         : mpl::false_
     {
@@ -35,23 +34,6 @@ 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,8 +45,7 @@
 # if BOOST_WORKAROUND(__MWERKS__, <= 0x3004)                        \
     /* pro9 reintroduced the bug */                                 \
     || (BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
-        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))   \
-    || BOOST_WORKAROUND(__GNUC__, < 3)
+        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 
 #  define BOOST_PYTHON_NO_MEMBER_POINTER_ORDERING 1
 
@@ -302,7 +301,6 @@ 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)
     {
@@ -317,47 +315,6 @@ 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 BOOST_MSVC < 1301 || _MSC_FULL_VER > 13102196
+# if _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,17 +13,9 @@ 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,7 +121,6 @@ struct is_object_manager
 {
 };
 
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T>
 struct is_reference_to_object_manager
     : mpl::false_
@@ -151,79 +150,6 @@ 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,8 +44,7 @@ struct registered
 {
 };
 
-# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
-    && !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
+# if !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,7 +14,6 @@ namespace boost { namespace python { namespace converter {
 
 struct registration;
 
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T>
 struct registered_pointee
     : registered<
@@ -26,37 +25,6 @@ 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__) && __GNUC__ >= 3 || defined(__EDG__)
+# if defined(__GNUC__) || 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__) && __GNUC__ >= 3 || defined(__EDG__)
+# if defined(__GNUC__) || 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) && !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#  if !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
 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(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(__EDG_VERSION__, <= 238))
+# if 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__) && __GNUC__ >= 3 || defined(__EDG__)
+# if defined(__GNUC__) || defined(__EDG__)
   {}
 # endif 
   ;

include/boost/python/detail/borrowed_ptr.hpp

@@ -19,7 +19,6 @@ template<class T> class borrowed
     typedef T type;
 };
 
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template<typename T>
 struct is_borrowed_ptr
 {
@@ -68,35 +67,6 @@ 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,9 +29,6 @@
 # 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,13 +8,7 @@
 namespace boost { namespace python { namespace detail { 
 
 template <class T, class Arg>
-void construct_pointee(void* storage, Arg& x
-# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
-                       , T const volatile*
-# else 
-                       , T const*
-# endif 
-    )
+void construct_pointee(void* storage, Arg& x, T const volatile*)
 {
     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_const_);
+    BOOST_STATIC_CONSTANT(bool, is_volatile = is_volatile_);
 };
 
 typedef cv_tag<false,false> cv_unqualified;

include/boost/python/detail/destroy.hpp

@@ -7,25 +7,12 @@
 
 # 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
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-  , bool enum_  // vc7 has a problem destroying enums
-# endif 
-    > struct value_destroyer;
+template <bool array> struct value_destroyer;
     
 template <>
-struct value_destroyer<
-    false
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-  , false
-# endif 
-    >
+struct value_destroyer<false>
 {
     template <class T>
     static void execute(T const volatile* p)
@@ -35,12 +22,7 @@ struct value_destroyer<
 };
 
 template <>
-struct value_destroyer<
-    true
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-  , false
-# endif 
-    >
+struct value_destroyer<true>
 {
     template <class A, class T>
     static void execute(A*, T const volatile* const first)
@@ -49,9 +31,6 @@ struct value_destroyer<
         {
             value_destroyer<
                 boost::is_array<T>::value
-# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
-              , boost::is_enum<T>::value
-# endif 
             >::execute(p);
         }
     }
@@ -63,25 +42,6 @@ struct value_destroyer<
     }
 };
 
-# 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& (*)())
 {
@@ -89,9 +49,6 @@ 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,40 +7,7 @@
 # include <boost/python/detail/sfinae.hpp>
 # include <boost/detail/workaround.hpp>
 
-# 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)
+#if !defined(BOOST_NO_SFINAE)
 #  include <boost/utility/enable_if.hpp>
 
 namespace boost { namespace python { namespace detail { 

include/boost/python/detail/force_instantiate.hpp

@@ -10,23 +10,9 @@ 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,46 +25,11 @@ 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(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__MWERKS__) && __MWERKS__ <= 0x2407)
+# if !(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>
@@ -73,7 +38,7 @@ struct elif_selected
 # endif 
 };
 
-# if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__MWERKS__) && __MWERKS__ <= 0x2407)
+# if !(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,15 +7,18 @@
 
 #include <typeinfo>
 #include <boost/type.hpp>
-#include <boost/type_traits/config.hpp>
 
 //
-// Fix for MSVC's broken typeid() implementation which doesn't strip
+// Fix for icc'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.
 //
 
-# if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(BOOST_INTEL_CXX_VERSION) && BOOST_INTEL_CXX_VERSION <= 700
+// 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
 
 namespace boost { namespace python { namespace detail { 
 
@@ -44,8 +47,14 @@ 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_TT_DECL is_ref_tester1(...) { return 0; }
+inline char BOOST_PYTT_DECL is_ref_tester1(...) { return 0; }
 
 template <class T>
 inline typeinfo msvc_typeid(boost::type<T>*)
@@ -71,5 +80,5 @@ inline typeinfo assert_array_typeid_compiles()
 
 }}} // namespace boost::python::detail
 
-# endif // BOOST_MSVC
+# endif // BOOST_INTEL_CXX_VERSION
 #endif // MSVC_TYPEINFO_DWA200222_HPP

include/boost/python/detail/referent_storage.hpp

@@ -42,7 +42,6 @@ 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&>
@@ -51,15 +50,6 @@ 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,9 +43,7 @@ namespace boost { namespace python { namespace detail {
 template <class R, class T>
 boost::type<R>* result(R (T::*), int = 0) { return 0; }
 
-#  if (defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140)  \
-   || (defined(__GNUC__) && __GNUC__ < 3)                 \
-   || (defined(__MWERKS__) && __MWERKS__ < 0x3000)
+#  if (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,7 +14,6 @@
 
 namespace boost { namespace python { namespace detail { 
 
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <class T>
 struct is_string_literal : mpl::false_
 {
@@ -45,43 +44,6 @@ 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,10 +30,6 @@
 #  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

@@ -1,107 +0,0 @@
-#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,35 +9,6 @@
 # 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>
@@ -57,6 +28,5 @@ struct value_is_##name                                                  \
                                                                         \
 };                                                              
 
-# endif
 
 #endif // VALUE_IS_XXX_DWA2003224_HPP

include/boost/python/exception_translator.hpp

@@ -8,6 +8,7 @@
 # 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,11 +19,9 @@
 # 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_MSVC, <= 1300) || BOOST_WORKAROUND(BOOST_INTEL_WIN, <= 900)
-// workaround for VC++ 6.x or 7.0
+#if BOOST_WORKAROUND(BOOST_INTEL_WIN, <= 900)
 # define BOOST_EXTRACT_WORKAROUND ()
 #else
 # define BOOST_EXTRACT_WORKAROUND

include/boost/python/handle.hpp

@@ -87,8 +87,6 @@ class handle
         return *this;
     }
 
-#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)
-
     template<typename Y>
     handle& operator=(handle<Y> const & r) // never throws
     {
@@ -97,8 +95,6 @@ class handle
         return *this;
     }
 
-#endif
-
     template <typename Y>
     handle(handle<Y> const& r)
         : m_p(python::xincref(python::upcast<T>(r.get())))
@@ -159,7 +155,6 @@ typedef handle<PyTypeObject> type_handle;
 //
 // Compile-time introspection
 //
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template<typename T>
 class is_handle
 {
@@ -173,28 +168,6 @@ 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,27 +76,6 @@ 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
@@ -108,7 +87,6 @@ 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/utility.hpp>
+# include <boost/noncopyable.hpp>
 # include <boost/python/type_id.hpp>
 # include <cstddef>
 

include/boost/python/make_constructor.hpp

@@ -104,14 +104,6 @@ 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
@@ -120,7 +112,6 @@ 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__) && __GNUC__ >= 3 || defined(__EDG__)
+# if defined(__GNUC__) || defined(__EDG__)
   {}
 # endif
   ;

include/boost/python/object/class.hpp

@@ -6,7 +6,6 @@
 # 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,11 +53,7 @@ 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,13 +12,7 @@
 # include <boost/ref.hpp>
 # include <boost/python/detail/value_arg.hpp>
 # include <boost/python/detail/copy_ctor_mutates_rhs.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 
+# include <boost/mpl/or.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -42,24 +36,13 @@ 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
 {
@@ -86,88 +69,6 @@ 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,35 +71,7 @@ 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,11 +46,7 @@ template <class T> class wrapper;
 
 namespace boost { namespace python { namespace objects {
 
-#  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 
+#define BOOST_PYTHON_UNFORWARD_LOCAL(z, n, _) BOOST_PP_COMMA_IF(n) objects::do_unforward(a##n,0)
 
 template <class Pointer, class Value>
 struct pointer_holder : instance_holder

include/boost/python/object/value_holder.hpp

@@ -33,11 +33,7 @@
 
 namespace boost { namespace python { namespace objects { 
 
-#  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 
+#define BOOST_PYTHON_UNFORWARD_LOCAL(z, n, _) BOOST_PP_COMMA_IF(n) objects::do_unforward(a##n,0)
 
 template <class Value>
 struct value_holder : instance_holder

include/boost/python/object_core.hpp

@@ -36,12 +36,6 @@
 # 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
@@ -98,11 +92,7 @@ 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
       //
@@ -139,25 +129,11 @@ namespace api
     
       template <class T>
       const_object_item
-      operator[](T const& key) const
-# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
-          ;
-# else 
-      {
-          return (*this)[object(key)];
-      }
-# endif 
+      operator[](T const& key) const;
     
       template <class T>
       object_item
-      operator[](T const& key)
-# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
-          ;
-# else 
-      {
-          return (*this)[object(key)];
-      }
-# endif
+      operator[](T const& key);
 
       // slicing
       //
@@ -175,29 +151,11 @@ namespace api
 
       template <class T, class V>
       const_object_slice
-      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
+      slice(T const& start, V const& end) const;
     
       template <class T, class V>
       object_slice
-      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
+      slice(T const& start, V const& end);
       
    private: // def visitation for adding callable objects as class methods
       
@@ -248,26 +206,6 @@ 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<
@@ -275,28 +213,13 @@ 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>
@@ -323,14 +246,7 @@ namespace api
       
       // explicit conversion from any C++ object to Python
       template <class T>
-      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 
-      )
+      explicit object(T const& x)
         : object_base(object_base_initializer(x))
       {
       }
@@ -348,31 +264,14 @@ 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(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)   \
+# 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) \
         : 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

include/boost/python/object_items.hpp

@@ -44,7 +44,6 @@ object_operators<U>::operator[](object_cref key) const
     return const_object_item(x, key);
 }
 
-# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
 template <class U>
 template <class T>
 inline const_object_item
@@ -60,8 +59,6 @@ object_operators<U>::operator[](T const& key)
 {
     return (*this)[object(key)];
 }
-# endif 
-
 
 inline object const_item_policies::get(object const& target, object const& key)
 {

include/boost/python/object_slices.hpp

@@ -99,7 +99,7 @@ object_operators<U>::slice(object_cref start, slice_nil) const
     object_cref2 x = *static_cast<U const*>(this);
     return const_object_slice(x, api::slice_key(borrowed(start.ptr()), allow_null((PyObject*)0)));
 }
-# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+
 template <class U>
 template <class T, class V>
 inline const_object_slice
@@ -119,8 +119,6 @@ object_operators<U>::slice(T const& start, V const& end)
         typename slice_bound<T>::type(start)
         , typename slice_bound<V>::type(end));
 }
-# endif 
-
 
 inline object const_slice_policies::get(object const& target, key_type const& key)
 {

include/boost/python/opaque_pointer_converter.hpp

@@ -172,28 +172,19 @@ PyTypeObject opaque<Pointee>::type_object =
 };
 }} // namespace boost::python
 
-#  if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-
-#  define BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID(Pointee)
-
-#  else
-
 // If you change the below, don't forget to alter the end of type_id.hpp
 #   define BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID(Pointee)                     \
     namespace boost { namespace python {                                        \
     template<>                                                                  \
-    inline type_info type_id<Pointee>(BOOST_PYTHON_EXPLICIT_TT_DEF(Pointee))    \
+    inline type_info type_id<Pointee>()                                         \
     {                                                                           \
         return type_info (typeid (Pointee *));                                  \
     }                                                                           \
     template<>                                                                  \
-    inline type_info type_id<const volatile Pointee&>(                          \
-        BOOST_PYTHON_EXPLICIT_TT_DEF(const volatile Pointee&))                  \
+    inline type_info type_id<const volatile Pointee&>()                         \
     {                                                                           \
         return type_info (typeid (Pointee *));                                  \
     }                                                                           \
     }}
 
-#  endif
-
 # endif    // OPAQUE_POINTER_CONVERTER_HPP_

include/boost/python/other.hpp

@@ -7,9 +7,7 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-# if _MSC_VER+0 >= 1020
-#  pragma once
-# endif
+# pragma once
 
 # include <boost/config.hpp>
 
@@ -20,7 +18,6 @@ template<class T> struct other
     typedef T type;
 };
 
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 namespace detail
 {
   template<typename T>
@@ -51,63 +48,6 @@ namespace detail
       typedef T type;
   };
 }
-# else // no partial specialization
-
-}} // namespace boost::python
-
-#include <boost/type.hpp>
-
-namespace boost { namespace python {
-
-namespace detail
-{
-  typedef char (&yes_other_t)[1];
-  typedef char (&no_other_t)[2];
-      
-  no_other_t is_other_test(...);
-
-  template<typename T>
-  yes_other_t is_other_test(type< other<T> >);
-
-  template<bool wrapped>
-  struct other_unwrapper
-  {
-      template <class T>
-      struct apply
-      {
-          typedef T type;
-      };
-  };
-
-  template<>
-  struct other_unwrapper<true>
-  {
-      template <class T>
-      struct apply
-      {
-          typedef typename T::type type;
-      };
-  };
-
-  template<typename T>
-  class is_other
-  {
-   public:
-      BOOST_STATIC_CONSTANT(
-          bool, value = (
-              sizeof(detail::is_other_test(type<T>()))
-              == sizeof(detail::yes_other_t)));
-  };
-
-  template <typename T>
-  class unwrap_other
-      : public detail::other_unwrapper<
-      is_other<T>::value
-  >::template apply<T>
-  {};
-}
-
-# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 }} // namespace boost::python
 

include/boost/python/proxy.hpp

@@ -15,11 +15,7 @@ class proxy : public object_operators<proxy<Policies> >
 {
     typedef typename Policies::key_type key_type;
     
-# if !defined(BOOST_MSVC) || BOOST_MSVC >= 1300
     typedef proxy const& assignment_self;
-# else
-    typedef proxy assignment_self;
-# endif
  public:
     proxy(object const& target, key_type const& key);
     operator object() const;

include/boost/python/ptr.hpp

@@ -11,9 +11,7 @@
 //  Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
 //  Copyright (C) 2001 Peter Dimov
 
-# if _MSC_VER+0 >= 1020
-#  pragma once
-# endif
+# pragma once
 
 # include <boost/config.hpp>
 # include <boost/mpl/bool.hpp>
@@ -38,7 +36,6 @@ inline pointer_wrapper<T> ptr(T t)
     return pointer_wrapper<T>(t);
 }
 
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template<typename T>
 class is_pointer_wrapper
     : public mpl::false_
@@ -64,64 +61,6 @@ class unwrap_pointer<pointer_wrapper<T> >
  public:
     typedef T type;
 };
-# else // no partial specialization
-
-}} // namespace boost::python
-
-#include <boost/type.hpp>
-
-namespace boost { namespace python {
-
-namespace detail
-{
-  typedef char (&yes_pointer_wrapper_t)[1];
-  typedef char (&no_pointer_wrapper_t)[2];
-      
-  no_pointer_wrapper_t is_pointer_wrapper_test(...);
-
-  template<typename T>
-  yes_pointer_wrapper_t is_pointer_wrapper_test(boost::type< pointer_wrapper<T> >);
-
-  template<bool wrapped>
-  struct pointer_unwrapper
-  {
-      template <class T>
-      struct apply
-      {
-          typedef T type;
-      };
-  };
-
-  template<>
-  struct pointer_unwrapper<true>
-  {
-      template <class T>
-      struct apply
-      {
-          typedef typename T::type type;
-      };
-  };
-}
-
-template<typename T>
-class is_pointer_wrapper
-{
- public:
-    BOOST_STATIC_CONSTANT(
-        bool, value = (
-        sizeof(detail::is_pointer_wrapper_test(boost::type<T>()))
-            == sizeof(detail::yes_pointer_wrapper_t)));
-    typedef mpl::bool_<value> type;
-};
-
-template <typename T>
-class unwrap_pointer
-    : public detail::pointer_unwrapper<
-        is_pointer_wrapper<T>::value
-      >::template apply<T>
-{};
-
-# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 }} // namespace boost::python
 

include/boost/python/pure_virtual.hpp

@@ -47,7 +47,7 @@ namespace detail
   // replaced by void, and whose first argument is replaced by C&.
   template <class C, class S>
   typename replace_front2<S,void,C&>::type
-  error_signature(S BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(C))
+  error_signature(S)
   {
       typedef typename replace_front2<S,void,C&>::type r;
       return r();

include/boost/python/reference_existing_object.hpp

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

include/boost/python/register_ptr_to_python.hpp

@@ -12,7 +12,7 @@
 namespace boost { namespace python {
     
 template <class P>
-void register_ptr_to_python(BOOST_EXPLICIT_TEMPLATE_TYPE(P))
+void register_ptr_to_python()
 {
     typedef typename boost::python::pointee<P>::type X;
     objects::class_value_wrapper<

include/boost/python/return_arg.hpp

@@ -29,7 +29,7 @@ namespace detail
 {
   template <std::size_t>
   struct return_arg_pos_argument_must_be_positive
-# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+# if defined(__GNUC__) || defined(__EDG__)
   {}
 # endif
   ;

include/boost/python/return_internal_reference.hpp

@@ -18,7 +18,7 @@ namespace detail
 {
   template <std::size_t>
   struct return_internal_reference_owner_arg_must_be_greater_than_zero
-# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+# if defined(__GNUC__) || defined(__EDG__)
   {}
 # endif
   ;

include/boost/python/scope.hpp

@@ -8,7 +8,6 @@
 # include <boost/python/detail/prefix.hpp>
 # include <boost/python/object.hpp>
 # include <boost/python/refcount.hpp>
-# include <boost/utility.hpp>
 
 namespace boost { namespace python { 
 

include/boost/python/suite/indexing/indexing_suite.hpp

@@ -131,11 +131,7 @@ namespace boost { namespace python {
         typedef detail::container_element<Container, Index, DerivedPolicies>
             container_element_t;
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        struct return_policy : return_internal_reference<> {};
-#else
         typedef return_internal_reference<> return_policy;
-#endif
 
         typedef typename mpl::if_<
             no_proxy

include/boost/python/to_python_converter.hpp

@@ -48,12 +48,7 @@ template < class T, class Conversion, bool has_get_pytype=false >
 struct to_python_converter 
 {
 #ifndef BOOST_PYTHON_NO_PY_SIGNATURES
-#if 0 //defined _MSC_VER && _MSC_VER >=1310
-    //probably other compilers could come here as well
-    typedef typename detail::test_get_pytype<Conversion> HasGetPytype;
-#else
     typedef boost::mpl::bool_<has_get_pytype> HasGetPytype;
-#endif
 
     static PyTypeObject const* get_pytype_1(boost::mpl::true_ *)
     {

include/boost/python/to_python_value.hpp

@@ -147,11 +147,6 @@ namespace detail
   template <class T>
   inline PyObject* registry_to_python_value<T>::operator()(argument_type x) const
   {
-      typedef converter::registered<argument_type> r;
-# if BOOST_WORKAROUND(__GNUC__, < 3)
-      // suppresses an ICE, somehow
-      (void)r::converters;
-# endif 
       return converter::registered<argument_type>::converters.to_python(&x);
   }
 

include/boost/python/type_id.hpp

@@ -15,11 +15,9 @@
 # include <boost/static_assert.hpp>
 # include <boost/detail/workaround.hpp>
 # include <boost/type_traits/same_traits.hpp>
-# include <boost/type_traits/broken_compiler_spec.hpp>
 
 #  ifndef BOOST_PYTHON_HAVE_GCC_CP_DEMANGLE
 #   if defined(__GNUC__)                                                \
-    && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)))   \
     && !defined(__EDG_VERSION__)
 #    define BOOST_PYTHON_HAVE_GCC_CP_DEMANGLE
 #   endif
@@ -30,7 +28,7 @@ namespace boost { namespace python {
 // for this compiler at least, cross-shared-library type_info
 // comparisons don't work, so use typeid(x).name() instead. It's not
 // yet clear what the best default strategy is.
-# if (defined(__GNUC__) && __GNUC__ >= 3) \
+# if defined(__GNUC__) \
  || defined(_AIX) \
  || (   defined(__sgi) && defined(__host_mips)) \
  || (defined(__hpux) && defined(__HP_aCC)) \
@@ -69,21 +67,18 @@ struct type_info : private totally_ordered<type_info>
     base_id_t m_base_type;
 };
 
-#  ifdef BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
-#   define BOOST_PYTHON_EXPLICIT_TT_DEF(T) ::boost::type<T>*
-#  else
-#   define BOOST_PYTHON_EXPLICIT_TT_DEF(T)
-#  endif
+
+// This macro is obsolete. Port away and remove.
+# define BOOST_PYTHON_EXPLICIT_TT_DEF(T)
 
 template <class T>
-inline type_info type_id(BOOST_EXPLICIT_TEMPLATE_TYPE(T))
+inline type_info type_id()
 {
     return type_info(
 #  if !defined(_MSC_VER)                                       \
-      || (!BOOST_WORKAROUND(BOOST_MSVC, <= 1300)                \
-          && !BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700))
+      || !BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700)
         typeid(T)
-#  else // strip the decoration which msvc and Intel mistakenly leave in
+#  else // strip the decoration which Intel mistakenly leaves in
         python::detail::msvc_typeid((boost::type<T>*)0)
 #  endif 
         );
@@ -99,7 +94,7 @@ inline type_info type_id(BOOST_EXPLICIT_TEMPLATE_TYPE(T))
 
 #   define BOOST_PYTHON_SIGNED_INTEGRAL_TYPE_ID(T)              \
 template <>                                                     \
-inline type_info type_id<T>(BOOST_PYTHON_EXPLICIT_TT_DEF(T))    \
+inline type_info type_id<T>()                                   \
 {                                                               \
     return type_info(typeid(T));                                \
 }
@@ -171,22 +166,19 @@ inline char const* type_info::name() const
 
 BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_info const&);
 
-#  if !BOOST_WORKAROUND(BOOST_MSVC, == 1200)
 template<>
-inline type_info type_id<void>(BOOST_PYTHON_EXPLICIT_TT_DEF(void))
+inline type_info type_id<void>()
 {
     return type_info (typeid (void *));
 }
 #   ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
 template<>
-inline type_info type_id<const volatile void>(BOOST_PYTHON_EXPLICIT_TT_DEF(const volatile void))
+inline type_info type_id<const volatile void>()
 {
     return type_info (typeid (void *));
 }
 #  endif
 
-# endif 
-
 }} // namespace boost::python
 
 #endif // TYPE_ID_DWA2002517_HPP

include/boost/python/with_custodian_and_ward.hpp

@@ -85,14 +85,10 @@ struct with_custodian_and_ward_postcall : BasePolicy_
     static PyObject* postcall(ArgumentPackage const& args_, PyObject* result)
     {
         std::size_t arity_ = detail::arity(args_);
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-        if ( custodian > arity_ || ward > arity_ )
-#else
         // check if either custodian or ward exceeds the arity
         // (this weird formulation avoids "always false" warnings
         // for arity_ = 0)
         if ( (std::max)(custodian, ward) > arity_ )
-#endif
         {
             PyErr_SetString(
                 PyExc_IndexError

meta/libraries.json

@@ -0,0 +1,15 @@
+{
+    "key": "python",
+    "name": "Python",
+    "authors": [
+        "Dave Abrahams"
+    ],
+    "description": "The Boost Python Library is a framework for interfacing Python and C++. It allows you to quickly and seamlessly expose C++ classes functions and objects to Python, and vice-versa, using no special tools -- just your C++ compiler.",
+    "category": [
+        "Inter-language"
+    ],
+    "maintainers": [
+        "Ralf Grosse-Kunstleve <rwgrosse-kunstleve -at- lbl.gov>",
+        "Ravi Rajagopal <lists_ravi -at- lavabit.com>"
+    ]
+}

src/converter/builtin_converters.cpp

@@ -377,7 +377,8 @@ namespace
       static unaryfunc* get_slot(PyObject* obj)
       {
 #if PY_VERSION_HEX >= 0x03000000
-          return (PyUnicode_Check(obj)) ? &py_unicode_as_string_unaryfunc : 0;
+          return (PyUnicode_Check(obj)) ? &py_unicode_as_string_unaryfunc : 
+                  PyBytes_Check(obj) ? &py_object_identity : 0;
 #else
           return (PyString_Check(obj)) ? &obj->ob_type->tp_str : 0;
 

src/exec.cpp

@@ -84,13 +84,14 @@ object BOOST_PYTHON_DECL exec_file(str filename, object global, object local)
   if (local.is_none()) local = global;
   // should be 'char const *' but older python versions don't use 'const' yet.
   char *f = python::extract<char *>(filename);
-#if PY_VERSION_HEX >= 0x03000000
-  // TODO(bhy) temporary workaround for Python 3.
-  // should figure out a way to avoid binary incompatibilities as the Python 2
-  // version did.
-  FILE *fs = fopen(f, "r");
-#else
   // Let python open the file to avoid potential binary incompatibilities.
+#if PY_VERSION_HEX >= 0x03040000
+  FILE *fs = _Py_fopen(f, "r");
+#elif PY_VERSION_HEX >= 0x03000000
+  PyObject *fo = Py_BuildValue("s", f);
+  FILE *fs = _Py_fopen(fo, "r");
+  Py_DECREF(fo);
+#else
   PyObject *pyfile = PyFile_FromString(f, const_cast<char*>("r"));
   if (!pyfile) throw std::invalid_argument(std::string(f) + " : no such file");
   python::handle<> file(pyfile);
@@ -99,7 +100,7 @@ object BOOST_PYTHON_DECL exec_file(str filename, object global, object local)
   PyObject* result = PyRun_File(fs,
                 f,
                 Py_file_input,
-                global.ptr(), local.ptr());
+		global.ptr(), local.ptr());
   if (!result) throw_error_already_set();
   return object(detail::new_reference(result));
 }

test/const_argument.cpp

@@ -9,10 +9,8 @@
  * compiler's bug.
  */
 #include <boost/python.hpp>
-#include <boost/type_traits/broken_compiler_spec.hpp>
 using namespace boost::python;
 
-BOOST_TT_BROKEN_COMPILER_SPEC( object )
 
 #if BOOST_WORKAROUND(BOOST_MSVC, == 1200)
 bool accept_const_arg( object );