merged from trunk

[SVN r49607]
merged from trunk
2026-01-20 04:42:28 +00:00 · 2008-11-06 00:15:47 +00:00 · 2008-10-05 01:47:33 +00:00 · 2008-09-08 21:00:49 +00:00 · 2008-08-05 05:39:57 +00:00 · 2008-06-05 05:50:03 +00:00
55 changed files with 621 additions and 133 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -0,0 +1,64 @@
+if (PYTHON_LIBRARIES)
+  include_directories(${PYTHON_INCLUDE_PATH})
+
+  # Determine extra libraries we need to link against to build Python
+  # extension modules.
+  if(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "dl")
+    if(CMAKE_COMPILER_IS_GNUCXX)
+      set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "rt")
+    endif(CMAKE_COMPILER_IS_GNUCXX)
+  elseif(CMAKE_SYSTEM_NAME MATCHES ".*BSD")
+    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread")
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "DragonFly")
+    # DragonFly is a variant of FreeBSD
+    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread")
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "OSF")
+    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread" "dl")
+    if(CMAKE_COMPILER_IS_GNUCXX)
+      set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "rt")
+    endif(CMAKE_COMPILER_IS_GNUCXX)    
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "QNX")
+    # No options necessary for QNX
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    # No options necessary for Mac OS X
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "HP-UX")
+    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "rt")
+  elseif(UNIX)
+    # Assume -pthread and -ldl on all other variants
+    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread" "dl")
+    if(CMAKE_COMPILER_IS_GNUCXX)
+      set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "util")
+    endif(CMAKE_COMPILER_IS_GNUCXX)    
+  endif(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+
+  # Macro for building Boost.Python extension modules
+  macro(boost_python_extension MODULE_NAME)
+    parse_arguments(BPL_EXT 
+      "" 
+      "" 
+      ${ARGN})
+
+    # Create the library target itself
+    add_library(${MODULE_NAME} MODULE ${BPL_EXT_DEFAULT_ARGS} )
+
+    # Miscellaneous target properties
+    set_target_properties(${MODULE_NAME} PROPERTIES PREFIX "")
+
+    # Link against Boost.Python library
+    target_link_libraries(${MODULE_NAME} boost_python-shared)
+
+    # Link against Python libraries
+    target_link_libraries(${MODULE_NAME} ${PYTHON_LIBRARIES})
+  endmacro(boost_python_extension)
+
+  boost_library_project(
+    Python
+    SRCDIRS src
+    TESTDIRS test
+    HEADERS python.hpp python
+    MODULARIZED
+    DESCRIPTION "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."
+    AUTHORS "David Abrahams <dave -at- boostpro.com>"
+    )
+endif (PYTHON_LIBRARIES)
--- a/doc/tutorial/doc/html/index.html
+++ b/doc/tutorial/doc/html/index.html
@@ -31,7 +31,7 @@
 <div><p class="copyright">Copyright © 2002-2005 Joel
      de Guzman, David Abrahams</p></div>
 <div><div class="legalnotice">
-<a name="id455921"></a><p>
+<a name="id455917"></a><p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">
        http://www.boost.org/LICENSE_1_0.txt </a>)
@@ -94,7 +94,7 @@
      (IDL).
    </p>
 <a name="quickstart.hello_world"></a><h2>
-<a name="id385276"></a>
+<a name="id385257"></a>
      Hello World
    </h2>
 <p>
@@ -145,7 +145,7 @@
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: March 24, 2008 at 23:09:39 GMT</small></p></td>
+<td align="left"><p><small>Last revised: November 07, 2007 at 03:34:24 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>
--- a/doc/tutorial/doc/html/python/embedding.html
+++ b/doc/tutorial/doc/html/python/embedding.html
@@ -40,7 +40,7 @@
      Python/C API at all. So stay tuned... <span class="inlinemediaobject"><img src="../images/smiley.png" alt="smiley"></span>
    </p>
 <a name="embedding.building_embedded_programs"></a><h2>
-<a name="id471330"></a>
+<a name="id471171"></a>
      Building embedded programs
    </h2>
 <p>
@@ -82,7 +82,7 @@ exe embedded_program # name of the executable
    &lt;find-library&gt;$(PYTHON_EMBEDDED_LIBRARY) ;
 </pre>
 <a name="embedding.getting_started"></a><h2>
-<a name="id471435"></a>
+<a name="id471276"></a>
      Getting started
    </h2>
 <p>
@@ -139,7 +139,7 @@ exe embedded_program # name of the executable
        automate the process.
      </p>
 <a name="using_the_interpreter.running_python_code"></a><h2>
-<a name="id471598"></a>
+<a name="id471439"></a>
        Running Python code
      </h2>
 <p>
@@ -190,7 +190,7 @@ exe embedded_program # name of the executable
        a phrase that is well-known in programming circles.
      </p>
 <a name="using_the_interpreter.manipulating_python_objects"></a><h2>
-<a name="id472186"></a>
+<a name="id472027"></a>
        Manipulating Python objects
      </h2>
 <p>
@@ -217,7 +217,7 @@ exe embedded_program # name of the executable
 <span class="keyword">int</span> <span class="identifier">five_squared</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">result</span><span class="special">);</span>
 </pre>
 <a name="using_the_interpreter.exception_handling"></a><h2>
-<a name="id472558"></a>
+<a name="id472399"></a>
        Exception handling
      </h2>
 <p>
--- a/doc/tutorial/doc/html/python/exposing.html
+++ b/doc/tutorial/doc/html/python/exposing.html
@@ -533,7 +533,7 @@
 <div class="titlepage"><div><div><h3 class="title">
 <a name="python.class_operators_special_functions"></a>Class Operators/Special Functions</h3></div></div></div>
 <a name="class_operators_special_functions.python_operators"></a><h2>
-<a name="id461482"></a>
+<a name="id461460"></a>
        Python Operators
      </h2>
 <p>
@@ -582,7 +582,7 @@
        expressions".
      </p>
 <a name="class_operators_special_functions.special_methods"></a><h2>
-<a name="id462239"></a>
+<a name="id462216"></a>
        Special Methods
      </h2>
 <p>
--- a/doc/tutorial/doc/html/python/functions.html
+++ b/doc/tutorial/doc/html/python/functions.html
@@ -212,7 +212,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <li><span class="bold"><b>BOOM!</b></span></li>
 </ol></div>
 <a name="call_policies.call_policies"></a><h2>
-<a name="id464236"></a>
+<a name="id464076"></a>
        Call Policies
      </h2>
 <p>
@@ -415,7 +415,7 @@ Namespaces are one honking great idea -- let's do more of those!
        </li>
 </ul></div>
 <a name="default_arguments.boost_python_function_overloads"></a><h2>
-<a name="id466276"></a>
+<a name="id466117"></a>
        BOOST_PYTHON_FUNCTION_OVERLOADS
      </h2>
 <p>
@@ -445,7 +445,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
 </pre>
 <a name="default_arguments.boost_python_member_function_overloads"></a><h2>
-<a name="id466595"></a>
+<a name="id466436"></a>
        BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
      </h2>
 <p>
@@ -491,7 +491,7 @@ Namespaces are one honking great idea -- let's do more of those!
        reference</a> for details.
      </p>
 <a name="default_arguments.init_and_optional"></a><h2>
-<a name="id466958"></a>
+<a name="id466799"></a>
        init and optional
      </h2>
 <p>
@@ -565,7 +565,7 @@ Namespaces are one honking great idea -- let's do more of those!
        (0) arguments and a maximum of 3 arguments.
      </p>
 <a name="auto_overloading.manual_wrapping"></a><h2>
-<a name="id467740"></a>
+<a name="id467581"></a>
        Manual Wrapping
      </h2>
 <p>
--- a/doc/tutorial/doc/html/python/hello.html
+++ b/doc/tutorial/doc/html/python/hello.html
@@ -26,7 +26,7 @@
 <div class="titlepage"><div><div><h2 class="title" style="clear: both">
 <a name="python.hello"></a> Building Hello World</h2></div></div></div>
 <a name="hello.from_start_to_finish"></a><h2>
-<a name="id386189"></a>
+<a name="id387672"></a>
      From Start To Finish
    </h2>
 <p>
@@ -92,7 +92,7 @@
      platforms. The complete list of Bjam executables can be found <a href="http://sourceforge.net/project/showfiles.php?group_id=7586" target="_top">here</a>.
    </p>
 <a name="hello.let_s_jam_"></a><h2>
-<a name="id386347"></a>
+<a name="id386265"></a>
      Let's Jam!
    </h2>
 <p>
@@ -108,7 +108,7 @@
      you going.
    </p>
 <a name="hello.running_bjam"></a><h2>
-<a name="id386404"></a>
+<a name="id386322"></a>
      Running bjam
    </h2>
 <p>
@@ -180,17 +180,6 @@ bjam
      Or something similar. If all is well, you should now have built the DLLs and
      run the Python program.
    </p>
-<div class="note"><table border="0" summary="Note">
-<tr>
-<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../../doc/html/images/note.png"></td>
-<th align="left">Note</th>
-</tr>
-<tr><td colspan="2" align="left" valign="top"><p>
-        Starting from Boost 1.35, bjam erases the generated executables (e.g. pyd
-        file) after the test has concluded to conserve disk space. To keep bjam from
-        doing that, pass --preserve-test-targets to bjam.
-      </p></td></tr>
-</table></div>
 <div class="blockquote"><blockquote class="blockquote">
 <p>
        </p>
--- a/doc/tutorial/doc/html/python/object.html
+++ b/doc/tutorial/doc/html/python/object.html
@@ -196,7 +196,7 @@
 </span><span class="identifier">d</span><span class="special">[</span><span class="char">'whatever'</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>           <span class="comment">// modifies the copy
 </span></pre>
 <a name="derived_object_types.class__lt_t_gt__as_objects"></a><h2>
-<a name="id469745"></a>
+<a name="id469586"></a>
        class_&lt;T&gt; as objects
      </h2>
 <p>
--- a/doc/v2/object.html
+++ b/doc/v2/object.html
@@ -655,6 +655,11 @@ namespace boost { namespace python { namespace api
      template &lt;class A0, class A1,...class An&gt;
      object operator()(A0 const&amp;, A1 const&amp;,...An const&amp;) const;

+      detail::args_proxy operator* () const; 
+      object operator()(detail::args_proxy const &amp;args) const; 
+      object operator()(detail::args_proxy const &amp;args, 
+                        detail::kwds_proxy const &amp;kwds) const; 
+
      // truth value testing
      //
      typedef unspecified bool_type;
@@ -704,6 +709,25 @@ object operator()(A0 const&amp; a1, A1 const&amp; a2,...An const&amp; aN) const;
      call&lt;object&gt;(object(*static_cast&lt;U*&gt;(this)).ptr(), a1,
      a2,...aN)</dt>
    </dl>
+
+<pre>
+object operator()(detail::args_proxy const &amp;args) const; 
+</pre>
+<dl class="function-semantics">
+  <dt><b>Effects:</b>
+  call object with arguments given by the tuple <varname>args</varname></dt>
+</dl>
+<pre>
+object operator()(detail::args_proxy const &amp;args, 
+                  detail::kwds_proxy const &amp;kwds) const; 
+</pre>
+<dl class="function-semantics">
+  <dt><b>Effects:</b>
+  call object with arguments given by the tuple <varname>args</varname>, and named
+  arguments given by the dictionary <varname>kwds</varname></dt>
+</dl>
+
+
 <pre>
 operator bool_type() const;
 </pre>
--- a/include/boost/python/call.hpp
+++ b/include/boost/python/call.hpp
@@ -38,7 +38,10 @@ namespace boost { namespace python {

 # endif // CALL_DWA2002411_HPP

-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, call.hpp)
@@ -76,4 +79,5 @@ call(PyObject* callable

 # undef N

+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/call_method.hpp
+++ b/include/boost/python/call_method.hpp
@@ -37,7 +37,10 @@ namespace boost { namespace python {

 # endif // CALL_METHOD_DWA2002411_HPP

-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, call_method.hpp)
@@ -76,4 +79,5 @@ call_method(PyObject* self, char const* name

 # undef N

+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif // BOOST_PP_IS_ITERATING
--- a/include/boost/python/converter/rvalue_from_python_data.hpp
+++ b/include/boost/python/converter/rvalue_from_python_data.hpp
@@ -117,9 +117,9 @@ struct rvalue_from_python_data : rvalue_from_python_storage<T>
 // Implementataions
 //
 template <class T>
-inline rvalue_from_python_data<T>::rvalue_from_python_data(rvalue_from_python_stage1_data const& stage1)
+inline rvalue_from_python_data<T>::rvalue_from_python_data(rvalue_from_python_stage1_data const& _stage1)
 {
-    this->stage1 = stage1;
+    this->stage1 = _stage1;
 }

 template <class T>
--- a/include/boost/python/data_members.hpp
+++ b/include/boost/python/data_members.hpp
@@ -265,7 +265,8 @@ inline object make_getter(D const& d, Policies const& policies)
 template <class D>
 inline object make_getter(D& x)
 {
-    detail::not_specified policy;
+    detail::not_specified policy
+        = detail::not_specified(); // suppress a SunPro warning
    return detail::make_getter(x, policy, is_member_pointer<D>(), 0L);
 }

@@ -273,7 +274,8 @@ inline object make_getter(D& x)
 template <class D>
 inline object make_getter(D const& d)
 {
-    detail::not_specified policy;
+    detail::not_specified policy
+        = detail::not_specified(); // Suppress a SunPro warning
    return detail::make_getter(d, policy, is_member_pointer<D>(), 0L);
 }
 #  endif
--- a/include/boost/python/detail/result.hpp
+++ b/include/boost/python/detail/result.hpp
@@ -86,7 +86,10 @@ result(X const&, short = 0) { return 0; }
 # endif // RESULT_DWA2002521_HPP

 /* --------------- function pointers --------------- */
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, result.hpp(function pointers))
@@ -128,4 +131,5 @@ boost::type<R>* result(R (T::*)(BOOST_PP_ENUM_PARAMS_Z(1, N, A)) Q, int = 0)
 # undef N
 # undef Q

+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/detail/target.hpp
+++ b/include/boost/python/detail/target.hpp
@@ -37,7 +37,10 @@ T& (* target(R (T::*)) )() { return 0; }
 # endif // TARGET_DWA2002521_HPP

 /* --------------- function pointers --------------- */
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == BOOST_PYTHON_FUNCTION_POINTER
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, target.hpp(function_pointers))
@@ -79,4 +82,5 @@ T& (* target(R (T::*)(BOOST_PP_ENUM_PARAMS_Z(1, N, A)) Q) )()
 # undef N
 # undef Q

+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/object/class_metadata.hpp
+++ b/include/boost/python/object/class_metadata.hpp
@@ -236,7 +236,7 @@ struct class_metadata
    //
    // Support for converting smart pointers to python
    //
-    inline static void maybe_register_pointer_to_python(void*,void*,void*) {}
+    inline static void maybe_register_pointer_to_python(...) {}

 #ifndef BOOST_PYTHON_NO_PY_SYGNATURES
    inline static void maybe_register_pointer_to_python(void*,void*,mpl::true_*) 
--- a/include/boost/python/object/make_holder.hpp
+++ b/include/boost/python/object/make_holder.hpp
@@ -47,7 +47,10 @@ template <int nargs> struct make_holder;

 # endif // MAKE_HOLDER_DWA20011215_HPP

-#elif BOOST_PP_ITERATION_DEPTH() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, make_holder.hpp)
@@ -102,4 +105,5 @@ struct make_holder<N>

 # undef N

+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/object/pointer_holder.hpp
+++ b/include/boost/python/object/pointer_holder.hpp
@@ -127,7 +127,14 @@ void* pointer_holder<Pointer, Value>::holds(type_info dst_t, bool null_ptr_only)
    )
        return &this->m_p;

-    Value* p = get_pointer(this->m_p);
+    Value* p
+#  if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+        = static_cast<Value*>( get_pointer(this->m_p) )
+#  else 
+        = get_pointer(this->m_p)
+#  endif
+        ;
+    
    if (p == 0)
        return 0;
    
@@ -163,7 +170,10 @@ void* pointer_holder_back_reference<Pointer, Value>::holds(type_info dst_t, bool
 # endif // POINTER_HOLDER_DWA20011215_HPP

 /* --------------- pointer_holder --------------- */
-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == 1
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, pointer_holder.hpp)
@@ -205,4 +215,5 @@ void* pointer_holder_back_reference<Pointer, Value>::holds(type_info dst_t, bool

 # undef N

+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/object/value_holder.hpp
+++ b/include/boost/python/object/value_holder.hpp
@@ -117,7 +117,10 @@ void* value_holder_back_reference<Value,Held>::holds(

 // --------------- value_holder ---------------

-#elif BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == 1
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1 && BOOST_PP_ITERATION_FLAGS() == 1
 # if !(BOOST_WORKAROUND(__MWERKS__, > 0x3100)                      \
        && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3201)))
 #  line BOOST_PP_LINE(__LINE__, value_holder.hpp(value_holder))
@@ -163,4 +166,5 @@ void* value_holder_back_reference<Value,Held>::holds(

 # undef N

+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif
--- a/include/boost/python/object_core.hpp
+++ b/include/boost/python/object_core.hpp
@@ -42,6 +42,12 @@

 namespace boost { namespace python { 

+namespace detail
+{
+  class kwds_proxy; 
+  class args_proxy; 
+} 
+
 namespace converter
 {
  template <class T> struct arg_to_python;
@@ -102,6 +108,11 @@ namespace api

 # define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PYTHON_MAX_ARITY, <boost/python/object_call.hpp>))
 # include BOOST_PP_ITERATE()
+    
+      detail::args_proxy operator* () const; 
+      object operator()(detail::args_proxy const &args) const; 
+      object operator()(detail::args_proxy const &args, 
+                        detail::kwds_proxy const &kwds) const; 

      // truth value testing
      //
@@ -219,11 +230,11 @@ namespace api
      inline object_base(object_base const&);
      inline object_base(PyObject* ptr);
      
-      object_base& operator=(object_base const& rhs);
-      ~object_base();
+      inline object_base& operator=(object_base const& rhs);
+      inline ~object_base();
        
      // Underlying object access -- returns a borrowed reference
-      PyObject* ptr() const;
+      inline PyObject* ptr() const;
      
   private:
      PyObject* m_ptr;
@@ -393,7 +404,7 @@ namespace api
      static PyObject*
      get(T const& x, U)
      {
-          return python::incref(get_managed_object(x, tag));
+          return python::incref(get_managed_object(x, boost::python::tag));
      }
  };

@@ -416,6 +427,62 @@ template <class T> struct extract;
 // implementation
 //

+namespace detail 
+{
+
+class call_proxy 
+{ 
+public: 
+  call_proxy(object target) : m_target(target) {} 
+  operator object() const { return m_target;} 
+ 
+ private: 
+    object m_target; 
+}; 
+ 
+class kwds_proxy : public call_proxy 
+{ 
+public: 
+  kwds_proxy(object o = object()) : call_proxy(o) {} 
+}; 
+class args_proxy : public call_proxy 
+{ 
+public: 
+  args_proxy(object o) : call_proxy(o) {} 
+  kwds_proxy operator* () const { return kwds_proxy(*this);} 
+}; 
+} 
+ 
+template <typename U> 
+detail::args_proxy api::object_operators<U>::operator* () const 
+{ 
+  object_cref2 x = *static_cast<U const*>(this); 
+  return boost::python::detail::args_proxy(x); 
+} 
+ 
+template <typename U> 
+object api::object_operators<U>::operator()(detail::args_proxy const &args) const 
+{ 
+  U const& self = *static_cast<U const*>(this); 
+  PyObject *result = PyObject_Call(get_managed_object(self, boost::python::tag), 
+                                   args.operator object().ptr(), 
+                                   0); 
+  return object(boost::python::detail::new_reference(result)); 
+ 
+} 
+ 
+template <typename U> 
+object api::object_operators<U>::operator()(detail::args_proxy const &args, 
+                                            detail::kwds_proxy const &kwds) const 
+{ 
+  U const& self = *static_cast<U const*>(this); 
+  PyObject *result = PyObject_Call(get_managed_object(self, boost::python::tag), 
+                                   args.operator object().ptr(), 
+                                   kwds.operator object().ptr()); 
+  return object(boost::python::detail::new_reference(result)); 
+ 
+}  
+
 inline object::object()
    : object_base(python::incref(Py_None))
 {}
--- a/include/boost/python/object_protocol.hpp
+++ b/include/boost/python/object_protocol.hpp
@@ -10,9 +10,11 @@
 # include <boost/python/object_protocol_core.hpp>
 # include <boost/python/object_core.hpp>

+# include <boost/detail/workaround.hpp>
+
 namespace boost { namespace python { namespace api {

-# if BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580)
+# if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
 // attempt to use SFINAE to prevent functions accepting T const& from
 // coming up as ambiguous with the one taking a char const* when a
 // string literal is passed
@@ -22,45 +24,45 @@ namespace boost { namespace python { namespace api {
 # endif

 template <class Target, class Key>
-object getattr(Target const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(key))
+object getattr(Target const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
    return getattr(object(target), object(key));
 }

 template <class Target, class Key, class Default>
-object getattr(Target const& target, Key const& key, Default const& default_ BOOST_PYTHON_NO_ARRAY_ARG(key))
+object getattr(Target const& target, Key const& key, Default const& default_ BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
    return getattr(object(target), object(key), object(default_));
 }


 template <class Key, class Value>
-void setattr(object const& target, Key const& key, Value const& value BOOST_PYTHON_NO_ARRAY_ARG(key))
+void setattr(object const& target, Key const& key, Value const& value BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
    setattr(target, object(key), object(value));
 }

 template <class Key>
-void delattr(object const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(key))
+void delattr(object const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
    delattr(target, object(key));
 }

 template <class Target, class Key>
-object getitem(Target const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(key))
+object getitem(Target const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
    return getitem(object(target), object(key));
 }


 template <class Key, class Value>
-void setitem(object const& target, Key const& key, Value const& value BOOST_PYTHON_NO_ARRAY_ARG(key))
+void setitem(object const& target, Key const& key, Value const& value BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
    setitem(target, object(key), object(value));
 }

 template <class Key>
-void delitem(object const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(key))
+void delitem(object const& target, Key const& key BOOST_PYTHON_NO_ARRAY_ARG(Key))
 {
    delitem(target, object(key));
 }
--- a/include/boost/python/object_slices.hpp
+++ b/include/boost/python/object_slices.hpp
@@ -27,6 +27,12 @@ struct slice_policies : const_slice_policies
    static void del(object const& target, key_type const& key);
 };

+template <class T, class U>
+inline slice_policies::key_type slice_key(T x, U y)
+{
+    return slice_policies::key_type(handle<>(x), handle<>(y));
+}
+    
 //
 // implementation
 //
@@ -35,7 +41,7 @@ object_slice
 object_operators<U>::slice(object_cref start, object_cref finish)
 {
    object_cref2 x = *static_cast<U*>(this);
-    return object_slice(x, std::make_pair(borrowed(start.ptr()), borrowed(finish.ptr())));
+    return object_slice(x, api::slice_key(borrowed(start.ptr()), borrowed(finish.ptr())));
 }

 template <class U>
@@ -43,7 +49,7 @@ const_object_slice
 object_operators<U>::slice(object_cref start, object_cref finish) const
 {
    object_cref2 x = *static_cast<U const*>(this);
-    return const_object_slice(x, std::make_pair(borrowed(start.ptr()), borrowed(finish.ptr())));
+    return const_object_slice(x, api::slice_key(borrowed(start.ptr()), borrowed(finish.ptr())));
 }

 template <class U>
@@ -51,7 +57,7 @@ object_slice
 object_operators<U>::slice(slice_nil, object_cref finish)
 {
    object_cref2 x = *static_cast<U*>(this);
-    return object_slice(x, std::make_pair(allow_null((PyObject*)0), borrowed(finish.ptr())));
+    return object_slice(x, api::slice_key(allow_null((PyObject*)0), borrowed(finish.ptr())));
 }

 template <class U>
@@ -59,7 +65,7 @@ const_object_slice
 object_operators<U>::slice(slice_nil, object_cref finish) const
 {
    object_cref2 x = *static_cast<U const*>(this);
-    return const_object_slice(x, std::make_pair(allow_null((PyObject*)0), borrowed(finish.ptr())));
+    return const_object_slice(x, api::slice_key(allow_null((PyObject*)0), borrowed(finish.ptr())));
 }

 template <class U>
@@ -67,7 +73,7 @@ object_slice
 object_operators<U>::slice(slice_nil, slice_nil)
 {
    object_cref2 x = *static_cast<U*>(this);
-    return object_slice(x, std::make_pair(allow_null((PyObject*)0), allow_null((PyObject*)0)));
+    return object_slice(x, api::slice_key(allow_null((PyObject*)0), allow_null((PyObject*)0)));
 }

 template <class U>
@@ -75,7 +81,7 @@ const_object_slice
 object_operators<U>::slice(slice_nil, slice_nil) const
 {
    object_cref2 x = *static_cast<U const*>(this);
-    return const_object_slice(x, std::make_pair(allow_null((PyObject*)0), allow_null((PyObject*)0)));
+    return const_object_slice(x, api::slice_key(allow_null((PyObject*)0), allow_null((PyObject*)0)));
 }

 template <class U>
@@ -83,7 +89,7 @@ object_slice
 object_operators<U>::slice(object_cref start, slice_nil)
 {
    object_cref2 x = *static_cast<U*>(this);
-    return object_slice(x, std::make_pair(borrowed(start.ptr()), allow_null((PyObject*)0)));
+    return object_slice(x, api::slice_key(borrowed(start.ptr()), allow_null((PyObject*)0)));
 }

 template <class U>
@@ -91,7 +97,7 @@ const_object_slice
 object_operators<U>::slice(object_cref start, slice_nil) const
 {
    object_cref2 x = *static_cast<U const*>(this);
-    return const_object_slice(x, std::make_pair(borrowed(start.ptr()), allow_null((PyObject*)0)));
+    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>
--- a/include/boost/python/signature.hpp
+++ b/include/boost/python/signature.hpp
@@ -113,7 +113,10 @@ struct most_derived

 # endif // SIGNATURE_JDG20020813_HPP

-#elif BOOST_PP_ITERATION_DEPTH() == 1 // defined(BOOST_PP_IS_ITERATING)
+// For gcc 4.4 compatability, we must include the
+// BOOST_PP_ITERATION_DEPTH test inside an #else clause.
+#else // BOOST_PP_IS_ITERATING
+#if BOOST_PP_ITERATION_DEPTH() == 1 // defined(BOOST_PP_IS_ITERATING)

 # define N BOOST_PP_ITERATION()

@@ -176,4 +179,5 @@ get_signature(
 # undef Q
 # undef N

+#endif // BOOST_PP_ITERATION_DEPTH()
 #endif // !defined(BOOST_PP_IS_ITERATING)
--- a/module.cmake
+++ b/module.cmake
@@ -0,0 +1,3 @@
+boost_module(python DEPENDS graph numeric)
+
+# numeric is there because of boost/cast.hpp from libs/python/src/errors.cpp:11
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -0,0 +1,64 @@
+if (PYTHON_DEBUG_LIBRARIES AND BUILD_BOOST_PYTHON)
+  # We have detected that there might be Python debug libraries
+  # available, but check for ourselves whether this is true by trying
+  # to compile/link a program against them.
+  set(CMAKE_REQUIRED_DEFINITIONS "-DBOOST_DEBUG_PYTHON -DPy_DEBUG")
+  get_directory_property(CMAKE_REQUIRED_INCLUDES INCLUDE_DIRECTORIES)
+  set(CMAKE_REQUIRED_LIBRARIES ${PYTHON_DEBUG_LIBRARIES})
+  set(CHECK_PYDEBUG_SOURCE
+    "#include <boost/python/object.hpp>")
+  check_cxx_source_compiles(
+    "#include <boost/python/object.hpp>
+    void check(PyObject *obj) { Py_INCREF(obj); } int main() { }" 
+    PYDEBUG_CAN_BUILD)
+
+  # Setup an option to enable/disable building variants with Python
+  # debugging. If we were able to link against the debug libraries,
+  # default to ON; otherwise, default to OFF.
+  option(BUILD_PYTHON_DEBUG
+    "Build an additional Boost.Python library with Python debugging enabled"
+    ${PYDEBUG_CAN_BUILD})
+endif (PYTHON_DEBUG_LIBRARIES AND BUILD_BOOST_PYTHON)
+
+# Always build the non-debug variants of the boost_python library
+set(BUILD_PYTHON_NODEBUG ON)
+
+boost_add_library(boost_python
+  numeric.cpp 
+  list.cpp 
+  long.cpp 
+  dict.cpp 
+  tuple.cpp 
+  str.cpp 
+  slice.cpp
+  converter/from_python.cpp 
+  converter/registry.cpp
+  converter/type_id.cpp
+  object/enum.cpp
+  object/class.cpp
+  object/function.cpp
+  object/inheritance.cpp
+  object/life_support.cpp
+  object/pickle_support.cpp
+  errors.cpp
+  module.cpp
+  converter/builtin_converters.cpp
+  converter/arg_to_python_base.cpp
+  object/iterator.cpp
+  object/stl_iterator.cpp
+  object_protocol.cpp
+  object_operators.cpp
+  wrapper.cpp
+  import.cpp
+  exec.cpp
+  object/function_doc_signature.cpp
+
+  STATIC_COMPILE_FLAGS "-DBOOST_PYTHON_SOURCE -DBOOST_PYTHON_STATIC_LIB"
+  SHARED_COMPILE_FLAGS "-DBOOST_PYTHON_SOURCE"
+  PYTHON_NODEBUG_LINK_LIBS "${PYTHON_LIBRARIES}"
+
+  # Support for Python debugging
+  EXTRA_VARIANTS PYTHON_NODEBUG:PYTHON_DEBUG
+  PYTHON_DEBUG_COMPILE_FLAGS "-DBOOST_DEBUG_PYTHON -DPy_DEBUG"
+  PYTHON_DEBUG_LINK_LIBS "${PYTHON_DEBUG_LIBRARIES}"
+  )
--- a/src/dict.cpp
+++ b/src/dict.cpp
@@ -29,7 +29,7 @@ namespace
 detail::new_reference dict_base::call(object const& arg_)
 {
    return (detail::new_reference)PyObject_CallFunction(
-        (PyObject*)&PyDict_Type, "(O)", 
+        (PyObject*)&PyDict_Type, const_cast<char*>("(O)"), 
        arg_.ptr());
 }

--- a/src/exec.cpp
+++ b/src/exec.cpp
@@ -39,7 +39,7 @@ object BOOST_PYTHON_DECL exec_file(str filename, object global, object local)
  // should be 'char const *' but older python versions don't use 'const' yet.
  char *f = python::extract<char *>(filename);
  // Let python open the file to avoid potential binary incompatibilities.
-  PyObject *pyfile = PyFile_FromString(f, "r");
+  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);
  PyObject* result = PyRun_File(PyFile_AsFile(file.get()),
--- a/src/list.cpp
+++ b/src/list.cpp
@@ -13,7 +13,7 @@ detail::new_non_null_reference list_base::call(object const& arg_)
    return (detail::new_non_null_reference)
        (expect_non_null)(
            PyObject_CallFunction(
-                (PyObject*)&PyList_Type, "(O)", 
+                (PyObject*)&PyList_Type, const_cast<char*>("(O)"), 
                arg_.ptr()));
 }

--- a/src/long.cpp
+++ b/src/long.cpp
@@ -9,21 +9,21 @@ namespace boost { namespace python { namespace detail {
 new_non_null_reference long_base::call(object const& arg_)
 {
    return (detail::new_non_null_reference)PyObject_CallFunction(
-        (PyObject*)&PyLong_Type, "(O)", 
+        (PyObject*)&PyLong_Type, const_cast<char*>("(O)"), 
        arg_.ptr());
 }

 new_non_null_reference long_base::call(object const& arg_, object const& base)
 {
    return (detail::new_non_null_reference)PyObject_CallFunction(
-        (PyObject*)&PyLong_Type, "(OO)", 
+        (PyObject*)&PyLong_Type, const_cast<char*>("(OO)"), 
        arg_.ptr(), base.ptr());
 }

 long_base::long_base()
    : object(
        detail::new_reference(
-            PyObject_CallFunction((PyObject*)&PyLong_Type, "()"))
+            PyObject_CallFunction((PyObject*)&PyLong_Type, const_cast<char*>("()")))
        )
 {}

--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -74,7 +74,7 @@ extern "C"
  {
      propertyobject *gs = (propertyobject *)self;

-      return PyObject_CallFunction(gs->prop_get, "()");
+      return PyObject_CallFunction(gs->prop_get, const_cast<char*>("()"));
  }

  static int
@@ -95,9 +95,9 @@ extern "C"
          return -1;
      }
      if (value == NULL)
-          res = PyObject_CallFunction(func, "()");
+          res = PyObject_CallFunction(func, const_cast<char*>("()"));
      else
-          res = PyObject_CallFunction(func, "(O)", value);
+          res = PyObject_CallFunction(func, const_cast<char*>("(O)"), value);
      if (res == NULL)
          return -1;
      Py_DECREF(res);
@@ -108,7 +108,7 @@ extern "C"
 static PyTypeObject static_data_object = {
    PyObject_HEAD_INIT(0)//&PyType_Type)
    0,
-    "Boost.Python.StaticProperty",
+    const_cast<char*>("Boost.Python.StaticProperty"),
    PyType_Type.tp_basicsize,
    0,
    0,                                      /* tp_dealloc */
@@ -212,7 +212,7 @@ extern "C"
 static PyTypeObject class_metatype_object = {
    PyObject_HEAD_INIT(0)//&PyType_Type)
    0,
-    "Boost.Python.class",
+    const_cast<char*>("Boost.Python.class"),
    PyType_Type.tp_basicsize,
    0,
    0,                                      /* tp_dealloc */
@@ -316,7 +316,7 @@ namespace objects
      {
          // Attempt to find the __instance_size__ attribute. If not present, no problem.
          PyObject* d = type_->tp_dict;
-          PyObject* instance_size_obj = PyObject_GetAttrString(d, "__instance_size__");
+          PyObject* instance_size_obj = PyObject_GetAttrString(d, const_cast<char*>("__instance_size__"));

          long instance_size = instance_size_obj ? PyInt_AsLong(instance_size_obj) : 0;
          
@@ -357,20 +357,20 @@ namespace objects


  static PyGetSetDef instance_getsets[] = {
-      {"__dict__",  instance_get_dict,  instance_set_dict, NULL, 0},
+      {const_cast<char*>("__dict__"),  instance_get_dict,  instance_set_dict, NULL, 0},
      {0, 0, 0, 0, 0}
  };

  
  static PyMemberDef instance_members[] = {
-      {"__weakref__", T_OBJECT, offsetof(instance<>, weakrefs), 0, 0},
+      {const_cast<char*>("__weakref__"), T_OBJECT, offsetof(instance<>, weakrefs), 0, 0},
      {0, 0, 0, 0, 0}
  };

  static PyTypeObject class_type_object = {
      PyObject_HEAD_INIT(0) //&class_metatype_object)
      0,
-      "Boost.Python.instance",
+      const_cast<char*>("Boost.Python.instance"),
      offsetof(instance<>,storage),           /* tp_basicsize */
      1,                                      /* tp_itemsize */
      instance_dealloc,                       /* tp_dealloc */
@@ -572,7 +572,7 @@ namespace objects
  {
      object property(
          (python::detail::new_reference)
-              PyObject_CallFunction((PyObject*)&PyProperty_Type, "Osss", fget.ptr(), 0, 0, docstr));
+          PyObject_CallFunction((PyObject*)&PyProperty_Type, const_cast<char*>("Osss"), fget.ptr(), 0, 0, docstr));
      
      this->setattr(name, property);
  }
@@ -582,7 +582,7 @@ namespace objects
  {
      object property(
          (python::detail::new_reference)
-              PyObject_CallFunction((PyObject*)&PyProperty_Type, "OOss", fget.ptr(), fset.ptr(), 0, docstr));
+          PyObject_CallFunction((PyObject*)&PyProperty_Type, const_cast<char*>("OOss"), fget.ptr(), fset.ptr(), 0, docstr));
      
      this->setattr(name, property);
  }
@@ -591,7 +591,7 @@ namespace objects
  {
      object property(
          (python::detail::new_reference)
-          PyObject_CallFunction(static_data(), "O", fget.ptr()));
+          PyObject_CallFunction(static_data(), const_cast<char*>("O"), fget.ptr()));
      
      this->setattr(name, property);
  }
@@ -600,7 +600,7 @@ namespace objects
  {
      object property(
          (python::detail::new_reference)
-          PyObject_CallFunction(static_data(), "OO", fget.ptr(), fset.ptr()));
+          PyObject_CallFunction(static_data(), const_cast<char*>("OO"), fget.ptr(), fset.ptr()));
      
      this->setattr(name, property);
  }
@@ -615,13 +615,13 @@ namespace objects
  {
    extern "C" PyObject* no_init(PyObject*, PyObject*)
    {
-        ::PyErr_SetString(::PyExc_RuntimeError, "This class cannot be instantiated from Python");
+        ::PyErr_SetString(::PyExc_RuntimeError, const_cast<char*>("This class cannot be instantiated from Python"));
        return NULL;
    }
    static ::PyMethodDef no_init_def = {
-        "__init__", no_init, METH_VARARGS,
-        "Raises an exception\n"
-        "This class cannot be instantiated from Python\n"
+        const_cast<char*>("__init__"), no_init, METH_VARARGS,
+        const_cast<char*>("Raises an exception\n"
+                          "This class cannot be instantiated from Python\n")
    };
  }
  
@@ -650,7 +650,7 @@ namespace objects

        ::PyErr_Format(
            PyExc_TypeError
-            , "staticmethod expects callable object; got an object of type %s, which is not callable"
+          , const_cast<char*>("staticmethod expects callable object; got an object of type %s, which is not callable")
            , callable->ob_type->tp_name
            );
        
--- a/src/object/enum.cpp
+++ b/src/object/enum.cpp
@@ -23,7 +23,7 @@ struct enum_object
 };

 static PyMemberDef enum_members[] = {
-    {"name", T_OBJECT_EX, offsetof(enum_object,name),READONLY, 0},
+    {const_cast<char*>("name"), T_OBJECT_EX, offsetof(enum_object,name),READONLY, 0},
    {0, 0, 0, 0, 0}
 };

@@ -32,7 +32,7 @@ extern "C"
 {
    static PyObject* enum_repr(PyObject* self_)
    {
-        const char *mod = PyString_AsString(PyObject_GetAttrString( self_, "__module__"));
+        const char *mod = PyString_AsString(PyObject_GetAttrString( self_, const_cast<char*>("__module__")));
        enum_object* self = downcast<enum_object>(self_);
        if (!self->name)
        {
@@ -65,7 +65,7 @@ extern "C"
 static PyTypeObject enum_type_object = {
    PyObject_HEAD_INIT(0) // &PyType_Type
    0,
-    "Boost.Python.enum",
+    const_cast<char*>("Boost.Python.enum"),
    sizeof(enum_object),                    /* tp_basicsize */
    0,                                      /* tp_itemsize */
    0,                                      /* tp_dealloc */
--- a/src/object/function.cpp
+++ b/src/object/function.cpp
@@ -297,7 +297,7 @@ object function::signatures(bool show_return_type) const
 void function::argument_error(PyObject* args, PyObject* /*keywords*/) const
 {
    static handle<> exception(
-        PyErr_NewException("Boost.Python.ArgumentError", PyExc_TypeError, 0));
+        PyErr_NewException(const_cast<char*>("Boost.Python.ArgumentError"), PyExc_TypeError, 0));

    object message = "Python argument types in\n    %s.%s("
        % make_tuple(this->m_namespace, this->m_name);
@@ -440,7 +440,7 @@ void function::add_to_namespace(
        else if (PyType_Check(ns))
            dict = ((PyTypeObject*)ns)->tp_dict;
        else    
-            dict = PyObject_GetAttrString(ns, "__dict__");
+            dict = PyObject_GetAttrString(ns, const_cast<char*>("__dict__"));

        if (dict == 0)
            throw_error_already_set();
@@ -487,7 +487,7 @@ void function::add_to_namespace(
            new_func->m_name = name;

        handle<> name_space_name(
-            allow_null(::PyObject_GetAttrString(name_space.ptr(), "__name__")));
+            allow_null(::PyObject_GetAttrString(name_space.ptr(), const_cast<char*>("__name__"))));
        
        if (name_space_name)
            new_func->m_namespace = object(name_space_name);
@@ -656,18 +656,18 @@ extern "C"
 }

 static PyGetSetDef function_getsetlist[] = {
-    {"__name__", (getter)function_get_name, 0, 0, 0 },
-    {"func_name", (getter)function_get_name, 0, 0, 0 },
-    {"__class__", (getter)function_get_class, 0, 0, 0 },    // see note above
-    {"__doc__", (getter)function_get_doc, (setter)function_set_doc, 0, 0},
-    {"func_doc", (getter)function_get_doc, (setter)function_set_doc, 0, 0},
+    {const_cast<char*>("__name__"), (getter)function_get_name, 0, 0, 0 },
+    {const_cast<char*>("func_name"), (getter)function_get_name, 0, 0, 0 },
+    {const_cast<char*>("__class__"), (getter)function_get_class, 0, 0, 0 },    // see note above
+    {const_cast<char*>("__doc__"), (getter)function_get_doc, (setter)function_set_doc, 0, 0},
+    {const_cast<char*>("func_doc"), (getter)function_get_doc, (setter)function_set_doc, 0, 0},
    {NULL, 0, 0, 0, 0} /* Sentinel */
 };

 PyTypeObject function_type = {
    PyObject_HEAD_INIT(0)
    0,
-    "Boost.Python.function",
+    const_cast<char*>("Boost.Python.function"),
    sizeof(function),
    0,
    (destructor)function_dealloc,               /* tp_dealloc */
@@ -753,7 +753,8 @@ namespace detail
  }
  void BOOST_PYTHON_DECL pure_virtual_called()
  {
-      PyErr_SetString(PyExc_RuntimeError, "Pure virtual function called");
+      PyErr_SetString(
+          PyExc_RuntimeError, const_cast<char*>("Pure virtual function called"));
      throw_error_already_set();
  }
 }
--- a/src/object/life_support.cpp
+++ b/src/object/life_support.cpp
@@ -38,7 +38,7 @@ extern "C"
 PyTypeObject life_support_type = {
    PyObject_HEAD_INIT(0)//(&PyType_Type)
    0,
-    "Boost.Python.life_support",
+    const_cast<char*>("Boost.Python.life_support"),
    sizeof(life_support),
    0,
    life_support_dealloc,               /* tp_dealloc */
--- a/src/object/stl_iterator.cpp
+++ b/src/object/stl_iterator.cpp
@@ -2,6 +2,10 @@
 // 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)
+//
+// Credits:
+//   Andreas Kl\:ockner for fixing increment() to handle
+//   error conditions.

 #include <boost/python/object.hpp>
 #include <boost/python/handle.hpp>
@@ -27,6 +31,8 @@ void stl_input_iterator_impl::increment()
 {
    this->ob_ = boost::python::handle<>(
        boost::python::allow_null(PyIter_Next(this->it_.ptr())));
+    if (PyErr_Occurred())
+        throw boost::python::error_already_set();
 }

 bool stl_input_iterator_impl::equal(stl_input_iterator_impl const &that) const
--- a/src/str.cpp
+++ b/src/str.cpp
@@ -10,7 +10,7 @@ namespace boost { namespace python { namespace detail {
 detail::new_reference str_base::call(object const& arg_)
 {
    return (detail::new_reference)PyObject_CallFunction(
-        (PyObject*)&PyString_Type, "(O)", 
+        (PyObject*)&PyString_Type, const_cast<char*>("(O)"), 
        arg_.ptr());
 } 

@@ -68,8 +68,9 @@ str str_base:: name ( BOOST_PP_ENUM_PARAMS(arity, object_cref x) ) const
    return str(new_reference(                                                   \
       expect_non_null(                                                         \
           PyObject_CallMethod(                                                 \
-               this->ptr(), #name,                                              \
-              "(" BOOST_PP_REPEAT(arity, BOOST_PYTHON_FORMAT_OBJECT, _) ")"     \
+               this->ptr(), const_cast<char*>( #name ),                         \
+               const_cast<char*>(                                               \
+                 "(" BOOST_PP_REPEAT(arity, BOOST_PYTHON_FORMAT_OBJECT, _) ")") \
               BOOST_PP_REPEAT_1(arity, BOOST_PYTHON_OBJECT_PTR, _)))));        \
 }

--- a/src/tuple.cpp
+++ b/src/tuple.cpp
@@ -9,7 +9,7 @@ namespace boost { namespace python { namespace detail {
 detail::new_reference tuple_base::call(object const& arg_)
 {
    return (detail::new_reference)PyObject_CallFunction(
-        (PyObject*)&PyTuple_Type, "(O)", 
+        (PyObject*)&PyTuple_Type, const_cast<char*>("(O)"), 
        arg_.ptr());
 }
    
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -0,0 +1,194 @@
+macro(bpl_test TESTNAME)
+  parse_arguments(BPL_TEST
+    "ARGS"
+    ""
+    ${ARGN})
+
+  # Determine the Python and C++ source files for this test
+  if (BPL_TEST_DEFAULT_ARGS)
+    # First argument is the Python source we will run, the rest are
+    # either extra Python sources we're dependent on or C++ files from
+    # which we will build extension modules.
+    car(BPL_TEST_PYSOURCE ${BPL_TEST_DEFAULT_ARGS})
+    cdr(BPL_TEST_DEFAULT_ARGS ${BPL_TEST_DEFAULT_ARGS})
+
+    get_filename_component(BPL_TEST_PYBASE ${BPL_TEST_PYSOURCE} NAME_WE)
+    foreach(SRC ${BPL_TEST_DEFAULT_ARGS})
+      get_filename_component(BPL_SRC_EXT ${SRC} EXT)
+      if (BPL_SRC_EXT STREQUAL ".cpp")
+        # Build a Python extension module from this source file
+        get_filename_component(BPL_SRC_NAME ${SRC} NAME_WE)
+        if(BPL_TEST_PYBASE STREQUAL "${BPL_SRC_NAME}")
+          boost_python_extension(${BPL_SRC_NAME}_ext ${SRC})
+        else(BPL_TEST_PYBASE STREQUAL "${BPL_SRC_NAME}")
+          boost_python_extension(${BPL_SRC_NAME} ${SRC})
+        endif(BPL_TEST_PYBASE STREQUAL "${BPL_SRC_NAME}")
+      endif (BPL_SRC_EXT STREQUAL ".cpp")
+    endforeach(SRC ${BPL_TEST_DEFAULT_ARGS})
+  else (BPL_TEST_DEFAULT_ARGS)
+    set(BPL_TEST_PYSOURCE "${TESTNAME}.py")
+
+    # Build a Python extension module from this source file
+    boost_python_extension(${TESTNAME}_ext "${TESTNAME}.cpp")
+  endif(BPL_TEST_DEFAULT_ARGS)
+
+  # We'll need the full patch to run the Python test
+  set(BPL_TEST_PYSOURCE ${CMAKE_CURRENT_SOURCE_DIR}/${BPL_TEST_PYSOURCE})
+    
+  # Run the test itself
+  file(TO_NATIVE_PATH "${LIBRARY_OUTPUT_PATH}" PYTHONPATH)
+  if(WIN32 AND NOT UNIX)
+    string(REPLACE "\\" "\\\\" PYTHONPATH "${PYTHONPATH}")
+  endif(WIN32 AND NOT UNIX)
+  add_test("${PROJECT_NAME}::${TESTNAME}"
+    ${PYTHON_EXECUTABLE} 
+    "${CMAKE_CURRENT_SOURCE_DIR}/pyrun.py" 
+    "${PYTHONPATH}"
+    ${BPL_TEST_PYSOURCE} ${BPL_TEST_ARGS})
+endmacro(bpl_test)
+
+macro(py_run TESTNAME)
+  boost_test_run(${TESTNAME} 
+    ${TESTNAME}.cpp
+    DEPENDS boost_python STATIC
+    LINK_LIBS ${PYTHON_LIBRARIES})
+endmacro(py_run)
+
+boost_test_run(exec 
+  DEPENDS boost_python STATIC 
+  ARGS "${CMAKE_CURRENT_SOURCE_DIR}/exec.py"
+  LINK_LIBS ${PYTHON_LIBRARIES})
+boost_test_run(exec-dynamic 
+  exec.cpp
+  ARGS "${CMAKE_CURRENT_SOURCE_DIR}/exec.py"
+  DEPENDS boost_python SHARED 
+  LINK_LIBS ${PYTHON_LIBRARIES})
+
+bpl_test(crossmod_exception 
+  crossmod_exception.py crossmod_exception_a.cpp crossmod_exception_b.cpp)
+
+bpl_test(injected)
+bpl_test(properties)
+bpl_test(return_arg)
+bpl_test(staticmethod)
+bpl_test(shared_ptr)
+bpl_test(andreas_beyer)
+bpl_test(polymorphism)
+bpl_test(polymorphism2)
+
+bpl_test(wrapper_held_type)
+bpl_test(polymorphism2_auto_ptr)
+
+bpl_test(auto_ptr)
+
+bpl_test(minimal)
+bpl_test(args)
+bpl_test(raw_ctor)
+bpl_test(numpy numpy.py printer.py numeric_tests.py numarray_tests.py numpy.cpp)
+bpl_test(enum)
+bpl_test(exception_translator)
+bpl_test(pearu1 test_cltree.py cltree.cpp)
+bpl_test(try newtest.py m1.cpp m2.cpp)
+bpl_test(const_argument)
+bpl_test(keywords keywords_test.py keywords.cpp)
+   
+boost_python_extension(builtin_converters_ext test_builtin_converters.cpp)
+bpl_test(builtin_converters test_builtin_converters.py builtin_converters_ext)
+
+bpl_test(test_pointer_adoption)
+bpl_test(operators)
+bpl_test(callbacks)
+bpl_test(defaults)
+
+bpl_test(object)
+bpl_test(list)
+bpl_test(long)
+bpl_test(dict)
+bpl_test(tuple)
+bpl_test(str)
+bpl_test(slice)
+
+bpl_test(virtual_functions)
+bpl_test(back_reference)
+bpl_test(implicit)
+bpl_test(data_members)
+
+bpl_test(ben_scott1)
+
+bpl_test(bienstman1)
+bpl_test(bienstman2)
+bpl_test(bienstman3)
+
+bpl_test(multi_arg_constructor)
+# TODO: A bug in the Win32 intel compilers causes compilation of one
+# of our tests to take forever when debug symbols are
+# enabled. This rule turns them off when added to the requirements
+# section 
+#   <toolset>intel-win:<debug-symbols>off
+
+bpl_test(iterator iterator.py iterator.cpp input_iterator.cpp)
+
+bpl_test(stl_iterator stl_iterator.py stl_iterator.cpp)
+
+bpl_test(extract)
+
+bpl_test (crossmod_opaque
+  crossmod_opaque.py crossmod_opaque_a.cpp crossmod_opaque_b.cpp)
+
+bpl_test(opaque)
+bpl_test(voidptr)
+
+bpl_test(pickle1)
+bpl_test(pickle2)
+bpl_test(pickle3)
+bpl_test(pickle4)
+
+bpl_test(nested)
+
+bpl_test(docstring)
+
+bpl_test(vector_indexing_suite)
+
+bpl_test(pointer_vector)
+# TODO: Turn off this test on HP CXX, as the test hangs when executing.
+# Whenever the cause for the failure of the polymorphism test is found
+# and fixed, this should be retested.
+#    <toolset>hp_cxx:<build>no
+      
+boost_python_extension(map_indexing_suite_ext 
+  map_indexing_suite.cpp int_map_indexing_suite.cpp a_map_indexing_suite.cpp)
+
+bpl_test(map_indexing_suite 
+  map_indexing_suite.py map_indexing_suite_ext)
+
+
+# --- unit tests of library components ---
+
+boost_test_compile(indirect_traits_test)
+boost_test_run(destroy_test)
+py_run(pointer_type_id_test)
+py_run(bases)
+boost_test_run(if_else)
+py_run(pointee)
+boost_test_run(result)
+
+boost_test_compile(string_literal)
+boost_test_compile(borrowed)
+boost_test_compile(object_manager)
+boost_test_compile(copy_ctor_mutates_rhs)
+
+py_run(upcast)
+  
+boost_test_compile(select_holder)
+
+boost_test_run(select_from_python_test
+  select_from_python_test.cpp ../src/converter/type_id.cpp
+  COMPILE_FLAGS "-DBOOST_PYTHON_STATIC_LIB"
+  LINK_LIBS ${PYTHON_LIBRARIES})
+  
+boost_test_compile(select_arg_to_python_test)
+
+boost_test_compile_fail(raw_pyobject_fail1)
+boost_test_compile_fail(raw_pyobject_fail2)
+boost_test_compile_fail(as_to_python_function)
+boost_test_compile_fail(object_fail1)
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -42,7 +42,7 @@ test-suite python
  :

  [
-    run exec.cpp ../build//boost_python/<link>static $(PY)
+    run exec.cpp /boost/python//boost_python/<link>static $(PY)
      : # program args
      : exec.py # input files
      : # requirements
@@ -171,7 +171,8 @@ bpl-test crossmod_opaque
    /boost/python//boost_python ]
 [ bpl-test  
    map_indexing_suite : map_indexing_suite.py map_indexing_suite_ext ]
-[ py-run import_.cpp : import_.py ]
+      
+[ run import_.cpp /boost/python//boost_python $(PY) : : import_.py ]

 # if $(TEST_BIENSTMAN_NON_BUGS)
 # {
--- a/test/andreas_beyer.cpp
+++ b/test/andreas_beyer.cpp
@@ -25,8 +25,8 @@ class B {
    B() {
       a = A::A_ptr(new A());
    }
-    void set(A::A_ptr a) {
-      this->a = a;
+    void set(A::A_ptr _a) {
+      this->a = _a;
    }
    A::A_ptr get() {
       return a;
--- a/test/back_reference.cpp
+++ b/test/back_reference.cpp
@@ -27,7 +27,7 @@ struct X
    X(X const& rhs) : x(rhs.x), magic(7654321) { ++counter; }
    virtual ~X() { BOOST_ASSERT(magic == 7654321); magic = 6666666; x = 9999; --counter; }

-    void set(int x) { BOOST_ASSERT(magic == 7654321); this->x = x; }
+    void set(int _x) { BOOST_ASSERT(magic == 7654321); this->x = _x; }
    int value() const { BOOST_ASSERT(magic == 7654321); return x; }
    static int count() { return counter; }
 private:
--- a/test/callbacks.cpp
+++ b/test/callbacks.cpp
@@ -34,7 +34,7 @@ struct X
    X(X const& rhs) : x(rhs.x), magic(7654321) { ++counter; }
    ~X() { BOOST_ASSERT(magic == 7654321); magic = 6666666; x = 9999; --counter; }

-    void set(int x) { BOOST_ASSERT(magic == 7654321); this->x = x; }
+    void set(int _x) { BOOST_ASSERT(magic == 7654321); this->x = _x; }
    int value() const { BOOST_ASSERT(magic == 7654321); return x; }
    static int count() { return counter; }
 private:
--- a/test/complicated.hpp
+++ b/test/complicated.hpp
@@ -19,10 +19,10 @@ struct complicated
    int n;
 };

-inline complicated::complicated(simple const&s, int n)
-    : s(s.s), n(n)
+inline complicated::complicated(simple const&s, int _n)
+    : s(s.s), n(_n)
 {
-    std::cout << "constructing complicated: " << this->s << ", " << n << std::endl;
+    std::cout << "constructing complicated: " << this->s << ", " << _n << std::endl;
 }

 inline complicated::~complicated()
--- a/test/exec.cpp
+++ b/test/exec.cpp
@@ -59,7 +59,7 @@ void eval_test()
 void exec_test()
 {
  // Register the module with the interpreter
-  if (PyImport_AppendInittab("embedded_hello", initembedded_hello) == -1)
+  if (PyImport_AppendInittab(const_cast<char*>("embedded_hello"), initembedded_hello) == -1)
    throw std::runtime_error("Failed to add embedded_hello to the interpreter's "
                 "builtin modules");
  // Retrieve the main module
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -34,7 +34,7 @@ struct NoddyObject : PyObject
 PyTypeObject NoddyType = {
    PyObject_HEAD_INIT(NULL)
    0,
-    "Noddy",
+    const_cast<char*>("Noddy"),
    sizeof(NoddyObject),
    0,
    dealloc,    /* tp_dealloc */
@@ -106,7 +106,7 @@ struct extract_simple_object
 PyTypeObject SimpleType = {
    PyObject_HEAD_INIT(NULL)
    0,
-    "Simple",
+    const_cast<char*>("Simple"),
    sizeof(SimpleObject),
    0,
    dealloc,    /* tp_dealloc */
@@ -159,7 +159,7 @@ PyTypeObject SimpleType = {
 PyObject* new_simple()
 {
    SimpleObject* simple = PyObject_New(SimpleObject, &SimpleType);
-    simple->x.s = "hello, world";
+    simple->x.s = const_cast<char*>("hello, world");
    return (PyObject*)simple;
 }

--- a/test/object.cpp
+++ b/test/object.cpp
@@ -187,6 +187,11 @@ bool check_string_slice()
    return s.slice(2,-1).slice(1,-1)  == "lo, wor";
 }

+object test_call(object c, object args, object kwds) 
+{ 
+    return c(*args, **kwds); 
+} 
+
 bool check_binary_operators()
 {
    int y;
@@ -377,6 +382,7 @@ BOOST_PYTHON_MODULE(object_ext)
    def("test_item", test_item);
    def("test_not_item", test_not_item);

+    def("test_call", test_call);
    def("check_binary_operators", check_binary_operators);
    def("check_inplace", check_inplace);
    def("check_string_slice", check_string_slice);
--- a/test/object.py
+++ b/test/object.py
@@ -134,7 +134,12 @@

        Operators

-        
+>>> def print_args(*args, **kwds): 
+...     print args, kwds 
+>>> test_call(print_args, (0, 1, 2, 3), {'a':'A'}) 
+(0, 1, 2, 3) {'a': 'A'}
+
+
 >>> assert check_binary_operators()

 >>> class X: pass
--- a/test/pickle1.cpp
+++ b/test/pickle1.cpp
@@ -27,8 +27,8 @@ namespace boost_python_test {
    private:
      std::string country;
    public:
-      world(const std::string& country) {
-        this->country = country;
+      world(const std::string& _country) {
+        this->country = _country;
      }
      std::string greet() const { return "Hello from " + country + "!"; }
      std::string get_country() const { return country; }
--- a/test/pickle2.cpp
+++ b/test/pickle2.cpp
@@ -34,8 +34,8 @@ namespace boost_python_test {
  class world
  {
    public:
-      world(const std::string& country) : secret_number(0) {
-        this->country = country;
+      world(const std::string& _country) : secret_number(0) {
+        this->country = _country;
      }
      std::string greet() const { return "Hello from " + country + "!"; }
      std::string get_country() const { return country; }
--- a/test/pickle3.cpp
+++ b/test/pickle3.cpp
@@ -35,8 +35,8 @@ namespace boost_python_test {
  class world
  {
    public:
-      world(const std::string& country) : secret_number(0) {
-        this->country = country;
+      world(const std::string& _country) : secret_number(0) {
+        this->country = _country;
      }
      std::string greet() const { return "Hello from " + country + "!"; }
      std::string get_country() const { return country; }
--- a/test/pickle4.cpp
+++ b/test/pickle4.cpp
@@ -23,8 +23,8 @@ namespace boost_python_test {
    private:
      std::string country;
    public:
-      world(const std::string& country) {
-        this->country = country;
+      world(const std::string& _country) {
+        this->country = _country;
      }
      std::string greet() const { return "Hello from " + country + "!"; }
      std::string get_country() const { return country; }
--- a/test/slice.cpp
+++ b/test/slice.cpp
@@ -100,7 +100,11 @@ bool accept_slice( slice) { return true; }
    || BOOST_WORKAROUND( BOOST_INTEL_WIN, == 710)
 int check_slice_get_indicies(slice index);
 #endif
-int check_slice_get_indicies(const slice index)
+int check_slice_get_indicies(
+#if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+    const
+#endif 
+    slice index)
 {
    // A vector of integers from [-5, 5].
    std::vector<int> coll(11);
--- a/test/staticmethod.cpp
+++ b/test/staticmethod.cpp
@@ -20,7 +20,7 @@ struct X
    X(X const& rhs) : x(rhs.x), magic(7654321) { ++counter; }
    virtual ~X() { BOOST_ASSERT(magic == 7654321); magic = 6666666; x = 9999; --counter; }

-    void set(int x) { BOOST_ASSERT(magic == 7654321); this->x = x; }
+    void set(int _x) { BOOST_ASSERT(magic == 7654321); this->x = _x; }
    int value() const { BOOST_ASSERT(magic == 7654321); return x; }
    static int count() { return counter; }
 private:
--- a/test/stl_iterator.py
+++ b/test/stl_iterator.py
@@ -12,6 +12,16 @@
 3
 4
 5
+>>> def generator():
+...   yield 1
+...   yield 2
+...   raise RuntimeError, "oops"
+>>> try:
+...   x.assign(iter(generator()))
+...   print "NOT OK"
+... except RuntimeError:
+...   print "OK"
+OK
 '''
 def run(args = None):
    import sys
--- a/test/test_class.hpp
+++ b/test/test_class.hpp
@@ -13,7 +13,7 @@ struct test_class
    test_class(test_class const& rhs) : x(rhs.x), magic(7654321 + n) { ++counter; }
    virtual ~test_class() { BOOST_TEST(magic == 7654321 + n); magic = 6666666; x = 9999; --counter; }

-    void set(int x) { BOOST_TEST(magic == 7654321 + n); this->x = x; }
+    void set(int _x) { BOOST_TEST(magic == 7654321 + n); this->x = _x; }
    int value() const { BOOST_TEST(magic == 7654321 + n); return x; }
    operator int() const { return x; }
    static int count() { return counter; }
--- a/test/test_pointer_adoption.cpp
+++ b/test/test_pointer_adoption.cpp
@@ -65,7 +65,7 @@ struct B
    B() : x(0) {}
    B(A* x_) : x(x_) {}

-    inner const* adopt(A* x) { this->x = x; return &x->get_inner(); }
+    inner const* adopt(A* _x) { this->x = _x; return &_x->get_inner(); }

    std::string a_content()
    {
--- a/test/virtual_functions.cpp
+++ b/test/virtual_functions.cpp
@@ -22,7 +22,7 @@ struct X
    X(X const& rhs) : x(rhs.x), magic(7654321) { ++counter; }
    virtual ~X() { BOOST_ASSERT(magic == 7654321); magic = 6666666; x = 9999; --counter; }

-    void set(int x) { BOOST_ASSERT(magic == 7654321); this->x = x; }
+    void set(int _x) { BOOST_ASSERT(magic == 7654321); this->x = _x; }
    int value() const { BOOST_ASSERT(magic == 7654321); return x; }
    static int count() { return counter; }
 private: