Release 1.41.0

[SVN r57747]

build/Jamfile.v2

@@ -4,6 +4,7 @@
 
 import os ;
 import modules ;
+import feature ;
 
 import python ;
 
@@ -22,6 +23,22 @@ if ! [ python.configured ] && ! ( --without-python in  [ modules.peek : ARGV ] )
     }
 }
 
+rule find-py3-version
+{
+    local versions = [ feature.values python ] ;
+    local py3ver ;
+    for local v in $(versions)
+    {
+        if $(v) >= 3.0
+        {
+            py3ver = $(v) ;
+        }
+    }
+    return $(py3ver) ;
+}
+
+py3-version = [ find-py3-version ] ;
+
 project boost/python
   : source-location ../src
   ;
@@ -29,66 +46,79 @@ project boost/python
 rule cond ( test ? : yes * : no * ) { if $(test) { return $(yes) ; } else { return $(no) ; } }
 rule unless ( test ? : yes * : no * ) { if ! $(test) { return $(yes) ; } else { return $(no) ; } }
 
-lib boost_python
-    : # sources
-    numeric.cpp
-    list.cpp
-    long.cpp
-    dict.cpp
-    tuple.cpp
-    str.cpp
-    slice.cpp
+rule lib_boost_python ( is-py3 ? )
+{
 
-    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
-    :   # requirements
-        <link>static:<define>BOOST_PYTHON_STATIC_LIB 
-        <define>BOOST_PYTHON_SOURCE
-      
-        # On Windows, all code using Python has to link to the Python
-        # import library.
-        #
-        # On *nix we never link libboost_python to libpython.  When
-        # extending Python, all Python symbols are provided by the
-        # Python interpreter executable.  When embedding Python, the
-        # client executable is expected to explicitly link to
-        # /python//python (the target representing libpython) itself.
-        #
-        # python_for_extensions is a target defined by Boost.Build to
-        # provide the Python include paths, and on Windows, the Python
-        # import library, as usage requirements.
-        [ cond [ python.configured ] : <library>/python//python_for_extensions ]
-        
-        # we prevent building when there is no python available
-        # as it's not possible anyway, and to cause dependents to
-        # fail to build
-        [ unless [ python.configured ] : <build>no ]
+    lib [ cond $(is-py3) : boost_python3 : boost_python ]
+        : # sources
+        numeric.cpp
+        list.cpp
+        long.cpp
+        dict.cpp
+        tuple.cpp
+        str.cpp
+        slice.cpp
 
-        <python-debugging>on:<define>BOOST_DEBUG_PYTHON
-    :   # default build
-        <link>shared
-    :   # usage requirements
-        <link>static:<define>BOOST_PYTHON_STATIC_LIB
-        <python-debugging>on:<define>BOOST_DEBUG_PYTHON
-    ;
+        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
+        :   # requirements
+            <link>static:<define>BOOST_PYTHON_STATIC_LIB 
+            <define>BOOST_PYTHON_SOURCE
+          
+            # On Windows, all code using Python has to link to the Python
+            # import library.
+            #
+            # On *nix we never link libboost_python to libpython.  When
+            # extending Python, all Python symbols are provided by the
+            # Python interpreter executable.  When embedding Python, the
+            # client executable is expected to explicitly link to
+            # /python//python (the target representing libpython) itself.
+            #
+            # python_for_extensions is a target defined by Boost.Build to
+            # provide the Python include paths, and on Windows, the Python
+            # import library, as usage requirements.
+            [ cond [ python.configured ] : <library>/python//python_for_extensions ]
+            
+            # we prevent building when there is no python available
+            # as it's not possible anyway, and to cause dependents to
+            # fail to build
+            [ unless [ python.configured ] : <build>no ]
 
+            <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+            [ cond $(is-py3) : <python>$(py3-version) ]
+        :   # default build
+            <link>shared
+        :   # usage requirements
+            <link>static:<define>BOOST_PYTHON_STATIC_LIB
+            <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+        ;
+
+}
+
+lib_boost_python ;
 boost-install boost_python ;
+
+if $(py3-version)
+{
+    lib_boost_python yes ;
+    boost-install boost_python3 ;
+}

build/VisualStudio/boost_python.dsp

@@ -1,902 +0,0 @@
-# Microsoft Developer Studio Project File - Name="boost_python" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
-
-CFG=BOOST_PYTHON - WIN32 RELEASE
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "boost_python.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "boost_python.mak" CFG="BOOST_PYTHON - WIN32 RELEASE"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "boost_python - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "boost_python - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "boost_python - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "../bin-stage"
-# PROP Intermediate_Dir "release-obj"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-F90=df.exe
-# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BPL_EXPORTS" /YX /FD /Zm800 /Zm800 /Zm800 /c
-# ADD CPP /nologo /MD /W3 /GR /GX /O2 /I "../../../../" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BOOST_PYTHON_DYNAMIC_LIB" /D "BOOST_PYTHON_SOURCE" /FD /Zm800 /Zm800 /Zm800 /Zm800 /c
-# SUBTRACT CPP /YX
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x1409 /d "NDEBUG"
-# ADD RSC /l 0x1409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 kernel32.lib user32.lib /nologo /dll /machine:I386
-
-!ELSEIF  "$(CFG)" == "boost_python - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "../bin-stage"
-# PROP Intermediate_Dir "debug-obj"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-F90=df.exe
-# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BPL_EXPORTS" /YX /FD /Zm800 /Zm800 /Zm800 /GZ /c
-# ADD CPP /nologo /MDd /W3 /GR /GX /Zi /Od /I "../../../../" /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "BOOST_PYTHON_DYNAMIC_LIB" /D "BOOST_PYTHON_SOURCE" /FD /Zm800 /Zm800 /Zm800 /Zm800 /Zm800 /GZ /c
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x1409 /d "_DEBUG"
-# ADD RSC /l 0x1409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib /nologo /dll /incremental:no /debug /machine:I386 /out:"../bin-stage/boost_python_debug.dll" /pdbtype:sept
-
-!ENDIF 
-
-# Begin Target
-
-# Name "boost_python - Win32 Release"
-# Name "boost_python - Win32 Debug"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=..\..\src\converter\arg_to_python_base.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\converter\builtin_converters.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\object\class.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\dict.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\object\enum.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\errors.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\converter\from_python.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\object\function.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\object\inheritance.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\object\iterator.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\object\life_support.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\list.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\long.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\module.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\numeric.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\object_operators.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\object_protocol.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\object\pickle_support.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\converter\registry.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\slice.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\object\stl_iterator.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\str.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\tuple.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\converter\type_id.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\wrapper.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\import.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\src\exec.cpp
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# Begin Group "detail"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\api_placeholder.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\arg_tuple_size.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\borrowed_ptr.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\call_object.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\caller.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\char_array.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\config.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\construct.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\convertible.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\cv_category.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\decorated_type_id.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\def_helper.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\defaults_def.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\defaults_gen.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\dependent.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\destroy.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\exception_handler.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\force_instantiate.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\if_else.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\indirect_traits.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\make_keyword_range_fn.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\make_tuple.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\map_entry.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\member_function_cast.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\module_base.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\module_init.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\msvc_typeinfo.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\none.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\not_specified.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\operator_id.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\overloads_fwd.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\pointee.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\preprocessor.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\python22_fixed.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\raw_pyobject.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\referent_storage.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\result.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\returning.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\scope.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\string_literal.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\target.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\translate_exception.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\type_list.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\type_list_impl.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\type_list_impl_no_pts.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\type_list_utils.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\unwind_type.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\void_ptr.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\void_return.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\detail\wrap_python.hpp
-# End Source File
-# End Group
-# Begin Group "converter"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\arg_from_python.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\arg_to_python.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\arg_to_python_base.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\builtin_converters.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\constructor_function.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\convertible_function.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\from_python.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\implicit.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\obj_mgr_arg_from_python.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\object_manager.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\pointer_type_id.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\pyobject_traits.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\pyobject_type.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\pytype_arg_from_python.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\pytype_object_mgr_traits.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\registered.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\registered_pointee.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\registrations.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\registry.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\return_from_python.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\rvalue_from_python_data.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\converter\to_python_function_type.hpp
-# End Source File
-# End Group
-# Begin Group "object"
-
-# PROP Default_Filter ""
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\add_to_namespace.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\class.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\class_converters.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\class_detail.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\class_wrapper.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\construct.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\enum_base.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\find_instance.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\forward.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\function.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\function_handle.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\function_object.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\inheritance.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\instance.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\iterator.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\iterator_core.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\life_support.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\make_holder.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\make_instance.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\pickle_support.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\pointer_holder.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\py_function.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\select_holder.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\stl_iterator_core.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\value_holder.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object\value_holder_fwd.hpp
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\arg_from_python.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\args.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\args_fwd.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\back_reference.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\base_type_traits.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\bases.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\borrowed.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\call.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\call_method.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\cast.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\class.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\class_fwd.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\copy_const_reference.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\copy_non_const_reference.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\data_members.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\def.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\default_call_policies.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\dict.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\enum.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\errors.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\exception_translator.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\extract.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\handle.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\handle_fwd.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\has_back_reference.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\implicit.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\init.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\instance_holder.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\iterator.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\list.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\long.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\lvalue_from_pytype.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\make_function.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\manage_new_object.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\module.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\module_init.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\numeric.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_attributes.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_call.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_core.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_fwd.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_items.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_operators.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_protocol.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_protocol_core.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\object_slices.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\operators.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\operators2.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\other.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\overloads.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\pointee.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\proxy.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\ptr.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\refcount.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\reference_existing_object.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\return_internal_reference.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\return_value_policy.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\scope.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\self.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\signature.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\slice_nil.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\stl_iterator.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\str.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\tag.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\to_python_converter.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\to_python_indirect.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\to_python_value.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\tuple.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\type_id.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\..\boost\python\with_custodian_and_ward.hpp
-# End Source File
-# End Group
-# Begin Group "Resource Files"
-
-# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
-# End Group
-# End Target
-# End Project

build/VisualStudio/boost_python.dsw

@@ -1,29 +0,0 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "boost_python"=".\boost_python.dsp" - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-

doc/building.html

@@ -9,7 +9,7 @@
 </head>
 <body>
 <div class="document" id="logo-boost-python-build-and-test-howto">
-<h1 class="title"><a class="reference external" href="../index.htm"><img alt="Boost C++ Libraries:" class="boost-logo" src="../../../boost.png" /></a> Boost.Python Build and Test HOWTO</h1>
+<h1 class="title"><a class="reference external" href="../index.html"><img alt="Boost C++ Libraries:" class="boost-logo" src="../../../boost.png" /></a> Boost.Python Build and Test HOWTO</h1>
 
 <!-- Copyright David Abrahams 2006. Distributed under the Boost -->
 <!-- Software License, Version 1.0. (See accompanying -->

doc/building.rst

@@ -11,7 +11,7 @@
    :alt: Boost C++ Libraries:
    :class: boost-logo
 
-__ ../index.htm
+__ ../index.html
 
 
 .. section-numbering::

doc/news.html

@@ -32,7 +32,43 @@
   <hr>
 
   <dl class="page-index">
+
     <dt>Current SVN</dt>
+    <dd>
+      <ul>
+        <li>Python 3 support:</li>
+          <ul>
+              <li>All the current Boost.Python test cases passed. Extension modules using 
+                  Boost.Python expected to support Python 3 smoothly.</li>
+              <li>Introduced <code>object.contains</code> where <code>x.contains(y)</code>
+                   is equivalent to Python code <code>y in x</code>. 
+                  Now <code>dict.has_key</code> is just a wrapper of <code>object.contains</code>.
+              </li>
+              <li>When building against Python 3, <code>str.decode</code> will be removed.</li>
+              <li>When building against Python 3, the original signature of <code>list.sort</code>, which is:
+                  <pre>void sort(object_cref cmpfunc);</pre>
+                  will change to:
+                  <pre>void sort(args_proxy const &args, kwds_proxy const &kwds);</pre>
+
+                  This is because in Python 3 <code>list.sort</code> requires all its arguments be keyword arguments.
+                  So you should call it like this:
+                  <pre>x.sort(*tuple(), **dict(make_tuple(make_tuple("reverse", true))));</pre>
+
+              </li>
+              <li>According to <a href="http://www.python.org/dev/peps/pep-3123/">PEP 3123</a>, 
+                  when building Boost.Python against Python older than 2.6, the following macros will
+                  be defined in Boost.Python header:
+                <pre>
+# define Py_TYPE(o)    (((PyObject*)(o))->ob_type)
+# define Py_REFCNT(o)  (((PyObject*)(o))->ob_refcnt)
+# define Py_SIZE(o)    (((PyVarObject*)(o))->ob_size)</pre>
+                  So extension writers can use these macro directly, to make code clean and compatible with Python 3.
+              </li>
+          </ul> 
+      </ul>
+    </dd>
+
+    <dt>1.39.0 Release</dt>
 
     <dd>
       <ul>

doc/projects.html

@@ -375,6 +375,27 @@
       application modules, including GUI and post-processing of results.</p>
     </dd>
 
+    <dt><b><a href="http://polybori.sourceforge.net/">PolyBoRi</a></b></dt>
+
+    <dd>
+      <p><a href="mailto:brickenstein@mfo.de"
+        >Michael Brickenstein</a> writes:</p>
+
+      <blockquote>
+        <p>The core of PolyBoRi is a C++ library, which provides
+        high-level data types for Boolean polynomials and monomials,
+        exponent vectors, as well as for the underlying polynomial
+        rings and subsets of the powerset of the Boolean variables. As
+        a unique approach, binary decision diagrams are used as
+        internal storage type for polynomial structures. On top of
+        this C++-library we provide a Python interface. This allows
+        parsing of complex polynomial systems, as well as sophisticated
+        and extendable strategies for Gr&ouml;bner basis computation.
+        Boost.Python has helped us to create this interface in a
+        very clean way.</p>
+      </blockquote>
+    </dd>
+
     <dt><b><a href="http://www.rationaldiscovery.com">Rational Discovery
     LLC</a></b></dt>
 
@@ -435,11 +456,11 @@
   </dl>
   <hr>
 
-  <p>Revised 
+  <p>Revised
   <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-   15 July, 2003</p>
+   29 May, 2008</p>
 
   <p><i>&copy; Copyright <a href="http://www.boost.org/people/dave_abrahams.htm">Dave
-  Abrahams</a> 2002-2003.</i></p>
+  Abrahams</a> 2002-2008.</i></p>
 </body>
 </html>

doc/tutorial/doc/Jamfile.v2

@@ -6,6 +6,8 @@ project boost/libs/python/doc/tutorial/doc ;
 import boostbook : boostbook ;
 using quickbook ;
 
+path-constant images : html ;
+
 boostbook tutorial
     :
         tutorial.qbk
@@ -13,4 +15,6 @@ boostbook tutorial
         <xsl:param>boost.root=../../../../../..
         <xsl:param>boost.libraries=../../../../../../libs/libraries.htm
         <xsl:param>html.stylesheet=../../../../../../doc/html/boostbook.css
+        <format>pdf:<xsl:param>img.src.path=$(images)/
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/python/doc/tutorial/doc/html
     ;

doc/tutorial/doc/html/index.html

@@ -1,7 +1,7 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
-<title>Chapter 1. python 1.0</title>
+<title>Chapter 1. python 2.0</title>
 <link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
 <meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
 <link rel="start" href="index.html" title="Chapter 1. python 1.0">
@@ -10,10 +10,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -31,7 +31,7 @@
 <div><p class="copyright">Copyright © 2002-2005 Joel
       de Guzman, David Abrahams</p></div>
 <div><div class="legalnotice">
-<a name="id455917"></a><p>
+<a name="id457106"></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,15 +94,14 @@
       (IDL).
     </p>
 <a name="quickstart.hello_world"></a><h2>
-<a name="id385257"></a>
+<a name="id386707"></a>
       Hello World
     </h2>
 <p>
       Following C/C++ tradition, let's start with the "hello, world". A
       C++ Function:
     </p>
-<pre class="programlisting">
-<span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">greet</span><span class="special">()</span>
+<pre class="programlisting"><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="identifier">greet</span><span class="special">()</span>
 <span class="special">{</span>
    <span class="keyword">return</span> <span class="string">"hello, world"</span><span class="special">;</span>
 <span class="special">}</span>
@@ -110,8 +109,7 @@
 <p>
       can be exposed to Python by writing a Boost.Python wrapper:
     </p>
-<pre class="programlisting">
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello_ext</span><span class="special">)</span>
 <span class="special">{</span>
@@ -125,8 +123,7 @@
     </p>
 <p>
     </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello_ext</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello_ext</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
 <span class="identifier">hello</span><span class="special">,</span> <span class="identifier">world</span>
 </pre>
@@ -145,7 +142,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: November 07, 2007 at 03:34:24 GMT</small></p></td>
+<td align="left"><p><small>Last revised: November 22, 2008 at 03:24:11 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

doc/tutorial/doc/html/python/embedding.html

@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -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="id471171"></a>
+<a name="id472330"></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="id471276"></a>
+<a name="id472435"></a>
       Getting started
     </h2>
 <p>
@@ -130,23 +130,22 @@ exe embedded_program # name of the executable
 <a name="python.using_the_interpreter"></a>Using the interpreter</h3></div></div></div>
 <p>
         As you probably already know, objects in Python are reference-counted. Naturally,
-        the <tt class="literal">PyObject</tt>s of the Python/C API are also reference-counted.
+        the <tt class="literal">PyObject</tt>s of the Python C API are also reference-counted.
         There is a difference however. While the reference-counting is fully automatic
-        in Python, the Python<span class="emphasis"><em>C API requires you to do it [@http:</em></span>/www.python.org/doc/current/api/refcounts.html
-        by hand]. This is messy and especially hard to get right in the presence
+        in Python, the Python C API requires you to do it <a href="http://www.python.org/doc/current/c-api/refcounting.html" target="_top">by
+        hand</a>. This is messy and especially hard to get right in the presence
         of C++ exceptions. Fortunately Boost.Python provides the <a href="../../../../v2/handle.html" target="_top">handle</a>
         and <a href="../../../../v2/object.html" target="_top">object</a> class templates to
         automate the process.
       </p>
 <a name="using_the_interpreter.running_python_code"></a><h2>
-<a name="id471439"></a>
+<a name="id472601"></a>
         Running Python code
       </h2>
 <p>
         Boost.python provides three related functions to run Python code from C++.
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">eval</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">expression</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">eval</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">expression</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
 <span class="identifier">object</span> <span class="identifier">exec</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">code</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
 <span class="identifier">object</span> <span class="identifier">exec_file</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">filename</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">globals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">(),</span> <span class="identifier">object</span> <span class="identifier">locals</span> <span class="special">=</span> <span class="identifier">object</span><span class="special">())</span>
 </pre>
@@ -165,8 +164,7 @@ exe embedded_program # name of the executable
 <p>
         Boost.python provides a function to import a module:
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">import</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">import</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
 </pre>
 <p>
         import imports a python module (potentially loading it into the running process
@@ -176,8 +174,7 @@ exe embedded_program # name of the executable
         Let's import the <tt class="literal"><span class="underline">_main</span>_</tt>
         module and run some Python code in its namespace:
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
 <span class="identifier">object</span> <span class="identifier">main_namespace</span> <span class="special">=</span> <span class="identifier">main_module</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">);</span>
 
 <span class="identifier">object</span> <span class="identifier">ignored</span> <span class="special">=</span> <span class="identifier">exec</span><span class="special">(</span><span class="string">"hello = file('hello.txt', 'w')\n"</span>
@@ -190,7 +187,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="id472027"></a>
+<a name="id473185"></a>
         Manipulating Python objects
       </h2>
 <p>
@@ -200,8 +197,7 @@ exe embedded_program # name of the executable
         derivatives. We've already seen that they can be constructed from a <tt class="literal">handle</tt>.
         The following examples should further illustrate this fact:
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">main_module</span> <span class="special">=</span> <span class="identifier">import</span><span class="special">(</span><span class="string">"__main__"</span><span class="special">);</span>
 <span class="identifier">object</span> <span class="identifier">main_namespace</span> <span class="special">=</span> <span class="identifier">main_module</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">);</span>
 <span class="identifier">object</span> <span class="identifier">ignored</span> <span class="special">=</span> <span class="identifier">exec</span><span class="special">(</span><span class="string">"result = 5 ** 2"</span><span class="special">,</span> <span class="identifier">main_namespace</span><span class="special">);</span>
 <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">main_namespace</span><span class="special">[</span><span class="string">"result"</span><span class="special">]);</span>
@@ -212,20 +208,18 @@ exe embedded_program # name of the executable
         this variable from the dictionary. Another way to achieve the same result
         is to use eval instead, which returns the result directly:
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5 ** 2"</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5 ** 2"</span><span class="special">);</span>
 <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="id472399"></a>
+<a name="id473554"></a>
         Exception handling
       </h2>
 <p>
         If an exception occurs in the evaluation of the python expression, <a href="../../../../v2/errors.html#error_already_set-spec" target="_top">error_already_set</a>
         is thrown:
       </p>
-<pre class="programlisting">
-<span class="keyword">try</span>
+<pre class="programlisting"><span class="keyword">try</span>
 <span class="special">{</span>
     <span class="identifier">object</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">eval</span><span class="special">(</span><span class="string">"5/0"</span><span class="special">);</span>
     <span class="comment">// execution will never get here:
@@ -240,14 +234,13 @@ exe embedded_program # name of the executable
         The <tt class="literal">error_already_set</tt> exception class doesn't carry any
         information in itself. To find out more about the Python exception that occurred,
         you need to use the <a href="http://www.python.org/doc/api/exceptionHandling.html" target="_top">exception
-        handling functions</a> of the Python<span class="emphasis"><em>C API in your catch-statement.
-        This can be as simple as calling [@http:</em></span>/www.python.org/doc/api/exceptionHandling.html#l2h-70
-        PyErr_Print()] to print the exception's traceback to the console, or comparing
-        the type of the exception with those of the <a href="http://www.python.org/doc/api/standardExceptions.html" target="_top">standard
+        handling functions</a> of the Python C API in your catch-statement. This
+        can be as simple as calling <a href="http://www.python.org/doc/api/exceptionHandling.html#l2h-70" target="_top">PyErr_Print()</a>
+        to print the exception's traceback to the console, or comparing the type
+        of the exception with those of the <a href="http://www.python.org/doc/api/standardExceptions.html" target="_top">standard
         exceptions</a>:
       </p>
-<pre class="programlisting">
-<span class="keyword">catch</span><span class="special">(</span><span class="identifier">error_already_set</span> <span class="keyword">const</span> <span class="special">&amp;)</span>
+<pre class="programlisting"><span class="keyword">catch</span><span class="special">(</span><span class="identifier">error_already_set</span> <span class="keyword">const</span> <span class="special">&amp;)</span>
 <span class="special">{</span>
     <span class="keyword">if</span> <span class="special">(</span><span class="identifier">PyErr_ExceptionMatches</span><span class="special">(</span><span class="identifier">PyExc_ZeroDivisionError</span><span class="special">))</span>
     <span class="special">{</span>

doc/tutorial/doc/html/python/exception.html

@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -30,14 +30,12 @@
       is the point where C++ meets Python. Boost.Python provides a default exception
       handler that translates selected standard exceptions, then gives up:
     </p>
-<pre class="programlisting">
-<span class="keyword">raise</span> <span class="identifier">RuntimeError</span><span class="special">,</span> <span class="string">'unidentifiable C++ Exception'</span>
+<pre class="programlisting"><span class="keyword">raise</span> <span class="identifier">RuntimeError</span><span class="special">,</span> <span class="string">'unidentifiable C++ Exception'</span>
 </pre>
 <p>
       Users may provide custom translation. Here's an example:
     </p>
-<pre class="programlisting">
-<span class="identifier">struct</span> <span class="identifier">PodBayDoorException</span><span class="special">;</span>
+<pre class="programlisting"><span class="identifier">struct</span> <span class="identifier">PodBayDoorException</span><span class="special">;</span>
 <span class="identifier">void</span> <span class="identifier">translator</span><span class="special">(</span><span class="identifier">PodBayDoorException</span> <span class="identifier">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">{</span>
     <span class="identifier">PyErr_SetString</span><span class="special">(</span><span class="identifier">PyExc_UserWarning</span><span class="special">,</span> <span class="string">"I'm sorry Dave..."</span><span class="special">);</span>
 <span class="special">}</span>

doc/tutorial/doc/html/python/exposing.html

@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -40,8 +40,7 @@
 <p>
       Consider a C++ class/struct that we want to expose to Python:
     </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">World</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">World</span>
 <span class="special">{</span>
     <span class="keyword">void</span> <span class="identifier">set</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">msg</span> <span class="special">=</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
     <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">greet</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
@@ -51,8 +50,7 @@
 <p>
       We can expose this to Python by writing a corresponding Boost.Python C++ Wrapper:
     </p>
-<pre class="programlisting">
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span>
@@ -71,8 +69,7 @@
     </p>
 <p>
     </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">World</span><span class="special">()</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span><span class="special">.</span><span class="identifier">set</span><span class="special">(</span><span class="string">'howdy'</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
@@ -87,8 +84,7 @@
         exposes the default constructor by default, which is why we were able to
         write
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">World</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">planet</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">World</span><span class="special">()</span>
 </pre>
 <p>
         We may wish to wrap a class with a non-default constructor. Let us build
@@ -96,8 +92,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">World</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">World</span>
 <span class="special">{</span>
     <span class="identifier">World</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">):</span> <span class="identifier">msg</span><span class="special">(</span><span class="identifier">msg</span><span class="special">)</span> <span class="special">{}</span> <span class="comment">// added constructor
 </span>    <span class="keyword">void</span> <span class="identifier">set</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">msg</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">this</span><span class="special">-&gt;</span><span class="identifier">msg</span> <span class="special">=</span> <span class="identifier">msg</span><span class="special">;</span> <span class="special">}</span>
@@ -111,8 +106,7 @@
         We have to tell <tt class="literal">class_&lt;World&gt;</tt> about the constructor
         we want to expose instead.
       </p>
-<pre class="programlisting">
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">python</span><span class="special">;</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">hello</span><span class="special">)</span>
@@ -133,8 +127,7 @@
         to the <tt class="literal">def()</tt> member function. Say for example we have
         another World constructor taking in two doubles:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">World</span><span class="special">&gt;(</span><span class="string">"World"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;())</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"greet"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">greet</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"set"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">World</span><span class="special">::</span><span class="identifier">set</span><span class="special">)</span>
@@ -144,8 +137,7 @@
         On the other hand, if we do not wish to expose any constructors at all, we
         may use <tt class="literal">no_init</tt> instead:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Abstract</span><span class="special">&gt;(</span><span class="string">"Abstract"</span><span class="special">,</span> <span class="identifier">no_init</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Abstract</span><span class="special">&gt;(</span><span class="string">"Abstract"</span><span class="special">,</span> <span class="identifier">no_init</span><span class="special">)</span>
 </pre>
 <p>
         This actually adds an <tt class="literal"><span class="underline">_init</span>_</tt>
@@ -161,8 +153,7 @@
         to be exposed may be regarded as <span class="bold"><b>read-only</b></span>
         or <span class="bold"><b>read-write</b></span>. Consider this class <tt class="literal">Var</tt>:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">Var</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Var</span>
 <span class="special">{</span>
     <span class="identifier">Var</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">name</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">name</span><span class="special">(</span><span class="identifier">name</span><span class="special">),</span> <span class="identifier">value</span><span class="special">()</span> <span class="special">{}</span>
     <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="keyword">const</span> <span class="identifier">name</span><span class="special">;</span>
@@ -173,8 +164,7 @@
         Our C++ <tt class="literal">Var</tt> class and its data members can be exposed
         to Python:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Var</span><span class="special">&gt;(</span><span class="string">"Var"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Var</span><span class="special">&gt;(</span><span class="string">"Var"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;())</span>
     <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"name"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Var</span><span class="special">::</span><span class="identifier">name</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def_readwrite</span><span class="special">(</span><span class="string">"value"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Var</span><span class="special">::</span><span class="identifier">value</span><span class="special">);</span>
 </pre>
@@ -184,8 +174,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">Var</span><span class="special">(</span><span class="string">'pi'</span><span class="special">)</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">Var</span><span class="special">(</span><span class="string">'pi'</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span> <span class="special">=</span> <span class="number">3.14</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">name</span><span class="special">,</span> <span class="string">'is around'</span><span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span>
 <span class="identifier">pi</span> <span class="keyword">is</span> <span class="identifier">around</span> <span class="number">3.14</span>
@@ -194,8 +183,7 @@
         Note that <tt class="literal">name</tt> is exposed as <span class="bold"><b>read-only</b></span>
         while <tt class="literal">value</tt> is exposed as <span class="bold"><b>read-write</b></span>.
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">name</span> <span class="special">=</span> <span class="string">'e'</span> <span class="comment"># can't change name
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">name</span> <span class="special">=</span> <span class="string">'e'</span> <span class="comment"># can't change name
 </span><span class="identifier">Traceback</span> <span class="special">(</span><span class="identifier">most</span> <span class="identifier">recent</span> <span class="identifier">call</span> <span class="identifier">last</span><span class="special">):</span>
   <span class="identifier">File</span> <span class="string">"&lt;stdin&gt;"</span><span class="special">,</span> <span class="identifier">line</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">in</span> #
 <span class="identifier">AttributeError</span><span class="special">:</span> <span class="identifier">can</span>#<span class="identifier">t</span> <span class="identifier">set</span> <span class="identifier">attribute</span>
@@ -212,8 +200,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">Num</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Num</span>
 <span class="special">{</span>
     <span class="identifier">Num</span><span class="special">();</span>
     <span class="keyword">float</span> <span class="identifier">get</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
@@ -227,8 +214,7 @@
         can just be a different syntax for a method call. Wrapping our <tt class="literal">Num</tt>
         class using Boost.Python:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;(</span><span class="string">"Num"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;(</span><span class="string">"Num"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"value"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">set</span><span class="special">);</span>
 </pre>
@@ -237,8 +223,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">Num</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">Num</span><span class="special">()</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span> <span class="special">=</span> <span class="number">3.14</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">value</span><span class="special">,</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">rovalue</span>
 <span class="special">(</span><span class="number">3.14</span><span class="special">,</span> <span class="number">3.14</span><span class="special">)</span>
@@ -251,8 +236,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">add_property</span><span class="special">(</span><span class="string">"rovalue"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Num</span><span class="special">::</span><span class="identifier">get</span><span class="special">)</span>
 </pre>
 </div>
 <div class="section" lang="en">
@@ -268,24 +252,21 @@
 <p>
         Consider this trivial inheritance structure:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">Base</span> <span class="special">{</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">();</span> <span class="special">};</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span> <span class="special">{</span> <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">();</span> <span class="special">};</span>
 <span class="keyword">struct</span> <span class="identifier">Derived</span> <span class="special">:</span> <span class="identifier">Base</span> <span class="special">{};</span>
 </pre>
 <p>
         And a set of C++ functions operating on <tt class="literal">Base</tt> and <tt class="literal">Derived</tt>
         object instances:
       </p>
-<pre class="programlisting">
-<span class="keyword">void</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">Base</span><span class="special">*);</span>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">b</span><span class="special">(</span><span class="identifier">Base</span><span class="special">*);</span>
 <span class="keyword">void</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">Derived</span><span class="special">*);</span>
 <span class="identifier">Base</span><span class="special">*</span> <span class="identifier">factory</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">Derived</span><span class="special">;</span> <span class="special">}</span>
 </pre>
 <p>
         We've seen how we can wrap the base class <tt class="literal">Base</tt>:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
     <span class="comment">/*...*/</span>
     <span class="special">;</span>
 </pre>
@@ -293,8 +274,7 @@
         Now we can inform Boost.Python of the inheritance relationship between <tt class="literal">Derived</tt>
         and its base class <tt class="literal">Base</tt>. Thus:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Derived</span><span class="special">,</span> <span class="identifier">bases</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"Derived"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Derived</span><span class="special">,</span> <span class="identifier">bases</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="string">"Derived"</span><span class="special">)</span>
     <span class="comment">/*...*/</span>
     <span class="special">;</span>
 </pre>
@@ -317,8 +297,7 @@
         Now, we will expose the C++ free functions <tt class="literal">b</tt> and <tt class="literal">d</tt>
         and <tt class="literal">factory</tt>:
       </p>
-<pre class="programlisting">
-<span class="identifier">def</span><span class="special">(</span><span class="string">"b"</span><span class="special">,</span> <span class="identifier">b</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"b"</span><span class="special">,</span> <span class="identifier">b</span><span class="special">);</span>
 <span class="identifier">def</span><span class="special">(</span><span class="string">"d"</span><span class="special">,</span> <span class="identifier">d</span><span class="special">);</span>
 <span class="identifier">def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span> <span class="identifier">factory</span><span class="special">);</span>
 </pre>
@@ -331,8 +310,7 @@
         is destroyed. We will see more of Boost.Python <a href="functions.html#python.call_policies" title="Call Policies">call
         policies</a> later.
       </p>
-<pre class="programlisting">
-<span class="comment">// Tell Python to take ownership of factory's result
+<pre class="programlisting"><span class="comment">// Tell Python to take ownership of factory's result
 </span><span class="identifier">def</span><span class="special">(</span><span class="string">"factory"</span><span class="special">,</span> <span class="identifier">factory</span><span class="special">,</span>
     <span class="identifier">return_value_policy</span><span class="special">&lt;</span><span class="identifier">manage_new_object</span><span class="special">&gt;());</span>
 </pre>
@@ -345,8 +323,7 @@
         through virtual functions. Continuing our example, let us add a virtual function
         to our <tt class="literal">Base</tt> class:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">Base</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
 <span class="special">{</span>
     <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">()</span> <span class="special">{}</span>
     <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
@@ -364,8 +341,7 @@
         that will unintrusively hook into the virtual functions so that a Python
         override may be called:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
 <span class="special">{</span>
     <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span>
     <span class="special">{</span>
@@ -397,8 +373,7 @@
 <p>
         Finally, exposing <tt class="computeroutput"><span class="identifier">Base</span></tt>:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">pure_virtual</span><span class="special">(&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">))</span>
     <span class="special">;</span>
 </pre>
@@ -437,8 +412,7 @@
         section</a>, we wrapped a class with a pure virtual function that we then
         implemented in C++, or Python classes derived from it. Our base class:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">Base</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
 <span class="special">{</span>
     <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
 <span class="special">};</span>
@@ -447,8 +421,7 @@
         had a pure virtual function <tt class="literal">f</tt>. If, however, its member
         function <tt class="literal">f</tt> was not declared as pure virtual:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">Base</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Base</span>
 <span class="special">{</span>
     <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">Base</span><span class="special">()</span> <span class="special">{}</span>
     <span class="keyword">virtual</span> <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
@@ -457,8 +430,7 @@
 <p>
         We wrap it this way:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">BaseWrap</span> <span class="special">:</span> <span class="identifier">Base</span><span class="special">,</span> <span class="identifier">wrapper</span><span class="special">&lt;</span><span class="identifier">Base</span><span class="special">&gt;</span>
 <span class="special">{</span>
     <span class="keyword">int</span> <span class="identifier">f</span><span class="special">()</span>
     <span class="special">{</span>
@@ -490,8 +462,7 @@
 <p>
         Finally, exposing:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">BaseWrap</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">noncopyable</span><span class="special">&gt;(</span><span class="string">"Base"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Base</span><span class="special">::</span><span class="identifier">f</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">BaseWrap</span><span class="special">::</span><span class="identifier">default_f</span><span class="special">)</span>
     <span class="special">;</span>
 </pre>
@@ -506,8 +477,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span> <span class="special">=</span> <span class="identifier">Base</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span> <span class="special">=</span> <span class="identifier">Base</span><span class="special">()</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">class</span> <span class="identifier">Derived</span><span class="special">(</span><span class="identifier">Base</span><span class="special">):</span>
 <span class="special">...</span>     <span class="keyword">def</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span>
 <span class="special">...</span>         <span class="keyword">return</span> <span class="number">42</span>
@@ -517,15 +487,13 @@
 <p>
         Calling <tt class="literal">base.f()</tt>:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">base</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
 <span class="number">0</span>
 </pre>
 <p>
         Calling <tt class="literal">derived.f()</tt>:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">derived</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">derived</span><span class="special">.</span><span class="identifier">f</span><span class="special">()</span>
 <span class="number">42</span>
 </pre>
 </div>
@@ -533,7 +501,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="id461460"></a>
+<a name="id462548"></a>
         Python Operators
       </h2>
 <p>
@@ -547,8 +515,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="keyword">class</span> <span class="identifier">FilePos</span> <span class="special">{</span> <span class="comment">/*...*/</span> <span class="special">};</span>
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">FilePos</span> <span class="special">{</span> <span class="comment">/*...*/</span> <span class="special">};</span>
 
 <span class="identifier">FilePos</span>     <span class="keyword">operator</span><span class="special">+(</span><span class="identifier">FilePos</span><span class="special">,</span> <span class="keyword">int</span><span class="special">);</span>
 <span class="identifier">FilePos</span>     <span class="keyword">operator</span><span class="special">+(</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">FilePos</span><span class="special">);</span>
@@ -562,8 +529,7 @@
         The class and the various operators can be mapped to Python rather easily
         and intuitively:
       </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">FilePos</span><span class="special">&gt;(</span><span class="string">"FilePos"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">FilePos</span><span class="special">&gt;(</span><span class="string">"FilePos"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">+</span> <span class="keyword">int</span><span class="special">())</span>          <span class="comment">// __add__
 </span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="keyword">int</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">self</span><span class="special">)</span>          <span class="comment">// __radd__
 </span>    <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">self</span> <span class="special">-</span> <span class="identifier">self</span><span class="special">)</span>           <span class="comment">// __sub__
@@ -582,7 +548,7 @@
         expressions".
       </p>
 <a name="class_operators_special_functions.special_methods"></a><h2>
-<a name="id462216"></a>
+<a name="id463302"></a>
         Special Methods
       </h2>
 <p>
@@ -592,8 +558,7 @@
         wrap C++ functions that correspond to these Python <span class="emphasis"><em>special functions</em></span>.
         Example:
       </p>
-<pre class="programlisting">
-<span class="keyword">class</span> <span class="identifier">Rational</span>
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">Rational</span>
 <span class="special">{</span> <span class="keyword">public</span><span class="special">:</span> <span class="keyword">operator</span> <span class="keyword">double</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span> <span class="special">};</span>
 
 <span class="identifier">Rational</span> <span class="identifier">pow</span><span class="special">(</span><span class="identifier">Rational</span><span class="special">,</span> <span class="identifier">Rational</span><span class="special">);</span>

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

@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -87,16 +87,14 @@ Namespaces are one honking great idea -- let's do more of those!
         so Boost.Python must deal with them. To do this, it may need your help. Consider
         the following C++ function:
       </p>
-<pre class="programlisting">
-<span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">);</span>
 </pre>
 <p>
         How should the library wrap this function? A naive approach builds a Python
         X object around result reference. This strategy might or might not work out.
         Here's an example where it didn't
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># x</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">some</span> <span class="identifier">C</span><span class="special">++</span> <span class="identifier">X</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># x</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">some</span> <span class="identifier">C</span><span class="special">++</span> <span class="identifier">X</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">del</span> <span class="identifier">y</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">some_method</span><span class="special">()</span> <span class="preprocessor"># CRASH</span><span class="special">!</span>
 </pre>
@@ -106,8 +104,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         Well, what if f() was implemented as shown below:
       </p>
-<pre class="programlisting">
-<span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="identifier">y</span><span class="special">.</span><span class="identifier">z</span> <span class="special">=</span> <span class="identifier">z</span><span class="special">;</span>
     <span class="keyword">return</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">x</span><span class="special">;</span>
@@ -145,8 +142,7 @@ Namespaces are one honking great idea -- let's do more of those!
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">).</span><span class="identifier">set</span><span class="special">(</span><span class="number">42</span><span class="special">)</span> <span class="comment"># Result disappears
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">).</span><span class="identifier">set</span><span class="special">(</span><span class="number">42</span><span class="special">)</span> <span class="comment"># Result disappears
 </span><span class="special">&gt;&gt;&gt;</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span>       <span class="comment"># No crash, but still bad
 </span><span class="number">3.14</span>
 </pre>
@@ -160,8 +156,7 @@ Namespaces are one honking great idea -- let's do more of those!
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">Y</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">Y</span>
 <span class="special">{</span>
     <span class="identifier">X</span> <span class="identifier">x</span><span class="special">;</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">;</span>
     <span class="keyword">int</span> <span class="identifier">z_value</span><span class="special">()</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">z</span><span class="special">-&gt;</span><span class="identifier">value</span><span class="special">();</span> <span class="special">}</span>
@@ -171,16 +166,14 @@ Namespaces are one honking great idea -- let's do more of those!
         Notice that the data member <tt class="literal">z</tt> is held by class Y using
         a raw pointer. Now we have a potential dangling pointer problem inside Y:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># y</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">z</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">z</span><span class="special">)</span> <span class="preprocessor"># y</span> <span class="identifier">refers</span> <span class="identifier">to</span> <span class="identifier">z</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">del</span> <span class="identifier">z</span>       <span class="preprocessor"># Kill</span> <span class="identifier">the</span> <span class="identifier">z</span> <span class="identifier">object</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">z_value</span><span class="special">()</span> <span class="preprocessor"># CRASH</span><span class="special">!</span>
 </pre>
 <p>
         For reference, here's the implementation of <tt class="literal">f</tt> again:
       </p>
-<pre class="programlisting">
-<span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">Y</span><span class="special">&amp;</span> <span class="identifier">y</span><span class="special">,</span> <span class="identifier">Z</span><span class="special">*</span> <span class="identifier">z</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="identifier">y</span><span class="special">.</span><span class="identifier">z</span> <span class="special">=</span> <span class="identifier">z</span><span class="special">;</span>
     <span class="keyword">return</span> <span class="identifier">y</span><span class="special">.</span><span class="identifier">x</span><span class="special">;</span>
@@ -212,7 +205,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="id464076"></a>
+<a name="id465291"></a>
         Call Policies
       </h2>
 <p>
@@ -220,8 +213,7 @@ Namespaces are one honking great idea -- let's do more of those!
         In our example, <tt class="literal">return_internal_reference</tt> and <tt class="literal">with_custodian_and_ward</tt>
         are our friends:
       </p>
-<pre class="programlisting">
-<span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span>
+<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span>
     <span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span>
         <span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span> <span class="special">&gt;());</span>
 </pre>
@@ -229,8 +221,7 @@ Namespaces are one honking great idea -- let's do more of those!
         What are the <tt class="literal">1</tt> and <tt class="literal">2</tt> parameters, you
         ask?
       </p>
-<pre class="programlisting">
-<span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span>
+<pre class="programlisting"><span class="identifier">return_internal_reference</span><span class="special">&lt;</span><span class="number">1</span>
 </pre>
 <p>
         Informs Boost.Python that the first argument, in our case <tt class="literal">Y&amp;
@@ -239,8 +230,7 @@ Namespaces are one honking great idea -- let's do more of those!
         In short: "return an internal reference <tt class="literal">X&amp;</tt> owned
         by the 1st argument <tt class="literal">Y&amp; y</tt>".
       </p>
-<pre class="programlisting">
-<span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="identifier">with_custodian_and_ward</span><span class="special">&lt;</span><span class="number">1</span><span class="special">,</span> <span class="number">2</span><span class="special">&gt;</span>
 </pre>
 <p>
         Informs Boost.Python that the lifetime of the argument indicated by ward
@@ -252,8 +242,7 @@ Namespaces are one honking great idea -- let's do more of those!
         It is also important to note that we have defined two policies above. Two
         or more policies can be composed by chaining. Here's the general syntax:
       </p>
-<pre class="programlisting">
-<span class="identifier">policy1</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
+<pre class="programlisting"><span class="identifier">policy1</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
     <span class="identifier">policy2</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...,</span>
         <span class="identifier">policy3</span><span class="special">&lt;</span><span class="identifier">args</span><span class="special">...&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span>
 </pre>
@@ -317,8 +306,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         We have here our C++ class:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">X</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
 <span class="special">{</span>
     <span class="keyword">bool</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">)</span>
     <span class="special">{</span>
@@ -345,8 +333,7 @@ Namespaces are one honking great idea -- let's do more of those!
         Class X has 4 overloaded functions. We will start by introducing some member
         function pointer variables:
       </p>
-<pre class="programlisting">
-<span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">)</span>              <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
+<pre class="programlisting"><span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">)</span>              <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx2</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">)</span>      <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx3</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">int</span>     <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx4</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
@@ -354,8 +341,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         With these in hand, we can proceed to define and wrap this for Python:
       </p>
-<pre class="programlisting">
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">)</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">)</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx2</span><span class="special">)</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx3</span><span class="special">)</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx4</span><span class="special">)</span>
@@ -369,30 +355,26 @@ Namespaces are one honking great idea -- let's do more of those!
         pointers carry no default argument info. Take a function <tt class="literal">f</tt>
         with default arguments:
       </p>
-<pre class="programlisting">
-<span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">,</span> <span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="special">=</span> <span class="string">"hello"</span><span class="special">);</span>
+<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">f</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span> <span class="special">=</span> <span class="number">3.14</span><span class="special">,</span> <span class="keyword">char</span> <span class="keyword">const</span><span class="special">*</span> <span class="special">=</span> <span class="string">"hello"</span><span class="special">);</span>
 </pre>
 <p>
         But the type of a pointer to the function <tt class="literal">f</tt> has no information
         about its default arguments:
       </p>
-<pre class="programlisting">
-<span class="keyword">int</span><span class="special">(*</span><span class="identifier">g</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">double</span><span class="special">,</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">;</span>    <span class="comment">// defaults lost!
+<pre class="programlisting"><span class="keyword">int</span><span class="special">(*</span><span class="identifier">g</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">double</span><span class="special">,</span><span class="keyword">char</span> <span class="keyword">const</span><span class="special">*)</span> <span class="special">=</span> <span class="identifier">f</span><span class="special">;</span>    <span class="comment">// defaults lost!
 </span></pre>
 <p>
         When we pass this function pointer to the <tt class="literal">def</tt> function,
         there is no way to retrieve the default arguments:
       </p>
-<pre class="programlisting">
-<span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span>                            <span class="comment">// defaults lost!
+<pre class="programlisting"><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span>                            <span class="comment">// defaults lost!
 </span></pre>
 <p>
         Because of this, when wrapping C++ code, we had to resort to manual wrapping
         as outlined in the <a href="functions.html#python.overloading" title="Overloading">previous section</a>,
         or writing thin wrappers:
       </p>
-<pre class="programlisting">
-<span class="comment">// write "thin wrappers"
+<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>
 
@@ -415,14 +397,13 @@ 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="id466117"></a>
+<a name="id467317"></a>
         BOOST_PYTHON_FUNCTION_OVERLOADS
       </h2>
 <p>
         Boost.Python now has a way to make it easier. For instance, given a function:
       </p>
-<pre class="programlisting">
-<span class="keyword">int</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">c</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">3</span><span class="special">)</span>
+<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">c</span> <span class="special">=</span> <span class="number">2</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">3</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="comment">/*...*/</span>
 <span class="special">}</span>
@@ -430,8 +411,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         The macro invocation:
       </p>
-<pre class="programlisting">
-<span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
 </pre>
 <p>
         will automatically create the thin wrappers for us. This macro will create
@@ -441,11 +421,10 @@ Namespaces are one honking great idea -- let's do more of those!
         number of arguments is 1 and the maximum number of arguments is 4. The <tt class="literal">def(...)</tt>
         function will automatically add all the foo variants for us:
       </p>
-<pre class="programlisting">
-<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 class="programlisting"><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="id466436"></a>
+<a name="id467632"></a>
         BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
       </h2>
 <p>
@@ -460,8 +439,7 @@ Namespaces are one honking great idea -- let's do more of those!
         may be used to automatically create the thin wrappers for wrapping member
         functions. Let's have an example:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">george</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">george</span>
 <span class="special">{</span>
     <span class="keyword">void</span>
     <span class="identifier">wack_em</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">int</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">c</span> <span class="special">=</span> <span class="char">'x'</span><span class="special">)</span>
@@ -473,8 +451,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         The macro invocation:
       </p>
-<pre class="programlisting">
-<span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">george_overloads</span><span class="special">,</span> <span class="identifier">wack_em</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">george_overloads</span><span class="special">,</span> <span class="identifier">wack_em</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
 </pre>
 <p>
         will generate a set of thin wrappers for george's <tt class="literal">wack_em</tt>
@@ -483,15 +460,14 @@ Namespaces are one honking great idea -- let's do more of those!
         in a class named <tt class="literal">george_overloads</tt> that can then be used
         as an argument to <tt class="literal">def(...)</tt>:
       </p>
-<pre class="programlisting">
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"wack_em"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">george</span><span class="special">::</span><span class="identifier">wack_em</span><span class="special">,</span> <span class="identifier">george_overloads</span><span class="special">());</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"wack_em"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">george</span><span class="special">::</span><span class="identifier">wack_em</span><span class="special">,</span> <span class="identifier">george_overloads</span><span class="special">());</span>
 </pre>
 <p>
         See the <a href="../../../../v2/overloads.html#BOOST_PYTHON_FUNCTION_OVERLOADS-spec" target="_top">overloads
         reference</a> for details.
       </p>
 <a name="default_arguments.init_and_optional"></a><h2>
-<a name="id466799"></a>
+<a name="id467992"></a>
         init and optional
       </h2>
 <p>
@@ -499,8 +475,7 @@ Namespaces are one honking great idea -- let's do more of those!
         arguments or a sequence of overloads. Remember <tt class="literal">init&lt;...&gt;</tt>?
         For example, given a class X with a constructor:
       </p>
-<pre class="programlisting">
-<span class="keyword">struct</span> <span class="identifier">X</span>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">X</span>
 <span class="special">{</span>
     <span class="identifier">X</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">a</span><span class="special">,</span> <span class="keyword">char</span> <span class="identifier">b</span> <span class="special">=</span> <span class="char">'D'</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">c</span> <span class="special">=</span> <span class="string">"constructor"</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">d</span> <span class="special">=</span> <span class="number">0.0</span><span class="special">);</span>
     <span class="comment">/*...*/</span>
@@ -509,8 +484,7 @@ Namespaces are one honking great idea -- let's do more of those!
 <p>
         You can easily add this constructor to Boost.Python in one shot:
       </p>
-<pre class="programlisting">
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
 </pre>
 <p>
         Notice the use of <tt class="literal">init&lt;...&gt;</tt> and <tt class="literal">optional&lt;...&gt;</tt>
@@ -526,8 +500,7 @@ Namespaces are one honking great idea -- let's do more of those!
         used for overloaded functions and member functions with a common sequence
         of initial arguments. Here is an example:
       </p>
-<pre class="programlisting">
-<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">()</span>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">foo</span><span class="special">()</span>
 <span class="special">{</span>
    <span class="comment">/*...*/</span>
 <span class="special">}</span>
@@ -551,21 +524,19 @@ Namespaces are one honking great idea -- let's do more of those!
         Like in the previous section, we can generate thin wrappers for these overloaded
         functions in one-shot:
       </p>
-<pre class="programlisting">
-<span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">BOOST_PYTHON_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">foo_overloads</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">,</span> <span class="number">0</span><span class="special">,</span> <span class="number">3</span><span class="special">)</span>
 </pre>
 <p>
         Then...
       </p>
-<pre class="programlisting">
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="special">(</span><span class="keyword">void</span><span class="special">(*)(</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">))</span><span class="number">0</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"foo"</span><span class="special">,</span> <span class="special">(</span><span class="keyword">void</span><span class="special">(*)(</span><span class="keyword">bool</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">))</span><span class="number">0</span><span class="special">,</span> <span class="identifier">foo_overloads</span><span class="special">());</span>
 </pre>
 <p>
         Notice though that we have a situation now where we have a minimum of zero
         (0) arguments and a maximum of 3 arguments.
       </p>
 <a name="auto_overloading.manual_wrapping"></a><h2>
-<a name="id467581"></a>
+<a name="id468767"></a>
         Manual Wrapping
       </h2>
 <p>
@@ -584,21 +555,18 @@ Namespaces are one honking great idea -- let's do more of those!
         to automatically wrap the first three of the <tt class="literal">def</tt>s and
         manually wrap just the last. Here's how we'll do this:
       </p>
-<pre class="programlisting">
-<span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">xf_overloads</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS</span><span class="special">(</span><span class="identifier">xf_overloads</span><span class="special">,</span> <span class="identifier">f</span><span class="special">,</span> <span class="number">1</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span>
 </pre>
 <p>
         Create a member function pointers as above for both X::f overloads:
       </p>
-<pre class="programlisting">
-<span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
+<pre class="programlisting"><span class="keyword">bool</span>    <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx1</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">double</span><span class="special">,</span> <span class="keyword">char</span><span class="special">)</span>    <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 <span class="keyword">int</span>     <span class="special">(</span><span class="identifier">X</span><span class="special">::*</span><span class="identifier">fx2</span><span class="special">)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)</span>        <span class="special">=</span> <span class="special">&amp;</span><span class="identifier">X</span><span class="special">::</span><span class="identifier">f</span><span class="special">;</span>
 </pre>
 <p>
         Then...
       </p>
-<pre class="programlisting">
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">,</span> <span class="identifier">xf_overloads</span><span class="special">());</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx1</span><span class="special">,</span> <span class="identifier">xf_overloads</span><span class="special">());</span>
 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"f"</span><span class="special">,</span> <span class="identifier">fx2</span><span class="special">)</span>
 </pre>
 </div>

doc/tutorial/doc/html/python/hello.html

@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -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="id387672"></a>
+<a name="id388718"></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="id386265"></a>
+<a name="id387300"></a>
       Let's Jam!
     </h2>
 <p>
@@ -108,7 +108,7 @@
       you going.
     </p>
 <a name="hello.running_bjam"></a><h2>
-<a name="id386322"></a>
+<a name="id387357"></a>
       Running bjam
     </h2>
 <p>
@@ -156,8 +156,7 @@ using python : 2.4 : C:/dev/tools<span class="emphasis"><em>Python</em></span> ;
 <p>
       Finally:
     </p>
-<pre class="programlisting">
-<span class="identifier">bjam</span>
+<pre class="programlisting"><span class="identifier">bjam</span>
 </pre>
 <p>
       It should be building now:
@@ -180,6 +179,17 @@ 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>

doc/tutorial/doc/html/python/iterators.html

@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -64,8 +64,7 @@
     </p>
 <p>
     </p>
-<pre class="programlisting">
-<span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">__iter__</span><span class="special">()</span>         <span class="comment"># get iterator
+<pre class="programlisting"><span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">.</span><span class="identifier">__iter__</span><span class="special">()</span>         <span class="comment"># get iterator
 </span><span class="keyword">try</span><span class="special">:</span>
     <span class="keyword">while</span> <span class="number">1</span><span class="special">:</span>
     <span class="identifier">y</span> <span class="special">=</span> <span class="identifier">iter</span><span class="special">.</span><span class="identifier">next</span><span class="special">()</span>         <span class="comment"># get each item
@@ -79,16 +78,14 @@
     </p>
 <p>
     </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">get_iterator</span> <span class="special">=</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;();</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">get_iterator</span> <span class="special">=</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;();</span>
 <span class="identifier">object</span> <span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">get_iterator</span><span class="special">(</span><span class="identifier">v</span><span class="special">);</span>
 <span class="identifier">object</span> <span class="identifier">first</span> <span class="special">=</span> <span class="identifier">iter</span><span class="special">.</span><span class="identifier">next</span><span class="special">();</span>
 </pre>
 <p>
       Or for use in class_&lt;&gt;:
     </p>
-<pre class="programlisting">
-<span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"__iter__"</span><span class="special">,</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
+<pre class="programlisting"><span class="special">.</span><span class="identifier">def</span><span class="special">(</span><span class="string">"__iter__"</span><span class="special">,</span> <span class="identifier">iterator</span><span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;())</span>
 </pre>
 <p>
       <span class="bold"><b>range</b></span>
@@ -134,8 +131,7 @@
     </p>
 <p>
     </p>
-<pre class="programlisting">
-<span class="identifier">f</span> <span class="special">=</span> <span class="identifier">Field</span><span class="special">()</span>
+<pre class="programlisting"><span class="identifier">f</span> <span class="special">=</span> <span class="identifier">Field</span><span class="special">()</span>
 <span class="keyword">for</span> <span class="identifier">x</span> <span class="keyword">in</span> <span class="identifier">f</span><span class="special">.</span><span class="identifier">pions</span><span class="special">:</span>
     <span class="identifier">smash</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span>
 <span class="keyword">for</span> <span class="identifier">y</span> <span class="keyword">in</span> <span class="identifier">f</span><span class="special">.</span><span class="identifier">bogons</span><span class="special">:</span>
@@ -146,8 +142,7 @@
     </p>
 <p>
     </p>
-<pre class="programlisting">
-<span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;(</span><span class="string">"Field"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">F</span><span class="special">&gt;(</span><span class="string">"Field"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">property</span><span class="special">(</span><span class="string">"pions"</span><span class="special">,</span> <span class="identifier">range</span><span class="special">(&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">p_begin</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">p_end</span><span class="special">))</span>
     <span class="special">.</span><span class="identifier">property</span><span class="special">(</span><span class="string">"bogons"</span><span class="special">,</span> <span class="identifier">range</span><span class="special">(&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_begin</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">F</span><span class="special">::</span><span class="identifier">b_end</span><span class="special">));</span>
 </pre>
@@ -163,8 +158,7 @@
     </p>
 <p>
     </p>
-<pre class="programlisting">
-<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
 <span class="keyword">void</span> <span class="identifier">list_assign</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">l</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">o</span><span class="special">)</span> <span class="special">{</span>
     <span class="comment">// Turn a Python sequence into an STL input range
 </span>    <span class="identifier">stl_input_iterator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">begin</span><span class="special">(</span><span class="identifier">o</span><span class="special">),</span> <span class="identifier">end</span><span class="special">;</span>
@@ -183,8 +177,7 @@
     </p>
 <p>
     </p>
-<pre class="programlisting">
-<span class="identifier">x</span> <span class="special">=</span> <span class="identifier">list_int</span><span class="special">();</span>
+<pre class="programlisting"><span class="identifier">x</span> <span class="special">=</span> <span class="identifier">list_int</span><span class="special">();</span>
 <span class="identifier">x</span><span class="special">.</span><span class="identifier">assign</span><span class="special">([</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">])</span>
 </pre>
 </div>

doc/tutorial/doc/html/python/object.html

@@ -12,10 +12,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -62,8 +62,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="keyword">def</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>
+<pre class="programlisting"><span class="keyword">def</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="keyword">if</span> <span class="special">(</span><span class="identifier">y</span> <span class="special">==</span> <span class="string">'foo'</span><span class="special">):</span>
          <span class="identifier">x</span><span class="special">[</span><span class="number">3</span><span class="special">:</span><span class="number">7</span><span class="special">]</span> <span class="special">=</span> <span class="string">'bar'</span>
      <span class="keyword">else</span><span class="special">:</span>
@@ -78,8 +77,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">object</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">object</span> <span class="identifier">x</span><span class="special">,</span> <span class="identifier">object</span> <span class="identifier">y</span><span class="special">)</span> <span class="special">{</span>
      <span class="keyword">if</span> <span class="special">(</span><span class="identifier">y</span> <span class="special">==</span> <span class="string">"foo"</span><span class="special">)</span>
          <span class="identifier">x</span><span class="special">.</span><span class="identifier">slice</span><span class="special">(</span><span class="number">3</span><span class="special">,</span><span class="number">7</span><span class="special">)</span> <span class="special">=</span> <span class="string">"bar"</span><span class="special">;</span>
      <span class="keyword">else</span>
@@ -126,23 +124,20 @@
         These derived <tt class="literal">object</tt> types act like real Python types.
         For instance:
       </p>
-<pre class="programlisting">
-<span class="identifier">str</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">==&gt;</span> <span class="string">"1"</span>
+<pre class="programlisting"><span class="identifier">str</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special">==&gt;</span> <span class="string">"1"</span>
 </pre>
 <p>
         Wherever appropriate, a particular derived <tt class="literal">object</tt> has
         corresponding Python type's methods. For instance, <tt class="literal">dict</tt>
         has a <tt class="literal">keys()</tt> method:
       </p>
-<pre class="programlisting">
-<span class="identifier">d</span><span class="special">.</span><span class="identifier">keys</span><span class="special">()</span>
+<pre class="programlisting"><span class="identifier">d</span><span class="special">.</span><span class="identifier">keys</span><span class="special">()</span>
 </pre>
 <p>
         <tt class="literal">make_tuple</tt> is provided for declaring <span class="emphasis"><em>tuple literals</em></span>.
         Example:
       </p>
-<pre class="programlisting">
-<span class="identifier">make_tuple</span><span class="special">(</span><span class="number">123</span><span class="special">,</span> <span class="char">'D'</span><span class="special">,</span> <span class="string">"Hello, World"</span><span class="special">,</span> <span class="number">0.0</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">make_tuple</span><span class="special">(</span><span class="number">123</span><span class="special">,</span> <span class="char">'D'</span><span class="special">,</span> <span class="string">"Hello, World"</span><span class="special">,</span> <span class="number">0.0</span><span class="special">);</span>
 </pre>
 <p>
         In C++, when Boost.Python <tt class="literal">object</tt>s are used as arguments
@@ -150,8 +145,7 @@
         <tt class="literal">f</tt>, as declared below, is wrapped, it will only accept
         instances of Python's <tt class="literal">str</tt> type and subtypes.
       </p>
-<pre class="programlisting">
-<span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">str</span> <span class="identifier">name</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="identifier">object</span> <span class="identifier">n2</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"upper"</span><span class="special">)();</span>   <span class="comment">// NAME = name.upper()
 </span>    <span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>            <span class="comment">// better
@@ -161,15 +155,13 @@
 <p>
         In finer detail:
       </p>
-<pre class="programlisting">
-<span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>
+<pre class="programlisting"><span class="identifier">str</span> <span class="identifier">NAME</span> <span class="special">=</span> <span class="identifier">name</span><span class="special">.</span><span class="identifier">upper</span><span class="special">();</span>
 </pre>
 <p>
         Illustrates that we provide versions of the str type's methods as C++ member
         functions.
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">msg</span> <span class="special">=</span> <span class="string">"%s is bigger than %s"</span> <span class="special">%</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">msg</span> <span class="special">=</span> <span class="string">"%s is bigger than %s"</span> <span class="special">%</span> <span class="identifier">make_tuple</span><span class="special">(</span><span class="identifier">NAME</span><span class="special">,</span><span class="identifier">name</span><span class="special">);</span>
 </pre>
 <p>
         Demonstrates that you can write the C++ equivalent of <tt class="literal">"format"
@@ -184,19 +176,17 @@
 <p>
         Python:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">dict</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special">)</span>     <span class="comment"># copies x.__dict__
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">dict</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">__dict__</span><span class="special">)</span>     <span class="comment"># copies x.__dict__
 </span><span class="special">&gt;&gt;&gt;</span> <span class="identifier">d</span><span class="special">[</span><span class="string">'whatever'</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span>        <span class="comment"># modifies the copy
 </span></pre>
 <p>
         C++:
       </p>
-<pre class="programlisting">
-<span class="identifier">dict</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>  <span class="comment">// copies x.__dict__
+<pre class="programlisting"><span class="identifier">dict</span> <span class="identifier">d</span><span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>  <span class="comment">// copies x.__dict__
 </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="id469586"></a>
+<a name="id470756"></a>
         class_&lt;T&gt; as objects
       </h2>
 <p>
@@ -207,8 +197,7 @@
 <p>
         We can use this to create wrapped instances. Example:
       </p>
-<pre class="programlisting">
-<span class="identifier">object</span> <span class="identifier">vec345</span> <span class="special">=</span> <span class="special">(</span>
+<pre class="programlisting"><span class="identifier">object</span> <span class="identifier">vec345</span> <span class="special">=</span> <span class="special">(</span>
     <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&gt;(</span><span class="string">"Vec2"</span><span class="special">,</span> <span class="identifier">init</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;())</span>
         <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"length"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Point</span><span class="special">::</span><span class="identifier">length</span><span class="special">)</span>
         <span class="special">.</span><span class="identifier">def_readonly</span><span class="special">(</span><span class="string">"angle"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">Point</span><span class="special">::</span><span class="identifier">angle</span><span class="special">)</span>
@@ -225,16 +214,14 @@
         can be achieved with the <tt class="literal">extract&lt;T&gt;</tt> function. Consider
         the following:
       </p>
-<pre class="programlisting">
-<span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">);</span> <span class="comment">// compile error
+<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">);</span> <span class="comment">// compile error
 </span></pre>
 <p>
         In the code above, we got a compiler error because Boost.Python <tt class="literal">object</tt>
         can't be implicitly converted to <tt class="literal">double</tt>s. Instead, what
         we wanted to do above can be achieved by writing:
       </p>
-<pre class="programlisting">
-<span class="keyword">double</span> <span class="identifier">l</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">));</span>
+<pre class="programlisting"><span class="keyword">double</span> <span class="identifier">l</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;(</span><span class="identifier">o</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"length"</span><span class="special">));</span>
 <span class="identifier">Vec2</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;(</span><span class="identifier">o</span><span class="special">);</span>
 <span class="identifier">assert</span><span class="special">(</span><span class="identifier">l</span> <span class="special">==</span> <span class="identifier">v</span><span class="special">.</span><span class="identifier">length</span><span class="special">());</span>
 </pre>
@@ -251,8 +238,7 @@
         be extracted, an appropriate exception is thrown. To avoid an exception,
         we need to test for extractibility:
       </p>
-<pre class="programlisting">
-<span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;</span> <span class="identifier">x</span><span class="special">(</span><span class="identifier">o</span><span class="special">);</span>
+<pre class="programlisting"><span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">Vec2</span><span class="special">&amp;&gt;</span> <span class="identifier">x</span><span class="special">(</span><span class="identifier">o</span><span class="special">);</span>
 <span class="keyword">if</span> <span class="special">(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">check</span><span class="special">())</span> <span class="special">{</span>
     <span class="identifier">Vec2</span><span class="special">&amp;</span> <span class="identifier">v</span> <span class="special">=</span> <span class="identifier">x</span><span class="special">();</span> <span class="special">...</span>
 </pre>
@@ -260,8 +246,7 @@
         <span class="inlinemediaobject"><img src="../images/tip.png" alt="tip"></span> The astute reader might have noticed that the <tt class="literal">extract&lt;T&gt;</tt>
         facility in fact solves the mutable copying problem:
       </p>
-<pre class="programlisting">
-<span class="identifier">dict</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">dict</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>
+<pre class="programlisting"><span class="identifier">dict</span> <span class="identifier">d</span> <span class="special">=</span> <span class="identifier">extract</span><span class="special">&lt;</span><span class="identifier">dict</span><span class="special">&gt;(</span><span class="identifier">x</span><span class="special">.</span><span class="identifier">attr</span><span class="special">(</span><span class="string">"__dict__"</span><span class="special">));</span>
 <span class="identifier">d</span><span class="special">[</span><span class="string">"whatever"</span><span class="special">]</span> <span class="special">=</span> <span class="number">3</span><span class="special">;</span>          <span class="comment">// modifies x.__dict__ !
 </span></pre>
 </div>
@@ -276,14 +261,12 @@
         typing to C++'s strong static typing (in C++, ints cannot be implicitly converted
         to enums). To illustrate, given a C++ enum:
       </p>
-<pre class="programlisting">
-<span class="keyword">enum</span> <span class="identifier">choice</span> <span class="special">{</span> <span class="identifier">red</span><span class="special">,</span> <span class="identifier">blue</span> <span class="special">};</span>
+<pre class="programlisting"><span class="keyword">enum</span> <span class="identifier">choice</span> <span class="special">{</span> <span class="identifier">red</span><span class="special">,</span> <span class="identifier">blue</span> <span class="special">};</span>
 </pre>
 <p>
         the construct:
       </p>
-<pre class="programlisting">
-<span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">choice</span><span class="special">&gt;(</span><span class="string">"choice"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">enum_</span><span class="special">&lt;</span><span class="identifier">choice</span><span class="special">&gt;(</span><span class="string">"choice"</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"red"</span><span class="special">,</span> <span class="identifier">red</span><span class="special">)</span>
     <span class="special">.</span><span class="identifier">value</span><span class="special">(</span><span class="string">"blue"</span><span class="special">,</span> <span class="identifier">blue</span><span class="special">)</span>
     <span class="special">;</span>
@@ -315,8 +298,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="identifier">my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="identifier">my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span>
 <span class="identifier">my_module</span><span class="special">.</span><span class="identifier">choice</span><span class="special">.</span><span class="identifier">red</span>
 </pre>
 <p>
@@ -325,8 +307,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="identifier">scope</span> <span class="identifier">in_X</span> <span class="special">=</span> <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;(</span><span class="string">"X"</span><span class="special">)</span>
+<pre class="programlisting"><span class="identifier">scope</span> <span class="identifier">in_X</span> <span class="special">=</span> <span class="identifier">class_</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;(</span><span class="string">"X"</span><span class="special">)</span>
                 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span>
                 <span class="special">.</span><span class="identifier">def</span><span class="special">(</span> <span class="special">...</span> <span class="special">)</span>
             <span class="special">;</span>

doc/tutorial/doc/html/python/techniques.html

@@ -11,10 +11,10 @@
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
 <table cellpadding="2" width="100%"><tr>
 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../../../index.htm">Home</a></td>
+<td align="center"><a href="../../../../../../../index.html">Home</a></td>
 <td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="../../../../../../../people/people.htm">People</a></td>
-<td align="center"><a href="../../../../../../../more/faq.htm">FAQ</a></td>
+<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
+<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
 <td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
 </tr></table>
 <hr>
@@ -53,8 +53,7 @@
         <tt class="literal">sounds</tt>. Our library already has a neat C++ namespace hierarchy,
         like so:
       </p>
-<pre class="programlisting">
-<span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span>
+<pre class="programlisting"><span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span>
 <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">io</span>
 <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">filters</span>
 </pre>
@@ -62,16 +61,14 @@
         We would like to present this same hierarchy to the Python user, allowing
         him to write code like this:
       </p>
-<pre class="programlisting">
-<span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
+<pre class="programlisting"><span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(...)</span> <span class="comment"># echo is a C++ function
 </span></pre>
 <p>
         The first step is to write the wrapping code. We have to export each module
         separately with Boost.Python, like this:
       </p>
-<pre class="programlisting">
-<span class="special">/*</span> <span class="identifier">file</span> <span class="identifier">core</span><span class="special">.</span><span class="identifier">cpp</span> <span class="special">*/</span>
+<pre class="programlisting"><span class="special">/*</span> <span class="identifier">file</span> <span class="identifier">core</span><span class="special">.</span><span class="identifier">cpp</span> <span class="special">*/</span>
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">core</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="special">/*</span> <span class="identifier">export</span> <span class="identifier">everything</span> <span class="keyword">in</span> <span class="identifier">the</span> <span class="identifier">sounds</span><span class="special">::</span><span class="identifier">core</span> <span class="identifier">namespace</span> <span class="special">*/</span>
@@ -129,8 +126,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">io</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">io</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sound</span> <span class="special">=</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">io</span><span class="special">.</span><span class="identifier">open</span><span class="special">(</span><span class="string">'file.mp3'</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">new_sound</span> <span class="special">=</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(</span><span class="identifier">sound</span><span class="special">,</span> <span class="number">1.0</span><span class="special">)</span>
@@ -152,8 +148,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="comment">/* file core.cpp */</span>
+<pre class="programlisting"><span class="comment">/* file core.cpp */</span>
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_core</span><span class="special">)</span>
 <span class="special">{</span>
     <span class="special">...</span>
@@ -185,8 +180,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">core</span><span class="special">.</span><span class="identifier">_core</span><span class="special">.</span><span class="identifier">foo</span><span class="special">(...)</span>
 </pre>
 <p>
@@ -196,15 +190,13 @@
         entire namespace from <tt class="literal">_core.pyd</tt> to <tt class="literal">core/__init__.py</tt>.
         So add this line of code to <tt class="literal">sounds<span class="emphasis"><em>core</em></span>__init__.py</tt>:
       </p>
-<pre class="programlisting">
-<span class="keyword">from</span> <span class="identifier">_core</span> <span class="keyword">import</span> <span class="special">*</span>
+<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">_core</span> <span class="keyword">import</span> <span class="special">*</span>
 </pre>
 <p>
         We do the same for the other packages. Now the user accesses the functions
         and classes in the extension modules like before:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(...)</span>
 </pre>
 <p>
@@ -217,8 +209,7 @@
         a file named <tt class="literal">sounds/filters/echo_noise.py</tt> and code our
         function:
       </p>
-<pre class="programlisting">
-<span class="keyword">import</span> <span class="identifier">_filters</span>
+<pre class="programlisting"><span class="keyword">import</span> <span class="identifier">_filters</span>
 <span class="keyword">def</span> <span class="identifier">echo_noise</span><span class="special">(</span><span class="identifier">sound</span><span class="special">):</span>
     <span class="identifier">s</span> <span class="special">=</span> <span class="identifier">_filters</span><span class="special">.</span><span class="identifier">echo</span><span class="special">(</span><span class="identifier">sound</span><span class="special">)</span>
     <span class="identifier">s</span> <span class="special">=</span> <span class="identifier">_filters</span><span class="special">.</span><span class="identifier">noise</span><span class="special">(</span><span class="identifier">sound</span><span class="special">)</span>
@@ -227,15 +218,13 @@
 <p>
         Next, we add this line to <tt class="literal">sounds<span class="emphasis"><em>filters</em></span>__init__.py</tt>:
       </p>
-<pre class="programlisting">
-<span class="keyword">from</span> <span class="identifier">echo_noise</span> <span class="keyword">import</span> <span class="identifier">echo_noise</span>
+<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">echo_noise</span> <span class="keyword">import</span> <span class="identifier">echo_noise</span>
 </pre>
 <p>
         And that's it. The user now accesses this function like any other function
         from the <tt class="literal">filters</tt> package:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">sounds</span><span class="special">.</span><span class="identifier">filters</span><span class="special">.</span><span class="identifier">echo_noise</span><span class="special">(...)</span>
 </pre>
 </div>
@@ -246,8 +235,7 @@
         Thanks to Python's flexibility, you can easily add new methods to a class,
         even after it was already created:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">class</span> <span class="identifier">C</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span> <span class="keyword">pass</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">class</span> <span class="identifier">C</span><span class="special">(</span><span class="identifier">object</span><span class="special">):</span> <span class="keyword">pass</span>
 <span class="special">&gt;&gt;&gt;</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="comment"># a regular function
 </span><span class="special">&gt;&gt;&gt;</span> <span class="keyword">def</span> <span class="identifier">C_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span> <span class="keyword">return</span> <span class="string">'A C instance!'</span>
@@ -270,8 +258,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="keyword">class</span> <span class="identifier">point</span> <span class="special">{...};</span>
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">point</span> <span class="special">{...};</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span>
 <span class="special">{</span>
@@ -284,8 +271,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="keyword">from</span> <span class="identifier">_geom</span> <span class="keyword">import</span> <span class="special">*</span>
+<pre class="programlisting"><span class="keyword">from</span> <span class="identifier">_geom</span> <span class="keyword">import</span> <span class="special">*</span>
 
 <span class="comment"># a regular function
 </span><span class="keyword">def</span> <span class="identifier">point_str</span><span class="special">(</span><span class="identifier">self</span><span class="special">):</span>
@@ -317,8 +303,7 @@
         You can even add a little syntactic sugar with the use of metaclasses. Let's
         create a special metaclass that "injects" methods in other classes.
       </p>
-<pre class="programlisting">
-<span class="comment"># The one Boost.Python uses for all wrapped classes.
+<pre class="programlisting"><span class="comment"># The one Boost.Python uses for all wrapped classes.
 </span><span class="comment"># You can use here any class exported by Boost instead of "point"
 </span><span class="identifier">BoostPythonMetaclass</span> <span class="special">=</span> <span class="identifier">point</span><span class="special">.</span><span class="identifier">__class__</span>
 
@@ -341,8 +326,7 @@
 <p>
         Now let's see how it got:
       </p>
-<pre class="programlisting">
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">point</span><span class="special">()</span>
+<pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">point</span><span class="special">()</span>
 <span class="identifier">Point</span><span class="special">(</span><span class="identifier">x</span><span class="special">=</span><span class="number">10</span><span class="special">,</span> <span class="identifier">y</span><span class="special">=</span><span class="number">10</span><span class="special">)</span>
 <span class="special">&gt;&gt;&gt;</span> <span class="identifier">point</span><span class="special">().</span><span class="identifier">foo</span><span class="special">()</span>
 <span class="identifier">foo</span><span class="special">!</span>
@@ -350,8 +334,7 @@
 <p>
         Another useful idea is to replace constructors with factory functions:
       </p>
-<pre class="programlisting">
-<span class="identifier">_point</span> <span class="special">=</span> <span class="identifier">point</span>
+<pre class="programlisting"><span class="identifier">_point</span> <span class="special">=</span> <span class="identifier">point</span>
 
 <span class="keyword">def</span> <span class="identifier">point</span><span class="special">(</span><span class="identifier">x</span><span class="special">=</span><span class="number">0</span><span class="special">,</span> <span class="identifier">y</span><span class="special">=</span><span class="number">0</span><span class="special">):</span>
     <span class="keyword">return</span> <span class="identifier">_point</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">)</span>
@@ -374,8 +357,7 @@
       </p>
 <p>
       </p>
-<pre class="programlisting">
-<span class="comment">/* file point.cpp */</span>
+<pre class="programlisting"><span class="comment">/* file point.cpp */</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">point</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
@@ -397,8 +379,7 @@
         Now you create a file <tt class="literal">main.cpp</tt>, which contains the <tt class="literal">BOOST_PYTHON_MODULE</tt>
         macro, and call the various export functions inside it.
       </p>
-<pre class="programlisting">
-<span class="keyword">void</span> <span class="identifier">export_point</span><span class="special">();</span>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">export_point</span><span class="special">();</span>
 <span class="keyword">void</span> <span class="identifier">export_triangle</span><span class="special">();</span>
 
 <span class="identifier">BOOST_PYTHON_MODULE</span><span class="special">(</span><span class="identifier">_geom</span><span class="special">)</span>
@@ -411,8 +392,7 @@
         Compiling and linking together all this files produces the same result as
         the usual approach:
       </p>
-<pre class="programlisting">
-<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">python</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">point</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">triangle</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span>
 

doc/tutorial/doc/tutorial.qbk

@@ -1,5 +1,5 @@
 [library python
-    [version 1.0]
+    [version 2.0]
     [authors [de Guzman, Joel], [Abrahams, David]]
     [copyright 2002 2003 2004 2005 Joel de Guzman, David Abrahams]
     [category inter-language support]
@@ -1381,10 +1381,10 @@ interpreter. This may be fixed in a future version of boost.python.]
 [section Using the interpreter]
 
 As you probably already know, objects in Python are reference-counted.
-Naturally, the [^PyObject]s of the Python/C API are also reference-counted.
+Naturally, the [^PyObject]s of the Python C API are also reference-counted.
 There is a difference however. While the reference-counting is fully
-automatic in Python, the Python/C API requires you to do it
-[@http://www.python.org/doc/current/api/refcounts.html by hand]. This is
+automatic in Python, the Python C API requires you to do it
+[@http://www.python.org/doc/current/c-api/refcounting.html by hand]. This is
 messy and especially hard to get right in the presence of C++ exceptions.
 Fortunately Boost.Python provides the [@../../../v2/handle.html handle] and
 [@../../../v2/object.html object] class templates to automate the process.
@@ -1466,7 +1466,7 @@ If an exception occurs in the evaluation of the python expression,
 The [^error_already_set] exception class doesn't carry any information in itself.
 To find out more about the Python exception that occurred, you need to use the
 [@http://www.python.org/doc/api/exceptionHandling.html exception handling functions]
-of the Python/C API in your catch-statement. This can be as simple as calling
+of the Python C API in your catch-statement. This can be as simple as calling
 [@http://www.python.org/doc/api/exceptionHandling.html#l2h-70 PyErr_Print()] to
 print the exception's traceback to the console, or comparing the type of the
 exception with those of the [@http://www.python.org/doc/api/standardExceptions.html

doc/tutorial/index.html

@@ -11,8 +11,8 @@
     <a href="doc/html/index.html">link</a> &nbsp;<hr>
     <p>© Copyright Beman Dawes, 2001</p>
     <p>Distributed under the Boost Software License, Version 1.0. (See 
-    accompanying file <a href="../../../LICENSE_1_0.txt">
+    accompanying file <a href="../../../../LICENSE_1_0.txt">
     LICENSE_1_0.txt</a> or copy at
     <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
   </body>
-</html>
+</html>

doc/v2/CallPolicies.html

@@ -137,7 +137,7 @@
         <td valign="top"><code>P::extract_return_type</code></td>
 
         <td>A model of <a href=
-          "../../../doc/refmanual/metafunction.html">Metafunction</a>.</td>
+          "../../../mpl/doc/refmanual/metafunction.html">Metafunction</a>.</td>
 
         <td>An MPL unary <a href=
           "../../../mpl/doc/refmanual/metafunction.html">Metafunction</a> used extract the return type from a given signature. By default it is derived from mpl::front.</td>

doc/v2/Dereferenceable.html

@@ -4,7 +4,7 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href=../../../../boost.css>
+<link rel="stylesheet" type="text/css" href="../../../../boost.css">
 <title>Boost.Python - Dereferenceable Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">

doc/v2/Extractor.html

@@ -4,7 +4,7 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href=../../../../boost.css>
+<link rel="stylesheet" type="text/css" href="../../../../boost.css">
 <title>Boost.Python - Extractor Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">

doc/v2/HolderGenerator.html

@@ -4,7 +4,7 @@
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href=../../../../boost.css>
+<link rel="stylesheet" type="text/css" href="../../../../boost.css">
 <title>Boost.Python - Holder Concept</title>
 </head>
 <body link="#0000ff" vlink="#800080">

doc/v2/object.html

@@ -74,6 +74,32 @@
             </dl>
           </dd>
 
+          <dt><a href="#const_objattribute_policies-spec">Class
+          <code>const_objattribute_policies</code></a></dt>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#const_objattribute_policies-spec-synopsis">Class
+              <code>const_objattribute_policies</code> synopsis</a></dt>
+
+              <dt><a href="#const_objattribute_policies-spec-statics">Class
+              <code>const_objattribute_policies</code> static functions</a></dt>
+            </dl>
+          </dd>
+
+          <dt><a href="#objattribute_policies-spec">Class
+          <code>objattribute_policies</code></a></dt>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#objattribute_policies-spec-synopsis">Class
+              <code>objattribute_policies</code> synopsis</a></dt>
+
+              <dt><a href="#objattribute_policies-spec-statics">Class
+              <code>objattribute_policies</code> static functions</a></dt>
+            </dl>
+          </dd>
+
           <dt><a href="#const_item_policies-spec">Class
           <code>const_item_policies</code></a></dt>
 
@@ -328,6 +354,102 @@ static void del(object const&amp;target, char const* key);
     <!-- end -->
     <!-- begin -->
 
+    <h3><a name="const_objattribute_policies-spec"></a>Class
+    <code>const_objattribute_policies</code></h3>
+
+    <p>The policies which are used for proxies representing an attribute
+    access to a <code>const&nbsp;object</code> when the attribute name is
+    given as a <code>const&nbsp;object</code>.</p>
+
+    <h4><a name="const_objattribute_policies-spec-synopsis"></a>Class
+    <code>const_objattribute_policies</code> synopsis</h4>
+<pre>
+namespace boost { namespace python { namespace api
+{
+  struct const_objattribute_policies
+  {
+      typedef object const& key_type;
+      static object get(object const&amp; target, object const& key);
+  };
+}}}
+</pre>
+
+    <h4><a name="const_objattribute_policies-spec-statics"></a>Class
+    <code>const_objattribute_policies</code> static functions</h4>
+<pre>
+static object get(object const&amp; target, object const& key);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
+      holding a string.</dt>
+
+      <dt><b>Effects:</b> accesses the attribute of <code>target</code> named
+      by <code>key</code>.</dt>
+
+      <dt><b>Returns:</b> An <code>object</code> managing the result of the
+      attribute access.</dt>
+
+      <dt><b>Throws:</b> <code><a href=
+      "errors.html#error_already_set-spec">error_already_set</a></code> if a
+      Python exception is raised.</dt>
+    </dl>
+
+    <h3><a name="objattribute_policies-spec"></a>Class
+    <code>objattribute_policies</code></h3>
+
+    <p>The policies which are used for proxies representing an attribute
+    access to a mutable <code>object</code> when the attribute name is
+    given as a <code>const&nbsp;object</code>.</p>
+
+    <h4><a name="objattribute_policies-spec-synopsis"></a>Class
+    <code>objattribute_policies</code> synopsis</h4>
+<pre>
+namespace boost { namespace python { namespace api
+{
+  struct objattribute_policies : const_objattribute_policies
+  {
+      static object const&amp; set(object const&amp; target, object const& key, object const&amp; value);
+      static void del(object const&amp;target, object const& key);
+  };
+}}}
+</pre>
+
+    <h4><a name="objattribute_policies-spec-statics"></a>Class
+    <code>objattribute_policies</code> static functions</h4>
+<pre>
+static object const&amp; set(object const&amp; target, object const& key, object const&amp; value);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
+      holding a string.</dt>
+
+      <dt><b>Effects:</b> sets the attribute of <code>target</code> named by
+      <code>key</code> to <code>value</code>.</dt>
+
+      <dt><b>Throws:</b> <code><a href=
+      "errors.html#error_already_set-spec">error_already_set</a></code> if a
+      Python exception is raised.</dt>
+    </dl>
+<pre>
+static void del(object const&amp;target, object const& key);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>key</code> is an <code>object</code>
+      holding a string.</dt>
+
+      <dt><b>Effects:</b> deletes the attribute of <code>target</code> named
+      by <code>key</code>.</dt>
+
+      <dt><b>Throws:</b> <code><a href=
+      "errors.html#error_already_set-spec">error_already_set</a></code> if a
+      Python exception is raised.</dt>
+    </dl>
+    <!-- end -->
+    <!-- begin -->
+
     <h3><a name="const_item_policies-spec"></a>Class
     <code>const_item_policies</code></h3>
 
@@ -533,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;
@@ -542,6 +669,8 @@ namespace boost { namespace python { namespace api
       //
       proxy&lt;const_object_attribute&gt; attr(char const*) const;
       proxy&lt;object_attribute&gt; attr(char const*);
+      proxy&lt;const_object_objattribute&gt; attr(object const&) const;
+      proxy&lt;object_objattribute&gt; attr(object const&);
 
       // item access
       //
@@ -580,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>
@@ -608,6 +756,21 @@ proxy&lt;object_attribute&gt; attr(char const* name);
       <code>name</code> as its key.</dt>
     </dl>
 <pre>
+proxy&lt;const_object_objattribute&gt; attr(const object& name) const;
+proxy&lt;object_objattribute&gt; attr(const object& name);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> name is a <code>object</code> holding a string.</dt>
+
+      <dt><b>Effects:</b> accesses the named attribute of
+      <code>*this</code>.</dt>
+
+      <dt><b>Returns:</b> a proxy object which binds
+      <code>object(*static_cast&lt;U*&gt;(this))</code> as its target, and
+      <code>name</code> as its key.</dt>
+    </dl>
+<pre>
 template &lt;class T&gt;
 proxy&lt;const_object_item&gt; operator[](T const&amp; key) const;
 template &lt;class T&gt;
@@ -938,11 +1101,11 @@ object sum_items(object seq)
 </pre>
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  13 January, 2006
+  27 May, 2008
   <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
     </p>
 
     <p><i>&copy; Copyright <a href=
-    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2006.</i></p>
+    "http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a> 2008.</i></p>
   </body>
 </html>

doc/v2/pickle.html

@@ -1,112 +1,93 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 
-<title>Boost.Python Pickle Support</title>
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+  <title>Boost.Python Pickle Support</title>
+</head>
 
-<div>
+<body>
+  <div>
+    <img src="../../../../boost.png" alt="boost.png (6897 bytes)" align=
+    "center" width="277" height="86" />
+    <hr />
 
-<img src="../../../../boost.png"
-     alt="boost.png (6897 bytes)"
-     align="center"
-     width="277" height="86">
+    <h1>Boost.Python Pickle Support</h1>Pickle is a Python module for object
+    serialization, also known as persistence, marshalling, or flattening.
 
-<hr>
-<h1>Boost.Python Pickle Support</h1>
+    <p>It is often necessary to save and restore the contents of an object to
+    a file. One approach to this problem is to write a pair of functions that
+    read and write data from a file in a special format. A powerful
+    alternative approach is to use Python's pickle module. Exploiting
+    Python's ability for introspection, the pickle module recursively
+    converts nearly arbitrary Python objects into a stream of bytes that can
+    be written to a file.</p>
 
-Pickle is a Python module for object serialization, also known
-as persistence, marshalling, or flattening.
+    <p>The Boost Python Library supports the pickle module through the
+    interface as described in detail in the <a href=
+    "http://www.python.org/doc/current/lib/module-pickle.html">Python Library
+    Reference for pickle.</a> This interface involves the special methods
+    <tt>__getinitargs__</tt>, <tt>__getstate__</tt> and <tt>__setstate__</tt>
+    as described in the following. Note that Boost.Python is also fully
+    compatible with Python's cPickle module.</p>
+    <hr />
 
-<p>
-It is often necessary to save and restore the contents of an object to
-a file. One approach to this problem is to write a pair of functions
-that read and write data from a file in a special format. A powerful
-alternative approach is to use Python's pickle module. Exploiting
-Python's ability for introspection, the pickle module recursively
-converts nearly arbitrary Python objects into a stream of bytes that
-can be written to a file.
+    <h2>The Boost.Python Pickle Interface</h2>At the user level, the
+    Boost.Python pickle interface involves three special methods:
 
-<p>
-The Boost Python Library supports the pickle module
-through the interface as described in detail in the
-<a href="http://www.python.org/doc/current/lib/module-pickle.html"
->Python Library Reference for pickle.</a> This interface
-involves the special methods <tt>__getinitargs__</tt>,
-<tt>__getstate__</tt> and <tt>__setstate__</tt> as described
-in the following. Note that Boost.Python is also fully compatible
-with Python's cPickle module.
+    <dl>
+      <dt><strong><tt>__getinitargs__</tt></strong></dt>
 
-<hr>
-<h2>The Boost.Python Pickle Interface</h2>
+      <dd>
+        When an instance of a Boost.Python extension class is pickled, the
+        pickler tests if the instance has a <tt>__getinitargs__</tt> method.
+        This method must return a Python tuple (it is most convenient to use
+        a boost::python::tuple). When the instance is restored by the
+        unpickler, the contents of this tuple are used as the arguments for
+        the class constructor.
 
-At the user level, the Boost.Python pickle interface involves three special
-methods:
+        <p>If <tt>__getinitargs__</tt> is not defined, <tt>pickle.load</tt>
+        will call the constructor (<tt>__init__</tt>) without arguments;
+        i.e., the object must be default-constructible.</p>
+      </dd>
 
-<dl>
-<dt>
-<strong><tt>__getinitargs__</tt></strong>
-<dd>
-  When an instance of a Boost.Python extension class is pickled, the
-  pickler tests if the instance has a <tt>__getinitargs__</tt> method.
-  This method must return a Python tuple (it is most convenient to use
-  a boost::python::tuple). When the instance is restored by the
-  unpickler, the contents of this tuple are used as the arguments for
-  the class constructor.
+      <dt><strong><tt>__getstate__</tt></strong></dt>
 
-  <p>
-  If <tt>__getinitargs__</tt> is not defined, <tt>pickle.load</tt>
-  will call the constructor (<tt>__init__</tt>) without arguments;
-  i.e., the object must be default-constructible.
+      <dd>When an instance of a Boost.Python extension class is pickled, the
+      pickler tests if the instance has a <tt>__getstate__</tt> method. This
+      method should return a Python object representing the state of the
+      instance.</dd>
 
-<p>
-<dt>
-<strong><tt>__getstate__</tt></strong>
+      <dt><strong><tt>__setstate__</tt></strong></dt>
 
-<dd>
-  When an instance of a Boost.Python extension class is pickled, the
-  pickler tests if the instance has a <tt>__getstate__</tt> method.
-  This method should return a Python object representing the state of
-  the instance.
+      <dd>When an instance of a Boost.Python extension class is restored by
+      the unpickler (<tt>pickle.load</tt>), it is first constructed using the
+      result of <tt>__getinitargs__</tt> as arguments (see above).
+      Subsequently the unpickler tests if the new instance has a
+      <tt>__setstate__</tt> method. If so, this method is called with the
+      result of <tt>__getstate__</tt> (a Python object) as the argument.</dd>
+    </dl>The three special methods described above may be <tt>.def()</tt>'ed
+    individually by the user. However, Boost.Python provides an easy to use
+    high-level interface via the
+    <strong><tt>boost::python::pickle_suite</tt></strong> class that also
+    enforces consistency: <tt>__getstate__</tt> and <tt>__setstate__</tt>
+    must be defined as pairs. Use of this interface is demonstrated by the
+    following examples.
+    <hr />
 
-<p>
-<dt>
-<strong><tt>__setstate__</tt></strong>
+    <h2>Examples</h2>There are three files in <tt>boost/libs/python/test</tt>
+    that show how to provide pickle support.
+    <hr />
 
-<dd>
-  When an instance of a Boost.Python extension class is restored by the
-  unpickler (<tt>pickle.load</tt>), it is first constructed using the
-  result of <tt>__getinitargs__</tt> as arguments (see above). Subsequently
-  the unpickler tests if the new instance has a <tt>__setstate__</tt>
-  method. If so, this method is called with the result of
-  <tt>__getstate__</tt> (a Python object) as the argument.
+    <h3><a href="../../test/pickle1.cpp"><tt>pickle1.cpp</tt></a></h3>The C++
+    class in this example can be fully restored by passing the appropriate
+    argument to the constructor. Therefore it is sufficient to define the
+    pickle interface method <tt>__getinitargs__</tt>. This is done in the
+    following way:
 
-</dl>
-
-The three special methods described above may be <tt>.def()</tt>'ed
-individually by the user. However, Boost.Python provides an easy to use
-high-level interface via the
-<strong><tt>boost::python::pickle_suite</tt></strong> class that also
-enforces consistency: <tt>__getstate__</tt> and <tt>__setstate__</tt>
-must be defined as pairs. Use of this interface is demonstrated by the
-following examples.
-
-<hr>
-<h2>Examples</h2>
-
-There are three files in 
-<tt>boost/libs/python/test</tt> that show how to
-provide pickle support.
-
-<hr>
-<h3><a href="../../test/pickle1.cpp"><tt>pickle1.cpp</tt></a></h3>
-
-    The C++ class in this example can be fully restored by passing the
-    appropriate argument to the constructor. Therefore it is sufficient
-    to define the pickle interface method <tt>__getinitargs__</tt>.
-    This is done in the following way:
-
-<ul>
-<li>1. Definition of the C++ pickle function:
-<pre>
+    <ul>
+      <li>1. Definition of the C++ pickle function:
+        <pre>
   struct world_pickle_suite : boost::python::pickle_suite
   {
     static
@@ -117,26 +98,28 @@ provide pickle support.
     }
   };
 </pre>
-<li>2. Establishing the Python binding:
-<pre>
+      </li>
+
+      <li>2. Establishing the Python binding:
+        <pre>
   class_&lt;world&gt;("world", args&lt;const std::string&amp;&gt;())
       // ...
       .def_pickle(world_pickle_suite())
       // ...
 </pre>
-</ul>
+      </li>
+    </ul>
+    <hr />
 
-<hr>
-<h3><a href="../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a></h3>
+    <h3><a href="../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a></h3>The C++
+    class in this example contains member data that cannot be restored by any
+    of the constructors. Therefore it is necessary to provide the
+    <tt>__getstate__</tt>/<tt>__setstate__</tt> pair of pickle interface
+    methods:
 
-    The C++ class in this example contains member data that cannot be
-    restored by any of the constructors. Therefore it is necessary to
-    provide the <tt>__getstate__</tt>/<tt>__setstate__</tt> pair of
-    pickle interface methods:
-
-<ul>
-<li>1. Definition of the C++ pickle functions:
-<pre>
+    <ul>
+      <li>1. Definition of the C++ pickle functions:
+        <pre>
   struct world_pickle_suite : boost::python::pickle_suite
   {
     static
@@ -161,92 +144,76 @@ provide pickle support.
     }
   };
 </pre>
-<li>2. Establishing the Python bindings for the entire suite:
-<pre>
+      </li>
+
+      <li>2. Establishing the Python bindings for the entire suite:
+        <pre>
   class_&lt;world&gt;("world", args&lt;const std::string&amp;&gt;())
       // ...
       .def_pickle(world_pickle_suite())
       // ...
 </pre>
-</ul>
+      </li>
+    </ul>
 
-    <p>
-    For simplicity, the <tt>__dict__</tt> is not included in the result
-    of <tt>__getstate__</tt>. This is not generally recommended, but a
-    valid approach if it is anticipated that the object's
-    <tt>__dict__</tt> will always be empty. Note that the safety guard
-    described below will catch the cases where this assumption is violated.
+    <p>For simplicity, the <tt>__dict__</tt> is not included in the result of
+    <tt>__getstate__</tt>. This is not generally recommended, but a valid
+    approach if it is anticipated that the object's <tt>__dict__</tt> will
+    always be empty. Note that the safety guard described below will catch
+    the cases where this assumption is violated.</p>
+    <hr />
 
-<hr>
-<h3><a href="../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a></h3>
+    <h3><a href="../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a></h3>This
+    example is similar to <a href=
+    "../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a>. However, the object's
+    <tt>__dict__</tt> is included in the result of <tt>__getstate__</tt>.
+    This requires a little more code but is unavoidable if the object's
+    <tt>__dict__</tt> is not always empty.
+    <hr />
 
-    This example is similar to <a
-    href="../../test/pickle2.cpp"><tt>pickle2.cpp</tt></a>. However, the
-    object's <tt>__dict__</tt> is included in the result of
-    <tt>__getstate__</tt>.  This requires a little more code but is
-    unavoidable if the object's <tt>__dict__</tt> is not always empty.
+    <h2>Pitfall and Safety Guard</h2>The pickle protocol described above has
+    an important pitfall that the end user of a Boost.Python extension module
+    might not be aware of:
 
-<hr>
-<h2>Pitfall and Safety Guard</h2>
+    <p><strong><tt>__getstate__</tt> is defined and the instance's
+    <tt>__dict__</tt> is not empty.</strong></p>
 
-The pickle protocol described above has an important pitfall that the
-end user of a Boost.Python extension module might not be aware of:
-<p>
-<strong>
-<tt>__getstate__</tt> is defined and the instance's <tt>__dict__</tt>
-is not empty.
-</strong>
-<p>
+    <p>The author of a Boost.Python extension class might provide a
+    <tt>__getstate__</tt> method without considering the possibilities
+    that:</p>
 
-  The author of a Boost.Python extension class might provide a
-  <tt>__getstate__</tt> method without considering the possibilities
-  that:
+    <ul>
+      <li>his class is used in Python as a base class. Most likely the
+      <tt>__dict__</tt> of instances of the derived class needs to be pickled
+      in order to restore the instances correctly.</li>
 
-  <p>
-  <ul>
-  <li>
-    his class is used in Python as a base class. Most likely the
-    <tt>__dict__</tt> of instances of the derived class needs to be
-    pickled in order to restore the instances correctly.
+      <li>the user adds items to the instance's <tt>__dict__</tt> directly.
+      Again, the <tt>__dict__</tt> of the instance then needs to be
+      pickled.</li>
+    </ul>
 
-  <p>
-  <li>
-    the user adds items to the instance's <tt>__dict__</tt> directly.
-    Again, the <tt>__dict__</tt> of the instance then needs to be
-    pickled.
-
-  </ul>
-  <p>
-
-  To alert the user to this highly unobvious problem, a safety guard is
-  provided. If <tt>__getstate__</tt> is defined and the instance's
-  <tt>__dict__</tt> is not empty, Boost.Python tests if the class has
-  an attribute <tt>__getstate_manages_dict__</tt>. An exception is
-  raised if this attribute is not defined:
-
-<pre>
+    <p>To alert the user to this highly unobvious problem, a safety guard is
+    provided. If <tt>__getstate__</tt> is defined and the instance's
+    <tt>__dict__</tt> is not empty, Boost.Python tests if the class has an
+    attribute <tt>__getstate_manages_dict__</tt>. An exception is raised if
+    this attribute is not defined:</p>
+    <pre>
     RuntimeError: Incomplete pickle support (__getstate_manages_dict__ not set)
-</pre>
-
-  To resolve this problem, it should first be established that the
-  <tt>__getstate__</tt> and <tt>__setstate__</tt> methods manage the
-  instances's <tt>__dict__</tt> correctly. Note that this can be done
-  either at the C++ or the Python level. Finally, the safety guard
-  should intentionally be overridden. E.g. in C++ (from
-  <a href="../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a>):
-
-<pre>
+</pre>To resolve this problem, it should first be established that the <tt>
+    __getstate__</tt> and <tt>__setstate__</tt> methods manage the
+    instances's <tt>__dict__</tt> correctly. Note that this can be done
+    either at the C++ or the Python level. Finally, the safety guard should
+    intentionally be overridden. E.g. in C++ (from <a href=
+    "../../test/pickle3.cpp"><tt>pickle3.cpp</tt></a>):
+    <pre>
   struct world_pickle_suite : boost::python::pickle_suite
   {
     // ...
 
     static bool getstate_manages_dict() { return true; }
   };
-</pre>
-
-  Alternatively in Python:
-
-<pre>
+</pre>Alternatively in Python:
+    <pre>
     import your_bpl_module
     class your_class(your_bpl_module.your_class):
       __getstate_manages_dict__ = 1
@@ -255,54 +222,41 @@ is not empty.
       def __setstate__(self, state):
         # your code here
 </pre>
+    <hr />
 
-<hr>
-<h2>Practical Advice</h2>
+    <h2>Practical Advice</h2>
 
-<ul>
-<li>
-  In Boost.Python extension modules with many extension classes,
-  providing complete pickle support for all classes would be a
-  significant overhead. In general complete pickle support should
-  only be implemented for extension classes that will eventually
-  be pickled.
+    <ul>
+      <li>In Boost.Python extension modules with many extension classes,
+      providing complete pickle support for all classes would be a
+      significant overhead. In general complete pickle support should only be
+      implemented for extension classes that will eventually be pickled.</li>
 
-<p>
-<li>
-  Avoid using <tt>__getstate__</tt> if the instance can also be
-  reconstructed by way of <tt>__getinitargs__</tt>. This automatically
-  avoids the pitfall described above.
+      <li>Avoid using <tt>__getstate__</tt> if the instance can also be
+      reconstructed by way of <tt>__getinitargs__</tt>. This automatically
+      avoids the pitfall described above.</li>
 
-<p>
-<li>
-  If <tt>__getstate__</tt> is required, include the instance's
-  <tt>__dict__</tt> in the Python object that is returned.
+      <li>If <tt>__getstate__</tt> is required, include the instance's
+      <tt>__dict__</tt> in the Python object that is returned.</li>
+    </ul>
+    <hr />
 
-</ul>
+    <h2>Light-weight alternative: pickle support implemented in Python</h2>
 
-<hr>
-<h2>Light-weight alternative: pickle support implemented in Python</h2>
-
-<h3><a href="../../test/pickle4.cpp"><tt>pickle4.cpp</tt></a></h3>
-
-The <tt>pickle4.cpp</tt> example demonstrates an alternative technique
-for implementing pickle support. First we direct Boost.Python via
-the <tt>class_::enable_pickling()</tt> member function to define only
-the basic attributes required for pickling:
-
-<pre>
+    <h3><a href="../../test/pickle4.cpp"><tt>pickle4.cpp</tt></a></h3>The
+    <tt>pickle4.cpp</tt> example demonstrates an alternative technique for
+    implementing pickle support. First we direct Boost.Python via the
+    <tt>class_::enable_pickling()</tt> member function to define only the
+    basic attributes required for pickling:
+    <pre>
   class_&lt;world&gt;("world", args&lt;const std::string&amp;&gt;())
       // ...
       .enable_pickling()
       // ...
-</pre>
-
-This enables the standard Python pickle interface as described
-in the Python documentation. By &quot;injecting&quot; a
-<tt>__getinitargs__</tt> method into the definition of the wrapped
-class we make all instances pickleable:
-
-<pre>
+</pre>This enables the standard Python pickle interface as described in the
+Python documentation. By "injecting" a <tt>__getinitargs__</tt> method into
+the definition of the wrapped class we make all instances pickleable:
+    <pre>
   # import the wrapped world class
   from pickle4_ext import world
 
@@ -312,18 +266,15 @@ class we make all instances pickleable:
 
   # now inject __getinitargs__ (Python is a dynamic language!)
   world.__getinitargs__ = world_getinitargs
-</pre>
+</pre>See also the <a href=
+"../tutorial/doc/html/python/techniques.html#python.extending_wrapped_objects_in_python">
+    tutorial section</a> on injecting additional methods from Python.
+    <hr />
+    © Copyright Ralf W. Grosse-Kunstleve 2001-2004. 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)
 
-See also the
-<a href="../tutorial/doc/html/python/techniques.html#python.extending_wrapped_objects_in_python"
->tutorial section</a> on injecting additional methods from Python.
-
-<hr>
-
-&copy; Copyright Ralf W. Grosse-Kunstleve 2001-2004. 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)
-
-<p>
-Updated: Feb 2004.
-</div>
+    <p>Updated: Feb 2004.</p>
+  </div>
+</body>
+</html>

example/tutorial/Jamroot

@@ -2,6 +2,15 @@
 # Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+import python ;
+
+if ! [ python.configured ]
+{
+    ECHO "notice: no Python configured in user-config.jam" ;
+    ECHO "notice: will use default configuration" ;
+    using python ;
+}
+
 # Specify the path to the Boost project.  If you move this project,
 # adjust this path to refer to the Boost root directory.
 use-project boost

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

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

include/boost/python/converter/builtin_converters.hpp

@@ -90,6 +90,14 @@ namespace detail
         BOOST_PYTHON_ARG_TO_PYTHON_BY_VALUE(T,expr)
 
 // Specialize converters for signed and unsigned T to Python Int
+#if PY_VERSION_HEX >= 0x03000000
+
+# define BOOST_PYTHON_TO_INT(T)                                         \
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, ::PyLong_FromLong(x), &PyLong_Type)      \
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned T, ::PyLong_FromUnsignedLong(x), &PyLong_Type)
+
+#else
+
 # define BOOST_PYTHON_TO_INT(T)                                         \
     BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, ::PyInt_FromLong(x), &PyInt_Type)      \
     BOOST_PYTHON_TO_PYTHON_BY_VALUE(                                    \
@@ -98,6 +106,7 @@ namespace detail
                 (std::numeric_limits<long>::max)())                     \
         ? ::PyLong_FromUnsignedLong(x)                                  \
         : ::PyInt_FromLong(x), &PyInt_Type)
+#endif
 
 // Bool is not signed.
 #if PY_VERSION_HEX >= 0x02030000
@@ -116,17 +125,24 @@ BOOST_PYTHON_TO_INT(long)
 // using Python's macro instead of Boost's - we don't seem to get the
 // config right all the time.
 # ifdef HAVE_LONG_LONG 
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed BOOST_PYTHON_LONG_LONG, ::PyLong_FromLongLong(x), &PyInt_Type)
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned BOOST_PYTHON_LONG_LONG, ::PyLong_FromUnsignedLongLong(x), &PyInt_Type)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed BOOST_PYTHON_LONG_LONG, ::PyLong_FromLongLong(x), &PyLong_Type)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned BOOST_PYTHON_LONG_LONG, ::PyLong_FromUnsignedLongLong(x), &PyLong_Type)
 # endif
     
 # undef BOOST_TO_PYTHON_INT
 
+#if PY_VERSION_HEX >= 0x03000000
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char, converter::do_return_to_python(x), &PyUnicode_Type)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, converter::do_return_to_python(x), &PyUnicode_Type)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, ::PyUnicode_FromStringAndSize(x.data(),implicit_cast<ssize_t>(x.size())), &PyUnicode_Type)
+#else
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(char, converter::do_return_to_python(x), &PyString_Type)
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, converter::do_return_to_python(x), &PyString_Type)
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, ::PyString_FromStringAndSize(x.data(),implicit_cast<ssize_t>(x.size())), &PyString_Type)
+#endif
+
 #if defined(Py_USING_UNICODE) && !defined(BOOST_NO_STD_WSTRING)
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::wstring, ::PyUnicode_FromWideChar(x.data(),implicit_cast<ssize_t>(x.size())), &PyString_Type)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::wstring, ::PyUnicode_FromWideChar(x.data(),implicit_cast<ssize_t>(x.size())), &PyUnicode_Type)
 # endif 
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, ::PyFloat_FromDouble(x), &PyFloat_Type)
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, ::PyFloat_FromDouble(x), &PyFloat_Type)

include/boost/python/converter/pyobject_traits.hpp

@@ -34,7 +34,9 @@ struct pyobject_traits<PyObject>
 // This is not an exhaustive list; should be expanded.
 BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Type);
 BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(List);
+#if PY_VERSION_HEX < 0x03000000
 BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Int);
+#endif
 BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Long);
 BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Dict);
 BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Tuple);

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>

include/boost/python/converter/shared_ptr_from_python.hpp

@@ -45,10 +45,14 @@ struct shared_ptr_from_python
         if (data->convertible == source)
             new (storage) shared_ptr<T>();
         else
+        {
+            boost::shared_ptr<void> hold_convertible_ref_count(
+              (void*)0, shared_ptr_deleter(handle<>(borrowed(source))) );
+            // use aliasing constructor
             new (storage) shared_ptr<T>(
-                static_cast<T*>(data->convertible),
-                shared_ptr_deleter(handle<>(borrowed(source)))
-                );
+                hold_convertible_ref_count,
+                static_cast<T*>(data->convertible));
+        }
         
         data->convertible = storage;
     }

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

include/boost/python/detail/decorated_type_id.hpp

@@ -55,8 +55,8 @@ inline decorated_type_info::decorated_type_info(type_info base_t, decoration dec
 inline bool decorated_type_info::operator<(decorated_type_info const& rhs) const
 {
     return m_decoration < rhs.m_decoration
-        || m_decoration == rhs.m_decoration
-           && m_base_type < rhs.m_base_type;
+      || (m_decoration == rhs.m_decoration
+          && m_base_type < rhs.m_base_type);
 }
 
 inline bool decorated_type_info::operator==(decorated_type_info const& rhs) const

include/boost/python/detail/operator_id.hpp

@@ -47,7 +47,11 @@ enum operator_id
     op_ixor,
     op_ior,
     op_complex,
+#if PY_VERSION_HEX >= 0x03000000
+    op_bool,
+#else
     op_nonzero,
+#endif
     op_repr
 };
 

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

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

include/boost/python/detail/translate_exception.hpp

@@ -2,13 +2,15 @@
 // 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 TRANSLATE_EXCEPTION_DWA2002810_HPP
-# define TRANSLATE_EXCEPTION_DWA2002810_HPP
+#ifndef TRANSLATE_EXCEPTION_TDS20091020_HPP
+# define TRANSLATE_EXCEPTION_TDS20091020_HPP
 
 # include <boost/python/detail/exception_handler.hpp>
 
 # include <boost/call_traits.hpp>
 # include <boost/type_traits/add_const.hpp>
+# include <boost/type_traits/add_reference.hpp>
+# include <boost/type_traits/remove_reference.hpp>
 
 # include <boost/function/function0.hpp>
 

include/boost/python/detail/wrap_python.hpp

@@ -175,6 +175,19 @@ typedef int pid_t;
         ( (op)->ob_type = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
 #endif
 
+// Define Python 3 macros for Python 2.x
+#if PY_VERSION_HEX < 0x02060000
+
+# define Py_TYPE(o)    (((PyObject*)(o))->ob_type)
+# define Py_REFCNT(o)  (((PyObject*)(o))->ob_refcnt)
+# define Py_SIZE(o)    (((PyVarObject*)(o))->ob_size)
+
+# define PyVarObject_HEAD_INIT(type, size)	\
+  	PyObject_HEAD_INIT(type) size,
+
+#endif
+
+
 #ifdef __MWERKS__
 # pragma warn_possunwant off
 #elif _MSC_VER

include/boost/python/enum.hpp

@@ -41,7 +41,7 @@ inline enum_<T>::enum_(char const* name, char const* doc )
         , &enum_<T>::convertible_from_python
         , &enum_<T>::construct
         , type_id<T>()
-		, doc
+        , doc
         )
 {
 }
@@ -79,7 +79,11 @@ void* enum_<T>::convertible_from_python(PyObject* obj)
 template <class T>
 void enum_<T>::construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data)
 {
+#if PY_VERSION_HEX >= 0x03000000
+    T x = static_cast<T>(PyLong_AS_LONG(obj));
+#else
     T x = static_cast<T>(PyInt_AS_LONG(obj));
+#endif
     void* const storage = ((converter::rvalue_from_python_storage<T>*)data)->storage.bytes;
     new (storage) T(x);
     data->convertible = storage;

include/boost/python/exec.hpp

@@ -20,6 +20,13 @@ object
 BOOST_PYTHON_DECL
 eval(str string, object global = object(), object local = object());
 
+// Execute an individual python statement from str.
+// global and local are the global and local scopes respectively,
+// used during execution.
+object 
+BOOST_PYTHON_DECL
+exec_statement(str string, object global = object(), object local = object());
+
 // Execute python source code from str.
 // global and local are the global and local scopes respectively,
 // used during execution.

include/boost/python/iterator.hpp

@@ -14,6 +14,16 @@
 # include <boost/type_traits/cv_traits.hpp>
 # include <boost/type_traits/transform_traits.hpp>
 
+# if defined(BOOST_MSVC) && (BOOST_MSVC == 1400) /*
+> warning C4180: qualifier applied to function type has no meaning; ignored
+Peter Dimov wrote:
+This warning is caused by an overload resolution bug in VC8 that cannot be
+worked around and will probably not be fixed by MS in the VC8 line. The
+problematic overload is only instantiated and never called, and the code
+works correctly. */
+#  pragma warning(disable: 4180)
+# endif
+
 # include <boost/bind.hpp>
 # include <boost/bind/protect.hpp>