Merge pull request #13 from ax3l/fix-missingPlaceholderInclude

Fix Trac #10932 Missing Include: Bind Placeholders

include/boost/python.hpp

@@ -53,7 +53,6 @@
 # include <boost/python/pointee.hpp>
 # include <boost/python/pure_virtual.hpp>
 # include <boost/python/ptr.hpp>
-# include <boost/python/raw_function.hpp>
 # include <boost/python/reference_existing_object.hpp>
 # include <boost/python/register_ptr_to_python.hpp>
 # include <boost/python/return_arg.hpp>
@@ -62,9 +61,7 @@
 # include <boost/python/return_value_policy.hpp>
 # include <boost/python/scope.hpp>
 # include <boost/python/self.hpp>
-# include <boost/python/slice.hpp>
 # include <boost/python/slice_nil.hpp>
-# include <boost/python/stl_iterator.hpp>
 # include <boost/python/str.hpp>
 # include <boost/python/to_python_converter.hpp>
 # include <boost/python/to_python_indirect.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/object_core.hpp

@@ -348,7 +348,7 @@ 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)               \
+# 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)          \
@@ -356,6 +356,23 @@ namespace api
     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/opaque_pointer_converter.hpp

@@ -182,12 +182,13 @@ PyTypeObject opaque<Pointee>::type_object =
 #   define BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID(Pointee)                     \
     namespace boost { namespace python {                                        \
     template<>                                                                  \
-    inline type_info type_id<Pointee>()                                         \
+    inline type_info type_id<Pointee>(BOOST_PYTHON_EXPLICIT_TT_DEF(Pointee))    \
     {                                                                           \
         return type_info (typeid (Pointee *));                                  \
     }                                                                           \
     template<>                                                                  \
-    inline type_info type_id<const volatile Pointee&>()                         \
+    inline type_info type_id<const volatile Pointee&>(                          \
+        BOOST_PYTHON_EXPLICIT_TT_DEF(const volatile Pointee&))                  \
     {                                                                           \
         return type_info (typeid (Pointee *));                                  \
     }                                                                           \

include/boost/python/type_id.hpp

@@ -69,9 +69,11 @@ struct type_info : private totally_ordered<type_info>
     base_id_t m_base_type;
 };
 
-
-// This macro is obsolete. Port away and remove.
-# define BOOST_PYTHON_EXPLICIT_TT_DEF(T)
+#  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
 
 template <class T>
 inline type_info type_id(BOOST_EXPLICIT_TEMPLATE_TYPE(T))
@@ -97,7 +99,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>()                                   \
+inline type_info type_id<T>(BOOST_PYTHON_EXPLICIT_TT_DEF(T))    \
 {                                                               \
     return type_info(typeid(T));                                \
 }
@@ -171,13 +173,13 @@ BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_info const&);
 
 #  if !BOOST_WORKAROUND(BOOST_MSVC, == 1200)
 template<>
-inline type_info type_id<void>()
+inline type_info type_id<void>(BOOST_PYTHON_EXPLICIT_TT_DEF(void))
 {
     return type_info (typeid (void *));
 }
 #   ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
 template<>
-inline type_info type_id<const volatile void>()
+inline type_info type_id<const volatile void>(BOOST_PYTHON_EXPLICIT_TT_DEF(const volatile void))
 {
     return type_info (typeid (void *));
 }

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/exec.cpp

@@ -84,22 +84,24 @@ 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 >= 0x03000000
+  // See http://www.codeproject.com/Articles/820116/Embedding-Python-program-in-a-C-Cplusplus-code
+  FILE *fs = _Py_fopen(f, "r");
+#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);
   FILE *fs = PyFile_AsFile(file.get());
 #endif
-  PyObject* result = PyRun_File(fs,
+
+  int closeit = 1;  // Close file before PyRun returns
+  PyObject* result = PyRun_FileEx(fs,
                 f,
                 Py_file_input,
-                global.ptr(), local.ptr());
+                global.ptr(), local.ptr(),
+                closeit);
   if (!result) throw_error_already_set();
   return object(detail::new_reference(result));
 }